monorepo/LCU.API.Operations.IncentiveAPI/LCU.API.Internal.Operations.IncentiveApiLib/Repositories/DepartmentRepository.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.API.Internal.Operations.IncentiveApiLib.Persistence;
using Microsoft.EntityFrameworkCore;
using Serilog;
using LCU.Library.Internal.IncentiveApiModels.Common;
using LCU.Library.Internal.IncentiveApiModels.Results;
using LCU.Library.Internal.IncentiveApiModels.Requests;

namespace LCU.API.Internal.Operations.IncentiveApiLib.Repositories;

public class DepartmentRepository : BaseRepository, IDepartmentRepository
{
    private const string BranchStr = "branch";

    public DepartmentRepository(IApplicationDbContext context) : base(context)
    {
    }

    public async Task<IReadOnlyCollection<Department>> GetAllDepartmentsAsync()
    {
        return await _context.Departments.OrderBy(x => x.DepartmentName).ToListAsync();
    }

    public async Task<Department> FindDepartmentByIdAsync(int id)
    {
        return await _context.Departments.FindAsync(id);
    }

    public async Task<Department> SaveDepartmentAsync(Department department)
    {
        await _context.Departments.AddAsync(department);
        return department;
    }

    public async Task<Department> FindOrCreateDepartment(ActiveEmployeeResult employee)
    {
        var departmentName = DetermineDepartmentName(employee.OrgUnit);
        var orgCode = employee.OrgCode.ToLower();
        var businessLine = BusinessLine.TryLookup(employee.OrgUnit);
        var department = await _context.Departments.FirstOrDefaultAsync(x =>
            x.DayForceGlCode.ToLower() == orgCode || x.DepartmentName.ToLower() == departmentName.ToLower());

        if (department == null)
        {
            department = new Department()
            {
                BusinessLineCode = businessLine.Code,
                State = DepartmentState.Active,
                DepartmentName = departmentName,
                DayforceDepartmentName = employee.OrgUnit,
                DayForceGlCode = employee.OrgCode,
                DnaOrgNbr = employee.GetDnaOrgCode()
            };
            await SaveDepartmentAsync(department);
        }

        department.DepartmentName = departmentName;
        return department;
    }

    public static string DetermineDepartmentName(string employeeOrgUnit)
    {
        if (string.IsNullOrWhiteSpace(employeeOrgUnit))
        {
            return null;
        }

        if (employeeOrgUnit.Contains("-"))
        {
            var unitNames = employeeOrgUnit.Split("-");
            var leftHalf = unitNames.First().Trim();
            var rightHalf = unitNames.ElementAt(1).Trim();

            if (string.Equals(rightHalf, BranchStr, StringComparison.CurrentCultureIgnoreCase))
            {
                return leftHalf;
            }

            return rightHalf;
        }

        return employeeOrgUnit.Trim();
    }

    public async Task<List<AppUser>> FindDepartmentAssignments(DepartmentPersonnelSearchRequest searchRequest)
    {
        var userDepartments = await _context.DepartmentAssignments
            .Include(x => x.Employee)
            .ThenInclude(x => x.AdditionalPermissions)
            .Where(x => x.DepartmentId == searchRequest.DepartmentId)
            .ToListAsync();

        var range = new MonthRange(searchRequest.Year, searchRequest.Month);
        var usersInRange = userDepartments
            .Where(x =>
                        x.StartDate.Date <= range.EndTime.Date &&
                        (x.EndDate == null || x.EndDate.Value.Date >= range.StartTime.Date));

        var users = usersInRange.Where(x => searchRequest.IncludeAllPersonnel ||
                                            x.Role.Permissions.Any(p =>
                                                p == Permission.HaveSalesGoals) ||
                                            x.Employee.AdditionalPermissions.Any(p =>
                                                p.Permission == Permission.HaveSalesGoals));

        return users.Select(x => x.Employee).ToList();
    }

    public async Task<Department> FindUserHomeDepartment(AppUser appUser)
    {
        try
        {
            var userDepartment = await _context.DepartmentAssignments.Include(x => x.Department)
                .Where(x => x.IsHome == true && x.EndDate == null
                            && x.Employee.EmployeeId.Equals(appUser.EmployeeId)).SingleOrDefaultAsync();
            return userDepartment?.Department;
        }
        catch (Exception ex)
        {
            Log.Error(ex,
                $"Error Finding User Home Department. User with EmployeeId {appUser.EmployeeId} may have no or multiple home assignments.");
            return null;
        }
    }

    public async Task<Department> FindDepartmentByBranchName(string name)
    {
        return await _context.Departments.SingleOrDefaultAsync(x => x.DepartmentName.ToLower() == name.ToLower());
    }

    public async Task<Department> GetDepartmentByDayforceGlCode(int glCode)
    {
        return await _context.Departments.AsNoTracking().FirstOrDefaultAsync(x => x.DayForceGlCode == glCode.ToString());
    }

    public async Task<IReadOnlyCollection<Department>> FindDepartmentsByRegionAsync(Region region)
    {
        return await _context.Departments
            .Where(x => x.RegionCode == region.Code)
            .OrderBy(x => x.DepartmentName)
            .ToListAsync();
    }

    public async Task<IReadOnlyCollection<Department>> FindDepartmentsByBusinessLineAsync(BusinessLine businessLine)
    {
        return await _context.Departments
            .Where(x => x.BusinessLineCode == businessLine.Code)
            .OrderBy(x => x.DepartmentName)
            .ToListAsync();
    }

    public async Task<IReadOnlyCollection<UserDepartment>> FindCurrentDepartmentAssignments(int departmentId)
    {
        return await FindDepartmentAssignmentsForRange(departmentId, new MonthRange());
    }

    public async Task<IReadOnlyCollection<UserDepartment>> FindDepartmentAssignmentsForRange(int departmentId,
        MonthRange monthRange)
    {
        return await _context.DepartmentAssignments
            .AsNoTracking()
            .Include(assignment => assignment.Employee)
            .Where(assignment => assignment.DepartmentId == departmentId &&
                                 assignment.StartDate.Date <= monthRange.EndTime.Date &&
                                 (assignment.EndDate == null ||
                                  assignment.EndDate.Value.Date >= monthRange.StartTime.Date))
            .ToListAsync();
    }
}