527 lines
24 KiB
C#
527 lines
24 KiB
C#
using _0_Framework.Application;
|
|
using WorkFlow.Application.Contracts.RollCallConfirmedAbsence;
|
|
using WorkFlow.Application.Contracts.RollCallConfirmedWithoutLunchBreak;
|
|
using WorkFlow.Application.Contracts.Shared;
|
|
using WorkFlow.Application.Contracts.WorkFlow;
|
|
using WorkFlow.Domain.RollCallConfirmedAbsenceAgg;
|
|
using WorkFlow.Domain.RollCallConfirmedWithoutLunchBreakAgg;
|
|
using WorkFlow.Infrastructure.ACL.Checkout;
|
|
using WorkFlow.Infrastructure.ACL.CustomizedWorkshopSettings;
|
|
using WorkFlow.Infrastructure.ACL.RollCall;
|
|
|
|
namespace WorkFlow.Application;
|
|
|
|
public class WorkFlowApplication : IWorkFlowApplication
|
|
{
|
|
private readonly IRollCallConfirmedAbsenceRepository _absenceRepository;
|
|
private readonly IWorkFlowRollCallACL _rollCallACL;
|
|
private readonly IWorkFlowCheckoutACL _checkoutACL;
|
|
private readonly IWorkFlowCustomizedWorkshopSettingsACL _customizedWorkshopSettingsACL;
|
|
private readonly IRollCallConfirmedWithoutLunchBreakRepository _rollCallConfirmedWithoutLunchBreakRepository;
|
|
|
|
public WorkFlowApplication(IRollCallConfirmedAbsenceRepository absenceRepository, IWorkFlowRollCallACL rollCallACL, IWorkFlowCheckoutACL checkoutACL, IWorkFlowCustomizedWorkshopSettingsACL customizedWorkshopSettingsACL, IRollCallConfirmedWithoutLunchBreakRepository rollCallConfirmedWithoutLunchBreakRepository)
|
|
{
|
|
_absenceRepository = absenceRepository;
|
|
_rollCallACL = rollCallACL;
|
|
_checkoutACL = checkoutACL;
|
|
_customizedWorkshopSettingsACL = customizedWorkshopSettingsACL;
|
|
_rollCallConfirmedWithoutLunchBreakRepository = rollCallConfirmedWithoutLunchBreakRepository;
|
|
}
|
|
|
|
public OperationResult CreateRollCallConfirmedAbsence(CreateRollCallConfirmedAbsence command)
|
|
{
|
|
OperationResult op = new OperationResult();
|
|
if (!command.AbsenceDate.TryToGeorgianDateTime(out var absenceDateGe))
|
|
{
|
|
throw new InvalidDataException("تاریخ را به درستی وارد کنید");
|
|
}
|
|
var entity = new RollCallConfirmedAbsence(command.WorkshopId, command.EmployeeId, absenceDateGe,
|
|
command.ConfirmedByAccountId);
|
|
|
|
_absenceRepository.Create(entity);
|
|
_absenceRepository.SaveChanges();
|
|
|
|
return op.Succcedded();
|
|
}
|
|
public OperationResult CreateRollCallConfirmedWithoutLunchBreak(CreateRollCallConfirmedWithoutLunchBreak command)
|
|
{
|
|
OperationResult op = new();
|
|
var entity = _rollCallACL.GetDetails(command.RollCallId);
|
|
|
|
if (entity == null)
|
|
return op.Failed("خطای سیستمی");
|
|
|
|
var newEntity = new RollCallConfirmedWithoutLunchBreak(command.RollCallId, entity.EmployeeId, entity.WorkshopId, entity.RollCallDate);
|
|
|
|
_rollCallConfirmedWithoutLunchBreakRepository.Create(newEntity);
|
|
_rollCallConfirmedWithoutLunchBreakRepository.SaveChanges();
|
|
|
|
return op.Succcedded();
|
|
}
|
|
|
|
public int GetCountAllWorkFlows(long workshopId)
|
|
{
|
|
int count = 0;
|
|
count += GetAllWorkFlowCount(workshopId);
|
|
return count;
|
|
}
|
|
public int GetRollCallAbsentsWorkFlows(long workshopId)
|
|
{
|
|
var now = DateTime.Now;
|
|
|
|
DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);
|
|
|
|
return _rollCallACL.GetRollCallAbsentsWorkFlowsCount(workshopId, now, twoMonthsAgo);
|
|
}
|
|
public int GetCountCutRollCallByBgService(long workshopId)
|
|
{
|
|
return GetRollCallWorkFlowsCutByBgService(workshopId).Count;
|
|
}
|
|
public int GetAllWorkFlowCount(long workshopId)
|
|
{
|
|
var count = 0;
|
|
var activeServiceByWorkshopId = _rollCallACL.GetActiveServiceByWorkshopId(workshopId);
|
|
if (activeServiceByWorkshopId == null)
|
|
{
|
|
return count;
|
|
}
|
|
//count += _rollCallACL.GetRollCallAbsentsWorkFlows(accId, workshopId);
|
|
count += GetAbsentRollCallWorkFlows(workshopId)?.Count ?? 0;
|
|
count += GetRollCallWorkFlowsCutByBgService(workshopId)?.Count ?? 0;
|
|
count += GetEmployeesWithoutLunchBreak(workshopId)?.Count ?? 0;
|
|
count += GetRollCallsOverlappingLeaves(workshopId)?.Count ?? 0;
|
|
count += GetUndefinedRollCalls(workshopId)?.Count ?? 0;
|
|
|
|
|
|
return count;
|
|
}
|
|
|
|
public DailyRollCallWorkFlowViewModel GetAbsentRollCallWorkFlowsByDate(long workshopId, DateTime date)
|
|
{
|
|
|
|
var startOfDay = date.Date;
|
|
var endOfDay = startOfDay.AddDays(1).Date.AddTicks(-1);
|
|
|
|
startOfDay.AddMonthsFa(-2, out var twoMonthsAgo);
|
|
|
|
var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, DateTime.Now);
|
|
|
|
var absences = _rollCallACL.GetAbsentRollCallWorkFlows(workshopId, startOfDay, endOfDay);
|
|
|
|
var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, startOfDay, endOfDay);
|
|
|
|
var confirmedAbssences = GetConfirmAbsencesBy(workshopId, startOfDay, endOfDay);
|
|
|
|
|
|
//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 = absences.FirstOrDefault();
|
|
if (allAbsencesInDate == null)
|
|
return new();
|
|
|
|
|
|
var newItem = new DailyRollCallWorkFlowViewModel()
|
|
{
|
|
DateTime = date.Date,
|
|
DateTimeFa = date.ToFarsi()
|
|
};
|
|
|
|
//dont count absences before the last checkout
|
|
var absencesWithoutCheckout = allAbsencesInDate.RollCallWorkFlowPerDayViewModels
|
|
.Where(x => !lastCheckouts.Any(y => x.EmployeeId == y.EmployeeId && y.CheckoutStart <= date && y.CheckoutEnd >= date) &&
|
|
activeEmployees.Any(y => y.EmployeeId == x.EmployeeId));
|
|
|
|
|
|
if (confirmedAbssences != null)
|
|
{
|
|
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();
|
|
}
|
|
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.DayOfWeekFa = newItem.DateTime.DayOfWeek.DayOfWeeKToPersian();
|
|
|
|
|
|
return newItem;
|
|
}
|
|
public DailyRollCallConfirmedWithoutLunchBreakViewModel GetEmployeesWithoutLunchBreakByDate(long workshopId, DateTime date)
|
|
{
|
|
var startOfDay = date.Date;
|
|
var endOfDay = startOfDay.AddDays(1).Date.AddTicks(-1);
|
|
|
|
startOfDay.AddMonthsFa(-2, out var twoMonthsAgo);
|
|
|
|
var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, DateTime.Now);
|
|
var notSlicedRollCalls = _rollCallACL.GetNotSlicedRollCallsByWorkshopId(workshopId, startOfDay, endOfDay);
|
|
var employeesWithoutBreakTime = _customizedWorkshopSettingsACL.GetEmployeesWithoutBreakTime(workshopId);
|
|
var activeEmployees = _rollCallACL.GetActiveWorkshopRollCallEmployees(workshopId, startOfDay, endOfDay);
|
|
notSlicedRollCalls = notSlicedRollCalls
|
|
.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 entites = _rollCallConfirmedWithoutLunchBreakRepository.GetByWorkshopId(workshopId, startOfDay, endOfDay).ToList();
|
|
|
|
return new DailyRollCallConfirmedWithoutLunchBreakViewModel()
|
|
{
|
|
DateFa = date.ToFarsi(),
|
|
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()
|
|
};
|
|
|
|
}
|
|
public DailyRollCallWorkFlowViewModel GetRollCallWorkFlowsCutByBgServiceByDate(long workshopId, DateTime date)
|
|
{
|
|
var startOfDay = date.Date;
|
|
var endOfDay = startOfDay.AddDays(1).Date.AddTicks(-1);
|
|
|
|
startOfDay.AddMonthsFa(-2, out var twoMonthsAgo);
|
|
|
|
var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, DateTime.Now.Date);
|
|
var rollCalls = _rollCallACL.GetRollCallWorkFlowsCutByBgService(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;
|
|
}
|
|
public DailyRollCallWorkFlowViewModel GetUndefinedRollCallsByDate(long workshopId, DateTime date)
|
|
{
|
|
var startOfDay = date.Date;
|
|
var endOfDay = startOfDay.AddDays(1).Date.AddTicks(-1);
|
|
|
|
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 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;
|
|
}
|
|
|
|
|
|
public DailyWorkFlowEmployeesWithRollCallOnLeaveViewModel GetRollCallsOverlappingLeaveByDate(long workshopId, DateTime date)
|
|
{
|
|
var startOfDay = date.Date;
|
|
var endOfDay = startOfDay.AddDays(1).Date.AddTicks(-1);
|
|
|
|
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 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 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();
|
|
|
|
|
|
}
|
|
|
|
|
|
public List<RollCallConfirmAbsenceViewModel> GetConfirmAbsencesBy(long workshopId, DateTime start, DateTime end)
|
|
{
|
|
return _absenceRepository.GetConfirmAbsencesBy(workshopId, start, end);
|
|
}
|
|
|
|
public 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()
|
|
{
|
|
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 List<DailyRollCallWorkFlowViewModel> GetRollCallWorkFlowsCutByBgService(long workshopId)
|
|
{
|
|
var now = DateTime.Now;
|
|
var yesterday = now.AddDays(-1).Date;
|
|
DateTime.Now.Date.AddMonthsFa(-2, out var twoMonthsAgo);
|
|
|
|
var lastCheckouts = _checkoutACL.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, twoMonthsAgo, now);
|
|
var rollCalls = _rollCallACL.GetRollCallWorkFlowsCutByBgService(workshopId, twoMonthsAgo, yesterday);
|
|
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 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 = 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()
|
|
{
|
|
EmployeeId = x.EmployeeId,
|
|
EmployeeName = x.EmployeeName,
|
|
Message = ""
|
|
}).ToList();
|
|
|
|
}
|
|
|
|
newItem.DayOfWeekFa = newItem.DateTime.DayOfWeek.DayOfWeeKToPersian();
|
|
if (newItem.RollCallWorkFlowPerDayViewModels.Count > 0)
|
|
result.Add(newItem);
|
|
|
|
}
|
|
return result.OrderBy(x => x.DateTime).ToList();
|
|
}
|
|
public 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();
|
|
|
|
}
|
|
public List<(long Id, string Name)> GetEmployeesWithoutGroup(long workshopId)
|
|
{
|
|
return _customizedWorkshopSettingsACL.GetEmployeesWithoutGroup(workshopId);
|
|
}
|
|
|
|
|
|
} |