Backend-Api/WorkFlow/Infrastructure/WorkFlow.Infrastructure.ACL/RollCall/WorkFlowRollCallACL.cs

using _0_Framework.Application;
using CompanyManagment.App.Contracts.RollCall;
using CompanyManagment.App.Contracts.RollCallEmployeeStatus;
using CompanyManagment.App.Contracts.RollCallService;
using WorkFlow.Application.Contracts.Shared;

namespace WorkFlow.Infrastructure.ACL.RollCall;

public class WorkFlowRollCallACL : IWorkFlowRollCallACL
{
    private readonly IRollCallApplication _rollCallApplication;
    private readonly IRollCallEmployeeStatusApplication _rollCallEmployeeStatusApplication;
    private readonly IRollCallServiceApplication _rollCallServiceApplication;
    public WorkFlowRollCallACL(IRollCallApplication rollCallApplication, IRollCallEmployeeStatusApplication rollCallEmployeeStatusApplication, IRollCallServiceApplication rollCallServiceApplication)
    {
        _rollCallApplication = rollCallApplication;
        _rollCallEmployeeStatusApplication = rollCallEmployeeStatusApplication;
        _rollCallServiceApplication = rollCallServiceApplication;
    }



    public List<DailyRollCallWorkFlowViewModel> GetRollCallWorkFlowsCutByBgService(long workshopId, DateTime start, DateTime end)
    {
        var result = _rollCallApplication.GetRollCallWorkFlowsCutByBgService(workshopId, start, end).Select(x =>
        {
            return new DailyRollCallWorkFlowViewModel()
            {
                DateTime = x.DateGr,
                DateTimeFa = x.DateFa,
                RollCallWorkFlowPerDayViewModels = x.ActiveEmployees.Select(e => new RollCallWorkFlowViewModel()
                {
                    EmployeeId = e.EmployeeId,
                    EmployeeName = e.EmployeeFullName,
                    Message = $"{TimeOnly.FromDateTime(e.StartDate!.Value):HH:mm} الی {TimeOnly.FromDateTime(e.EndDate.Value):HH:mm}",
                    RollCallId = e.Id
                }).ToList(),
                DayOfWeekFa = x.DateGr.DayOfWeek.DayOfWeeKToPersian(),
            };
        }).Where(x => x.RollCallWorkFlowPerDayViewModels.Count > 0).ToList();
        return result;
    }
    public List<DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel> GetRollCallsOverlappingLeaves(long workshopId, DateTime start, DateTime end)
    {
	    var rollCalls= _rollCallApplication.GetOverlappedRollCallsWithLeaveInDates(workshopId, start, end).Select(x =>
		    new WorkFlowEmployeeWithRollCallOnLeaveViewModel()
		    {
                EmployeeFullName = x.EmployeeFullName,
                EmployeeId = x.EmployeeId,
                RollCallId = x.RollCallId,
                EndOfOverlapDateFa = x.EndOfOverlapDateFa,
                EndOfOverlapTime = x.EndOfOverlapTime,
                LeaveId = x.LeaveId,
                StartOfOverlapDateFa = x.StartOfOverlapDateFa,
                StartOfOverlapTime = x.StartOfOverlapTime,
                EndOfOverlapDateTime = x.EndOfOverlapDateTime,
                StartOfOverlapDateTime = x.StartOfOverlapDateTime
		    }).GroupBy(x=>x.StartOfOverlapDateTime.Date).Select(x=> new DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel
			{
            DayOfWeek = x.Key.DayOfWeek.DayOfWeeKToPersian(),
            DateFa = x.Key.ToFarsi(),
            EmployeesList = x.ToList(),
            Date = x.Key
	    }).ToList();

	    return rollCalls;
    }
    public List<(long EmployeeId, string EmployeeName, DateTime startActive, DateTime endActive)> GetActiveWorkshopRollCallEmployees(long workshopId, DateTime start, DateTime end)
    {
        return _rollCallEmployeeStatusApplication.GetActiveByWorkshopIdInDate(workshopId, start, end).Select(x => (x.EmployeeId, x.EmployeeName, x.StartDateGr, x.EndDateGr))
            .ToList();
    }
    public int GetCountCutRollCallByBgService(long workshopId)
    {
        var now = DateTime.Now;

        DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);

        return GetRollCallWorkFlowsCutByBgService(workshopId, twoMonthsAgo, now).Count;
    }

    public int GetRollCallAbsentsWorkFlowsCount(long workshopId, DateTime durationEnd, DateTime durationStart)
    {
        return GetAbsentRollCallWorkFlows(workshopId, durationStart, durationEnd).Count;
    }

    public List<DailyRollCallWorkFlowViewModel> GetAbsentRollCallWorkFlows(long workshopId, DateTime durationStart, DateTime durationEnd)
    {
        return _rollCallApplication.GetWorkshopAbsentHistory(workshopId, durationStart, durationEnd).Select(x => new DailyRollCallWorkFlowViewModel()
        {
            IsHoliday = x.IsHoliday,
            DateTime = x.DateGr,
            DateTimeFa = x.DateFa,
            DayOfWeekFa = x.DayOfWeekFa,
            IsFriday = x.IsFriday,
            RollCallWorkFlowPerDayViewModels = x.ActiveEmployees.Select(a => new RollCallWorkFlowViewModel()
            {
                EmployeeId = a.EmployeeId,
                Message = "",
                EmployeeName = a.EmployeeFullName,
                WorkshopId = a.WorkshopId
            }).ToList()
        }).ToList();


    }

    public List<RollCallWorkFlowViewModel> GetNotSlicedRollCallsByWorkshopId(long workshopId, DateTime durationStart, DateTime durationEnd)
    {
        return _rollCallApplication.GetNotSlicedRollCallsByWorkshopId(workshopId, durationStart, durationEnd)
            .Select(x => new RollCallWorkFlowViewModel
            {
                EmployeeId = x.EmployeeId,
                EmployeeName = x.EmployeeFullName,
                RollCallDate = x.DateGr,
                RollCallId = x.Id
            }).ToList();
    }

    public RollCallWorkFlowViewModel GetDetails(long rollCallId)
    {
        var entity = _rollCallApplication.GetDetails(rollCallId);
        if (entity == null)
            return null;
        return new RollCallWorkFlowViewModel
        {
            EmployeeId = entity.EmployeeId,
            EmployeeName = entity.EmployeeFullName,
            RollCallId = rollCallId,
            RollCallDate = entity.DateGr.Date,
            WorkshopId = entity.WorkshopId
        };
    }
    public RollCallServiceViewModel GetActiveServiceByWorkshopId(long workshopId)
    {
        return _rollCallServiceApplication.GetActiveServiceByWorkshopId(workshopId);
    }

    public List<DailyRollCallWorkFlowViewModel> GetUndefinedRollCalls(long workshopId, DateTime durationStart, DateTime durationEnd)
    {
        var result = _rollCallApplication.GetUndefinedRollCallWorkFlowsService(workshopId, durationStart, durationEnd).Select(x =>
        {
            return new DailyRollCallWorkFlowViewModel()
            {
                DateTime = x.DateGr,
                DateTimeFa = x.DateFa,
                RollCallWorkFlowPerDayViewModels = x.ActiveEmployees.Select(e => new RollCallWorkFlowViewModel()
                {
                    EmployeeId = e.EmployeeId,
                    EmployeeName = e.EmployeeFullName,
                    //Message = $"{TimeOnly.FromDateTime(e.StartDate!.Value):HH:mm} الی {TimeOnly.FromDateTime(e.EndDate.Value):HH:mm}",
                    RollCallId = e.Id
                }).ToList(),
                DayOfWeekFa = x.DayOfWeekFa,
            };
        }).Where(x => x.RollCallWorkFlowPerDayViewModels.Count > 0).ToList();
        return result;
    }
}