public async Task <ApiResponse> Handle(AddAdvanceCommand request, CancellationToken cancellationToken)
{
ApiResponse response = new ApiResponse();
try
{
var record = await _dbContext.Advances.Include(x => x.EmployeeDetail)
.FirstOrDefaultAsync(x => x.OfficeId == request.OfficeId && x.EmployeeId == request.EmployeeId &&
x.AdvanceDate.Date.Month <= request.AdvanceDate.Date.Month &&
x.AdvanceDate.Date.Year <= request.AdvanceDate.Date.Year && x.IsDeleted == false &&
x.IsDeducted == false);
if (record == null)
{
Advances obj = _mapper.Map <Advances>(request);
obj.IsDeleted = false;
await _dbContext.Advances.AddAsync(obj);
await _dbContext.SaveChangesAsync();
response.StatusCode = StaticResource.successStatusCode;
response.Message = "Success";
}
else
{
response.StatusCode = StaticResource.failStatusCode;
response.Message = string.Format(StaticResource.CannotAddAdvance, record.EmployeeDetail.EmployeeCode, record.EmployeeDetail.EmployeeName);
}
}
catch (Exception ex)
{
response.StatusCode = StaticResource.failStatusCode;
response.Message = ex.Message;
}
return(response);
}
public async Task <ApiResponse> Handle(EmployeeApprovePayrollCommand request, CancellationToken cancellationToken)
{
ApiResponse response = new ApiResponse();
try
{
foreach (EmployeeMonthlyPayrollModel finalPayroll in request.EmployeeMonthlyPayroll)
{
EmployeeMonthlyAttendance xEmployeeMonthlyAttendance = await _dbContext.EmployeeMonthlyAttendance
.FirstOrDefaultAsync(x => x.EmployeeId == finalPayroll.EmployeeId && x.IsDeleted == false &&
x.Month == finalPayroll.Month && x.Year == finalPayroll.Year);
if (xEmployeeMonthlyAttendance != null)
{
xEmployeeMonthlyAttendance.IsApproved = true;
xEmployeeMonthlyAttendance.AdvanceAmount = finalPayroll.AdvanceAmount ?? 0;
xEmployeeMonthlyAttendance.AdvanceRecoveryAmount = finalPayroll.AdvanceRecoveryAmount ?? 0;
xEmployeeMonthlyAttendance.IsAdvanceApproved = finalPayroll.IsAdvanceApproved;
xEmployeeMonthlyAttendance.IsAdvanceRecovery = finalPayroll.IsAdvanceRecovery;
xEmployeeMonthlyAttendance.ModifiedById = request.ModifiedById;
xEmployeeMonthlyAttendance.ModifiedDate = request.ModifiedDate;
_dbContext.EmployeeMonthlyAttendance.Update(xEmployeeMonthlyAttendance);
await _dbContext.SaveChangesAsync();
}
EmployeePaymentTypes EmployeeApprovedPayroll = new EmployeePaymentTypes();
EmployeeApprovedPayroll.IsDeleted = false;
EmployeeApprovedPayroll.Absent = finalPayroll.AbsentDays;
EmployeeApprovedPayroll.AdvanceAmount = finalPayroll.AdvanceAmount;
EmployeeApprovedPayroll.AdvanceRecoveryAmount = finalPayroll.IsAdvanceRecovery? finalPayroll.AdvanceRecoveryAmount:0;
EmployeeApprovedPayroll.Attendance = finalPayroll.PresentDays;
EmployeeApprovedPayroll.BasicPay = Convert.ToSingle(finalPayroll.TotalGeneralAmount);
EmployeeApprovedPayroll.CurrencyId = finalPayroll.CurrencyId;
EmployeeApprovedPayroll.EmployeeID = finalPayroll.EmployeeId;
EmployeeApprovedPayroll.GrossSalary = finalPayroll.GrossSalary;
EmployeeApprovedPayroll.HourlyRate = finalPayroll.HourlyRate;
EmployeeApprovedPayroll.IsAdvanceApproved = finalPayroll.IsAdvanceApproved;
EmployeeApprovedPayroll.IsAdvanceRecovery = finalPayroll.IsAdvanceRecovery;
EmployeeApprovedPayroll.IsApproved = true;
EmployeeApprovedPayroll.LeaveDays = finalPayroll.LeaveHours;
EmployeeApprovedPayroll.NetSalary = finalPayroll.NetSalary;
EmployeeApprovedPayroll.OfficeId = finalPayroll.OfficeId;
EmployeeApprovedPayroll.OverTimeHours = finalPayroll.OverTimeHours;
EmployeeApprovedPayroll.PaymentType = finalPayroll.PaymentType;
EmployeeApprovedPayroll.PayrollMonth = finalPayroll.Month;
EmployeeApprovedPayroll.PayrollYear = finalPayroll.Year;
EmployeeApprovedPayroll.PensionAmount = finalPayroll.PensionAmount;
EmployeeApprovedPayroll.PensionRate = finalPayroll.PensionRate;
EmployeeApprovedPayroll.SalaryTax = finalPayroll.SalaryTax;
EmployeeApprovedPayroll.TotalAllowance = finalPayroll.TotalAllowance;
EmployeeApprovedPayroll.TotalDeduction = finalPayroll.TotalDeduction;
EmployeeApprovedPayroll.TotalDuration = finalPayroll.TotalWorkHours;
EmployeeApprovedPayroll.TotalGeneralAmount = finalPayroll.NetSalary;
EmployeeApprovedPayroll.PaymentDate = new DateTime(finalPayroll.Year, finalPayroll.Month, DateTime.Now.Day);
EmployeeApprovedPayroll.CreatedById = request.CreatedById;
EmployeeApprovedPayroll.CreatedDate = request.CreatedDate;
await _dbContext.EmployeePaymentTypes.AddAsync(EmployeeApprovedPayroll);
await _dbContext.SaveChangesAsync();
if (finalPayroll.EmployeePayrollList.Count > 0)
{
foreach (var payroll in finalPayroll.EmployeePayrollList)
{
EmployeePayrollMonth employeePayrollMonth = new EmployeePayrollMonth();
employeePayrollMonth.CurrencyId = payroll.CurrencyId;
employeePayrollMonth.Date = new DateTime(finalPayroll.Year, finalPayroll.Month, DateTime.Now.Day);
employeePayrollMonth.EmployeeID = finalPayroll.EmployeeId;
employeePayrollMonth.IsDeleted = false;
employeePayrollMonth.MonthlyAmount = payroll.MonthlyAmount;
employeePayrollMonth.SalaryHeadId = payroll.SalaryHeadId;
employeePayrollMonth.HeadTypeId = payroll.HeadTypeId;
employeePayrollMonth.PaymentType = payroll.PaymentType;
employeePayrollMonth.AccountNo = payroll.AccountNo;
employeePayrollMonth.TransactionTypeId = payroll.TransactionTypeId;
employeePayrollMonth.CreatedById = request.CreatedById;
employeePayrollMonth.CreatedDate = request.CreatedDate;
await _dbContext.EmployeePayrollMonth.AddAsync(employeePayrollMonth);
await _dbContext.SaveChangesAsync();
}
}
if (finalPayroll.IsAdvanceRecovery)
{
Advances xAdvances = await _dbContext.Advances.FirstOrDefaultAsync(x => x.IsDeleted == false && x.IsApproved == true &&
x.EmployeeId == finalPayroll.EmployeeId && x.OfficeId == finalPayroll.OfficeId &&
x.AdvanceDate < DateTime.Now && x.IsDeducted == false);
if (xAdvances != null && finalPayroll.IsAdvanceRecovery)
{
if (xAdvances.RecoveredAmount != xAdvances.AdvanceAmount)
{
xAdvances.RecoveredAmount += finalPayroll.AdvanceRecoveryAmount.Value;
xAdvances.IsAdvanceRecovery = finalPayroll.IsAdvanceRecovery;
xAdvances.DeductedDate = DateTime.Now;
xAdvances.NumberOfInstallments -= 1;
if (xAdvances.RecoveredAmount == xAdvances.AdvanceAmount)
{
xAdvances.IsAdvanceRecovery = false;
xAdvances.IsDeducted = true;
}
EmployeeApprovedPayroll.AdvanceId = xAdvances.AdvancesId;
EmployeeApprovedPayroll.ModifiedById = request.ModifiedById;
EmployeeApprovedPayroll.ModifiedDate = request.ModifiedDate;
_dbContext.EmployeePaymentTypes.Update(EmployeeApprovedPayroll);
await _dbContext.SaveChangesAsync();
}
xAdvances.ModifiedById = request.ModifiedById;
xAdvances.ModifiedDate = request.ModifiedDate;
_dbContext.Advances.Update(xAdvances);
await _dbContext.SaveChangesAsync();
}
}
}
response.StatusCode = StaticResource.successStatusCode;
response.Message = "Success";
}
catch (Exception ex)
{
response.StatusCode = StaticResource.failStatusCode;
response.Message = ex.Message;
}
return(response);
}
public override string ToString()
{
return(Text + ", [" + string.Join(",", Advances.Select(p => p.ToString()).ToArray()) + "]");
}
public async Task <ApiResponse> Handle(GetEmployeesMonthlyPayrollQuery request, CancellationToken cancellationToken)
{
ApiResponse response = new ApiResponse();
try
{
ICollection <EmployeeMonthlyAttendance> empPayrollAttendanceList = await _dbContext.EmployeeMonthlyAttendance
.Include(x => x.EmployeeDetails)
.Where(x => x.OfficeId == request.OfficeId &&
x.Month == request.Month && x.Year == request.Year &&
x.IsDeleted == false && x.IsApproved == false &&
x.EmployeeDetails.IsDeleted == false)
.ToListAsync();
//Note: default 0.045 i.e. (4.5 %)
double?pensionRate = _dbContext.EmployeePensionRate.FirstOrDefault(x => x.IsDefault == true && x.IsDeleted == false)?.PensionRate;
List <EmployeeMonthlyPayrollModel> payrollFinal = new List <EmployeeMonthlyPayrollModel>();
foreach (EmployeeMonthlyAttendance payrollAttendance in empPayrollAttendanceList)
{
List <EmployeePayrollModel> payrollDetail = new List <EmployeePayrollModel>();
var payroll = await _dbContext.EmployeePayroll.Include(x => x.SalaryHeadDetails).Where(x => x.EmployeeID == payrollAttendance.EmployeeId && x.IsDeleted == false).ToListAsync();
if (payroll.Any(x => x.AccountNo == null))
{
throw new Exception($"Payroll details not set for Employee code: {payrollAttendance.EmployeeDetails.EmployeeCode}");
}
payrollDetail = payroll.Select(x => new EmployeePayrollModel
{
PayrollId = x.PayrollId,
CurrencyId = x.CurrencyId ?? 0,
EmployeeId = x.EmployeeID,
HeadTypeId = x.SalaryHeadDetails.HeadTypeId,
IsDeleted = x.IsDeleted,
MonthlyAmount = x.MonthlyAmount ?? 0,
PaymentType = 2, //hourly
PensionRate = pensionRate != null ? pensionRate : DefaultValues.DefaultPensionRate,
SalaryHeadId = x.SalaryHeadId ?? 0,
SalaryHeadType = x.SalaryHeadDetails.HeadTypeId == (int)SalaryHeadType.ALLOWANCE ? "Allowance" : x.SalaryHeadDetails.HeadTypeId == (int)SalaryHeadType.DEDUCTION ? "Deduction" : x.SalaryHeadDetails.HeadTypeId == (int)SalaryHeadType.GENERAL ? "General" : "",
SalaryHead = x.SalaryHeadDetails.HeadName,
AccountNo = x.AccountNo,
TransactionTypeId = x.TransactionTypeId
}).OrderBy(x => x.TransactionTypeId).ThenBy(x => x.SalaryHeadType).ToList();
if (payrollDetail.Count > 0)
{
if (payrollAttendance.GrossSalary == 0 || payrollAttendance.GrossSalary == null)
{
int iCurrencyId = payrollDetail.FirstOrDefault(x => x.HeadTypeId == 3).CurrencyId;
EmployeeMonthlyPayrollModel obj = new EmployeeMonthlyPayrollModel();
obj.EmployeeId = payrollAttendance.EmployeeId.Value;
obj.EmployeeCode = payrollAttendance.EmployeeDetails.EmployeeCode;
obj.EmployeeName = payrollAttendance.EmployeeDetails.EmployeeName;
obj.PaymentType = 2;
obj.AbsentDays = payrollAttendance.AbsentHours == null ? 0 : payrollAttendance.AbsentHours.Value;
obj.LeaveDays = payrollAttendance.LeaveHours == null ? 0 : payrollAttendance.LeaveHours.Value;
obj.PresentDays = payrollAttendance.AttendanceHours == null ? 0 : payrollAttendance.AttendanceHours.Value + Convert.ToInt32(Math.Floor((float)payrollAttendance.AttendanceMinutes / 60f));
obj.LeaveHours = payrollAttendance.LeaveHours == null ? 0 : payrollAttendance.LeaveHours.Value;
obj.WorkingDays = payrollAttendance.AttendanceHours == null ? 0 : payrollAttendance.AttendanceHours.Value + Convert.ToInt32(Math.Floor((float)payrollAttendance.AttendanceMinutes / 60f));
obj.TotalWorkHours = payrollAttendance.TotalDuration == null ? 0 : payrollAttendance.TotalDuration.Value;
obj.OverTimeHours = payrollAttendance.OvertimeHours == null ? 0 : payrollAttendance.OvertimeHours.Value + Math.Floor(((float)payrollAttendance.OverTimeMinutes / 60f));
obj.IsAdvanceRecovery = payrollAttendance.IsAdvanceRecovery;
obj.AdvanceAmount = payrollAttendance.AdvanceAmount;
obj.CurrencyId = payrollDetail.FirstOrDefault().CurrencyId;
obj.TotalAllowance = payrollDetail.Where(x => x.HeadTypeId == (int)SalaryHeadType.ALLOWANCE).Sum(s => s.MonthlyAmount);
obj.TotalDeduction = payrollDetail.Where(x => x.HeadTypeId == (int)SalaryHeadType.DEDUCTION).Sum(s => s.MonthlyAmount);
obj.TotalGeneralAmount = payrollDetail.Where(x => x.HeadTypeId == (int)SalaryHeadType.GENERAL).Sum(s => s.MonthlyAmount);
if (obj.TotalGeneralAmount == 0)
{
throw new Exception($"Basic Pay not defined for Employee Code-{payrollAttendance.EmployeeDetails.EmployeeCode}");
}
double convertMinutesToHours = Math.Round(((double)(payrollAttendance.OverTimeMinutes + payrollAttendance.AttendanceMinutes) / 60d), 2);
obj.GrossSalary = Math.Round((double)(obj.TotalGeneralAmount * (payrollAttendance.AttendanceHours.Value + obj.LeaveHours + payrollAttendance.OvertimeHours.Value + convertMinutesToHours) + obj.TotalAllowance), 2);
obj.PensionAmount = Math.Round(((double)(obj.GrossSalary * payrollDetail.FirstOrDefault().PensionRate) / 100), 2); // i.e. 4.5 % => 0.045
// eliminate hours and only show minutes if minutes is 60 we already added them to overtime hours so minutes = 0
decimal overtimeHour = Math.Round((decimal)((float)payrollAttendance.OverTimeMinutes / 60f), 2);
obj.OvertimeMinutes = Convert.ToInt32((overtimeHour - Math.Truncate(overtimeHour)) * 60);
// eliminate hours and only show minutes if minutes is 60 we already added them to AttendanceHours so minutes = 0
decimal attendanceMinutes = Math.Round((decimal)((float)payrollAttendance.AttendanceMinutes / 60f), 2);
obj.WorkingMinutes = Convert.ToInt32((attendanceMinutes - Math.Truncate(attendanceMinutes)) * 60);
if (obj.GrossSalary > 5000)
{
double? dExchangeRate1 = 0.0;
ExchangeRateDetail exchangeRateDetail = _dbContext.ExchangeRateDetail.OrderByDescending(x => x.Date).FirstOrDefault(x => x.FromCurrency == iCurrencyId && x.ToCurrency == (int)Currency.AFG);
if (exchangeRateDetail == null)
{
string currencyCode = _dbContext.CurrencyDetails.FirstOrDefault(x => x.IsDeleted == false && x.CurrencyId == iCurrencyId).CurrencyCode;
throw new Exception($"Exchange Rate Not Defined from {currencyCode} to AFG");
}
else
{
dExchangeRate1 = (double)exchangeRateDetail.Rate;
}
obj.SalaryTax = obj.SalaryTax == null ? 0 : obj.SalaryTax;
obj.SalaryTax = Math.Round(Convert.ToDouble((StaticFunctions.SalaryCalculate(obj.GrossSalary.Value, dExchangeRate1.Value))), 2);
}
else
{
obj.SalaryTax = 0;
}
//Net Salary = (Gross + Allowances) - Deductions
obj.NetSalary = Math.Round((double)(obj.GrossSalary - (obj.TotalDeduction != null ? obj.TotalDeduction : 0) - (obj.SalaryTax != null ? obj.SalaryTax : 0) - payrollAttendance.AdvanceRecoveryAmount - (obj.PensionAmount != null ? obj.PensionAmount : 0)), 2);
obj.EmployeePayrollList.AddRange(payrollDetail);
payrollFinal.Add(obj);
Advances xAdvances = await _dbContext.Advances.FirstOrDefaultAsync(x => x.IsDeleted == false && x.IsApproved == true &&
x.EmployeeId == payrollAttendance.EmployeeId && x.OfficeId == payrollAttendance.OfficeId &&
x.AdvanceDate < DateTime.Now && x.IsDeducted == false);
if (xAdvances != null)
{
if (xAdvances.RecoveredAmount == 0)
{
if (xAdvances.NumberOfInstallments == 0)
{
xAdvances.NumberOfInstallments = 1;
}
obj.AdvanceRecoveryAmount = Math.Round((Convert.ToDouble(xAdvances.AdvanceAmount / xAdvances.NumberOfInstallments ?? 1)), 2);
obj.AdvanceAmount = xAdvances.AdvanceAmount;
obj.IsAdvanceApproved = xAdvances.IsApproved;
}
else
{
Double iBalanceAmount = xAdvances.AdvanceAmount - xAdvances.RecoveredAmount;
obj.AdvanceRecoveryAmount = Math.Round((Convert.ToDouble(iBalanceAmount / xAdvances.NumberOfInstallments)), 2);
obj.IsAdvanceApproved = xAdvances.IsApproved;
obj.AdvanceAmount = iBalanceAmount;
}
}
else
{
obj.AdvanceRecoveryAmount = 0;
obj.AdvanceAmount = 0;
obj.IsAdvanceApproved = false;
}
}
else
{
EmployeeMonthlyPayrollModel obj = new EmployeeMonthlyPayrollModel();
obj.AbsentDays = payrollAttendance.AbsentHours == null ? 0 : payrollAttendance.AbsentHours.Value;
obj.OverTimeHours = payrollAttendance.OvertimeHours;
obj.AdvanceAmount = payrollAttendance.AdvanceAmount;
obj.AdvanceRecoveryAmount = payrollAttendance.AdvanceRecoveryAmount;
obj.CurrencyId = payrollDetail[0].CurrencyId;
obj.EmployeeId = payrollAttendance.EmployeeId.Value;
obj.EmployeeCode = payrollAttendance.EmployeeDetails.EmployeeCode;
obj.EmployeeName = payrollAttendance.EmployeeDetails.EmployeeName;
obj.GrossSalary = payrollAttendance.GrossSalary == null ? 0 : payrollAttendance.GrossSalary;
obj.IsAdvanceApproved = payrollAttendance.IsAdvanceApproved;
obj.IsAdvanceRecovery = payrollAttendance.IsAdvanceRecovery;
obj.LeaveDays = payrollAttendance.LeaveHours == null ? 0 : payrollAttendance.LeaveHours.Value;
obj.LeaveHours = payrollAttendance.LeaveHours == null ? 0 : payrollAttendance.LeaveHours.Value;
obj.NetSalary = payrollAttendance.NetSalary == null ? 0 : payrollAttendance.NetSalary;
obj.PaymentType = 2;
obj.PensionAmount = payrollAttendance.PensionAmount == null ? 0 : payrollAttendance.PensionAmount;
obj.PresentDays = payrollAttendance.AttendanceHours == null ? 0 : payrollAttendance.AttendanceHours.Value;
obj.SalaryTax = payrollAttendance.SalaryTax == null ? 0 : payrollAttendance.SalaryTax.Value;
obj.TotalAllowance = payrollAttendance.TotalAllowance == null ? 0 : payrollAttendance.TotalAllowance.Value;
obj.TotalDeduction = payrollAttendance.TotalDeduction == null ? 0 : payrollAttendance.TotalDeduction.Value;
obj.TotalGeneralAmount = payrollAttendance.TotalGeneralAmount == null ? 0 : payrollAttendance.TotalGeneralAmount.Value;
obj.WorkingDays = payrollAttendance.AttendanceHours == null ? 0 : payrollAttendance.AttendanceHours.Value;
obj.TotalWorkHours = payrollAttendance.TotalDuration == null ? 0 : payrollAttendance.TotalDuration.Value;
obj.OvertimeMinutes = payrollAttendance.OverTimeMinutes; // eliminate hours and only show minutes
obj.WorkingMinutes = payrollAttendance.AttendanceMinutes; // eliminate hours and only show minutes
obj.EmployeePayrollList.AddRange(payrollDetail.Where(x => x.EmployeeId == obj.EmployeeId));
payrollFinal.Add(obj);
}
}
else
{
throw new Exception($"Employee Payroll not defined for Employee Code-{payrollAttendance.EmployeeDetails.EmployeeCode}");
}
}
response.data.EmployeeMonthlyPayrolllist = payrollFinal;
response.StatusCode = StaticResource.successStatusCode;
response.Message = "Success";
}
catch (Exception ex)
{
response.StatusCode = StaticResource.failStatusCode;
response.Message = ex.Message;
}
return(response);
}
public async Task <ApiResponse> Handle(AddAttendanceDetailCommand request, CancellationToken cancellationToken)
{
DateTime OfficeInTime = new DateTime();
DateTime OfficeOutTime = new DateTime();
ApiResponse response = new ApiResponse();
try
{
if (!request.EmployeeAttendance.Any() && request.EmployeeAttendance == null)
{
throw new Exception(StaticResource.NoAttendanceToAdd);
}
var existrecord = await _dbContext.EmployeeAttendance.Where(x => x.Date.Date == request.EmployeeAttendance[0].Date.Date).ToListAsync();
//gets the total working hours in a day for an office
PayrollMonthlyHourDetail payrollMonthlyHourDetail = await _dbContext.PayrollMonthlyHourDetail
.FirstOrDefaultAsync(x => x.OfficeId == request.EmployeeAttendance.First().OfficeId &&
x.PayrollYear == request.EmployeeAttendance.First().Date.Year &&
x.PayrollMonth == request.EmployeeAttendance.First().Date.Month &&
x.AttendanceGroupId == request.EmployeeAttendance.First().AttendanceGroupId);
int?officeDailyHour = payrollMonthlyHourDetail.Hours;
int?officeMonthlyHour = payrollMonthlyHourDetail.WorkingTime;
if (officeDailyHour != null && officeMonthlyHour != null)
{
var financiallist = await _dbContext.FinancialYearDetail.FirstOrDefaultAsync(x => x.IsDefault == true);
foreach (var list in request.EmployeeAttendance)
{
TimeSpan?totalworkhour;
TimeSpan?totalovertime;
int? overtime = 0, workingHours = 0, workingMinutes = 0, overtimeMinutes = 0;
var isemprecord = existrecord.Where(x => x.EmployeeId == list.EmployeeId && x.Date.Date == list.Date.Date).ToList();
totalworkhour = list.OutTime - list.InTime;
if (isemprecord.Count == 0)
{
if (totalworkhour.ToString() == "00:00:00" || list.AttendanceTypeId == (int)AttendanceType.A)
{
list.AttendanceTypeId = 2;
list.InTime = list.Date;
list.OutTime = list.Date;
totalworkhour = list.Date.Date - list.Date.Date;
}
OfficeInTime = new DateTime(list.InTime.Value.Year, list.InTime.Value.Month, list.InTime.Value.Day, payrollMonthlyHourDetail.InTime.Value.Hour, payrollMonthlyHourDetail.InTime.Value.Minute, payrollMonthlyHourDetail.InTime.Value.Second);
OfficeOutTime = new DateTime(list.OutTime.Value.Year, list.OutTime.Value.Month, list.OutTime.Value.Day, payrollMonthlyHourDetail.OutTime.Value.Hour, payrollMonthlyHourDetail.OutTime.Value.Minute, payrollMonthlyHourDetail.OutTime.Value.Second);
if (list.InTime < OfficeInTime)
{
totalovertime = OfficeInTime - list.InTime;
overtime += totalovertime.Value.Hours;
overtimeMinutes += totalovertime.Value.Minutes;
if (list.OutTime <= OfficeOutTime)
{
totalworkhour = list.OutTime - OfficeInTime;
workingHours += totalworkhour.Value.Hours;
workingMinutes += totalworkhour.Value.Minutes;
}
if (list.OutTime > OfficeOutTime)
{
totalovertime = list.OutTime - OfficeOutTime;
overtime += totalovertime.Value.Hours;
overtimeMinutes += totalovertime.Value.Minutes;
totalworkhour = OfficeOutTime - OfficeInTime;
workingHours += totalworkhour.Value.Hours;
workingMinutes += totalworkhour.Value.Minutes;
}
list.TotalWorkTime = workingHours.ToString();
list.WorkTimeMinutes = workingMinutes;
list.HoverTimeHours = overtime;
list.OvertimeMinutes = overtimeMinutes;
}
else if (list.InTime >= OfficeInTime)
{
if (list.OutTime <= OfficeOutTime)
{
totalworkhour = list.OutTime - list.InTime;
workingHours += totalworkhour.Value.Hours;
workingMinutes += totalworkhour.Value.Minutes;
}
if (list.OutTime > OfficeOutTime)
{
totalovertime = list.OutTime - OfficeOutTime;
overtime += totalovertime.Value.Hours;
overtimeMinutes += totalovertime.Value.Minutes;
totalworkhour = OfficeOutTime - list.InTime;
workingHours += totalworkhour.Value.Hours;
workingMinutes += totalworkhour.Value.Minutes;
}
list.TotalWorkTime = workingHours.ToString();
list.WorkTimeMinutes = workingMinutes;
list.HoverTimeHours = overtime;
list.OvertimeMinutes = overtimeMinutes;
}
else
{
list.TotalWorkTime = workingHours.ToString();
list.HoverTimeHours = overtime;
}
list.FinancialYearId = financiallist.FinancialYearId;
list.CreatedById = list.CreatedById;
list.CreatedDate = DateTime.UtcNow;
list.IsDeleted = false;
EmployeeAttendance obj = _mapper.Map <EmployeeAttendance>(list);
await _dbContext.EmployeeAttendance.AddAsync(obj);
await _dbContext.SaveChangesAsync();
}
EmployeeMonthlyAttendance xEmployeeMonthlyAttendanceRecord = await _dbContext.EmployeeMonthlyAttendance.FirstOrDefaultAsync(x => x.EmployeeId == list.EmployeeId && x.Month == list.Date.Month && x.Year == list.Date.Year && x.IsDeleted == false);
EmployeeMonthlyAttendance xEmployeeMonthlyAttendance = new EmployeeMonthlyAttendance();
//If Employee record is present in monthly attendance table then
if (xEmployeeMonthlyAttendanceRecord != null)
{
//if Employee is absent without any leave
if (totalworkhour.ToString() == "00:00:00" || list.AttendanceTypeId == (int)AttendanceType.A)
{
xEmployeeMonthlyAttendance.AbsentHours = xEmployeeMonthlyAttendance.AbsentHours == null ? 0 : xEmployeeMonthlyAttendance.AbsentHours;
xEmployeeMonthlyAttendance.AbsentHours += officeDailyHour;
}
//update total attendance hours
if ((workingHours != 0 || workingMinutes != 0) && overtime == 0)
{
xEmployeeMonthlyAttendanceRecord.AttendanceHours += totalworkhour.Value.Hours;
xEmployeeMonthlyAttendanceRecord.AttendanceMinutes += workingMinutes.Value;
xEmployeeMonthlyAttendanceRecord.OverTimeMinutes += overtimeMinutes.Value;
}
//update total attendance hours and also add overtime hours
else if ((workingHours != 0 || workingMinutes != 0) && overtime != 0)
{
xEmployeeMonthlyAttendanceRecord.AttendanceHours += totalworkhour.Value.Hours;
xEmployeeMonthlyAttendanceRecord.OvertimeHours = xEmployeeMonthlyAttendanceRecord.OvertimeHours ?? 0;
xEmployeeMonthlyAttendanceRecord.OvertimeHours += overtime;
xEmployeeMonthlyAttendanceRecord.AttendanceMinutes += workingMinutes.Value;
xEmployeeMonthlyAttendanceRecord.OverTimeMinutes += overtimeMinutes.Value;
}
//updating employee monthly attendance record
_dbContext.EmployeeMonthlyAttendance.Update(xEmployeeMonthlyAttendanceRecord);
await _dbContext.SaveChangesAsync();
}
else// if employee monthly attendance record does not exists then add a record
{
// int monthDays = GetMonthDays(modellist.FirstOrDefault().Date.Month, modellist.FirstOrDefault().Date.Year);
int monthDays = DateTime.DaysInMonth(list.Date.Year, list.Date.Month);
//if employee is absent without any leave
if (totalworkhour.ToString() == "00:00:00" || list.AttendanceTypeId == (int)AttendanceType.A)
{
xEmployeeMonthlyAttendance.IsDeleted = false;
xEmployeeMonthlyAttendance.EmployeeId = list.EmployeeId;
xEmployeeMonthlyAttendance.Month = list.Date.Month;
xEmployeeMonthlyAttendance.Year = list.Date.Year;
xEmployeeMonthlyAttendance.AttendanceHours = 0;
xEmployeeMonthlyAttendance.OvertimeHours = 0;
xEmployeeMonthlyAttendance.AbsentHours = officeDailyHour;
xEmployeeMonthlyAttendance.OfficeId = list.OfficeId;
xEmployeeMonthlyAttendance.TotalDuration = officeMonthlyHour;
}
else
{
xEmployeeMonthlyAttendance.IsDeleted = false;
xEmployeeMonthlyAttendance.EmployeeId = list.EmployeeId;
xEmployeeMonthlyAttendance.Month = list.Date.Month;
xEmployeeMonthlyAttendance.Year = list.Date.Year;
xEmployeeMonthlyAttendance.AttendanceHours = workingHours;
xEmployeeMonthlyAttendance.OvertimeHours = overtime;
xEmployeeMonthlyAttendance.OfficeId = list.OfficeId;
xEmployeeMonthlyAttendance.TotalDuration = officeMonthlyHour;
xEmployeeMonthlyAttendance.AttendanceMinutes = list.WorkTimeMinutes.Value;
xEmployeeMonthlyAttendance.OverTimeMinutes = list.OvertimeMinutes.Value;
}
Advances xAdvances = await _dbContext.Advances.Where(x => x.IsDeleted == false && x.IsApproved == true &&
x.EmployeeId == list.EmployeeId && x.OfficeId == list.OfficeId && x.IsDeducted == false &&
x.AdvanceDate <= DateTime.Now).FirstOrDefaultAsync();
if (xAdvances != null)
{
xEmployeeMonthlyAttendance.AdvanceId = xAdvances.AdvancesId;
xEmployeeMonthlyAttendance.IsAdvanceApproved = xAdvances.IsApproved;
xEmployeeMonthlyAttendance.AdvanceAmount = xAdvances.AdvanceAmount - xAdvances.RecoveredAmount;
}
await _dbContext.EmployeeMonthlyAttendance.AddAsync(xEmployeeMonthlyAttendance);
await _dbContext.SaveChangesAsync();
}
}
//If Employee is not present then check the leave table and update leave record accordingly
List <EmployeeApplyLeave> xEmployeeLeaveDetailList = await _dbContext.EmployeeApplyLeave
.Include(x => x.EmployeeDetails.EmployeeProfessionalDetail)
.Where(x => x.FromDate.Date >= request.EmployeeAttendance.First().Date.Date&&
x.ToDate.Date <= request.EmployeeAttendance.First().Date.Date&&
x.EmployeeDetails.EmployeeProfessionalDetail.OfficeId == request.EmployeeAttendance.First().OfficeId &&
x.IsDeleted == false)
.ToListAsync();
//If leave Exists then check the status of leave if approved then add the working hours of the day in attendance hours
if (xEmployeeLeaveDetailList.Count != 0)
{
int monthDays = DateTime.DaysInMonth(request.EmployeeAttendance.First().Date.Year, request.EmployeeAttendance.First().Date.Month);
foreach (EmployeeApplyLeave xEmployeeApplyLeave in xEmployeeLeaveDetailList)
{
EmployeeMonthlyAttendance xEmployeeMonthlyAttendanceRecord = await _dbContext.EmployeeMonthlyAttendance.FirstOrDefaultAsync(x => x.EmployeeId == xEmployeeApplyLeave.EmployeeId && x.Month == request.EmployeeAttendance.First().Date.Date.Month&& x.Year == request.EmployeeAttendance.First().Date.Date.Year&& x.IsDeleted == false);
if (xEmployeeMonthlyAttendanceRecord == null)
{
EmployeeMonthlyAttendance xEmployeeMonthlyAttendance = new EmployeeMonthlyAttendance();
if (xEmployeeApplyLeave.ApplyLeaveStatusId == 1)
{
//remove hardcoded attendance hours once all office hours are available in master table
xEmployeeMonthlyAttendance.IsDeleted = false;
xEmployeeMonthlyAttendance.OfficeId = request.EmployeeAttendance.First().OfficeId;
xEmployeeMonthlyAttendance.EmployeeId = xEmployeeApplyLeave.EmployeeId;
xEmployeeMonthlyAttendance.Month = request.EmployeeAttendance.First().Date.Month;
xEmployeeMonthlyAttendance.Year = request.EmployeeAttendance.First().Date.Year;
xEmployeeMonthlyAttendance.AttendanceHours = xEmployeeMonthlyAttendance.AttendanceHours != null ? xEmployeeMonthlyAttendance.AttendanceHours.Value : 0;
//xEmployeeMonthlyAttendance.AttendanceHours += officeDailyHour;
xEmployeeMonthlyAttendance.LeaveHours += xEmployeeMonthlyAttendance.LeaveHours != null ? xEmployeeMonthlyAttendance.LeaveHours : 0;
xEmployeeMonthlyAttendance.LeaveHours += officeDailyHour;
xEmployeeMonthlyAttendance.TotalDuration = officeMonthlyHour;
Advances xAdvances = await _dbContext.Advances.Where(x => x.IsDeleted == false && x.IsApproved == true && x.IsDeducted == false &&
x.EmployeeId == xEmployeeApplyLeave.EmployeeId && x.OfficeId == request.EmployeeAttendance.First().OfficeId &&
x.AdvanceDate <= DateTime.Now).FirstOrDefaultAsync();
if (xAdvances != null)
{
xEmployeeMonthlyAttendance.AdvanceId = xAdvances.AdvancesId;
xEmployeeMonthlyAttendance.IsAdvanceApproved = xAdvances.IsApproved;
xEmployeeMonthlyAttendance.AdvanceAmount = xAdvances.AdvanceAmount - xAdvances.RecoveredAmount;
}
await _dbContext.EmployeeMonthlyAttendance.AddAsync(xEmployeeMonthlyAttendance);
await _dbContext.SaveChangesAsync();
}
else
{
xEmployeeMonthlyAttendance.IsDeleted = false;
xEmployeeMonthlyAttendance.OfficeId = request.EmployeeAttendance.First().OfficeId;
xEmployeeMonthlyAttendance.EmployeeId = xEmployeeApplyLeave.EmployeeId;
xEmployeeMonthlyAttendance.Month = request.EmployeeAttendance.First().Date.Month;
xEmployeeMonthlyAttendance.Year = request.EmployeeAttendance.First().Date.Year;
xEmployeeMonthlyAttendance.AbsentHours = xEmployeeMonthlyAttendance.AbsentHours == null ? 0 : xEmployeeMonthlyAttendance.AbsentHours;
xEmployeeMonthlyAttendance.AbsentHours += officeDailyHour;
xEmployeeMonthlyAttendance.TotalDuration = officeMonthlyHour;
Advances xAdvances = await _dbContext.Advances.Where(x => x.IsDeleted == false && x.IsApproved == true && x.IsDeducted == false &&
x.EmployeeId == xEmployeeApplyLeave.EmployeeId && x.OfficeId == request.EmployeeAttendance.First().OfficeId &&
x.AdvanceDate < DateTime.Now).FirstOrDefaultAsync();
if (xAdvances != null)
{
xEmployeeMonthlyAttendance.AdvanceId = xAdvances.AdvancesId;
xEmployeeMonthlyAttendance.AdvanceAmount = xAdvances.AdvanceAmount - xAdvances.RecoveredAmount;
xEmployeeMonthlyAttendance.IsAdvanceApproved = xAdvances.IsApproved;
}
await _dbContext.EmployeeMonthlyAttendance.AddAsync(xEmployeeMonthlyAttendance);
await _dbContext.SaveChangesAsync();
}
}
else//if Employee Monthly Attendance Record is present then add leave hours
{
if (xEmployeeApplyLeave.ApplyLeaveStatusId == (int)ApplyLeaveStatus.Approve)
{
xEmployeeMonthlyAttendanceRecord.LeaveHours = officeDailyHour;
_dbContext.EmployeeMonthlyAttendance.Update(xEmployeeMonthlyAttendanceRecord);
await _dbContext.SaveChangesAsync();
}
}
}
}
response.StatusCode = StaticResource.successStatusCode;
response.Message = "Success";
}
else
{
response.StatusCode = StaticResource.failStatusCode;
response.Message = "Office Hours Not Set";
}
}
catch (Exception ex)
{
response.StatusCode = StaticResource.failStatusCode;
response.Message = ex.Message;
}
return(response);
}
