1588 lines
72 KiB
C#
1588 lines
72 KiB
C#
using _0_Framework.Application;
|
|
using _0_Framework.Domain.CustomizeCheckoutShared.ValueObjects;
|
|
using Company.Domain.CheckoutAgg;
|
|
using Company.Domain.CheckoutAgg.ValueObjects;
|
|
using Company.Domain.ContractAgg;
|
|
using Company.Domain.EmployeeAgg;
|
|
using Company.Domain.empolyerAgg;
|
|
using Company.Domain.InsuranceListAgg;
|
|
using Company.Domain.LeaveAgg;
|
|
using Company.Domain.LeftWorkAgg;
|
|
using Company.Domain.LeftWorkInsuranceAgg;
|
|
using Company.Domain.RollCallAgg;
|
|
using Company.Domain.RollCallEmployeeAgg;
|
|
using Company.Domain.WorkingHoursTempAgg;
|
|
using Company.Domain.WorkshopAgg;
|
|
using Company.Domain.YearlySalaryAgg;
|
|
using CompanyManagment.App.Contracts.Checkout;
|
|
using CompanyManagment.App.Contracts.Checkout.Dto;
|
|
using CompanyManagment.App.Contracts.Contract;
|
|
using CompanyManagment.App.Contracts.HolidayItem;
|
|
using CompanyManagment.App.Contracts.Hubs;
|
|
using CompanyManagment.App.Contracts.InstitutionContract;
|
|
using CompanyManagment.App.Contracts.InsuranceList;
|
|
using CompanyManagment.App.Contracts.Leave;
|
|
using CompanyManagment.App.Contracts.MandantoryHours;
|
|
using CompanyManagment.App.Contracts.PersonalContractingParty;
|
|
using CompanyManagment.App.Contracts.RollCall;
|
|
using CompanyManagment.App.Contracts.WorkingHoursTemp;
|
|
using CompanyManagment.App.Contracts.Workshop;
|
|
using CompanyManagment.App.Contracts.YearlySalary;
|
|
using CompanyManagment.EFCore.Migrations;
|
|
using CompanyManagment.EFCore.Repository;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.AspNetCore.SignalR;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
|
|
|
|
namespace CompanyManagment.Application;
|
|
|
|
public class CheckoutApplication : ICheckoutApplication
|
|
{
|
|
private readonly ICheckoutRepository _checkoutRepository;
|
|
private readonly IYearlySalaryRepository _yearlySalaryRepository;
|
|
private readonly ILeftWorkRepository _leftWorkRepository;
|
|
private readonly IEmployerRepository _employerRepository;
|
|
private readonly IPersonalContractingPartyApp _contractingPartyApp;
|
|
private readonly ILeaveApplication _leaveApplication;
|
|
private readonly IMandatoryHoursApplication _mandatoryHoursApplication;
|
|
private readonly IRollCallMandatoryRepository _rollCallMandatoryRepository;
|
|
private readonly IRollCallRepository _rollCallRepository;
|
|
private readonly IHolidayItemApplication _holidayItemApplication;
|
|
private readonly IWorkingHoursTempRepository _workingHoursTempRepository;
|
|
private readonly IWorkshopRepository _workshopRepository;
|
|
private readonly IAuthHelper _authHelper;
|
|
private readonly IHubContext<CheckoutHub> _hubContext;
|
|
private readonly IRollCallEmployeeRepository _rollCallEmployeeRepository;
|
|
private readonly IContractRepository _contractRepository;
|
|
private readonly IInsuranceListRepository _insuranceListRepository;
|
|
private readonly ILeftWorkInsuranceRepository _leftWorkInsuranceRepository;
|
|
private readonly IInsuranceListApplication _insuranceListApplication;
|
|
|
|
|
|
|
|
public CheckoutApplication(ICheckoutRepository checkoutRepository, IYearlySalaryRepository yearlySalaryRepository,
|
|
ILeftWorkRepository leftWorkRepository,
|
|
IEmployerRepository employerRepository, IPersonalContractingPartyApp contractingPartyApp, ILeaveApplication leaveApplication, IMandatoryHoursApplication mandatoryHoursApplication, IRollCallMandatoryRepository rollCallMandatoryRepository, IRollCallRepository rollCallRepository, IHolidayItemApplication holidayItemApplication, IWorkingHoursTempRepository workingHoursTempRepository, IWorkshopRepository workshopRepository, IAuthHelper authHelper, IHubContext<CheckoutHub> hubContext, IRollCallEmployeeRepository rollCallEmployeeRepository, IContractRepository contractRepository, IInsuranceListRepository insuranceListRepository, ILeftWorkInsuranceRepository leftWorkInsuranceRepository, IInsuranceListApplication insuranceListApplication)
|
|
{
|
|
_checkoutRepository = checkoutRepository;
|
|
_yearlySalaryRepository = yearlySalaryRepository;
|
|
_leftWorkRepository = leftWorkRepository;
|
|
_employerRepository = employerRepository;
|
|
_contractingPartyApp = contractingPartyApp;
|
|
_leaveApplication = leaveApplication;
|
|
_mandatoryHoursApplication = mandatoryHoursApplication;
|
|
_rollCallMandatoryRepository = rollCallMandatoryRepository;
|
|
_rollCallRepository = rollCallRepository;
|
|
_holidayItemApplication = holidayItemApplication;
|
|
_workingHoursTempRepository = workingHoursTempRepository;
|
|
_workshopRepository = workshopRepository;
|
|
_authHelper = authHelper;
|
|
_hubContext = hubContext;
|
|
_rollCallEmployeeRepository = rollCallEmployeeRepository;
|
|
_contractRepository = contractRepository;
|
|
_insuranceListRepository = insuranceListRepository;
|
|
_leftWorkInsuranceRepository = leftWorkInsuranceRepository;
|
|
_insuranceListApplication = insuranceListApplication;
|
|
}
|
|
|
|
[SuppressMessage("ReSharper.DPA", "DPA0007: Large number of DB records", MessageId = "count: 241")]
|
|
public void Create(CreateCheckout command)
|
|
{
|
|
var operation = new OperationResult();
|
|
var syear = Convert.ToInt32(command.ContractStart.Substring(0, 4));
|
|
var smonth = Convert.ToInt32(command.ContractStart.Substring(5, 2));
|
|
string month = string.Empty;
|
|
switch (smonth)
|
|
{
|
|
case 1:
|
|
month = "فروردین";
|
|
break;
|
|
case 2:
|
|
month = "اردیبهشت";
|
|
break;
|
|
case 3:
|
|
month = "خرداد";
|
|
break;
|
|
case 4:
|
|
month = "تیر";
|
|
break;
|
|
case 5:
|
|
month = "مرداد";
|
|
break;
|
|
case 6:
|
|
month = "شهریور";
|
|
break;
|
|
case 7:
|
|
month = "مهر";
|
|
break;
|
|
case 8:
|
|
month = "آبان";
|
|
break;
|
|
case 9:
|
|
month = "آذر";
|
|
break;
|
|
case 10:
|
|
month = "دی";
|
|
break;
|
|
case 11:
|
|
month = "بهمن";
|
|
break;
|
|
case 12:
|
|
month = "اسفند";
|
|
break;
|
|
}
|
|
var year = syear.ToString();
|
|
|
|
#region SickLeav
|
|
|
|
//var serachModel = new LeaveSearchModel()
|
|
//{
|
|
// EmployeeId = command.EmployeeId,
|
|
// WorkshopId = command.WorkshopId,
|
|
// LeaveType = "استعلاجی",
|
|
// StartLeave = command.ContractStart,
|
|
// EndLeave = command.ContractEnd,
|
|
// IsAccepted = true,
|
|
//};
|
|
//var leavList = _leaveApplication.search(serachModel);
|
|
// int sickLeaveCount = 0;
|
|
//if (leavList.Count > 0)
|
|
//{
|
|
|
|
// foreach (var leave in leavList)
|
|
// {
|
|
// if (leave.StartLeaveGr < command.ContractStartGr && leave.EndLeaveGr <= command.ContractEndGr)
|
|
// {
|
|
// int res = (int)((leave.EndLeaveGr - command.ContractStartGr).TotalDays +1);
|
|
// sickLeaveCount += res;
|
|
// }
|
|
// else if (leave.StartLeaveGr >= command.ContractStartGr && leave.EndLeaveGr > command.ContractEndGr)
|
|
// {
|
|
// int res = (int)((command.ContractEndGr - leave.StartLeaveGr).TotalDays + 1);
|
|
// sickLeaveCount += res;
|
|
// }
|
|
// else
|
|
// {
|
|
// int res = (int)((leave.EndLeaveGr - leave.StartLeaveGr).TotalDays + 1);
|
|
// sickLeaveCount += res;
|
|
// }
|
|
|
|
// }
|
|
//}
|
|
|
|
#endregion
|
|
|
|
var dayliWage = command.DayliWage.MoneyToDouble();
|
|
// کمک هزینه اقلام
|
|
var consumableItem = command.ConsumableItems.MoneyToDouble();
|
|
//حق اولاد
|
|
var familyAllowance = command.FamilyAllowance.MoneyToDouble();
|
|
//کمک هزینه مسکن
|
|
var housingAllowance = command.HousingAllowance.MoneyToDouble();
|
|
//حق تاهل
|
|
var marriedAllowance = command.MarriedAllowance.MoneyToDouble();
|
|
//var MontlyYearsBunos =
|
|
//_yearlySalaryRepository.GetMontlyBunosYears(command.WeeklyTime, command.ContractStartGr, command.ContractEndGr, dayliWage, command.WorkingWeeklyTime, command.officialholiday, command.friday, command.TotalHolidaysAndNotH, command.TotalHolidaysAndNotM, command.Basic, command.FridayStarttoEnd, command.DailFeeComplete, command.HasRollCall, command.HolidayWorking, command.ShiftWork);
|
|
//دستمزد ماهانه
|
|
|
|
#region Salary
|
|
|
|
var totalDays = (command.ContractEndGr - command.ContractStartGr).TotalDays + 1;
|
|
|
|
var mandatoryDays = totalDays - command.FridayStarttoEnd - command.officialholiday;
|
|
|
|
if (!command.HasRollCall && command.ShiftWork != "4")
|
|
mandatoryDays = totalDays - command.FridayStarttoEnd;
|
|
var monthlyWage = command.DailySalaryAffected * totalDays;
|
|
|
|
//پایه سنوات
|
|
var bacicYears = command.BaseYearAffected * totalDays;
|
|
#endregion
|
|
|
|
//سنوات
|
|
var years = command.YearsPay;
|
|
//عیدی و پاداش
|
|
var bunos = command.BonusesPay;
|
|
|
|
//فاطمه احمدژاد === موقت عیدی و پاداش و سنوات حساب نشه
|
|
if (command.EmployeeId == 45104 && command.WorkshopId == 315)
|
|
{
|
|
years = 0;
|
|
|
|
bunos = 0;
|
|
}
|
|
|
|
var sumOfWorkingDays = $"{totalDays}";
|
|
if (command.friday > 0)
|
|
{
|
|
var fridayPercent = dayliWage * 40 / 100;
|
|
//فوق العاده جمعه کاری
|
|
command.FridayPay = fridayPercent * command.friday;
|
|
}
|
|
//حق بیمه سهم کارگر
|
|
#region InsuranceDeduction
|
|
|
|
double insuranceDeduction = 0;
|
|
bool hasInsuranceShareTheSameAsList = false;
|
|
if (command.InsuranceDeduction == 0)
|
|
{
|
|
var insuranceOverTime = command.HasInsuranceChekoutOverTime ? command.OvertimePay : 0;
|
|
insuranceDeduction = (monthlyWage + bacicYears + consumableItem + housingAllowance + marriedAllowance + insuranceOverTime) * 7 / 100;
|
|
}
|
|
else
|
|
{
|
|
insuranceDeduction = command.InsuranceDeduction;
|
|
hasInsuranceShareTheSameAsList = true;
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
if (command.OvertimePay > 0 && command.AbsenceDeduction > 0)
|
|
{
|
|
if (command.AbsenceDeduction >= command.OvertimePay)
|
|
{
|
|
command.AbsenceDeduction = command.AbsenceDeduction - command.OvertimePay;
|
|
command.OvertimePay = 0;
|
|
command.OverTimeWorkValue = "00:00";
|
|
}
|
|
else
|
|
{
|
|
command.OvertimePay = command.OvertimePay - command.AbsenceDeduction;
|
|
command.AbsenceDeduction = 0;
|
|
}
|
|
|
|
}
|
|
var checkoutStart = $"{command.Year}/{command.Month}/01";
|
|
var checkoutEnd = checkoutStart.FindeEndOfMonth();
|
|
var salaryAids =
|
|
_rollCallMandatoryRepository.SalaryAidsForCheckout(command.EmployeeId, command.WorkshopId, checkoutStart.ToGeorgianDateTime(), checkoutEnd.ToGeorgianDateTime())
|
|
.Select(x => new CheckoutSalaryAid(x.Amount, x.SalaryAidDateTimeGe, x.SalaryAidDateTimeFa, x.CalculationDateTimeGe, x.CalculationDateTimeFa, x.Id)).ToList();
|
|
|
|
command.SalaryAidDeduction = salaryAids.Sum(x => x.Amount.MoneyToDouble());
|
|
|
|
var loanInstallments = _rollCallMandatoryRepository.LoanInstallmentForCheckout(command.EmployeeId,
|
|
command.WorkshopId, command.ContractStartGr, command.HasLeft ? DateTime.MaxValue : command.ContractEndGr)
|
|
.Select(x =>
|
|
new CheckoutLoanInstallment(x.Amount, x.Month, x.Year, x.IsActive, x.RemainingAmount, x.LoanAmount, x.Id)).ToList();
|
|
|
|
command.InstallmentDeduction = loanInstallments.Sum(x => x.AmountForMonth.MoneyToDouble());
|
|
|
|
var rewards = new List<CheckoutReward>();
|
|
double rewardPay = 0;
|
|
if (command.RewardPayCompute)
|
|
{
|
|
rewards = _rollCallMandatoryRepository.RewardForCheckout(command.EmployeeId, command.WorkshopId, checkoutEnd.ToGeorgianDateTime(), checkoutStart.ToGeorgianDateTime())
|
|
.Select(x => new CheckoutReward(x.Amount, x.AmountDouble, x.GrantDateFa, x.GrantDateGr, x.Description, x.Title, x.Id)).ToList();
|
|
|
|
rewardPay = rewards.Sum(x => x.AmountDouble);
|
|
}
|
|
|
|
|
|
|
|
|
|
var firstDayOfMonth = $"{command.ContractStart.Substring(0, 8)}01".ToGeorgianDateTime();
|
|
var firstDayOfCurrentMonth = new DateTime(syear, smonth, 1, new PersianCalendar());
|
|
|
|
LeaveSearchModel sickLeaveSearch = new LeaveSearchModel()
|
|
{
|
|
EmployeeId = command.EmployeeId,
|
|
WorkshopId = command.WorkshopId,
|
|
StartLeaveGr = command.ContractStartGr,
|
|
EndLeaveGr = command.ContractEndGr,
|
|
IsAccepted = true,
|
|
};
|
|
var leaves = _leaveApplication.search(sickLeaveSearch);
|
|
|
|
firstDayOfMonth.AddMonthsFa(1, out var lastDayOfCurrentMonth);
|
|
|
|
lastDayOfCurrentMonth = lastDayOfCurrentMonth.AddDays(-1);
|
|
|
|
int dateRange = (int)(lastDayOfCurrentMonth - firstDayOfCurrentMonth).TotalDays + 1;
|
|
|
|
var holidays = _holidayItemApplication.Search(new HolidayItemSearchModel()
|
|
{
|
|
HolidayYear = command.ContractStartGr.ToFarsiYear()
|
|
});
|
|
//all the dates from start to end, to be compared with present days to get absent dates
|
|
var completeDaysList = Enumerable.Range(0, dateRange).Select(offset => firstDayOfCurrentMonth.AddDays(offset).Date).ToList();
|
|
|
|
var absentRecords = completeDaysList
|
|
.ExceptBy(command.GroupedRollCalls.Select(x => x.CreationDate.Date), y => y.Date)
|
|
.Select(x =>
|
|
{
|
|
var leave = leaves.FirstOrDefault(y =>
|
|
y.EmployeeId == command.EmployeeId && y.EndLeaveGr.Date >= x.Date && y.StartLeaveGr.Date <= x.Date);
|
|
var isHoliday = holidays.Any(y => y.HolidaydateGr == x.Date);
|
|
var isFriday = x.Date.DayOfWeek == DayOfWeek.Friday;
|
|
var isNormalWorkingDay = isHoliday == false && isFriday == false;
|
|
return new CheckoutDailyRollCallViewModel()
|
|
{
|
|
StartDate1 = null,
|
|
EndDate1 = null,
|
|
DateTimeGr = x.Date,
|
|
DayOfWeek = x.Date.DayOfWeek.ToString(),
|
|
RollCallDateFa = x.Date.ToFarsi(),
|
|
LeaveType = leave != null ? leave.LeaveType : "",
|
|
IsAbsent = leave == null && isNormalWorkingDay
|
|
};
|
|
});
|
|
|
|
var presentDays = command.GroupedRollCalls.Select(x =>
|
|
{
|
|
|
|
var orderedRollcalls = x.ShiftList.OrderBy(y => y.Start);
|
|
|
|
var rollCallTimeSpanPerDay = x.SumOneDaySpan;
|
|
TimeSpan breakTimePerDay = x.BreakTime;
|
|
|
|
return new CheckoutDailyRollCallViewModel()
|
|
{
|
|
StartDate1 = orderedRollcalls.FirstOrDefault().Start.ToString("HH:mm"),
|
|
EndDate1 = orderedRollcalls.FirstOrDefault().EndWithOutResTime.ToString("HH:mm"),
|
|
|
|
StartDate2 = orderedRollcalls.Skip(1).FirstOrDefault()?.Start.ToString("HH:mm") ?? "",
|
|
EndDate2 = orderedRollcalls.Skip(1).FirstOrDefault()?.EndWithOutResTime.ToString("HH:mm") ?? "",
|
|
|
|
TotalhourseSpan = rollCallTimeSpanPerDay,
|
|
|
|
BreakTimeTimeSpan = breakTimePerDay,
|
|
|
|
DayOfWeek = x.CreationDate.DayOfWeek.DayOfWeeKToPersian(),
|
|
RollCallDateFa = x.CreationDate.Date.ToFarsi(),
|
|
DateTimeGr = x.CreationDate.Date,
|
|
IsSliced = x.ShiftList.Count() > 2,
|
|
IsAbsent = false
|
|
};
|
|
});
|
|
|
|
|
|
presentDays = presentDays.Select(x => new CheckoutDailyRollCallViewModel
|
|
{
|
|
StartDate1 = x.StartDate1,
|
|
EndDate1 = x.EndDate1,
|
|
EndDate2 = x.EndDate2,
|
|
StartDate2 = x.StartDate2,
|
|
TotalWorkingHours = $"{(int)(x.TotalhourseSpan.TotalHours)}:{x.TotalhourseSpan.Minutes:00}",
|
|
BreakTimeString = $"{(int)(x.BreakTimeTimeSpan.TotalHours)}:{x.BreakTimeTimeSpan.Minutes:00}",
|
|
TotalhourseSpan = x.TotalhourseSpan,
|
|
BreakTimeTimeSpan = x.BreakTimeTimeSpan,
|
|
DayOfWeek = x.DayOfWeek,
|
|
RollCallDateFa = x.RollCallDateFa,
|
|
DateTimeGr = x.DateTimeGr,
|
|
IsSliced = x.IsSliced,
|
|
IsAbsent = false
|
|
});
|
|
|
|
var result = presentDays.Concat(absentRecords).OrderBy(x => x.DateTimeGr).ToList();
|
|
result.ForEach(x =>
|
|
{
|
|
x.IsHoliday = holidays.Any(y => x.DateTimeGr.Date == y.HolidaydateGr.Date);
|
|
x.IsFriday = x.DateTimeGr.DayOfWeek == DayOfWeek.Friday;
|
|
});
|
|
|
|
var checkoutRollCallDays = result.Select(x => new CheckoutRollCallDay(x.DateTimeGr,
|
|
x.StartDate1, x.EndDate1, x.StartDate2, x.EndDate2,
|
|
x.BreakTimeTimeSpan, x.IsSliced, x.TotalhourseSpan, x.IsAbsent, x.IsFriday, x.IsHoliday, x.LeaveType))
|
|
.ToList();
|
|
|
|
|
|
double mandatoryHours = _mandatoryHoursApplication.GetMandatoryHoursByYearAndMonth(syear, smonth);
|
|
int mandatoryWholeHours = (int)mandatoryHours;
|
|
int mandatoryMinutes = (int)((mandatoryHours - mandatoryWholeHours) * 60);
|
|
|
|
var totalMandatoryHours = TimeSpan.FromHours(mandatoryWholeHours).Add(TimeSpan.FromMinutes(mandatoryMinutes));
|
|
var checkoutRollCall = new CheckoutRollCall(totalMandatoryHours, command.TotalPresentTimeSpan, command.TotalBreakTimeSpan,
|
|
command.TotalWorkingTimeSpan, command.TotalPaidLeave, command.TotalSickLeave, checkoutRollCallDays);
|
|
|
|
|
|
|
|
|
|
var totalClaimsDouble = monthlyWage + bacicYears + consumableItem + housingAllowance + marriedAllowance + command.OvertimePay +
|
|
command.NightworkPay + familyAllowance + bunos + years + command.LeavePay + command.FridayPay + command.ShiftPay + rewardPay;
|
|
var totalClaims = totalClaimsDouble.ToMoney();
|
|
var totalDeductionDouble = insuranceDeduction + command.AbsenceDeduction + command.InstallmentDeduction + command.SalaryAidDeduction;
|
|
var totalDeductions = totalDeductionDouble.ToMoney();
|
|
var totalPayment = totalClaimsDouble - totalDeductionDouble;
|
|
|
|
if (_checkoutRepository.Exists(x =>
|
|
x.Month == command.Month && x.Year == command.Year && x.ContractNo == command.ContractNo))
|
|
{
|
|
operation.Failed("امکان ثبت رکورد تکراری وجود ندارد");
|
|
}
|
|
else
|
|
{
|
|
if (string.IsNullOrWhiteSpace(command.Signature))
|
|
{
|
|
command.Signature = "0";
|
|
}
|
|
|
|
|
|
var checkout = new Checkout(command.EmployeeFullName, command.FathersName, command.NationalCode
|
|
, command.DateOfBirth, command.EmployeeId, command.WorkshopName, command.WorkshopId, command.ContractNo, command.ContractStartGr, command.ContractEndGr, month, year,
|
|
command.ContractId, command.WorkingHoursId, monthlyWage, bacicYears, consumableItem, housingAllowance
|
|
, command.OvertimePay, command.NightworkPay, command.FridayPay, 0, command.ShiftPay, familyAllowance, bunos, years, command.LeavePay, insuranceDeduction, 0, command.InstallmentDeduction, command.SalaryAidDeduction, command.AbsenceDeduction, sumOfWorkingDays,
|
|
command.ArchiveCode, command.PersonnelCode, totalClaims, totalDeductions, totalPayment, command.Signature, marriedAllowance, command.LeaveCheckout, command.CreditLeaves, command.AbsencePeriod, command.AverageHoursPerDay, command.HasRollCall, command.OverTimeWorkValue, command.OverNightWorkValue
|
|
, command.FridayWorkValue, command.RotatingShiftValue, command.AbsenceValue, command.TotalDayOfLeaveCompute, command.TotalDayOfYearsCompute, command.TotalDayOfBunosesCompute,
|
|
loanInstallments, salaryAids, checkoutRollCall, command.EmployeeMandatoryHours, hasInsuranceShareTheSameAsList, rewards, rewardPay);
|
|
|
|
_checkoutRepository.CreateCheckout(checkout).GetAwaiter().GetResult();
|
|
//_checkoutRepository.SaveChanges();
|
|
|
|
//var employeeFullName = new SqlParameter("@EmployeeFullName", SqlDbType.NVarChar, 50);
|
|
//employeeFullName.Value = command.EmployeeFullName;
|
|
//var fathersName = new SqlParameter("@FathersName", SqlDbType.NVarChar, 20);
|
|
//fathersName.Value = command.EmployeeFullName;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public OperationResult Edit(EditCheckout command)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public EditCheckout GetDetails(long id)
|
|
{
|
|
return _checkoutRepository.GetDetails(id);
|
|
}
|
|
|
|
public async Task<CreateCheckoutListViewModel> GetContractResultToCreateCheckout(long workshopId, long employeeId, string year, string month,
|
|
string contractStart, string contractEnd)
|
|
{
|
|
return await _checkoutRepository.GetContractResultToCreateCheckout(workshopId, employeeId, year, month, contractStart,
|
|
contractEnd);
|
|
|
|
}
|
|
|
|
public Task<List<CheckoutViewModel>> SearchCheckoutOptimized(CheckoutSearchModel searchModel)
|
|
{
|
|
return _checkoutRepository.SearchCheckoutOptimized(searchModel);
|
|
}
|
|
|
|
public async Task<List<CheckoutViewModel>> Search(CheckoutSearchModel searchModel)
|
|
{
|
|
var watch = System.Diagnostics.Stopwatch.StartNew();
|
|
watch.Start();
|
|
var result = new List<CheckoutViewModel>();
|
|
var query = await _checkoutRepository.SearchForMainCheckout(searchModel);
|
|
query = query.Select(x => new CheckoutViewModel()
|
|
{
|
|
Id = x.Id,
|
|
EmployeeFullName = x.EmployeeFullName,
|
|
ContractStart = x.ContractStart,
|
|
ContractEnd = x.ContractEnd,
|
|
ContractStartGr = x.ContractStartGr,
|
|
ContractEndGr = x.ContractEndGr,
|
|
PersonnelCode = x.PersonnelCode,
|
|
PersonnelCodeInt = x.PersonnelCodeInt,
|
|
ArchiveCode = x.ArchiveCode,
|
|
SumOfWorkingDays = x.SumOfWorkingDays,
|
|
WorkshopName = x.WorkshopName,
|
|
Month = x.Month,
|
|
Year = x.Year,
|
|
ContractNo = x.ContractNo,
|
|
ContractId = x.ContractId,
|
|
WorkshopId = x.WorkshopId,
|
|
EmployeeId = x.EmployeeId,
|
|
IsActiveString = x.IsActiveString,
|
|
Signature = x.Signature,
|
|
CreationDate = x.CreationDate,
|
|
EmployerName = _employerRepository.GetEmployerByWorkshopId(x.WorkshopId).FirstOrDefault()?.EmployerFullName,
|
|
IsBlockCantracingParty = _employerRepository.GetEmployerByWorkshopId(x.WorkshopId).FirstOrDefault()?.IsBlockContractingParty,
|
|
}).ToList();
|
|
//foreach (var items in query)
|
|
//{
|
|
// var s = _employerRepository.GetEmployerByWorkshopId(items.WorkshopId);
|
|
// if (s != null)
|
|
// {
|
|
// items.EmployerName = s.FirstOrDefault().EmployerFullName;
|
|
// }
|
|
// result.Add(items);
|
|
// //var employeId = _context.WorkshopEmployers?.Where(x => x.WorkshopId == items.WorkshopId)
|
|
// // .Select(x => x.EmployerId).FirstOrDefault();
|
|
// //var employerName = _context.Employers?.FirstOrDefault(x => x.id == employeId).FullName;
|
|
// // = employerName;
|
|
|
|
//}
|
|
Console.WriteLine("old : " + watch.Elapsed);
|
|
return query;
|
|
|
|
}
|
|
|
|
public List<CheckoutViewModel> SimpleSearch(CheckoutSearchModel searchModel)
|
|
{
|
|
return _checkoutRepository.SimpleSearch(searchModel);
|
|
}
|
|
|
|
public List<CheckoutViewModel> PrintAll(List<long> id)
|
|
{
|
|
var result = _checkoutRepository.PrintAll(id);
|
|
var oneRecord = result.FirstOrDefault();
|
|
if (oneRecord == null)
|
|
return new();
|
|
result.ForEach(x =>
|
|
{
|
|
|
|
|
|
int yearFa;
|
|
int monthFa;
|
|
try
|
|
{
|
|
yearFa = int.Parse(oneRecord.Year);
|
|
monthFa = oneRecord.Month.ToMonthByStringValue();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return;
|
|
}
|
|
double mandatoryHours = _mandatoryHoursApplication.GetMandatoryHoursByYearAndMonth(yearFa, monthFa);
|
|
int mandatoryWholeHours = (int)mandatoryHours;
|
|
int mandatoryMinutes = (int)((mandatoryHours - mandatoryWholeHours) * 60);
|
|
var totalWorking = new TimeSpan(x.MonthlyRollCall.Sum(y => y.TotalhourseSpan.Ticks));
|
|
var totalBreakTime = new TimeSpan(x.MonthlyRollCall.Sum(y => y.BreakTimeTimeSpan.Ticks));
|
|
TimeSpan totalPresent = totalWorking + totalBreakTime;
|
|
if (x.CheckoutRollCall == null)
|
|
{
|
|
if (x.HasRollCall)
|
|
{
|
|
totalWorking = new TimeSpan(x.MonthlyRollCall.Sum(x => x.TotalhourseSpan.Ticks)) -
|
|
x.TotalHourlyLeave;
|
|
totalBreakTime = new TimeSpan(x.MonthlyRollCall.Sum(x => x.BreakTimeTimeSpan.Ticks));
|
|
totalPresent = totalWorking + totalBreakTime;
|
|
}
|
|
else
|
|
{
|
|
totalBreakTime = new TimeSpan(x.MonthlyRollCall.Sum(x => x.BreakTimeTimeSpan.Ticks));
|
|
totalPresent = new TimeSpan(x.MonthlyRollCall.Sum(x => x.TotalhourseSpan.Ticks));
|
|
totalWorking = totalPresent - totalBreakTime;
|
|
}
|
|
|
|
x.TotalWorkingTimeStr =
|
|
Tools.ToFarsiHoursAndMinutes((int)totalWorking.TotalHours, totalWorking.Minutes, "-");
|
|
x.TotalBreakTimeStr =
|
|
Tools.ToFarsiHoursAndMinutes((int)totalBreakTime.TotalHours, totalBreakTime.Minutes, "-");
|
|
x.TotalPresentTimeStr =
|
|
Tools.ToFarsiHoursAndMinutes((int)totalPresent.TotalHours, totalPresent.Minutes, "-");
|
|
x.TotalMandatoryTimeStr = Tools.ToFarsiHoursAndMinutes(mandatoryWholeHours, mandatoryMinutes, "-");
|
|
|
|
}
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
public CheckoutViewModel PrintOne(long id)
|
|
{
|
|
var result = _checkoutRepository.PrintOne(id);
|
|
|
|
int yearFa;
|
|
int monthFa;
|
|
try
|
|
{
|
|
yearFa = int.Parse(result.Year);
|
|
monthFa = result.Month.ToMonthByStringValue();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return new();
|
|
}
|
|
double mandatoryHours = _mandatoryHoursApplication.GetMandatoryHoursByYearAndMonth(yearFa, monthFa);
|
|
int mandatoryWholeHours = (int)mandatoryHours;
|
|
int mandatoryMinutes = (int)((mandatoryHours - mandatoryWholeHours) * 60);
|
|
TimeSpan totalWorking;
|
|
TimeSpan totalBreakTime;
|
|
TimeSpan totalPresent;
|
|
TimeSpan totalHoursLeave;
|
|
if (result.HasRollCall)
|
|
{
|
|
totalWorking = new TimeSpan(result.MonthlyRollCall.Sum(x => x.TotalhourseSpan.Ticks)) - result.TotalHourlyLeave;
|
|
totalBreakTime = new TimeSpan(result.MonthlyRollCall.Sum(x => x.BreakTimeTimeSpan.Ticks));
|
|
totalPresent = totalWorking + totalBreakTime;
|
|
}
|
|
else
|
|
{
|
|
totalBreakTime = new TimeSpan(result.MonthlyRollCall.Sum(x => x.BreakTimeTimeSpan.Ticks));
|
|
totalPresent = new TimeSpan(result.MonthlyRollCall.Sum(x => x.TotalhourseSpan.Ticks));
|
|
totalWorking = totalPresent - totalBreakTime;
|
|
}
|
|
|
|
result.TotalWorkingTimeStr = Tools.ToFarsiHoursAndMinutes((int)totalWorking.TotalHours, totalWorking.Minutes, "-");
|
|
result.TotalBreakTimeStr = Tools.ToFarsiHoursAndMinutes((int)totalBreakTime.TotalHours, totalBreakTime.Minutes, "-");
|
|
result.TotalPresentTimeStr = Tools.ToFarsiHoursAndMinutes((int)totalPresent.TotalHours, totalPresent.Minutes, "-");
|
|
result.TotalMandatoryTimeStr = Tools.ToFarsiHoursAndMinutes(mandatoryWholeHours, mandatoryMinutes, "-");
|
|
|
|
return result;
|
|
}
|
|
|
|
public CheckoutLeavePrintViewModel LeavePrint(long id)
|
|
{
|
|
return _checkoutRepository.PrintLeave(id);
|
|
}
|
|
|
|
public OperationResult Sign(long id)
|
|
{
|
|
var opration = new OperationResult();
|
|
var contract = _checkoutRepository.Get(id);
|
|
if (contract == null)
|
|
return opration.Failed("رکورد مورد نظر یافت نشد");
|
|
|
|
contract.Sign();
|
|
|
|
|
|
_checkoutRepository.SaveChanges();
|
|
opration.IsSuccedded = true;
|
|
return opration.Succcedded();
|
|
}
|
|
|
|
public OperationResult UnSign(long id)
|
|
{
|
|
var opration = new OperationResult();
|
|
var contract = _checkoutRepository.Get(id);
|
|
if (contract == null)
|
|
return opration.Failed("رکورد مورد نظر یافت نشد");
|
|
|
|
contract.UnSign();
|
|
|
|
|
|
_checkoutRepository.SaveChanges();
|
|
opration.IsSuccedded = true;
|
|
return opration.Succcedded();
|
|
}
|
|
|
|
public OperationResult Active(long id)
|
|
{
|
|
var opration = new OperationResult();
|
|
var contract = _checkoutRepository.Get(id);
|
|
if (contract == null)
|
|
return opration.Failed("رکورد مورد نظر یافت نشد");
|
|
|
|
contract.Active();
|
|
|
|
_checkoutRepository.SaveChanges();
|
|
return opration.Succcedded();
|
|
}
|
|
|
|
public OperationResult DeActive(long id)
|
|
{
|
|
var opration = new OperationResult();
|
|
var contract = _checkoutRepository.Get(id);
|
|
if (contract == null)
|
|
return opration.Failed("رکورد مورد نظر یافت نشد");
|
|
|
|
contract.DeActive();
|
|
|
|
|
|
_checkoutRepository.SaveChanges();
|
|
|
|
return opration.Succcedded();
|
|
}
|
|
|
|
public OperationResult RemoveCheckout(long id)
|
|
{
|
|
return _checkoutRepository.RemoveCheckout(id);
|
|
}
|
|
|
|
public OperationResult CustomSet(long id, double rewardPay, double salaryAidDeduction)
|
|
{
|
|
var opration = new OperationResult();
|
|
var checkout = _checkoutRepository.Get(id);
|
|
var totalClaimsDouble = checkout.TotalClaims.MoneyToDouble();
|
|
var totalDeductionsDouble = checkout.TotalDeductions.MoneyToDouble();
|
|
totalClaimsDouble = (double)(totalClaimsDouble - checkout.RewardPay);
|
|
totalDeductionsDouble = totalDeductionsDouble - checkout.SalaryAidDeduction;
|
|
|
|
var totalClaims = totalClaimsDouble + rewardPay;
|
|
var totalDeductions = totalDeductionsDouble + salaryAidDeduction;
|
|
|
|
|
|
|
|
var totalClaimsString = totalClaims.ToMoney();
|
|
var totalDeductionsString = totalDeductions.ToMoney();
|
|
var totalPayment = totalClaims - totalDeductions;
|
|
|
|
checkout.CustomSet(rewardPay, salaryAidDeduction, totalClaimsString, totalDeductionsString, totalPayment);
|
|
|
|
_checkoutRepository.SaveChanges();
|
|
opration.IsSuccedded = true;
|
|
return opration.Succcedded();
|
|
}
|
|
|
|
#region Client
|
|
|
|
public List<CheckoutViewModel> SearchForClient(CheckoutSearchModel searchModel)
|
|
{
|
|
return _checkoutRepository.SearchForClient(searchModel);
|
|
}
|
|
|
|
#endregion
|
|
#region NewChangeByHeydari
|
|
public List<long> CheckHasSignature(List<long> ids)
|
|
{
|
|
return _checkoutRepository.CheckHasSignature(ids);
|
|
}
|
|
public OperationResult DeleteAllCheckouts(List<long> ids)
|
|
{
|
|
return _checkoutRepository.DeleteAllCheckouts(ids);
|
|
}
|
|
public OperationResult DeleteCheckout(long id)
|
|
{
|
|
return _checkoutRepository.DeleteCheckout(id);
|
|
}
|
|
public async Task<List<CheckoutViewModel>> SearchForMainCheckout(CheckoutSearchModel searchModel)
|
|
{
|
|
return await _checkoutRepository.SearchForMainCheckout(searchModel);
|
|
}
|
|
#endregion
|
|
#region Pooya
|
|
|
|
|
|
public List<(long EmployeeId, DateTime CheckoutStart, DateTime CheckoutEnd)> GetLastCheckoutsByWorkshopIdForWorkFlow(long workshopId, DateTime start, DateTime end)
|
|
{
|
|
return _checkoutRepository.GetLastCheckoutsByWorkshopIdForWorkFlow(workshopId, start, end);
|
|
}
|
|
|
|
public async Task<PagedResult<CheckoutListClientDto>> GetListForClient(long workshopId,CheckoutListClientSearchModel searchModel)
|
|
{
|
|
return await _checkoutRepository.GetListForClient(workshopId, searchModel);
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#region ForApi
|
|
|
|
#region CreateWorkshop
|
|
|
|
/// <summary>
|
|
/// دریافت سلکت لیست پرسنل کارگاه
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
public async Task<List<EmployeeSelectListDto>> GetEmployeeSelectListByWorkshopId(long id)
|
|
{
|
|
return await _checkoutRepository.GetEmployeeSelectListByWorkshopId(id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// دریافت لیست قراردادها برای ایجاد فیش حقوقی
|
|
/// </summary>
|
|
/// <param name="workshopId"></param>
|
|
/// <param name="year"></param>
|
|
/// <param name="month"></param>
|
|
/// <param name="employeeId"></param>
|
|
/// <returns></returns>
|
|
public async Task<OperationResult<List<ContractsListToCreateCheckoutDto>>> GetContractToCreateCheckout(long workshopId, string year, string month, long employeeId)
|
|
{
|
|
var op = new OperationResult<List<ContractsListToCreateCheckoutDto>>();
|
|
if (workshopId < 1)
|
|
return op.Failed("کارگاه را انتخاب کنید");
|
|
|
|
if (!string.IsNullOrWhiteSpace(year) && string.IsNullOrWhiteSpace(month))
|
|
return op.Failed("ماه را انتخاب کنید");
|
|
if (string.IsNullOrWhiteSpace(year) && !string.IsNullOrWhiteSpace(month))
|
|
return op.Failed("سال را انتخاب کنید");
|
|
|
|
if (string.IsNullOrWhiteSpace(year) && string.IsNullOrWhiteSpace(month))
|
|
{
|
|
year = "0";
|
|
month = "0";
|
|
}
|
|
|
|
|
|
var result = await GetContractResultToCreateCheckout(workshopId, employeeId, year, month, null,
|
|
null);
|
|
if (result.CreateCheckoutList.Count == 0)
|
|
return op.Failed("موردی یافت نشد");
|
|
var finalResult = result.CreateCheckoutList.Select(x => new ContractsListToCreateCheckoutDto
|
|
{
|
|
Id = x.Id,
|
|
ContractNo = x.ContractNo,
|
|
WorkshopName = x.WorkshopName,
|
|
EmployeeName = x.EmployeeName,
|
|
ContractStart = x.ContractStart,
|
|
ContractEnd = x.ContractEnd,
|
|
PersonnelCode = x.PersonnelCode,
|
|
Description = x.Description,
|
|
LeftWorkDate = x.LeftWorkDate,
|
|
CreateCheckoutStatus = x.HasCheckout ? CreateCheckoutStatus.HasCheckout : x.Extension == false ? CreateCheckoutStatus.NotValid : CreateCheckoutStatus.ReadyToCreate
|
|
|
|
}).ToList();
|
|
|
|
return op.Succcedded(finalResult);
|
|
}
|
|
|
|
|
|
public async Task<OperationResult> CreateCheckoutApi(List<long> ids, string year, string month, long workshopId)
|
|
{
|
|
|
|
var op = new OperationResult();
|
|
|
|
//آی دی کاربر لاگین شده برای استفاده در signalR
|
|
var currntAcc = _authHelper.CurrentAccountId();
|
|
|
|
var signalR = _hubContext.Clients.Group(CheckoutHub.GetGroupName(currntAcc));
|
|
|
|
|
|
|
|
|
|
var getContractsData = await
|
|
_checkoutRepository.GetContractsAndIncludeDataDataToCreateCheckout(ids, year, month, workshopId);
|
|
|
|
|
|
#region GetInsuranceData
|
|
|
|
|
|
|
|
var startMonthFa = $"{year}/{month.PadLeft(2, '0')}/01";
|
|
DateTime startDateGr = startMonthFa.ToGeorgianDateTime();
|
|
DateTime endDateGr = startMonthFa.FindeEndOfMonth().ToGeorgianDateTime();
|
|
int endOfMonth = Convert.ToInt32((startMonthFa.FindeEndOfMonth()).Substring(8, 2));
|
|
|
|
|
|
var insuranceListData =
|
|
_insuranceListRepository.EmployeeInsuranceDataBy(startDateGr, getContractsData.Data.WorkshopId);
|
|
var yearlysaleries = _yearlySalaryRepository.GetInsuranceItems(startDateGr, endDateGr, year);
|
|
|
|
var insuranceEmployeeData =
|
|
_leftWorkInsuranceRepository.GetEmployeeInsuranceLeftWorksAndInformation(getContractsData.Data.WorkshopId, startDateGr,
|
|
endDateGr);
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
if (!getContractsData.IsSuccedded)
|
|
{
|
|
|
|
await signalR.SendAsync("StartProcessingFailed", getContractsData.Message);
|
|
return op.Failed(getContractsData.Message);
|
|
}
|
|
|
|
|
|
var timer = new Stopwatch();
|
|
timer.Start();
|
|
|
|
int successProcess = 1;
|
|
int countList = getContractsData.Data.ContractIncludedData.Count;
|
|
List<string> createFailedList = [];
|
|
int createSuccessCount = 0;
|
|
int createFailedCount = 0;
|
|
foreach (var item in getContractsData.Data.ContractIncludedData)
|
|
{
|
|
|
|
try
|
|
{
|
|
//آیا کل مرخصی به ساعت کاراضافه شود؟
|
|
bool totalLeaveCompute = false;
|
|
//آیا غیبت محاسبه شود؟
|
|
bool abcenseDeductionCompute = false;
|
|
switch (item.ComputeOption)
|
|
{
|
|
case "OnEndOfYear":
|
|
var endOfYearCheckout = item.Separation.ContractEnd.Substring(5, 2);
|
|
|
|
totalLeaveCompute = true;
|
|
abcenseDeductionCompute = item.Separation.HasLeft || endOfYearCheckout == "12";
|
|
break;
|
|
case "OnLeftWork":
|
|
|
|
totalLeaveCompute = true;
|
|
abcenseDeductionCompute = item.Separation.HasLeft;
|
|
break;
|
|
case "OnEndOfContract":
|
|
var startMonth = item.ContractStart.Substring(5, 2);
|
|
var endMonth = item.ContractEnd.Substring(5, 2);
|
|
|
|
totalLeaveCompute = startMonth != endMonth;
|
|
abcenseDeductionCompute = (startMonth != endMonth && item.Separation.HasLeft) || (startMonth != endMonth && item.ContractEndGr == item.Separation.ContractEndGr);
|
|
break;
|
|
}
|
|
|
|
|
|
//دستمزد روزانه بدون تاثیر ساعت کار
|
|
#region DailyWageCommpute
|
|
|
|
var contract = new EditContract()
|
|
{
|
|
ContractStartGr = item.ContractStartGr,
|
|
ContractEndGr = item.ContractEndGr,
|
|
DailySalaryUnAffected = item.DailySalaryUnAffected,
|
|
DailyWageType = item.DailyWageType,
|
|
ContarctStart = item.ContractStart,
|
|
ContractEnd = item.ContractEnd,
|
|
GetWorkDate = item.FirstGetWorkingDay,
|
|
GetWorkDateHide = item.FirstGetWorkingDay,
|
|
|
|
};
|
|
|
|
//دستمزد روزانه بدون تاثیر ساعت کار
|
|
var dailyWageUnAffected = await _yearlySalaryRepository.GetCheckoutDailyWage(contract,
|
|
item.Separation.ContractStartGr, item.Separation.ContractEndGr);
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
var hasRollCall = await _rollCallEmployeeRepository.HasRollCallRecord(item.EmployeeId, workshopId, item.Separation.ContractStartGr, item.Separation.ContractEndGr);
|
|
if (getContractsData.Data.IsStaticCheckout)
|
|
hasRollCall = false;
|
|
|
|
var isStaticCheckout = hasRollCall == false;
|
|
//محاسبه موظفی
|
|
#region MandatoryCompute
|
|
var mandatoryCompute = new ComputingViewModel();
|
|
|
|
item.WorkingHours.ContractStartGr = item.Separation.ContractStartGr;
|
|
item.WorkingHours.ContractEndGr = item.Separation.ContractEndGr;
|
|
item.WorkingHours.ContarctStart = item.Separation.ContarctStart;
|
|
item.WorkingHours.ContractEnd = item.Separation.ContractEnd;
|
|
item.WorkingHours.GetWorkDate = contract.GetWorkDate;
|
|
item.WorkingHours.GetWorkDateHide = contract.GetWorkDate;
|
|
item.WorkingHours.WorkshopId = workshopId;
|
|
item.WorkingHours.EmployeeId = item.EmployeeId;
|
|
|
|
mandatoryCompute = await _rollCallMandatoryRepository.MandatoryCompute(item.EmployeeId, workshopId,
|
|
item.Separation.ContractStartGr, item.Separation.ContractEndGr, item.WorkingHours, getContractsData.Data.WorkshopHolidayWorking,
|
|
isStaticCheckout, getContractsData.Data.RotatingShiftCompute, dailyWageUnAffected, totalLeaveCompute);
|
|
|
|
#endregion
|
|
|
|
|
|
if (contract.EmployeeId == 9659)
|
|
mandatoryCompute.SumTime44 = "48 - 24";
|
|
|
|
var officialHoliday = mandatoryCompute.OfficialHoliday;
|
|
var Friday = int.Parse(mandatoryCompute.NumberOfFriday);
|
|
var fridayStartToEnd = mandatoryCompute.FridayStartToEnd;
|
|
|
|
var totalHoursH = mandatoryCompute.TotalHoursesH;
|
|
var totalHoursM = mandatoryCompute.TotalHoursesM;
|
|
var dayliWage = mandatoryCompute.SalaryCompute.MoneyToDouble();
|
|
var consumableItemDouble = mandatoryCompute.ConsumableItems.MoneyToDouble();
|
|
var housingAllowanceDouble = mandatoryCompute.HousingAllowance.MoneyToDouble();
|
|
var familyAllowanceDouble = mandatoryCompute.FamilyAllowance.MoneyToDouble();
|
|
var marriedAllowanceDouble = mandatoryCompute.MarriedAllowance.MoneyToDouble();
|
|
|
|
//اضافه کاری
|
|
var overTimePay = _yearlySalaryRepository.GetOverTimeWorking(dayliWage,
|
|
mandatoryCompute.OverTimeWorkH, mandatoryCompute.OverTimeWorkM);
|
|
//شبکاری
|
|
var overNightPay = _yearlySalaryRepository.GetOverNightWorking(dayliWage,
|
|
mandatoryCompute.OverNightWorkH, mandatoryCompute.OverNightWorkM, mandatoryCompute.SumTime44,
|
|
officialHoliday, Friday, item.Separation.ContractStartGr, item.Separation.ContractEndGr, totalHoursH,
|
|
totalHoursM);
|
|
|
|
|
|
//سنوات
|
|
var yearsPay = _yearlySalaryRepository.Years(item.Separation.ContractStartGr, item.Separation.LeftWorkDate,
|
|
item.Separation.ContractEndGr,
|
|
dayliWage, item.YearsOption, item.Separation.HasLeft, item.Separation.StartWorkDate, contract.ContractStartGr,
|
|
contract.ContractEndGr, contract.WorkshopIds, contract.EmployeeId, getContractsData.Data.IsOldContract);
|
|
//عیدی
|
|
#region BonusesPay
|
|
var bunosesPay = _yearlySalaryRepository.Bunoses(item.Separation.ContarctStart, item.Separation.LeftWorkDate,
|
|
item.Separation.ContractStartGr, item.Separation.ContractEndGr,
|
|
dayliWage, item.BonusesOption, item.Separation.HasLeft, item.Separation.StartWorkDate,
|
|
contract.ContractStartGr,
|
|
contract.ContractEndGr, contract.WorkshopIds, contract.EmployeeId, getContractsData.Data.IsOldContract);
|
|
//اگر تصفیه حساب پاک شده برای عیدی یا سنوات وجود داشت
|
|
if (bunosesPay.NotCompleted || yearsPay.NotCompleted)
|
|
{
|
|
|
|
List<BunosesAndYearsPayStatus> lostCheckoutsDates = new List<BunosesAndYearsPayStatus>();
|
|
if ((bunosesPay.NotCompleted && yearsPay.NotCompleted) || (bunosesPay.NotCompleted && !yearsPay.NotCompleted))
|
|
lostCheckoutsDates = bunosesPay.BunosesStatusList;
|
|
if (!bunosesPay.NotCompleted && yearsPay.NotCompleted)
|
|
lostCheckoutsDates = yearsPay.BunosesStatusList;
|
|
|
|
foreach (var found in lostCheckoutsDates)
|
|
{
|
|
ComputingViewModel foundMandatoryCompute = new ComputingViewModel();
|
|
var foundContract = _contractRepository.GetContractByStartEnd(found.ContractStart,
|
|
found.ContractEnd, contract.WorkshopIds, contract.EmployeeId);
|
|
|
|
if (foundContract.Id > 0)
|
|
{
|
|
var foundWorkingHours = _workingHoursTempRepository.GetByContractIdConvertToShiftwork4(foundContract.Id);
|
|
foundWorkingHours.ContractStartGr = found.ContractStart;
|
|
foundWorkingHours.ContractEndGr = found.ContractEnd;
|
|
foundWorkingHours.ContarctStart = found.ContractStart.ToFarsi();
|
|
foundWorkingHours.ContractEnd = found.ContractEnd.ToFarsi();
|
|
foundWorkingHours.GetWorkDate = foundContract.GetWorkDate;
|
|
foundWorkingHours.GetWorkDateHide = foundContract.GetWorkDate;
|
|
foundWorkingHours.WorkshopId = contract.WorkshopIds;
|
|
foundWorkingHours.EmployeeId = contract.EmployeeId;
|
|
bool foundHasRollCall = await _rollCallEmployeeRepository.HasRollCallRecord(item.EmployeeId, workshopId, found.ContractStart, found.ContractEnd);
|
|
|
|
if (getContractsData.Data.IsStaticCheckout)
|
|
foundHasRollCall = false;
|
|
|
|
foundMandatoryCompute = await _rollCallMandatoryRepository.MandatoryCompute(contract.EmployeeId,
|
|
contract.WorkshopIds,
|
|
found.ContractStart, found.ContractEnd, foundWorkingHours, getContractsData.Data.WorkshopHolidayWorking, foundHasRollCall, getContractsData.Data.RotatingShiftCompute, dailyWageUnAffected, totalLeaveCompute);
|
|
|
|
|
|
|
|
|
|
|
|
var MontlyYearsBunos =
|
|
_yearlySalaryRepository.GetMontlyBunosYears(foundMandatoryCompute.weeklyTime, found.ContractStart, found.ContractEnd,
|
|
foundMandatoryCompute.SalaryCompute.MoneyToDouble(), foundMandatoryCompute.SumTime44, foundMandatoryCompute.OfficialHoliday,
|
|
int.Parse(foundMandatoryCompute.NumberOfFriday), foundMandatoryCompute.TotalHolidayAndNotH, foundMandatoryCompute.TotalHolidayAndNotM,
|
|
foundMandatoryCompute.Basic, foundMandatoryCompute.FridayStartToEnd, foundMandatoryCompute.DayliFeeComplete, hasRollCall, getContractsData.Data.WorkshopHolidayWorking, item.WorkingHours.ShiftWork);
|
|
double foundMontlySalary = MontlyYearsBunos.MontlyWage + MontlyYearsBunos.BasicYears;
|
|
int foundTotaldays = Convert.ToInt32(MontlyYearsBunos.SumOfWorkingDay);
|
|
double foundDayliWage = foundMontlySalary / foundTotaldays;
|
|
if (bunosesPay.NotCompleted)
|
|
{
|
|
double foundBonuses = ((foundDayliWage * 60) / 365) * foundTotaldays;
|
|
bunosesPay.Bunoses += foundBonuses;
|
|
bunosesPay.TotalDayCompute += foundTotaldays;
|
|
}
|
|
|
|
if (yearsPay.NotCompleted)
|
|
{
|
|
double foundBonuses = ((foundDayliWage * 30) / 365) * foundTotaldays;
|
|
yearsPay.YearsPay += foundBonuses;
|
|
yearsPay.TotalDayCompute += foundTotaldays;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
//مزد مرخصی جدید
|
|
var leavePayNew = _yearlySalaryRepository.LeavePay(item.Separation.ContarctStart,
|
|
item.Separation.LeftWorkDate, item.Separation.ContractStartGr, item.Separation.ContractEndGr,
|
|
dayliWage, item.ComputeOption, item.Separation.HasLeft, item.Separation.StartWorkDate,
|
|
contract.ContractStartGr,
|
|
contract.ContractEndGr, contract.WorkshopIds, contract.EmployeeId, fridayStartToEnd,
|
|
officialHoliday, totalHoursH, totalHoursM, consumableItemDouble, housingAllowanceDouble,
|
|
familyAllowanceDouble, marriedAllowanceDouble, getContractsData.Data.IsOldContract);
|
|
|
|
|
|
|
|
|
|
#region Insurance
|
|
|
|
double insuranceShare = 0;
|
|
//اگر پرسنل داری شروع بکار بیمه بود
|
|
var insuranceEmployeeDataItem =
|
|
insuranceEmployeeData.FirstOrDefault(x => x.EmployeeId == contract.EmployeeId);
|
|
|
|
//اگر لیست بیمه برای پرسنل ساخته شده بود
|
|
var insuranceListDataWithDetails =
|
|
insuranceListData.FirstOrDefault(x => x.EmployeeId == contract.EmployeeId);
|
|
if (insuranceListDataWithDetails != null)
|
|
{
|
|
insuranceShare = insuranceListDataWithDetails.InsuranceShare;
|
|
}
|
|
else
|
|
{
|
|
if (insuranceEmployeeDataItem != null && insuranceEmployeeDataItem.StartWorkDateGr <= item.Separation.ContractEndGr)
|
|
{
|
|
var workingDays = Tools.GetEmployeeInsuranceWorkingDays(insuranceEmployeeDataItem.StartWorkDateGr, item.Separation.LeftWorkDate, startDateGr, endDateGr, insuranceEmployeeDataItem.EmployeeId);
|
|
var leftWorkFa = workingDays.hasLeftWorkInMonth ? item.Separation.LeftWorkDate.ToFarsi() : "";
|
|
|
|
//به دست آوردن دستمزد روزانه با توجه به اینکه کارگاه مشاغل مقطوع است یا خیر
|
|
|
|
double dailyWage = 0;
|
|
if (getContractsData.Data.FixedSalary)
|
|
{
|
|
var res = _insuranceListApplication.GetDailyWageFixedSalary(year, getContractsData.Data.WorkshopId, insuranceEmployeeDataItem.EmployeeId, startDateGr,
|
|
endDateGr, insuranceEmployeeDataItem.JobId, getContractsData.Data.Population, getContractsData.Data.InsuranceJobId);
|
|
dailyWage = res ?? 0;
|
|
|
|
}
|
|
else
|
|
{
|
|
var res = _insuranceListApplication.ComputeDailyWage(yearlysaleries.DayliWage, insuranceEmployeeDataItem.EmployeeId, getContractsData.Data.WorkshopId, year);
|
|
dailyWage = res;
|
|
}
|
|
|
|
//بدست آوردن پایه سنوات
|
|
var baseYears = _insuranceListRepository.GetEmployeeInsuranceBaseYear(insuranceEmployeeDataItem.EmployeeId, getContractsData.Data.WorkshopId,
|
|
workingDays.countWorkingDays, startDateGr, endDateGr, workingDays.startWork, workingDays.endWork, workingDays.hasLeftWorkInMonth);
|
|
|
|
//جمع مزد روزانه و پایه سنوات
|
|
var dailyWagePlusBaseYears = dailyWage + baseYears.baseYear;
|
|
|
|
|
|
//دستمزد ماهانه با محاسبه پایه سنوات
|
|
var monthlySalary = Tools.GetRoundDoubleValue(dailyWagePlusBaseYears * workingDays.countWorkingDays);
|
|
|
|
//حق تاهل
|
|
var marriedAllowanceForInsurance = item.MaritalStatus == "متاهل" ? yearlysaleries.MarriedAllowance : 0;
|
|
|
|
//محاسبه مزایای ماهانه
|
|
var monthlyBenefits = _insuranceListApplication.GetMonthlyBenefits(endOfMonth, yearlysaleries.ConsumableItems, yearlysaleries.HousingAllowance, marriedAllowanceForInsurance, workingDays.countWorkingDays, getContractsData.Data.TypeOfInsuranceSend, insuranceEmployeeDataItem.JobId, insuranceEmployeeDataItem.EmployeeId, insuranceEmployeeDataItem.IncludeStatus);
|
|
if (getContractsData.Data.HasInsuranceCheckoutOverTime)
|
|
{
|
|
|
|
monthlyBenefits = Tools.GetRoundDoubleValue(monthlyBenefits += overTimePay);
|
|
}
|
|
|
|
//محاسبه جمع مزایای مشمول و دستمزد ماهانه
|
|
var benefitsIncludedContinuous = monthlyBenefits + monthlySalary;
|
|
|
|
//محاسبه حق بیمه سهم بیمه شده
|
|
insuranceShare = (benefitsIncludedContinuous * 7) / 100;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
#region ResultToSave
|
|
|
|
var syear = Convert.ToInt32(item.ContractStart.Substring(0, 4));
|
|
var smonth = Convert.ToInt32(item.ContractStart.Substring(5, 2));
|
|
|
|
string monthfarsiName = (item.ContractStart.Substring(5, 2)).ToFarsiMonthByNumber();
|
|
|
|
var yearShamsi = item.ContractStart.Substring(0, 4);
|
|
|
|
|
|
var dayliWageDouble = mandatoryCompute.SalaryCompute.MoneyToDouble();
|
|
// کمک هزینه اقلام
|
|
var consumableItem = mandatoryCompute.ConsumableItems.MoneyToDouble();
|
|
//حق اولاد
|
|
var familyAllowance = mandatoryCompute.FamilyAllowance.MoneyToDouble();
|
|
//کمک هزینه مسکن
|
|
var housingAllowance = mandatoryCompute.HousingAllowance.MoneyToDouble();
|
|
//حق تاهل
|
|
var marriedAllowance = mandatoryCompute.MarriedAllowance.MoneyToDouble();
|
|
|
|
#region Salary
|
|
|
|
var totalDays = (item.Separation.ContractEndGr - item.Separation.ContractStartGr).TotalDays + 1;
|
|
|
|
//حقوق ماهانه
|
|
var monthlyWage = mandatoryCompute.DailySalaryAffected * totalDays;
|
|
//پایه سنوات
|
|
var bacicYears = mandatoryCompute.BaseYearAffected * totalDays;
|
|
#endregion
|
|
|
|
|
|
//سنوات
|
|
var years = yearsPay.YearsPay;
|
|
//عیدی و پاداش
|
|
var bunos = bunosesPay.Bunoses;
|
|
|
|
//فاطمه احمدژاد === موقت عیدی و پاداش و سنوات حساب نشه
|
|
if (item.EmployeeId == 45104 && getContractsData.Data.WorkshopId == 315)
|
|
{
|
|
years = 0;
|
|
|
|
bunos = 0;
|
|
}
|
|
|
|
//تعداد زروز های فیش
|
|
var sumOfWorkingDays = $"{totalDays}";
|
|
|
|
//مبلغ جمعه کاری
|
|
double fridayPay = 0;
|
|
if (Friday > 0)
|
|
{
|
|
var fridayPercent = dayliWageDouble * 40 / 100;
|
|
//فوق العاده جمعه کاری
|
|
fridayPay = fridayPercent * Friday;
|
|
}
|
|
|
|
|
|
//حق بیمه سهم کارگر
|
|
#region InsuranceDeduction
|
|
|
|
double insuranceDeduction = 0;
|
|
bool hasInsuranceShareTheSameAsList = false;
|
|
var inshuranceShareRound = Tools.GetRoundDoubleValue(insuranceShare);
|
|
if (inshuranceShareRound == 0)
|
|
{
|
|
var insuranceOverTime = getContractsData.Data.HasInsuranceCheckoutOverTime ? overTimePay : 0;
|
|
insuranceDeduction = (monthlyWage + bacicYears + consumableItem + housingAllowance + marriedAllowance + insuranceOverTime) * 7 / 100;
|
|
}
|
|
else
|
|
{
|
|
insuranceDeduction = inshuranceShareRound;
|
|
hasInsuranceShareTheSameAsList = true;
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
//مقادیر - روز - تعداد - ساعت
|
|
#region Values
|
|
|
|
//مدت شب کاری
|
|
var overNightWorkValue =
|
|
$"{Convert.ToInt32(mandatoryCompute.OverNightWorkH):00}:{Convert.ToInt32(mandatoryCompute.OverNightWorkM):00}";
|
|
//تعداد جمعه کاری
|
|
var fridayWorkValue = $"{Friday}";
|
|
//نوع نوبت کاری
|
|
var rotatingShiftValue = mandatoryCompute.RotatingShiftValue;
|
|
// تعداد سال های سنوات
|
|
var totalDayOfYearsCompute = yearsPay.YearsPay > 0 ? $"{yearsPay.TotalDayCompute}" : "0";
|
|
//تعداد روز های عیدی و پاداش
|
|
var totalDayOfBunosesCompute = bunosesPay.Bunoses > 0 ? $"{bunosesPay.TotalDayCompute}" : "0";
|
|
//مدت اضافه کارس
|
|
var overTimeWorkValue =
|
|
$"{Convert.ToInt32(mandatoryCompute.OverTimeWorkH):00}:{Convert.ToInt32(mandatoryCompute.OverTimeWorkM):00}";
|
|
|
|
|
|
#endregion
|
|
|
|
//کسر اضافه کار از غیبت یا بلعکس
|
|
#region OverTimeAndAbsencSubtraction
|
|
var absenceDeduction = abcenseDeductionCompute ? leavePayNew.AbsenceDeduction : 0;
|
|
|
|
if (overTimePay > 0 && absenceDeduction > 0)
|
|
{
|
|
if (absenceDeduction >= overTimePay)
|
|
{
|
|
absenceDeduction -= overTimePay;
|
|
overTimePay = 0;
|
|
overTimeWorkValue = "00:00";
|
|
}
|
|
else
|
|
{
|
|
overTimePay -= absenceDeduction;
|
|
absenceDeduction = 0;
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
//مساعده
|
|
#region SalaryAid
|
|
|
|
var salaryAids =
|
|
_rollCallMandatoryRepository.SalaryAidsForCheckout(contract.EmployeeId, contract.WorkshopIds, startDateGr, endDateGr)
|
|
.Select(x => new CheckoutSalaryAid(x.Amount, x.SalaryAidDateTimeGe, x.SalaryAidDateTimeFa, x.CalculationDateTimeGe, x.CalculationDateTimeFa, x.Id)).ToList();
|
|
|
|
var salaryAidDeduction = salaryAids.Sum(x => x.Amount.MoneyToDouble());
|
|
|
|
#endregion
|
|
|
|
//اقساط وام
|
|
#region LoanInstallment
|
|
|
|
var loanInstallments = _rollCallMandatoryRepository.LoanInstallmentForCheckout(contract.EmployeeId, contract.WorkshopIds,
|
|
item.Separation.ContractStartGr, item.Separation.HasLeft ? DateTime.MaxValue : item.Separation.ContractEndGr)
|
|
.Select(x =>
|
|
new CheckoutLoanInstallment(x.Amount, x.Month, x.Year, x.IsActive, x.RemainingAmount, x.LoanAmount, x.Id)).ToList();
|
|
|
|
var installmentDeduction = loanInstallments.Sum(x => x.AmountForMonth.MoneyToDouble());
|
|
|
|
#endregion
|
|
|
|
//پاداش
|
|
#region Reward
|
|
|
|
|
|
var rewards = new List<CheckoutReward>();
|
|
double rewardPay = 0;
|
|
if (getContractsData.Data.RewardComputeOnCheckout)
|
|
{
|
|
rewards = _rollCallMandatoryRepository.RewardForCheckout(contract.EmployeeId, contract.WorkshopIds, startDateGr, endDateGr)
|
|
.Select(x => new CheckoutReward(x.Amount, x.AmountDouble, x.GrantDateFa, x.GrantDateGr, x.Description, x.Title, x.Id)).ToList();
|
|
|
|
rewardPay = rewards.Sum(x => x.AmountDouble);
|
|
}
|
|
|
|
#endregion
|
|
|
|
//جدول حضورغیاب پرسنل
|
|
#region CheckoutRollCall
|
|
|
|
//کارکرد واقعی - محاسبات شامل مرخصی افزوده شده
|
|
var totalWorkingTimeSpan = mandatoryCompute.TotalWorkingTimeSpan;
|
|
//ساعت استراحت
|
|
var totalBreakTimeSpan = mandatoryCompute.TotalBreakTimeSpan;
|
|
// ساعت حضور - بدون مرخصی افزده شده
|
|
var totalPresentTimeSpan = mandatoryCompute.TotalPresentTimeSpan;
|
|
//مدت مرخصی استحقاقی
|
|
var totalPaidLeave = mandatoryCompute.TotalPaidLeave;
|
|
//مدت مرخصی استعلاجی
|
|
var totalSickLeave = mandatoryCompute.TotalSickLeave;
|
|
|
|
|
|
var firstDayOfMonth = startDateGr;
|
|
var firstDayOfCurrentMonth = new DateTime(syear, smonth, 1, new PersianCalendar());
|
|
|
|
LeaveSearchModel sickLeaveSearch = new LeaveSearchModel()
|
|
{
|
|
EmployeeId = contract.EmployeeId,
|
|
WorkshopId = contract.WorkshopIds,
|
|
StartLeaveGr = item.Separation.ContractStartGr,
|
|
EndLeaveGr = item.Separation.ContractEndGr,
|
|
IsAccepted = true,
|
|
};
|
|
var leaves = _leaveApplication.search(sickLeaveSearch);
|
|
|
|
firstDayOfMonth.AddMonthsFa(1, out var lastDayOfCurrentMonth);
|
|
|
|
lastDayOfCurrentMonth = lastDayOfCurrentMonth.AddDays(-1);
|
|
|
|
int dateRange = (int)(lastDayOfCurrentMonth - firstDayOfCurrentMonth).TotalDays + 1;
|
|
|
|
var holidays = _holidayItemApplication.Search(new HolidayItemSearchModel()
|
|
{
|
|
HolidayYear = item.Separation.ContractStartGr.ToFarsiYear()
|
|
});
|
|
//all the dates from start to end, to be compared with present days to get absent dates
|
|
var completeDaysList = Enumerable.Range(0, dateRange).Select(offset => firstDayOfCurrentMonth.AddDays(offset).Date).ToList();
|
|
|
|
var absentRecords = completeDaysList
|
|
.ExceptBy(mandatoryCompute.GroupedRollCalls.Select(x => x.CreationDate.Date), y => y.Date)
|
|
.Select(x =>
|
|
{
|
|
var leave = leaves.FirstOrDefault(y =>
|
|
y.EmployeeId == contract.EmployeeId && y.EndLeaveGr.Date >= x.Date && y.StartLeaveGr.Date <= x.Date);
|
|
var isHoliday = holidays.Any(y => y.HolidaydateGr == x.Date);
|
|
var isFriday = x.Date.DayOfWeek == DayOfWeek.Friday;
|
|
var isNormalWorkingDay = isHoliday == false && isFriday == false;
|
|
return new CheckoutDailyRollCallViewModel()
|
|
{
|
|
StartDate1 = null,
|
|
EndDate1 = null,
|
|
DateTimeGr = x.Date,
|
|
DayOfWeek = x.Date.DayOfWeek.ToString(),
|
|
RollCallDateFa = x.Date.ToFarsi(),
|
|
LeaveType = leave != null ? leave.LeaveType : "",
|
|
IsAbsent = leave == null && isNormalWorkingDay
|
|
};
|
|
});
|
|
|
|
|
|
var presentDays = mandatoryCompute.GroupedRollCalls.Select(x =>
|
|
{
|
|
|
|
var orderedRollcalls = x.ShiftList.OrderBy(y => y.Start);
|
|
|
|
var rollCallTimeSpanPerDay = x.SumOneDaySpan;
|
|
TimeSpan breakTimePerDay = x.BreakTime;
|
|
|
|
return new CheckoutDailyRollCallViewModel()
|
|
{
|
|
StartDate1 = orderedRollcalls.FirstOrDefault().Start.ToString("HH:mm"),
|
|
EndDate1 = orderedRollcalls.FirstOrDefault().EndWithOutResTime.ToString("HH:mm"),
|
|
|
|
StartDate2 = orderedRollcalls.Skip(1).FirstOrDefault()?.Start.ToString("HH:mm") ?? "",
|
|
EndDate2 = orderedRollcalls.Skip(1).FirstOrDefault()?.EndWithOutResTime.ToString("HH:mm") ?? "",
|
|
|
|
TotalhourseSpan = rollCallTimeSpanPerDay,
|
|
|
|
BreakTimeTimeSpan = breakTimePerDay,
|
|
|
|
DayOfWeek = x.CreationDate.DayOfWeek.DayOfWeeKToPersian(),
|
|
RollCallDateFa = x.CreationDate.Date.ToFarsi(),
|
|
DateTimeGr = x.CreationDate.Date,
|
|
IsSliced = x.ShiftList.Count() > 2,
|
|
IsAbsent = false
|
|
};
|
|
});
|
|
|
|
|
|
presentDays = presentDays.Select(x => new CheckoutDailyRollCallViewModel
|
|
{
|
|
StartDate1 = x.StartDate1,
|
|
EndDate1 = x.EndDate1,
|
|
EndDate2 = x.EndDate2,
|
|
StartDate2 = x.StartDate2,
|
|
TotalWorkingHours = $"{(int)(x.TotalhourseSpan.TotalHours)}:{x.TotalhourseSpan.Minutes:00}",
|
|
BreakTimeString = $"{(int)(x.BreakTimeTimeSpan.TotalHours)}:{x.BreakTimeTimeSpan.Minutes:00}",
|
|
TotalhourseSpan = x.TotalhourseSpan,
|
|
BreakTimeTimeSpan = x.BreakTimeTimeSpan,
|
|
DayOfWeek = x.DayOfWeek,
|
|
RollCallDateFa = x.RollCallDateFa,
|
|
DateTimeGr = x.DateTimeGr,
|
|
IsSliced = x.IsSliced,
|
|
IsAbsent = false
|
|
});
|
|
|
|
var result = presentDays.Concat(absentRecords).OrderBy(x => x.DateTimeGr).ToList();
|
|
result.ForEach(x =>
|
|
{
|
|
x.IsHoliday = holidays.Any(y => x.DateTimeGr.Date == y.HolidaydateGr.Date);
|
|
x.IsFriday = x.DateTimeGr.DayOfWeek == DayOfWeek.Friday;
|
|
});
|
|
|
|
var checkoutRollCallDays = result.Select(x => new CheckoutRollCallDay(x.DateTimeGr,
|
|
x.StartDate1, x.EndDate1, x.StartDate2, x.EndDate2,
|
|
x.BreakTimeTimeSpan, x.IsSliced, x.TotalhourseSpan, x.IsAbsent, x.IsFriday, x.IsHoliday, x.LeaveType))
|
|
.ToList();
|
|
|
|
|
|
double mandatoryHours = _mandatoryHoursApplication.GetMandatoryHoursByYearAndMonth(syear, smonth);
|
|
int mandatoryWholeHours = (int)mandatoryHours;
|
|
int mandatoryMinutes = (int)((mandatoryHours - mandatoryWholeHours) * 60);
|
|
|
|
var totalMandatoryHours = TimeSpan.FromHours(mandatoryWholeHours).Add(TimeSpan.FromMinutes(mandatoryMinutes));
|
|
var checkoutRollCall = new CheckoutRollCall(totalMandatoryHours, totalPresentTimeSpan, totalBreakTimeSpan,
|
|
totalWorkingTimeSpan, totalPaidLeave, totalSickLeave, checkoutRollCallDays);
|
|
#endregion
|
|
|
|
//مقادیر پرداخت نهایی - مطالبات - کسورات
|
|
#region TotalPayment
|
|
|
|
var shiftPay = contract.WorkshopIds == 552 && hasRollCall ? 0 : mandatoryCompute.ShiftPay;
|
|
|
|
|
|
var totalClaimsDouble = monthlyWage + bacicYears + consumableItem + housingAllowance + marriedAllowance + overTimePay +
|
|
overNightPay + familyAllowance + bunos + years + leavePayNew.LeavPay + fridayPay + shiftPay + rewardPay;
|
|
var totalDeductionDouble = insuranceDeduction + absenceDeduction + installmentDeduction + salaryAidDeduction;
|
|
|
|
//مطالبات
|
|
var totalClaims = totalClaimsDouble.ToMoney();
|
|
//کسورات
|
|
var totalDeductions = totalDeductionDouble.ToMoney();
|
|
|
|
//مبلغ قابل پرداخت
|
|
var totalPayment = totalClaimsDouble - totalDeductionDouble;
|
|
|
|
#endregion
|
|
|
|
|
|
#region CreateCheckoutModel
|
|
|
|
var checkout = new Checkout(item.EmployeeFullName, item.FathersName, item.NationalCode
|
|
, item.DateOfBirth, item.EmployeeId, getContractsData.Data.WorkshopName, getContractsData.Data.WorkshopId, item.ContractNo, item.Separation.ContractStartGr, item.Separation.ContractEndGr, monthfarsiName, yearShamsi,
|
|
item.ContractId, item.WorkingHours.WorknigHoursId, monthlyWage, bacicYears, consumableItem, housingAllowance
|
|
, overTimePay, overNightPay, fridayPay, 0, shiftPay, familyAllowance, bunos, years, leavePayNew.LeavPay, insuranceDeduction, 0, installmentDeduction, salaryAidDeduction, absenceDeduction, sumOfWorkingDays,
|
|
getContractsData.Data.ArchiveCode, item.PersonnelCode, totalClaims, totalDeductions, totalPayment, "0", marriedAllowance, leavePayNew.LeaveCheckout, leavePayNew.CreditLeaves, leavePayNew.AbsencePeriod, leavePayNew.AverageHoursPerDay, hasRollCall, overTimeWorkValue, overNightWorkValue
|
|
, fridayWorkValue, rotatingShiftValue, "0", leavePayNew.TotalDayOfLeaveCompute, totalDayOfYearsCompute, totalDayOfBunosesCompute,
|
|
loanInstallments, salaryAids, checkoutRollCall, mandatoryCompute.EmployeeMandatoryHours, hasInsuranceShareTheSameAsList, rewards, rewardPay);
|
|
|
|
#endregion
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region SaveToDb
|
|
|
|
|
|
var saveToDb = await _checkoutRepository.CreateCheckout(checkout);
|
|
if (!saveToDb)
|
|
{
|
|
createFailedCount += 1;
|
|
createFailedList.Add(item.EmployeeFullName);
|
|
}
|
|
else
|
|
{
|
|
createSuccessCount += 1;
|
|
}
|
|
#endregion
|
|
}
|
|
catch (Exception)
|
|
{
|
|
createFailedCount += 1;
|
|
createFailedList.Add(item.EmployeeFullName);
|
|
|
|
}
|
|
|
|
|
|
var percent = (successProcess / (double)countList) * 100;
|
|
// await signalR.SendAsync("showStatus", countList, createFailedCount, createSuccessCount, (int)percent, createFailedList);
|
|
await signalR.SendAsync("all", countList);
|
|
await signalR.SendAsync("failed", createFailedCount);
|
|
await signalR.SendAsync("Success", createSuccessCount);
|
|
await signalR.SendAsync("percent", (int)percent);
|
|
await signalR.SendAsync("failedList", createFailedList);
|
|
|
|
successProcess += 1;
|
|
|
|
Console.ForegroundColor = ConsoleColor.Cyan;
|
|
Console.WriteLine("================================================================== ");
|
|
Console.WriteLine("======================================== Counter " + successProcess + " ================== ");
|
|
Console.WriteLine("================================================================== ");
|
|
Console.ResetColor();
|
|
|
|
}
|
|
|
|
|
|
Console.ForegroundColor = ConsoleColor.Yellow;
|
|
Console.WriteLine("after GetData To mandatoryCompute" + timer.Elapsed);
|
|
Console.ResetColor();
|
|
return op.Succcedded();
|
|
}
|
|
#endregion
|
|
|
|
|
|
public async Task<PagedResult<CheckoutDto>> GetList(CheckoutSearchModelDto searchModel)
|
|
{
|
|
return await _checkoutRepository.GetList(searchModel);
|
|
}
|
|
|
|
|
|
public async Task<RotatingShiftOfCheckoutDto> GetRotatingShiftApi(long id)
|
|
{
|
|
var result = new ComputingViewModel();
|
|
var checkout = GetDetails(id);
|
|
var workingHours = _workingHoursTempRepository.GetByContractIdConvertToShiftwork4(checkout.ContractId);
|
|
var typeOfWorkingHours = "";
|
|
if (checkout.HasRollCall)
|
|
{
|
|
result = await _rollCallMandatoryRepository.RotatingShiftReport(checkout.WorkshopId, checkout.EmployeeId, checkout.ContractStartGr, checkout.ContractEndGr, workingHours.ShiftWork, true, workingHours, false);
|
|
typeOfWorkingHours = "دارای حضورغیاب";
|
|
|
|
}
|
|
else
|
|
{
|
|
var workshop = _workshopRepository.GetDetails(checkout.WorkshopId);
|
|
result = await _rollCallMandatoryRepository.RotatingShiftReport(checkout.WorkshopId, checkout.EmployeeId, checkout.ContractStartGr, checkout.ContractEndGr, workingHours.ShiftWork, false, workingHours, workshop.WorkshopHolidayWorking);
|
|
typeOfWorkingHours = "بدون حضورغیاب";
|
|
}
|
|
|
|
var items = result.RotatingResultList.Select(x => new RotatingShiftListDto()
|
|
{
|
|
MorningShiftSpan = x.MorningString,
|
|
EveningShiftSpan = x.EveningString,
|
|
NightShiftSpan = x.NightString,
|
|
|
|
IsMorningShift = x.IsMorningShift,
|
|
IsEveningShift = x.IsEveningShift,
|
|
IsNightShift = x.IsNightShift,
|
|
|
|
ShiftDate = x.RotatingDate
|
|
}).ToList();
|
|
return new RotatingShiftOfCheckoutDto()
|
|
{
|
|
FullName = checkout.EmployeeFullName,
|
|
YearAndMonth = $"{checkout.Month} {checkout.Year}",
|
|
HasRotatingShift = result.RotatingStatus != "نوبت کاری ندارد",
|
|
RotatingShiftStatus = result.RotatingStatus,
|
|
TypeOfWorkingHours = typeOfWorkingHours,
|
|
RotatingShiftList = items
|
|
};
|
|
}
|
|
|
|
public Task<List<CheckoutPrintDto>> CheckoutPrint(List<long> ids)
|
|
{
|
|
return _checkoutRepository.CheckoutPrint(ids);
|
|
}
|
|
|
|
#endregion
|
|
} |