workFlow capsolat and undifin bug fixed - sum of leave on client

WorkFlow/Application/WorkFlow.Application.Contracts/Shared/NotSlicedRollCallWorkFlowViewModel.cs

@@ -0,0 +1,10 @@
+#nullable disable
+namespace WorkFlow.Application.Contracts.Shared;
+
+public class NotSlicedRollCallWorkFlowViewModel
+{
+    public DateTime RollCallDate { get; set; }
+    public long EmployeeId { get; set; }
+    public string EmployeeName { get; set; }
+    public long RollCallId { get; set; }
+}

WorkFlow/Application/WorkFlow.Application.Contracts/Shared/RollCallWorkFlowTimesViewModel.cs

@@ -0,0 +1,8 @@
+#nullable disable
+namespace WorkFlow.Application.Contracts.Shared;
+
+public class RollCallWorkFlowTimesViewModel
+{
+    public string StartTimeAndEndTimeAsMessage { get; set; }
+    public long RollCallId { get; set; }
+}

WorkFlow/Application/WorkFlow.Application.Contracts/Shared/RollCallWorkFlowViewModel.cs

@@ -6,7 +6,7 @@ public class RollCallWorkFlowViewModel
     public long EmployeeId { get; set; }
     public string EmployeeName { get; set; }
     public long WorkshopId { get; set; }
-    public string Message { get; set; }
-    public long RollCallId { get; set; }
+    public List<RollCallWorkFlowTimesViewModel> TimesList { get; set; }
+
     public DateTime RollCallDate { get; set; }
-}
+}

WorkFlow/Application/WorkFlow.Application.Contracts/WorkFlow/IWorkFlowApplication.cs

@@ -7,32 +7,32 @@ namespace WorkFlow.Application.Contracts.WorkFlow;
 
 public interface IWorkFlowApplication
 {
-	Task<OperationResult> CreateRollCallConfirmedAbsence(CreateRollCallConfirmedAbsence command);
-	Task<OperationResult> CreateRollCallConfirmedWithoutLunchBreak(CreateRollCallConfirmedWithoutLunchBreak command);
+    Task<OperationResult> CreateRollCallConfirmedAbsence(CreateRollCallConfirmedAbsence command);
+    Task<OperationResult> CreateRollCallConfirmedWithoutLunchBreak(CreateRollCallConfirmedWithoutLunchBreak command);
 
 
-	Task<int> GetCountAllWorkFlows(long workshopId);
-	Task<int> GetRollCallAbsentsWorkFlows(long workshopId);
-	Task<int> GetCountCutRollCallByBgService(long workshopId);
-	Task<int> GetAllWorkFlowCount(long workshopId);
-	Task<int> GetAllWorkFlowCountAsync(long workshopId);
+    Task<int> GetCountAllWorkFlows(long workshopId);
+    Task<int> GetRollCallAbsentsWorkFlows(long workshopId);
+    Task<int> GetCountCutRollCallByBgService(long workshopId);
+    Task<int> GetAllWorkFlowCount(long workshopId);
+    Task<int> GetAllWorkFlowCountAsync(long workshopId);
 
-	Task<DailyRollCallWorkFlowViewModel> GetAbsentRollCallWorkFlowsByDate(long workshopId, DateTime date);
-	Task<DailyRollCallConfirmedWithoutLunchBreakViewModel> GetEmployeesWithoutLunchBreakByDate(long workshopId, DateTime date);
-	Task<DailyRollCallWorkFlowViewModel> GetRollCallWorkFlowsCutByBgServiceByDate(long workshopId, DateTime date);
-	Task<DailyRollCallWorkFlowViewModel> GetUndefinedRollCallsByDate(long workshopId, DateTime date);
+    Task<DailyRollCallWorkFlowViewModel> GetAbsentRollCallWorkFlowsByDate(long workshopId, DateTime date);
+    Task<DailyRollCallConfirmedWithoutLunchBreakViewModel> GetEmployeesWithoutLunchBreakByDate(long workshopId, DateTime date);
+    Task<DailyRollCallWorkFlowViewModel> GetRollCallWorkFlowsCutByBgServiceByDate(long workshopId, DateTime date);
+    Task<DailyRollCallWorkFlowViewModel> GetUndefinedRollCallsByDate(long workshopId, DateTime date);
 
-	Task<DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel> GetRollCallsOverlappingLeaveByDate(long workshopId,
-		DateTime date);
+    Task<DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel> GetRollCallsOverlappingLeaveByDate(long workshopId,
+	    DateTime date);
 
 	Task<List<RollCallConfirmAbsenceViewModel>> GetConfirmAbsencesBy(long workshopId, DateTime start, DateTime end);
 	Task<List<DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel>> GetRollCallsOverlappingLeaves(long workshopId);
 	Task<List<DailyRollCallWorkFlowViewModel>> GetRollCallWorkFlowsCutByBgService(long workshopId);
-	Task<List<DailyRollCallWorkFlowViewModel>> GetAbsentRollCallWorkFlows(long workshopId);
-	Task<List<DailyRollCallWorkFlowViewModel>> GetUndefinedRollCalls(long workshopId);
+    Task<List<DailyRollCallWorkFlowViewModel>> GetAbsentRollCallWorkFlows(long workshopId);
+    Task<List<DailyRollCallWorkFlowViewModel>> GetUndefinedRollCalls(long workshopId);
 
 
 
 	Task<List<DailyRollCallConfirmedWithoutLunchBreakViewModel>> GetEmployeesWithoutLunchBreak(long workshopId);
-	Task<List<(long Id, string Name)>> GetEmployeesWithoutGroup(long workshopId);
+    Task<List<(long Id, string Name)>> GetEmployeesWithoutGroup(long workshopId);
 }

WorkFlow/Application/WorkFlow.Application/WorkFlow.Application.csproj

@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\..\Company.Domain\Company.Domain.csproj" />
     <ProjectReference Include="..\..\Domain\WorkFlow.Domain\WorkFlow.Domain.csproj" />
     <ProjectReference Include="..\..\Infrastructure\WorkFlow.Infrastructure.ACL\WorkFlow.Infrastructure.ACL.csproj" />
 

WorkFlow/Application/WorkFlow.Application/WorkFlowApplication.cs

@@ -1,4 +1,6 @@
 using _0_Framework.Application;
+using _0_Framework.Domain.CustomizeCheckoutShared.Enums;
+using Company.Domain.RollCallAgg.DomainService;
 using WorkFlow.Application.Contracts.RollCallConfirmedAbsence;
 using WorkFlow.Application.Contracts.RollCallConfirmedWithoutLunchBreak;
 using WorkFlow.Application.Contracts.Shared;
@@ -17,15 +19,17 @@ public class WorkFlowApplication : IWorkFlowApplication
     private readonly IWorkFlowRollCallACL _rollCallACL;
     private readonly IWorkFlowCheckoutACL _checkoutACL;
     private readonly IWorkFlowCustomizedWorkshopSettingsACL _customizedWorkshopSettingsACL;
+    private readonly IRollCallDomainService _rollCallDomainService;
     private readonly IRollCallConfirmedWithoutLunchBreakRepository _rollCallConfirmedWithoutLunchBreakRepository;
 
-    public WorkFlowApplication(IRollCallConfirmedAbsenceRepository absenceRepository, IWorkFlowRollCallACL rollCallACL, IWorkFlowCheckoutACL checkoutACL, IWorkFlowCustomizedWorkshopSettingsACL customizedWorkshopSettingsACL, IRollCallConfirmedWithoutLunchBreakRepository rollCallConfirmedWithoutLunchBreakRepository)
+    public WorkFlowApplication(IRollCallConfirmedAbsenceRepository absenceRepository, IWorkFlowRollCallACL rollCallACL, IWorkFlowCheckoutACL checkoutACL, IWorkFlowCustomizedWorkshopSettingsACL customizedWorkshopSettingsACL, IRollCallConfirmedWithoutLunchBreakRepository rollCallConfirmedWithoutLunchBreakRepository, IRollCallDomainService rollCallDomainService)
     {
         _absenceRepository = absenceRepository;
         _rollCallACL = rollCallACL;
         _checkoutACL = checkoutACL;
         _customizedWorkshopSettingsACL = customizedWorkshopSettingsACL;
         _rollCallConfirmedWithoutLunchBreakRepository = rollCallConfirmedWithoutLunchBreakRepository;
+        _rollCallDomainService = rollCallDomainService;
     }
 
     public async Task<OperationResult> CreateRollCallConfirmedAbsence(CreateRollCallConfirmedAbsence command)
@@ -89,18 +93,22 @@ public class WorkFlowApplication : IWorkFlowApplication
         count += (await GetAbsentRollCallWorkFlows(workshopId))?.Count ?? 0;
         count += (await GetRollCallWorkFlowsCutByBgService(workshopId))?.Count ?? 0;
         count += (await GetEmployeesWithoutLunchBreak(workshopId))?.Count ?? 0;
-        //count += (await GetRollCallsOverlappingLeaves(workshopId))?.Count ?? 0;
+        count += (await GetRollCallsOverlappingLeaves(workshopId))?.Count ?? 0;
         count += (await GetUndefinedRollCalls(workshopId))?.Count ?? 0;
 
 
 		return count;
     }
-
     public Task<int> GetAllWorkFlowCountAsync(long workshopId)
     {
         return Task.FromResult(20);
     }
 
+    #region Methods For Ajax
+
+    /// <summary>
+    ///غیبت ها
+    /// </summary>
     public async Task<DailyRollCallWorkFlowViewModel> GetAbsentRollCallWorkFlowsByDate(long workshopId, DateTime date)
     {
 
@@ -135,7 +143,8 @@ public class WorkFlowApplication : IWorkFlowApplication
         var newItem = new DailyRollCallWorkFlowViewModel()
         {
             DateTime = date.Date,
-            DateTimeFa = date.ToFarsi()
+            DateTimeFa = date.ToFarsi(),
+            
         };
 
         //dont count absences before the last checkout
@@ -148,36 +157,40 @@ public class WorkFlowApplication : IWorkFlowApplication
         {
             newItem.RollCallWorkFlowPerDayViewModels = absencesWithoutCheckout
                 .Where(x => confirmedAbssences.All(y => x.EmployeeId != y.EmployeeId))
-                .Select(x => new RollCallWorkFlowViewModel()
-                {
-                    EmployeeId = x.EmployeeId,
-                    EmployeeName = x.EmployeeName,
-                    Message = "",
-                    RollCallDate = x.RollCallDate,
-                    RollCallId = x.RollCallId,
-                    WorkshopId = x.WorkshopId
-                }).ToList();
+                .ToList();
         }
         else
         {
-            newItem.RollCallWorkFlowPerDayViewModels = absencesWithoutCheckout.Select(x => new RollCallWorkFlowViewModel()
-            {
-                EmployeeId = x.EmployeeId,
-                EmployeeName = x.EmployeeName,
-                Message = "",
-                RollCallDate = x.RollCallDate,
-                RollCallId = x.RollCallId,
-                WorkshopId = x.WorkshopId
-
-            }).ToList();
+            newItem.RollCallWorkFlowPerDayViewModels = absencesWithoutCheckout.ToList();
 
         }
 
+
+
+        FilterWithOffset(workshopId, date,ref newItem);
+
         newItem.DayOfWeekFa = newItem.DateTime.DayOfWeek.DayOfWeeKToPersian();
 
 
         return newItem;
     }
+
+    private void FilterWithOffset(long workshopId, DateTime date,ref DailyRollCallWorkFlowViewModel dailyRollCall)
+    {
+	    if(date.Date == DateTime.Now.Date.AddDays(-1))
+	    {
+		    foreach (var item in dailyRollCall.RollCallWorkFlowPerDayViewModels.ToList())
+		    {
+			    var employeeOffset = _rollCallDomainService.GetEmployeeOffSetForRegularSettings(item.EmployeeId, workshopId);
+			    if (DateTime.Now < DateTime.Today + employeeOffset.ToTimeSpan())
+				    dailyRollCall.RollCallWorkFlowPerDayViewModels.Remove(item);
+		    }
+	    }
+    }
+
+    /// <summary>
+    /// بدون ثبت استراحت
+    /// </summary>
     public async Task<DailyRollCallConfirmedWithoutLunchBreakViewModel> GetEmployeesWithoutLunchBreakByDate(long workshopId, DateTime date)
     {
         var startOfDay = date.Date;
@@ -193,11 +206,12 @@ public class WorkFlowApplication : IWorkFlowApplication
             .Where(x => !lastCheckouts.Any(y => y.EmployeeId == x.EmployeeId && y.CheckoutStart.Date <= x.RollCallDate.Date &&
                                                 y.CheckoutEnd.Date >= x.RollCallDate.Date) && activeEmployees.Any(y => y.EmployeeId == x.EmployeeId)).ToList();
 
-        var employeeWithoutBreakTimeAndNotSliced = notSlicedRollCalls.Join(employeesWithoutBreakTime, x => x.EmployeeId, y => y.EmployeeId, (x, y) =>
-        new { y.EmployeeId, x.EmployeeName, x.RollCallId, x.RollCallDate }).ToList();
+        var employeeWithoutBreakTimeAndNotSliced = notSlicedRollCalls
+            .Join(employeesWithoutBreakTime, x => x.EmployeeId, y => y.EmployeeId, (x, y) =>
+        new { x.EmployeeId, x.EmployeeName, x.RollCallId, x.RollCallDate }).ToList();
 
 
-        var entites = _rollCallConfirmedWithoutLunchBreakRepository.GetByWorkshopId(workshopId, startOfDay, endOfDay).ToList();
+        var confirmed = _rollCallConfirmedWithoutLunchBreakRepository.GetByWorkshopId(workshopId, startOfDay, endOfDay).ToList();
 
         return new DailyRollCallConfirmedWithoutLunchBreakViewModel()
         {
@@ -205,15 +219,19 @@ public class WorkFlowApplication : IWorkFlowApplication
             DateGr = date.Date,
             DayOfWeekFa = date.DayOfWeek.DayOfWeeKToPersian(),
             RollCallConfirmedWithoutLunchList = employeeWithoutBreakTimeAndNotSliced
-            .Where(x => entites.All(y => y.RollCallId != x.RollCallId)).Select(y => new RollCallConfirmedWithoutLunchBreakViewModel
-            {
-                EmployeeId = y.EmployeeId,
-                EmployeeName = y.EmployeeName,
-                RollCallId = y.RollCallId
-            }).ToList()
+                .Where(x => confirmed.All(y => y.RollCallId != x.RollCallId)).Select(y => new RollCallConfirmedWithoutLunchBreakViewModel
+                {
+                    EmployeeId = y.EmployeeId,
+                    EmployeeName = y.EmployeeName,
+                    RollCallId = y.RollCallId
+                }).ToList()
         };
 
     }
+
+    /// <summary>
+    /// قطع شده توسط سیستم
+    /// </summary>
     public async Task<DailyRollCallWorkFlowViewModel> GetRollCallWorkFlowsCutByBgServiceByDate(long workshopId, DateTime date)
     {
         var startOfDay = date.Date;
@@ -235,296 +253,300 @@ public class WorkFlowApplication : IWorkFlowApplication
             RollCallWorkFlowPerDayViewModels = rollCallsForDate.RollCallWorkFlowPerDayViewModels
             .Where(y => !lastCheckouts.Any(z => z.EmployeeId == y.EmployeeId && z.CheckoutStart.Date <= rollCallsForDate.DateTime.Date &&
                                                 z.CheckoutEnd.Date >= rollCallsForDate.DateTime.Date) && activeEmployees.Any(z => y.EmployeeId == z.EmployeeId))
-            .Select(e => new RollCallWorkFlowViewModel()
-            {
-                EmployeeId = e.EmployeeId,
-                EmployeeName = e.EmployeeName,
-                Message = e.Message,
-                RollCallId = e.RollCallId
-            }).ToList(),
+            .ToList(),
             DayOfWeekFa = date.DayOfWeek.DayOfWeeKToPersian()
         };
         return result;
     }
+
+
+    /// <summary>
+    /// تعیین وضعیت تردد پرسنل
+    /// </summary>
     public async Task<DailyRollCallWorkFlowViewModel> GetUndefinedRollCallsByDate(long workshopId, DateTime date)
     {
-	    var startOfDay = date.Date;
-	    var endOfDay = startOfDay.AddDays(1).Date.AddTicks(-1);
+        var startOfDay = date.Date;
+        var endOfDay = startOfDay.AddDays(1).Date.AddTicks(-1);
 
-	    startOfDay.AddMonthsFa(-2, out var twoMonthsAgo);
+        startOfDay.AddMonthsFa(-2, out var twoMonthsAgo);
 
-	    var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, DateTime.Now.Date);
-	    var rollCalls = _rollCallACL.GetUndefinedRollCalls(workshopId, startOfDay, endOfDay);
-	    var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, startOfDay, endOfDay);
+        var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, DateTime.Now.Date);
+        var rollCalls = _rollCallACL.GetUndefinedRollCalls(workshopId, startOfDay, endOfDay);
+        var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, startOfDay, endOfDay);
 
-	    var rollCallsForDate = rollCalls.FirstOrDefault();
-	    if (rollCallsForDate == null)
-		    return new();
-	    var result = new DailyRollCallWorkFlowViewModel()
-	    {
-		    DateTime = date.Date,
-		    DateTimeFa = date.ToFarsi(),
-		    RollCallWorkFlowPerDayViewModels = rollCallsForDate.RollCallWorkFlowPerDayViewModels
-			    .Where(y => !lastCheckouts.Any(z => z.EmployeeId == y.EmployeeId && z.CheckoutStart.Date <= rollCallsForDate.DateTime.Date &&
-			                                        z.CheckoutEnd.Date >= rollCallsForDate.DateTime.Date) && activeEmployees.Any(z => y.EmployeeId == z.EmployeeId))
-			    .Select(e => new RollCallWorkFlowViewModel()
-			    {
-				    EmployeeId = e.EmployeeId,
-				    EmployeeName = e.EmployeeName,
-				    Message = e.Message,
-				    RollCallId = e.RollCallId
-			    }).ToList(),
-		    DayOfWeekFa = date.DayOfWeek.DayOfWeeKToPersian()
-	    };
-	    return result;
+        var rollCallsForDate = rollCalls.FirstOrDefault();
+        if (rollCallsForDate == null)
+            return new();
+        var result = new DailyRollCallWorkFlowViewModel()
+        {
+            DateTime = date.Date,
+            DateTimeFa = date.ToFarsi(),
+            RollCallWorkFlowPerDayViewModels = rollCallsForDate.RollCallWorkFlowPerDayViewModels
+                .Where(y => !lastCheckouts.Any(z => z.EmployeeId == y.EmployeeId && z.CheckoutStart.Date <= rollCallsForDate.DateTime.Date &&
+                                                    z.CheckoutEnd.Date >= rollCallsForDate.DateTime.Date) && activeEmployees.Any(z => y.EmployeeId == z.EmployeeId))
+                .ToList(),
+            DayOfWeekFa = date.DayOfWeek.DayOfWeeKToPersian()
+        };
+        return result;
     }
 
-
-    public async Task<DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel> GetRollCallsOverlappingLeaveByDate(long workshopId,
-	    DateTime date)
+    /// <summary>
+    /// تداخل مرخصی و حضور
+    /// </summary>
+    public async Task<DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel> GetRollCallsOverlappingLeaveByDate(long workshopId, DateTime date)
     {
-	    var startOfDay = date.Date;
-	    var endOfDay = startOfDay.AddDays(1).Date.AddTicks(-1);
+        var startOfDay = date.Date;
+        var endOfDay = startOfDay.AddDays(1).Date.AddTicks(-1);
 
-	    startOfDay.AddMonthsFa(-2, out var twoMonthsAgo);
+        startOfDay.AddMonthsFa(-2, out var twoMonthsAgo);
 
-	    var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, DateTime.Now.Date);
-	    var rollCalls = _rollCallACL.GetRollCallsOverlappingLeaves(workshopId, startOfDay, endOfDay);
-	    var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, startOfDay, endOfDay);
+        var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, DateTime.Now.Date);
+        var rollCalls = _rollCallACL.GetRollCallsOverlappingLeaves(workshopId, startOfDay, endOfDay);
+        var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, startOfDay, endOfDay);
 
-	    var rollCallsForDate = rollCalls.FirstOrDefault(x => x.Date == date);
-	    if (rollCallsForDate == null)
-		    return new();
+        var rollCallsForDate = rollCalls.FirstOrDefault(x => x.Date == date);
+        if (rollCallsForDate == null)
+            return new();
 
-	    var result = new DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel()
-	    {
-		    Date = date.Date,
-		    DateFa = date.ToFarsi(),
-		    EmployeesList = rollCallsForDate. EmployeesList
-			    .Where(y => !lastCheckouts.Any(z => z.EmployeeId == y.EmployeeId &&
-			                                        z.CheckoutStart.Date <= rollCallsForDate.Date.Date &&
-			                                        z.CheckoutEnd.Date >= rollCallsForDate.Date.Date) && activeEmployees.Any(z => y.EmployeeId == z.EmployeeId))
-			    .Select(e => new WorkFlowEmployeeWithRollCallOnLeaveViewModel()
-			    {
-				    EmployeeId = e.EmployeeId,
-				    EmployeeFullName = e.EmployeeFullName,
-				   LeaveId = e.LeaveId,
-                   EndOfOverlapTime = e.EndOfOverlapTime,
-                   StartOfOverlapTime = e.StartOfOverlapTime,
-                   RollCallId = e.RollCallId,
-                   EndOfOverlapDateFa = e.EndOfOverlapDateFa,
-                   EndOfOverlapDateTime = e.EndOfOverlapDateTime,
-                   StartOfOverlapDateFa = e.StartOfOverlapDateFa,
-                   StartOfOverlapDateTime = e.StartOfOverlapDateTime
-			    }).ToList(),
-		    DayOfWeek = date.DayOfWeek.DayOfWeeKToPersian()
-	    };
-	    return result;
-	}
-	public async Task<List<DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel>> GetRollCallsOverlappingLeaves(long workshopId)
-    {
-		var now = DateTime.Now;
-		DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);
-		var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, now);
-		var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, twoMonthsAgo, now);
-		var rollCalls = _rollCallACL.GetRollCallsOverlappingLeaves(workshopId, twoMonthsAgo, now);
-		return rollCalls
-			.Select(x => new DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel()
-			{
-				Date = x.Date,
-				DateFa = x.DateFa,
-				EmployeesList = x.EmployeesList
-					.Where(y => !lastCheckouts.Any(z => z.EmployeeId == y.EmployeeId &&
-					                                    z.CheckoutStart.Date <= x.Date.Date &&
-					                                    z.CheckoutEnd.Date >= x.Date.Date) && activeEmployees.Any(z => y.EmployeeId == z.EmployeeId))
-					.Select(e => new WorkFlowEmployeeWithRollCallOnLeaveViewModel()
-					{
-						EmployeeId = e.EmployeeId,
-						EmployeeFullName = e.EmployeeFullName,
-						LeaveId = e.LeaveId,
-						EndOfOverlapTime = e.EndOfOverlapTime,
-						StartOfOverlapTime = e.StartOfOverlapTime,
-						RollCallId = e.RollCallId,
-						EndOfOverlapDateFa = e.EndOfOverlapDateFa,
-						EndOfOverlapDateTime = e.EndOfOverlapDateTime,
-						StartOfOverlapDateFa = e.StartOfOverlapDateFa,
-						StartOfOverlapDateTime = e.StartOfOverlapDateTime
-					}).ToList(),
-				DayOfWeek = x.DayOfWeek
-			})
-			.Where(y => y.EmployeesList != null && y.EmployeesList.Any())
-			.OrderBy(x => x.Date).ToList();
+        var result = new DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel()
+        {
+            Date = date.Date,
+            DateFa = date.ToFarsi(),
+            EmployeesList = rollCallsForDate.EmployeesList
+                .Where(y => !lastCheckouts.Any(z => z.EmployeeId == y.EmployeeId &&
+                                                    z.CheckoutStart.Date <= rollCallsForDate.Date.Date &&
+                                                    z.CheckoutEnd.Date >= rollCallsForDate.Date.Date) && activeEmployees.Any(z => y.EmployeeId == z.EmployeeId))
+                .Select(e => new WorkFlowEmployeeWithRollCallOnLeaveViewModel()
+                {
+                    EmployeeId = e.EmployeeId,
+                    EmployeeFullName = e.EmployeeFullName,
+                    LeaveId = e.LeaveId,
+                    EndOfOverlapTime = e.EndOfOverlapTime,
+                    StartOfOverlapTime = e.StartOfOverlapTime,
+                    RollCallId = e.RollCallId,
+                    EndOfOverlapDateFa = e.EndOfOverlapDateFa,
+                    EndOfOverlapDateTime = e.EndOfOverlapDateTime,
+                    StartOfOverlapDateFa = e.StartOfOverlapDateFa,
+                    StartOfOverlapDateTime = e.StartOfOverlapDateTime
+                }).ToList(),
+            DayOfWeek = date.DayOfWeek.DayOfWeeKToPersian()
+        };
+        return result;
+    }
 
+    #endregion
 
-	}
-
-
-	public async Task<List<RollCallConfirmAbsenceViewModel>> GetConfirmAbsencesBy(long workshopId, DateTime start, DateTime end)
+    public async Task<List<RollCallConfirmAbsenceViewModel>> GetConfirmAbsencesBy(long workshopId, DateTime start, DateTime end)
     {
         return _absenceRepository.GetConfirmAbsencesBy(workshopId, start, end);
     }
 
-    public async Task<List<DailyRollCallWorkFlowViewModel>> GetUndefinedRollCalls(long workshopId)
-    {
-        var now = DateTime.Now;
 
-        DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);
 
-        var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, now);
-        List<DailyRollCallWorkFlowViewModel> rollCalls = _rollCallACL.GetUndefinedRollCalls(workshopId, twoMonthsAgo, now.AddDays(-1).Date);
-        var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, twoMonthsAgo, now);
-        return rollCalls.Select(x => new DailyRollCallWorkFlowViewModel()
+
+    #region Methods For OnGet
+
+
+        /// <summary>
+        /// لیست تداخل مرخصی و حضور
+        /// </summary>
+        public async Task<List<DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel>> GetRollCallsOverlappingLeaves(long workshopId)
         {
-            DateTime = x.DateTime,
-            DateTimeFa = x.DateTimeFa,
-            RollCallWorkFlowPerDayViewModels = x.RollCallWorkFlowPerDayViewModels
-    .Where(y => 
-        !lastCheckouts.Any(z => z.EmployeeId == y.EmployeeId && z.CheckoutStart.Date <= x.DateTime.Date && 
-                                z.CheckoutEnd.Date >= x.DateTime.Date) &&
-        activeEmployees.Any(z => z.EmployeeId == y.EmployeeId && x.DateTime.Date >= z.startActive &&
-        x.DateTime.Date <= z.endActive))
-    .Select(e => new RollCallWorkFlowViewModel()
-    {
-        EmployeeId = e.EmployeeId,
-        EmployeeName = e.EmployeeName,
-        Message = e.Message,
-        RollCallId = e.RollCallId
-    }).ToList(),
-            DayOfWeekFa = x.DateTime.DayOfWeek.DayOfWeeKToPersian()
-        }).Where(y => y.RollCallWorkFlowPerDayViewModels != null && y.RollCallWorkFlowPerDayViewModels.Any()).OrderBy(x => x.DateTime).ToList();
-    }
-
-    public async Task<List<DailyRollCallWorkFlowViewModel>> GetRollCallWorkFlowsCutByBgService(long workshopId)
-    {
-        var now = DateTime.Now;
-
-        DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);
-
-        var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, now);
-        var rollCalls = _rollCallACL.GetRollCallWorkFlowsCutByBgService(workshopId, twoMonthsAgo, now.AddDays(-1).Date);
-        var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, twoMonthsAgo, now);
-        return rollCalls.Select(x => new DailyRollCallWorkFlowViewModel()
-        {
-            DateTime = x.DateTime,
-            DateTimeFa = x.DateTimeFa,
-            RollCallWorkFlowPerDayViewModels = x.RollCallWorkFlowPerDayViewModels
-            .Where(y => !lastCheckouts.Any(z => z.EmployeeId == y.EmployeeId && z.CheckoutStart.Date <= x.DateTime.Date &&
-                                                z.CheckoutEnd.Date >= x.DateTime.Date) && activeEmployees.Any(z => z.EmployeeId == y.EmployeeId && x.DateTime.Date >= z.startActive &&
-                x.DateTime.Date <= z.endActive))
-            .Select(e => new RollCallWorkFlowViewModel()
-            {
-                EmployeeId = e.EmployeeId,
-                EmployeeName = e.EmployeeName,
-                Message = e.Message,
-                RollCallId = e.RollCallId
-            }).ToList(),
-            DayOfWeekFa = x.DateTime.DayOfWeek.DayOfWeeKToPersian()
-        }).Where(y => y.RollCallWorkFlowPerDayViewModels != null && y.RollCallWorkFlowPerDayViewModels.Any())
-        .OrderBy(x => x.DateTime).ToList();
-    }
-    public async Task<List<DailyRollCallWorkFlowViewModel>> GetAbsentRollCallWorkFlows(long workshopId)
-    {
-
-        var now = DateTime.Now;
-
-        DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);
-
-
-        var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, now);
-
-        var absences = _rollCallACL.GetAbsentRollCallWorkFlows(workshopId, twoMonthsAgo, now.AddDays(-1).Date);
-        var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, twoMonthsAgo, now);
-
-        var confirmedAbssences = await GetConfirmAbsencesBy(workshopId, twoMonthsAgo,
-            now);
-
-
-        var groupedConfirmedAbssencesByDate = confirmedAbssences.GroupBy(x => x.AbsenceDate.Date).ToList();
-
-        List<DailyRollCallWorkFlowViewModel> result = new();
-
-        //iterating day by day in absences
-        foreach (var item in absences)
-        {
-
-            var allAbsencesInDate = item.RollCallWorkFlowPerDayViewModels;
-            var confirmedAbssencesInDate = groupedConfirmedAbssencesByDate.FirstOrDefault(x => x.Key == item.DateTime.Date);
-            //set the date of new item
-            var newItem = new DailyRollCallWorkFlowViewModel()
-            {
-                DateTime = item.DateTime,
-                DateTimeFa = item.DateTime.ToFarsi()
-            };
-
-            //dont count absences before the last checkout
-            allAbsencesInDate = allAbsencesInDate.Where(x => !lastCheckouts.Any(y =>
-                x.EmployeeId == y.EmployeeId && y.CheckoutStart <= item.DateTime.Date && y.CheckoutEnd >= item.DateTime.Date) && activeEmployees.Any(y =>
-                item.DateTime.Date >= y.startActive && item.DateTime.Date <= y.endActive)).ToList();
-
-
-            if (confirmedAbssencesInDate != null)
-            {
-                newItem.RollCallWorkFlowPerDayViewModels = allAbsencesInDate
-                    .Where(x => confirmedAbssencesInDate.All(y => x.EmployeeId != y.EmployeeId))
-                    .Select(x => new RollCallWorkFlowViewModel()
-                    {
-                        EmployeeId = x.EmployeeId,
-                        EmployeeName = x.EmployeeName,
-                        Message = ""
-                    }).ToList();
-            }
-            else
-            {
-                newItem.RollCallWorkFlowPerDayViewModels = allAbsencesInDate.Select(x => new RollCallWorkFlowViewModel()
+            var now = DateTime.Now;
+            DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);
+            var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, now);
+            var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, twoMonthsAgo, now);
+            var rollCalls = _rollCallACL.GetRollCallsOverlappingLeaves(workshopId, twoMonthsAgo, now);
+            return rollCalls
+                .Select(x => new DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel()
                 {
-                    EmployeeId = x.EmployeeId,
-                    EmployeeName = x.EmployeeName,
-                    Message = ""
-                }).ToList();
+                    Date = x.Date,
+                    DateFa = x.DateFa,
+                    EmployeesList = x.EmployeesList
+                        .Where(y => !lastCheckouts.Any(z => z.EmployeeId == y.EmployeeId &&
+                                                            z.CheckoutStart.Date <= x.Date.Date &&
+                                                            z.CheckoutEnd.Date >= x.Date.Date) && activeEmployees.Any(z => y.EmployeeId == z.EmployeeId))
+                        .Select(e => new WorkFlowEmployeeWithRollCallOnLeaveViewModel()
+                        {
+                            EmployeeId = e.EmployeeId,
+                            EmployeeFullName = e.EmployeeFullName,
+                            LeaveId = e.LeaveId,
+                            EndOfOverlapTime = e.EndOfOverlapTime,
+                            StartOfOverlapTime = e.StartOfOverlapTime,
+                            RollCallId = e.RollCallId,
+                            EndOfOverlapDateFa = e.EndOfOverlapDateFa,
+                            EndOfOverlapDateTime = e.EndOfOverlapDateTime,
+                            StartOfOverlapDateFa = e.StartOfOverlapDateFa,
+                            StartOfOverlapDateTime = e.StartOfOverlapDateTime
+                        }).ToList(),
+                    DayOfWeek = x.DayOfWeek
+                })
+                .Where(y => y.EmployeesList != null && y.EmployeesList.Any())
+                .OrderBy(x => x.Date).ToList();
 
-            }
-
-            newItem.DayOfWeekFa = newItem.DateTime.DayOfWeek.DayOfWeeKToPersian();
-            if (newItem.RollCallWorkFlowPerDayViewModels.Count > 0)
-                result.Add(newItem);
 
         }
-        return result.OrderBy(x => x.DateTime).ToList();
-    }
-    public async Task<List<DailyRollCallConfirmedWithoutLunchBreakViewModel>> GetEmployeesWithoutLunchBreak(long workshopId)
-    {
-        var now = DateTime.Now.Date;
 
-        now.AddMonthsFa(-2, out var twoMonthsAgo);
+        /// <summary>
+        /// لیست وضعیت تردد پرسنل
+        /// </summary>
+        public async Task<List<DailyRollCallWorkFlowViewModel>> GetUndefinedRollCalls(long workshopId)
+        {
+            var now = DateTime.Now;
 
-        var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, now);
-        var notSlicedRollCalls = _rollCallACL.GetNotSlicedRollCallsByWorkshopId(workshopId, twoMonthsAgo, now.AddDays(-1).Date);
-        var employeesWithoutBreakTime = _customizedWorkshopSettingsACL.GetEmployeesWithoutBreakTime(workshopId);
+            DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);
 
-        notSlicedRollCalls = notSlicedRollCalls
-            .Where(x => !lastCheckouts.Any(y => y.EmployeeId == x.EmployeeId && y.CheckoutStart.Date <= x.RollCallDate.Date && y.CheckoutEnd.Date >= x.RollCallDate.Date)).ToList();
-
-        var employeeWithoutBreakTimeAndNotSliced = notSlicedRollCalls.Join(employeesWithoutBreakTime, x => x.EmployeeId, y => y.EmployeeId, (x, y) =>
-        new { y.EmployeeId, x.EmployeeName, x.RollCallId, x.RollCallDate }).ToList();
-
-
-        var entites = _rollCallConfirmedWithoutLunchBreakRepository.GetByWorkshopId(workshopId, twoMonthsAgo, now).ToList();
-
-        return employeeWithoutBreakTimeAndNotSliced.Where(x => !entites.Any(y => y.RollCallId == x.RollCallId))
-            .GroupBy(x => x.RollCallDate.Date).OrderBy(x => x.Key).Select(x => new DailyRollCallConfirmedWithoutLunchBreakViewModel
+            var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, now);
+            List<DailyRollCallWorkFlowViewModel> rollCalls = _rollCallACL.GetUndefinedRollCalls(workshopId, twoMonthsAgo, now.AddDays(-1).Date);
+            var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, twoMonthsAgo, now);
+            return rollCalls.Select(x => new DailyRollCallWorkFlowViewModel()
             {
-                DateGr = x.Key.Date,
-                DateFa = x.Key.Date.ToFarsi(),
-                DayOfWeekFa = x.Key.DayOfWeek.DayOfWeeKToPersian(),
-                RollCallConfirmedWithoutLunchList = x.Select(y => new RollCallConfirmedWithoutLunchBreakViewModel
-                {
-                    EmployeeId = y.EmployeeId,
-                    EmployeeName = y.EmployeeName,
-                    RollCallId = y.RollCallId
-                }).ToList()
-            }).ToList();
+                DateTime = x.DateTime,
+                DateTimeFa = x.DateTimeFa,
+                RollCallWorkFlowPerDayViewModels = x.RollCallWorkFlowPerDayViewModels
+        .Where(y =>
+            !lastCheckouts.Any(z => z.EmployeeId == y.EmployeeId && z.CheckoutStart.Date <= x.DateTime.Date &&
+                                    z.CheckoutEnd.Date >= x.DateTime.Date) &&
+            activeEmployees.Any(z => z.EmployeeId == y.EmployeeId && x.DateTime.Date >= z.startActive &&
+            x.DateTime.Date <= z.endActive))
+        .ToList(),
+                DayOfWeekFa = x.DateTime.DayOfWeek.DayOfWeeKToPersian()
+            }).Where(y => y.RollCallWorkFlowPerDayViewModels != null && y.RollCallWorkFlowPerDayViewModels.Any()).OrderBy(x => x.DateTime).ToList();
+        }
+
+        /// <summary>
+        /// لیست قطع شده توسط سیستم
+        /// </summary>
+        public async Task<List<DailyRollCallWorkFlowViewModel>> GetRollCallWorkFlowsCutByBgService(long workshopId)
+        {
+            var now = DateTime.Now;
+
+            DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);
+
+            var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, now);
+            var rollCalls = _rollCallACL.GetRollCallWorkFlowsCutByBgService(workshopId, twoMonthsAgo, now.AddDays(-1).Date);
+            var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, twoMonthsAgo, now);
+            return rollCalls.Select(x => new DailyRollCallWorkFlowViewModel()
+            {
+                DateTime = x.DateTime,
+                DateTimeFa = x.DateTimeFa,
+                RollCallWorkFlowPerDayViewModels = x.RollCallWorkFlowPerDayViewModels
+                .Where(y => !lastCheckouts.Any(z => z.EmployeeId == y.EmployeeId && z.CheckoutStart.Date <= x.DateTime.Date &&
+                                                    z.CheckoutEnd.Date >= x.DateTime.Date) && activeEmployees.Any(z => z.EmployeeId == y.EmployeeId && x.DateTime.Date >= z.startActive &&
+                    x.DateTime.Date <= z.endActive))
+                .ToList(),
+                DayOfWeekFa = x.DateTime.DayOfWeek.DayOfWeeKToPersian()
+            }).Where(y => y.RollCallWorkFlowPerDayViewModels != null && y.RollCallWorkFlowPerDayViewModels.Any())
+            .OrderBy(x => x.DateTime).ToList();
+        }
+
+        /// <summary>
+        /// لیست غیبت ها
+        /// </summary>
+        public async Task<List<DailyRollCallWorkFlowViewModel>> GetAbsentRollCallWorkFlows(long workshopId)
+        {
+
+            var now = DateTime.Now;
+
+            DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);
+
+
+            var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, now);
+
+            var absences = _rollCallACL.GetAbsentRollCallWorkFlows(workshopId, twoMonthsAgo, now.AddDays(-1).Date);
+            var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, twoMonthsAgo, now);
+
+            var confirmedAbssences = await GetConfirmAbsencesBy(workshopId, twoMonthsAgo,
+                now);
+
+
+            var groupedConfirmedAbssencesByDate = confirmedAbssences.GroupBy(x => x.AbsenceDate.Date).ToList();
+
+            List<DailyRollCallWorkFlowViewModel> result = new();
+
+            //iterating day by day in absences
+            foreach (var item in absences)
+            {
+
+                var allAbsencesInDate = item.RollCallWorkFlowPerDayViewModels;
+                var confirmedAbssencesInDate = groupedConfirmedAbssencesByDate.FirstOrDefault(x => x.Key == item.DateTime.Date);
+                //set the date of new item
+                var newItem = new DailyRollCallWorkFlowViewModel()
+                {
+                    DateTime = item.DateTime,
+                    DateTimeFa = item.DateTime.ToFarsi()
+                };
+
+                //dont count absences before the last checkout
+                allAbsencesInDate = allAbsencesInDate.Where(x => !lastCheckouts.Any(y =>
+                    x.EmployeeId == y.EmployeeId && y.CheckoutStart <= item.DateTime.Date && y.CheckoutEnd >= item.DateTime.Date) && activeEmployees.Any(y =>
+                    item.DateTime.Date >= y.startActive && item.DateTime.Date <= y.endActive)).ToList();
+
+
+                if (confirmedAbssencesInDate != null)
+                {
+                    newItem.RollCallWorkFlowPerDayViewModels = allAbsencesInDate
+                        .Where(x => confirmedAbssencesInDate.All(y => x.EmployeeId != y.EmployeeId))
+                        .ToList();
+                }
+                else
+                {
+                    newItem.RollCallWorkFlowPerDayViewModels = allAbsencesInDate.ToList();
+
+                }
+
+                newItem.DayOfWeekFa = newItem.DateTime.DayOfWeek.DayOfWeeKToPersian();
+                FilterWithOffset(workshopId,item.DateTime,ref newItem);
+                if (newItem.RollCallWorkFlowPerDayViewModels.Count > 0)
+                    result.Add(newItem);
+
+            }
+            return result.OrderBy(x => x.DateTime).ToList();
+        }
+
+        /// <summary>
+        /// لیست بدون ثبت استرحت
+        /// </summary>
+        public async Task<List<DailyRollCallConfirmedWithoutLunchBreakViewModel>> GetEmployeesWithoutLunchBreak(long workshopId)
+        {
+            var now = DateTime.Now.Date;
+
+            now.AddMonthsFa(-2, out var twoMonthsAgo);
+
+            var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, now);
+            var notSlicedRollCalls = _rollCallACL.GetNotSlicedRollCallsByWorkshopId(workshopId, twoMonthsAgo, now.AddDays(-1).Date);
+            var employeesWithoutBreakTime = _customizedWorkshopSettingsACL.GetEmployeesWithoutBreakTime(workshopId);
+
+            notSlicedRollCalls = notSlicedRollCalls
+                .Where(x => !lastCheckouts.Any(y => y.EmployeeId == x.EmployeeId && y.CheckoutStart.Date <= x.RollCallDate.Date && y.CheckoutEnd.Date >= x.RollCallDate.Date)).ToList();
+
+            var employeeWithoutBreakTimeAndNotSliced = notSlicedRollCalls
+                .Join(employeesWithoutBreakTime, x => x.EmployeeId, 
+                    y => y.EmployeeId, (x, y) => 
+                        new { y.EmployeeId, x.EmployeeName, x.RollCallId, x.RollCallDate }).ToList();
+
+
+            var entites = _rollCallConfirmedWithoutLunchBreakRepository.GetByWorkshopId(workshopId, twoMonthsAgo, now).ToList();
+
+            return employeeWithoutBreakTimeAndNotSliced.Where(x => !entites.Any(y => y.RollCallId == x.RollCallId))
+                .GroupBy(x => x.RollCallDate.Date).OrderBy(x => x.Key).Select(x => new DailyRollCallConfirmedWithoutLunchBreakViewModel
+                {
+                    DateGr = x.Key.Date,
+                    DateFa = x.Key.Date.ToFarsi(),
+                    DayOfWeekFa = x.Key.DayOfWeek.DayOfWeeKToPersian(),
+                    RollCallConfirmedWithoutLunchList = x.Select(y => new RollCallConfirmedWithoutLunchBreakViewModel
+                    {
+                        EmployeeId = y.EmployeeId,
+                        EmployeeName = y.EmployeeName,
+                        RollCallId = y.RollCallId,
+                    }).ToList()
+                }).ToList();
+
+        }
+
+    #endregion
+
 
-    }
     public async Task<List<(long Id, string Name)>> GetEmployeesWithoutGroup(long workshopId)
     {
         return _customizedWorkshopSettingsACL.GetEmployeesWithoutGroup(workshopId);

WorkFlow/Infrastructure/WorkFlow.Infrastructure.ACL/RollCall/IWorkFlowRollCallACL.cs

@@ -24,7 +24,8 @@ public interface IWorkFlowRollCallACL
 	/// <returns></returns>
 	int GetCountCutRollCallByBgService(long workshopId);
 
-    List<RollCallWorkFlowViewModel> GetNotSlicedRollCallsByWorkshopId(long workshopId, DateTime durationStart, DateTime durationEnd);
+    List<NotSlicedRollCallWorkFlowViewModel> GetNotSlicedRollCallsByWorkshopId(long workshopId, DateTime durationStart,
+        DateTime durationEnd);
     int GetRollCallAbsentsWorkFlowsCount(long workshopId, DateTime durationEnd, DateTime durationStart);
     List<(long EmployeeId, string EmployeeName, DateTime startActive, DateTime endActive)> GetActiveWorkshopRollCallEmployees(long workshopId, DateTime start, DateTime end);
     List<DailyRollCallWorkFlowViewModel> GetAbsentRollCallWorkFlows(long workshopId, DateTime durationStart, DateTime durationEnd);

WorkFlow/Infrastructure/WorkFlow.Infrastructure.ACL/RollCall/WorkFlowRollCallACL.cs

@@ -1,4 +1,5 @@
 using _0_Framework.Application;
+using _0_Framework.Domain.CustomizeCheckoutShared.Enums;
 using CompanyManagment.App.Contracts.RollCall;
 using CompanyManagment.App.Contracts.RollCallEmployeeStatus;
 using CompanyManagment.App.Contracts.RollCallService;
@@ -19,57 +20,6 @@ public class WorkFlowRollCallACL : IWorkFlowRollCallACL
     }
 
 
-
-    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;
@@ -83,7 +33,59 @@ public class WorkFlowRollCallACL : IWorkFlowRollCallACL
     {
         return GetAbsentRollCallWorkFlows(workshopId, durationStart, durationEnd).Count;
     }
+    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 List<DailyRollCallWorkFlowViewModel> GetRollCallWorkFlowsCutByBgService(long workshopId, DateTime start, DateTime end)
+    {
+        return _rollCallApplication.GetRollCallWorkFlowsCutByBgService(workshopId, start, end).Select(x =>
+        {
+            return new DailyRollCallWorkFlowViewModel()
+            {
+                DateTime = x.DateGr,
+                DateTimeFa = x.DateFa,
+                RollCallWorkFlowPerDayViewModels = x.ActiveEmployees.GroupBy(y=>y.EmployeeId).Select(e => new RollCallWorkFlowViewModel()
+                {
+                    EmployeeId = e.Key,
+                    EmployeeName = e.First().EmployeeFullName,
+                    TimesList = e.Select(y=>new RollCallWorkFlowTimesViewModel()
+                    {
+                        RollCallId = y.Id,
+                        StartTimeAndEndTimeAsMessage = $"{TimeOnly.FromDateTime(y.StartDate!.Value):HH:mm} الی {TimeOnly.FromDateTime(y.EndDate.Value):HH:mm}"
+                    }).ToList(),
+                }).ToList(),
+                DayOfWeekFa = x.DateGr.DayOfWeek.DayOfWeeKToPersian(),
+            };
+        }).Where(x => x.RollCallWorkFlowPerDayViewModels.Count > 0).ToList();
+    }
+    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<DailyRollCallWorkFlowViewModel> GetAbsentRollCallWorkFlows(long workshopId, DateTime durationStart, DateTime durationEnd)
     {
         return _rollCallApplication.GetWorkshopAbsentHistory(workshopId, durationStart, durationEnd).Select(x => new DailyRollCallWorkFlowViewModel()
@@ -96,7 +98,6 @@ public class WorkFlowRollCallACL : IWorkFlowRollCallACL
             RollCallWorkFlowPerDayViewModels = x.ActiveEmployees.Select(a => new RollCallWorkFlowViewModel()
             {
                 EmployeeId = a.EmployeeId,
-                Message = "",
                 EmployeeName = a.EmployeeFullName,
                 WorkshopId = a.WorkshopId
             }).ToList()
@@ -104,11 +105,10 @@ public class WorkFlowRollCallACL : IWorkFlowRollCallACL
 
 
     }
-
-    public List<RollCallWorkFlowViewModel> GetNotSlicedRollCallsByWorkshopId(long workshopId, DateTime durationStart, DateTime durationEnd)
+    public List<NotSlicedRollCallWorkFlowViewModel> GetNotSlicedRollCallsByWorkshopId(long workshopId, DateTime durationStart, DateTime durationEnd)
     {
         return _rollCallApplication.GetNotSlicedRollCallsByWorkshopId(workshopId, durationStart, durationEnd)
-            .Select(x => new RollCallWorkFlowViewModel
+            .Select(x => new NotSlicedRollCallWorkFlowViewModel()
             {
                 EmployeeId = x.EmployeeId,
                 EmployeeName = x.EmployeeFullName,
@@ -117,6 +117,7 @@ public class WorkFlowRollCallACL : IWorkFlowRollCallACL
             }).ToList();
     }
 
+
     public RollCallWorkFlowViewModel GetDetails(long rollCallId)
     {
         var entity = _rollCallApplication.GetDetails(rollCallId);
@@ -126,7 +127,13 @@ public class WorkFlowRollCallACL : IWorkFlowRollCallACL
         {
             EmployeeId = entity.EmployeeId,
             EmployeeName = entity.EmployeeFullName,
-            RollCallId = rollCallId,
+            TimesList =
+            [
+                new RollCallWorkFlowTimesViewModel()
+                {
+                    RollCallId =entity.Id
+                }
+            ],
             RollCallDate = entity.DateGr.Date,
             WorkshopId = entity.WorkshopId
         };
@@ -135,7 +142,6 @@ public class WorkFlowRollCallACL : IWorkFlowRollCallACL
     {
         return _rollCallServiceApplication.GetActiveServiceByWorkshopId(workshopId);
     }
-
     public List<DailyRollCallWorkFlowViewModel> GetUndefinedRollCalls(long workshopId, DateTime durationStart, DateTime durationEnd)
     {
         var result = _rollCallApplication.GetUndefinedRollCallWorkFlowsService(workshopId, durationStart, durationEnd).Select(x =>
@@ -149,7 +155,13 @@ public class WorkFlowRollCallACL : IWorkFlowRollCallACL
                     EmployeeId = e.EmployeeId,
                     EmployeeName = e.EmployeeFullName,
                     //Message = $"{TimeOnly.FromDateTime(e.StartDate!.Value):HH:mm} الی {TimeOnly.FromDateTime(e.EndDate.Value):HH:mm}",
-                    RollCallId = e.Id
+                    TimesList =
+                    [
+                        new RollCallWorkFlowTimesViewModel()
+                        {
+                            RollCallId =e.Id
+                        }
+                    ],
                 }).ToList(),
                 DayOfWeekFa = x.DayOfWeekFa,
             };