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

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using _0_Framework.Application;
using _0_Framework.InfraStructure;
using Company.Domain.RollCallEmployeeAgg;
using CompanyManagment.App.Contracts.RollCallEmployee;
using CompanyManagment.App.Contracts.RollCallEmployeeStatus;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;

namespace CompanyManagment.EFCore.Repository;

public class RollCallEmployeeRepository : RepositoryBase<long, RollCallEmployee>, IRollCallEmployeeRepository
{
    private readonly CompanyContext _context;
    private readonly IPasswordHasher _passwordHasher;
    private readonly IWebHostEnvironment _webHostEnvironment;

    public RollCallEmployeeRepository(CompanyContext context, IPasswordHasher passwordHasher, IWebHostEnvironment webHostEnvironment) : base(context)
    {
        _context = context;
        _passwordHasher = passwordHasher;
        _webHostEnvironment = webHostEnvironment;
    }

    public List<RollCallEmployeeViewModel> GetByWorkshopId(long workshopId)
    {
        var query = _context.RollCallEmployees.Select(x => new RollCallEmployeeViewModel()
        {
            Id = x.id,
            EmployeeId = x.EmployeeId,
            WorkshopId = x.WorkshopId,
            EmployeeFullName = x.EmployeeFullName,
            IsActiveString = x.IsActiveString,
            HasUploadedImage = x.HasUploadedImage
        }).Where(x => x.WorkshopId == workshopId);

        return query.ToList();
    }



    public EditRollCallEmployee GetDetails(long id)
    {
        return _context.RollCallEmployees.Select(x => new RollCallEmployeeViewModel()
        {
            Id = x.id,
            WorkshopId = x.WorkshopId,
            EmployeeFullName = x.EmployeeFullName,
            IsActiveString = x.IsActiveString,
            HasUploadedImage = x.HasUploadedImage
        }).FirstOrDefault(x => x.Id == id);
    }

    public RollCallEmployeeViewModel GetByEmployeeIdAndWorkshopId(long employeeId, long workshopId)
    {
        return _context.RollCallEmployees.Where(x => x.EmployeeId == employeeId && x.WorkshopId == workshopId).Select(x => new RollCallEmployeeViewModel()
        {
            Id = x.id,
            WorkshopId = x.WorkshopId,
            EmployeeFullName = x.EmployeeFullName,
            IsActiveString = x.IsActiveString,
            HasUploadedImage = x.HasUploadedImage
        }).FirstOrDefault();
    }

    public List<RollCallEmployeeViewModel> GetPersonnelRollCallListPaginate(RollCallEmployeeSearchModel command)
    {
        var dateNow = DateTime.Now;
        var rawQuery = _context.Employees.Include(x => x.LeftWorks).Include(x => x.LeftWorkInsurances)
            .Where(x => x.LeftWorks.Any(y =>
                            y.WorkshopId == command.WorkshopId && y.StartWorkDate <= dateNow &&
                            y.LeftWorkDate > dateNow) ||
                        x.LeftWorkInsurances.Any(y =>
                            y.WorkshopId == command.WorkshopId && y.StartWorkDate <= dateNow &&
                            (y.LeftWorkDate > dateNow || y.LeftWorkDate == null))).OrderByDescending(x => x.id).AsQueryable().AsSplitQuery();
        if (!string.IsNullOrWhiteSpace(command.Name))
            rawQuery = rawQuery.Where(x => (x.FName + " " + x.LName).Contains(command.Name));

        var rollCallEmployees = _context.RollCallEmployees.Where(x => x.WorkshopId == command.WorkshopId);


        var joinedQuery = from employee in rawQuery
                          join rollCallEmployee in rollCallEmployees
                              on employee.id equals rollCallEmployee.EmployeeId into grp
                          from joinedRollCall in grp.DefaultIfEmpty()
                          select new RollCallEmployeeViewModel()
                          {
                              WorkshopId = command.WorkshopId,
                              EmployeeId = employee.id,
                              Id = joinedRollCall == null ? 0 : joinedRollCall.id,
                              EmployeeFullName = employee.FullName,
                              NationalCode = employee.NationalCode,
                              IsActiveString = joinedRollCall == null ? "false" : joinedRollCall.IsActiveString,
                              HasUploadedImage = joinedRollCall == null ? "false" : joinedRollCall.HasUploadedImage
                          };
        var firstlist = joinedQuery.AsSplitQuery();
        var list = firstlist.OrderByDescending(x => x.IsActiveString == "true" ? 1 : 0)
            .ThenByDescending(x => x.HasUploadedImage == "true" ? 1 : 0)
            .Skip(command.PageIndex).Take(30).ToList();

        list = list.Select(x => new RollCallEmployeeViewModel()
        {
            WorkshopId = x.WorkshopId,
            EmployeeId = x.EmployeeId,
            Id = x.Id,
            EmployeeFullName = x.EmployeeFullName,
            NationalCode = x.NationalCode,
            IsActiveString = x.IsActiveString,
            HasUploadedImage = x.HasUploadedImage,
            EmployeeSlug = _passwordHasher.SlugHasher(x.EmployeeId),
            ImagePath = (System.IO.File.Exists(Path.Combine(_webHostEnvironment.ContentRootPath, "Faces", command.WorkshopId.ToString(), x.EmployeeId.ToString(), "1.jpg")))
                ? Tools.ResizeImage(Path.Combine(_webHostEnvironment.ContentRootPath, "Faces", command.WorkshopId.ToString(), x.EmployeeId.ToString(), "1.jpg"), 150, 150) : ""
        }).ToList();
    
    

         return list;
    }

    public RollCallEmployee GetWithRollCallStatus(long id)
    {
        return _context.RollCallEmployees.Include(x => x.EmployeesStatus)
            .FirstOrDefault(x => x.id == id);
    }

    public int activedPerson(long workshopId)
    {
        return _context.RollCallEmployees.Count(x => x.WorkshopId == workshopId && x.IsActiveString == "true" && x.HasUploadedImage == "true");
    }

    #region Pooya
    public List<RollCallEmployeeViewModel> GetByEmployeeIdWithStatuses(long employeeId)
    {
        return _context.RollCallEmployees.Include(x => x.EmployeesStatus)
            .Where(x => x.EmployeeId == employeeId).Select(x =>
                new RollCallEmployeeViewModel()
                {
                    EmployeeId = x.EmployeeId,
                    EmployeeFullName = x.EmployeeFullName,
                    Id = x.id,
                    WorkshopId = x.WorkshopId,
                    IsActiveString = x.IsActiveString,
                    HasUploadedImage = x.HasUploadedImage,
                    Statuses = x.EmployeesStatus.Select(y => new RollCallEmployeeStatusViewModel()
                    {
                        StartDateGr = y.StartDate,
                        EndDateGr = y.EndDate,
                        Id = y.id
                    })

                }).ToList(); ;
    }

    public List<RollCallEmployeeViewModel> GetActivePersonnelByWorkshopId(long workshopId)
    {
        var rollCallEmployeeIdQuery = _context.RollCallEmployees.Where(x => x.WorkshopId == workshopId
                                                                            && x.IsActiveString == "true" && x.HasUploadedImage == "true");

        var personnel =
            _context.PersonnelCodeSet.Include(x => x.Employee).Where(x => rollCallEmployeeIdQuery.Any(y => y.EmployeeId == x.EmployeeId && y.WorkshopId == x.WorkshopId));

        return personnel.Select(x => new RollCallEmployeeViewModel()
        {
            PersonelCode = x.PersonnelCode,
            EmployeeFName = x.Employee.FName,
            EmployeeLName = x.Employee.LName
        }).OrderBy(x => x.EmployeeLName).ToList();


    }

    public List<RollCallEmployeeViewModel> GetEmployeeRollCalls(long workshopId)
    {
        var dateNow = DateTime.Now;
        var f = _context.RollCallEmployees.Where(x => x.WorkshopId == workshopId);

        var res = f.Select(x => new RollCallEmployeeViewModel
        {
            RollCallEmployeeId = x.id,
            EmployeeId = x.EmployeeId,
            EmployeeFullName = x.EmployeeFullName
        })
            .ToList();

        return res;
    }

    public List<RollCallEmployeeViewModel> GetPersonnelRollCallListAll(long workshopId)
    {
        var dateNow = DateTime.Now;
        var f = _context.Employees.Include(x => x.LeftWorks).Include(x => x.LeftWorkInsurances)
            .Where(x => x.LeftWorks.Any(y => y.WorkshopId == workshopId && y.StartWorkDate <= dateNow && y.LeftWorkDate > dateNow) ||
                        x.LeftWorkInsurances.Any(y => y.WorkshopId == workshopId && y.StartWorkDate <= dateNow &&
                                                      (y.LeftWorkDate > dateNow || y.LeftWorkDate == null))).ToList();


        var res = f.Select(x => new RollCallEmployeeViewModel
        {
            WorkshopId = workshopId,
            EmployeeId = x.id,
            Id = _context.RollCallEmployees.Any(r => r.EmployeeId == x.id && r.WorkshopId == workshopId) ?
                    _context.RollCallEmployees.FirstOrDefault(r => r.EmployeeId == x.id && r.WorkshopId == workshopId)!.id : 0,
            EmployeeFullName = $"{x.FName} {x.LName}",
            EmployeeSlug = _passwordHasher.SlugHasher(x.id),
            NationalCode = _context.Employees.FirstOrDefault(e => e.id == x.id).NationalCode,
            IsActiveString = _context.RollCallEmployees.Any(r => r.EmployeeId == x.id && r.WorkshopId == workshopId && r.IsActiveString == "true") ? "true" : "false",
            HasUploadedImage = _context.RollCallEmployees.Any(r => r.EmployeeId == x.id && r.WorkshopId == workshopId && r.HasUploadedImage == "true") ? "true" : "false",
            ImagePath = (System.IO.File.Exists(Path.Combine(_webHostEnvironment.ContentRootPath, "Faces", workshopId.ToString(), x.id.ToString(), "1.jpg")))
                    ? Tools.ResizeImage(Path.Combine(_webHostEnvironment.ContentRootPath, "Faces", workshopId.ToString(), x.id.ToString(), "1.jpg"), 150, 150)
                    : "",
        }).OrderBy(x => x.PersonelCode)
            .ToList();

        return res;
    }

    #endregion
}