Backend-Api/CompanyManagment.EFCore/Repository/ClassificationEmployeeRepository.cs

using System.Collections.Generic;
using System.Linq;
using System;
using System.Threading.Tasks;
using _0_Framework.Application;
using _0_Framework.InfraStructure;
using Company.Domain.ClassificationSchemeAgg;
using CompanyManagment.App.Contracts.ClassificationScheme;
using CompanyManagment.App.Contracts.Workshop;
using Microsoft.EntityFrameworkCore;

namespace CompanyManagment.EFCore.Repository;

public class ClassificationEmployeeRepository : RepositoryBase<long, ClassificationEmployee>, IClassificationEmployeeRepository
{
    private readonly CompanyContext _context;
    public ClassificationEmployeeRepository(CompanyContext context) : base(context)
    {
        _context = context;
    }


    public async Task<List<EmployeeInfoList>> GetEmployeeListData(long schemeId)
    {
        var leftDate = new DateTime(2121, 3, 21);
        var workshopId =  _context.ClassificationSchemes.FirstOrDefault(x => x.id == schemeId)!.WorkshopId;
        var join = new List<PersonnelInfoViewModel>();
        var contractLeftWork =await _context.LeftWorkList.Include(em=>em.Employee).Select(x => new PersonnelInfoViewModel()
        {
            WorkshopId = x.WorkshopId,
            EmployeeId = x.EmployeeId,
            FullName = x.Employee.FullName,
            PersonnelCode = 0,
            ContractPerson = true,
            ContractLeft = x.LeftWorkDate != leftDate,
            StartWork = x.StartWorkDate,
            LeftWork = x.LeftWorkDate,
            LastStartInsuranceWork = "-",
            LastLeftInsuranceWork = "-",
        }).Where(x => x.WorkshopId == workshopId)
            .OrderByDescending(x => x.StartWork)
            .ToListAsync();

        contractLeftWork = contractLeftWork.Select(x => new PersonnelInfoViewModel()
        {
            WorkshopId = x.WorkshopId,
            EmployeeId = x.EmployeeId,
            FullName = x.FullName,
            
            ContractPerson = true,
            ContractLeft = x.ContractLeft,
            LastStartContractWork = x.StartWork.ToFarsi(),
            LastLeftContractWork = x.LeftWork != leftDate ? x.LeftWork.ToFarsi() : "-",
            StartWork = x.StartWork,
            LeftWork = x.LeftWork,
            LastStartInsuranceWork = x.LastStartInsuranceWork,
            LastLeftInsuranceWork = x.LastLeftInsuranceWork,
        }).ToList();

        var insuranceLeftWork =await _context.LeftWorkInsuranceList.Include(em=> em.Employee).Select(x => new PersonnelInfoViewModel()
        {
            WorkshopId = x.WorkshopId,
            EmployeeId = x.EmployeeId,
            FullName = x.Employee.FullName,
            PersonnelCode = 0,
            InsurancePerson = true,
            InsuranceLeft = x.LeftWorkDate != null,
            StartWork = x.StartWorkDate,
            LastStartInsuranceWork = x.StartWorkDate.ToFarsi(),
            LastLeftInsuranceWork = x.LeftWorkDate != null ? x.LeftWorkDate.ToFarsi() : "-",
        }).Where(x => x.WorkshopId == workshopId)
            .OrderByDescending(x => x.StartWork).ToListAsync();

        insuranceLeftWork = insuranceLeftWork.Select(x => new PersonnelInfoViewModel()
        {
            WorkshopId = x.WorkshopId,
            EmployeeId = x.EmployeeId,
            FullName = x.FullName,
            PersonnelCode = _context.PersonnelCodeSet.Any(p => p.EmployeeId == x.EmployeeId && p.WorkshopId == x.WorkshopId) ?
                _context.PersonnelCodeSet.FirstOrDefault(p => p.EmployeeId == x.EmployeeId && p.WorkshopId == x.WorkshopId)!.PersonnelCode : 0,
            InsurancePerson = true,
            InsuranceLeft = x.InsuranceLeft,
            StartWork = x.StartWork,
            LastStartInsuranceWork = x.LastStartInsuranceWork,
            LastLeftInsuranceWork = x.LastLeftInsuranceWork,
        }).ToList();

        var joinEqualList = contractLeftWork.Join(insuranceLeftWork,
            x => x.EmployeeId,
            c => c.EmployeeId,
            (first, second) => new PersonnelInfoViewModel
            {
                EmployeeId = first.EmployeeId,
                ContractPerson = first.ContractPerson,
                ContractLeft = first.ContractLeft,
                InsurancePerson = second.InsurancePerson,
                InsuranceLeft = second.InsuranceLeft,
                LastStartContractWork = first.LastStartContractWork,
                LastLeftContractWork = first.LastLeftContractWork,
                StartWork = first.StartWork,
                LeftWork = first.LeftWork,
                LastStartInsuranceWork = second.LastStartInsuranceWork,
                LastLeftInsuranceWork = second.LastLeftInsuranceWork,
            }).ToList();

        if (contractLeftWork.Any() && !insuranceLeftWork.Any())
        {
            join = contractLeftWork.ToList();
        }
        else if (!contractLeftWork.Any() && insuranceLeftWork.Any())
        {
            join = insuranceLeftWork.ToList();
        }
        else if (contractLeftWork.Any() && insuranceLeftWork.Any())
        {
            join = contractLeftWork.Concat(insuranceLeftWork).ToList();
        }

        //if (joinEqualList.Count == 0)
        //    return new List<EmployeeInfoList>();

        //join = join.GroupBy(x => x.EmployeeId).Select(d => d.First()).ToList();


        var employeeWhitGroup = _context.ClassificationEmployees.Include(g=>g.ClassificationGroup)
            .Where(x => x.ClassificationSchemeId == schemeId);



        
        
        var finalList = join.Select(x =>
        {
            var hasGroup = employeeWhitGroup.Any(em => em.EmployeeId == x.EmployeeId);
            var groupNo = "";
            if (hasGroup)
            {
                var group = employeeWhitGroup.Where(g => g.EmployeeId == x.EmployeeId)
                    .Select(n => n.ClassificationGroup.GroupNo).ToList();
                if (group.Count > 0)
                    groupNo = string.Join(" - ", group);  
                


            }


            var contractPerson = joinEqualList.Any(c => c.EmployeeId == x.EmployeeId) ? joinEqualList.FirstOrDefault(c => c.EmployeeId == x.EmployeeId)!.ContractPerson : x.ContractPerson;
            var insurancePerson = joinEqualList.Any(c => c.EmployeeId == x.EmployeeId) ? joinEqualList.FirstOrDefault(c => c.EmployeeId == x.EmployeeId)!.InsurancePerson : x.InsurancePerson;
            var contractLeft = joinEqualList.Any(c => c.EmployeeId == x.EmployeeId) ? joinEqualList.FirstOrDefault(c => c.EmployeeId == x.EmployeeId)!.ContractLeft : x.ContractLeft;
            var insuranceLeft = joinEqualList.Any(c => c.EmployeeId == x.EmployeeId) ? joinEqualList.FirstOrDefault(c => c.EmployeeId == x.EmployeeId)!.InsuranceLeft : x.InsuranceLeft;


            var lastStartInsuranceWork = joinEqualList.Any(c => c.EmployeeId == x.EmployeeId) ? joinEqualList.FirstOrDefault(c => c.EmployeeId == x.EmployeeId)!.LastStartInsuranceWork : x.LastStartInsuranceWork;
            var lastLeftInsuranceWork = joinEqualList.Any(c => c.EmployeeId == x.EmployeeId) ? joinEqualList.FirstOrDefault(c => c.EmployeeId == x.EmployeeId)!.LastLeftInsuranceWork : x.LastLeftInsuranceWork;

            return new EmployeeInfoList
            {
                HasGroup = hasGroup,
                GroupNo = groupNo,
                EmployeeId = x.EmployeeId,
                FullName = x.FullName,
                ContractPerson = contractPerson,
                InsurancePerson = insurancePerson,
                ContractLeft = contractLeft,
                InsuranceLeft = insuranceLeft,
                Black = ((contractPerson && insurancePerson && insuranceLeft && contractLeft) || (contractPerson && !insurancePerson && contractLeft) || (insurancePerson && !contractPerson && insuranceLeft)) ? true : false,
                LastStartContractWork = x.LastStartContractWork,
                LastLeftContractWork = x.LastLeftContractWork,
                LastStartInsuranceWork = lastStartInsuranceWork,
                LastLeftInsuranceWork = lastLeftInsuranceWork,
            };
        }).ToList();


        var final = finalList.GroupBy(x => x.EmployeeId).Select(x => x.First()).ToList();
        return final;
    }


    /// <summary>
    ///  دریافت اطلاعات عضویتی پرسنل در گروه
    /// </summary>
    /// <param name="employeeId"></param>
    /// <returns></returns>
    public async Task<List<EditEmployeeGroupList>> GetEmployeeMemberizeData(long employeeId)
    {
        return await _context.ClassificationEmployees.Where(x => x.EmployeeId == employeeId).Include(x=>x.ClassificationGroup).Select(x=> new EditEmployeeGroupList
        {
            Id = x.id,
            WorkshopId = x.WorkshopId,
            SchemeId = x.ClassificationSchemeId,
            ClassificationGroupId = x.ClassificationGroupId,
            ClassificationGroupJobId = x.ClassificationGroupJobId,
            StartGroupDate = x.StartGroupDate,
            EndGroupDate = x.EndGroupDate,
            StartGroupDateFa = x.StartGroupDate.HasValue ? x.StartGroupDate.ToFarsi() : "",
            EndGroupDateFa = x.EndGroupDate.HasValue ? x.EndGroupDate.ToFarsi() : "",
            GroupNo = x.ClassificationGroup.GroupNo
            

        }).OrderBy(x=>x.StartGroupDate).ToListAsync();


    }


    public async Task CreateTransferRange(List<ClassificationEmployee> command)
    {
       await _context.AddRangeAsync(command);
       await _context.SaveChangesAsync();
    }

    /// <summary>
    /// حذف پرسنل از گروه از سمت ویرایش
    /// </summary>
    /// <param name="command"></param>
    /// <returns></returns>
    public async Task RemoveRangeByEdit(List<ClassificationEmployee> command)
    {
         _context.RemoveRange(command);
       
    }
}