CelHRTeam/CEL_Payroll
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
CEL_Payroll/Payroll.BO/Salary/SalaryCalculator.cs

1619 lines
86 KiB
C#
Raw Permalink Normal View History

Initiate
2024-09-17 14:30:13 +06:00
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Ease.CoreV35;
using Ease.CoreV35.Model;
using Ease.CoreV35.Caching;
using System.Data;
using System.Collections;
namespace Payroll.BO
{
public delegate void ProcessStatus(string processStatus);
public delegate void ProgressStatus(EnumProcessStatus status);
public delegate void ErrorMessage(String error);
public enum EnumProcessStatus
{
Start = 1,
PerformStep = 2,
End = 3
}
[Serializable]
public class SalaryCalculator : SalaryException
{
#region Define Class Veriable
private ObjectsTemplate<Employee> _employees;
private ObjectsTemplate<AllowanceDeduction> _allowdeducitons;
private ObjectsTemplate<ProcessItem> _processItems;
private ObjectsTemplate<SalaryMonthly> _salaryMonthlys;
private List<SalaryProcessStatus> _processStatuses;
private ObjectsTemplate<SalaryMonthly> _PrvMonthsalary;
private ObjectsTemplate<ADParameter> _adParameters;
private ObjectsTemplate<DailyAttnProcess> _objDailyAttnProcess;
public DateTime _processMonth;
public int _nYear;
public event ProcessStatus ProcessStatus;
public event ProgressStatus ProgressStatus;
ObjectsTemplate<MonthlyWorkingHour> _workingHours;
#endregion Define Class Veriable
public bool _isDesignationFromDescriptionText;
public ObjectsTemplate<SalaryMonthly> SalaryMonthlies
{
get
{
return _salaryMonthlys;
}
}
public SalaryCalculator(ObjectsTemplate<ProcessItem> ProcessItems)
{
_processItems = ProcessItems;
}
public SalaryCalculator()
{
_processItems = ProcessItem.Get();
}
public List<SalaryProcessStatus> ErrorList
{
get
{
return _processStatuses;
}
}
private void UpdateprocessStatus(string statusString)
{
if (ProcessStatus != null) ProcessStatus(statusString);
}
private void UpdateProgressStatus(EnumProcessStatus status)
{
if (ProgressStatus != null) ProgressStatus(status);
}
public ObjectsTemplate<Employee> Employees
{
get
{
return _employees;
}
}
public void FixAmount()
{
List<Employee> oEmps = Employee.GetAllEmps();
foreach (SalaryMonthly sm in this._salaryMonthlys)
{
Employee emp = oEmps.Find(x => x.ID == sm.EmployeeID);
double nAmount = 0;
double nBasicAmount = 0;
int nCount = 0;
double nOtherAmount = 0;
double nFinalAmount = 0;
double arrearamount = 0;
if (emp != null)
{
foreach (SalaryMonthlyDetail smd in sm.Details)
{
smd.ChangedAmount = Math.Round(smd.ChangedAmount);
smd.CalculatedAmount = smd.ChangedAmount;
if (smd.itemGroupCode != EnumSalaryGroup.Arrear)
{
if ((smd.ItemCode == EnumSalaryItemCode.Basic_Salary && smd.ItemID == -101) || (smd.ItemCode == EnumSalaryItemCode.Allowance && smd.ItemID == 1) || (smd.ItemCode == EnumSalaryItemCode.Allowance && smd.ItemID == 2) || (smd.ItemCode == EnumSalaryItemCode.Allowance && smd.ItemID == 3))
{
nAmount += smd.ChangedAmount;
}
if (smd.ItemCode == EnumSalaryItemCode.Basic_Salary && smd.ItemID == -101)
{
nBasicAmount = smd.ChangedAmount;
nCount++;
}
}
else
{
if ((smd.ItemCode == EnumSalaryItemCode.Basic_Salary && smd.ItemID == -101) || (smd.ItemCode == EnumSalaryItemCode.Allowance && smd.ItemID == 1) || (smd.ItemCode == EnumSalaryItemCode.Allowance && smd.ItemID == 2) || (smd.ItemCode == EnumSalaryItemCode.Allowance && smd.ItemID == 3))
{
arrearamount += smd.ChangedAmount;
}
}
}
double nDiff = 0;
if (nBasicAmount < emp.BasicSalary) continue;
if (nCount < 2)
nDiff = emp.GrossSalary - nAmount;
SalaryMonthlyDetail det = sm.Details.Find(x => x.ItemCode == EnumSalaryItemCode.Allowance && x.ItemID == 10);
if (det != null)
{
//if (nDiff > 0)
//{
det.ChangedAmount = nDiff;
det.CalculatedAmount = nDiff;
nOtherAmount = det.CalculatedAmount;
//}
//else
//{
// det.ChangedAmount -= Math.Abs(nDiff);
//}
}
}
if (sm.ArrearGradeSalaries.Count > 0)
{
foreach (EmployeeGradeSalary gs in sm.ArrearGradeSalaries)
{
double lastmonthgross = gs.GrossSalary;
nFinalAmount = lastmonthgross - arrearamount;
this.AddDetail(sm, EnumSalaryGroup.Arrear, EnumSalaryItemCode.Allowance, 10, 4, "Other Allowance", GlobalFunctions.Round(nFinalAmount));
}
}
}
}
public void Process(ObjectsTemplate<Employee> employees, DateTime processMonth, int nYear)
{
//SalaryException oSException = new SalaryException();
_employees = employees;
_processMonth = processMonth;
_nYear = nYear;
UpdateprocessStatus("Collecting Employee basic information....");
this.Initialize();
this.AddEmployeeToProcess();
//if (_processStatuses.Count > 0) return;
UpdateprocessStatus("Calculating basic Salary....");
this.BasicSalary();
UpdateprocessStatus("Calculating benifits and deduction....");
this.AllowanceDeduction();
UpdateprocessStatus("Calculating OverTime....");
this.OverTimeProcess();
UpdateprocessStatus("Calculating Bonus....");
this.CalculateBonus();
UpdateprocessStatus("Calculating Salary deduct item(unauthorized leave)....");
this.UnAuthorizeLeave();
if (Payroll.BO.SystemInformation.CurrentSysInfo.PayrollTypeID.Integer != 2)
{
UpdateprocessStatus("Calculating PF & CPF....");
this.PF();
}
this.OverTimeArrearProcess();
//UpdateprocessStatus("Calculating Employees Income tax....");
UpdateprocessStatus("Calculating Income Tax");
this.FixAmount();
this.Tax();
UpdateprocessStatus("Calculating Cost-Center");
this.PrepareCostcenterData();
UpdateprocessStatus("Calculating Loan Installment");
this.LoanProcess();
UpdateprocessStatus("Calculating Net Income");
this.NetIncome();
UpdateprocessStatus("Calculating Attendance Days");
this.AttendanceDayProcess();
UpdateprocessStatus("Calculating Leave Days");
this.LeaveDayProcess();
UpdateprocessStatus("Calculating Salary Exception");
this.SalaryExceptionCalculation(this);
UpdateprocessStatus("");
//this.LeavePrepare(oSException.GetEmpLeaveStatus());
}
private void Initialize()
{
_processStatuses = new List<SalaryProcessStatus>();
_salaryMonthlys = new ObjectsTemplate<SalaryMonthly>();
_PrvMonthsalary = SalaryMonthly.Get(GlobalFunctions.LastDateOfMonth(_processMonth.AddMonths(-1)));
}
private bool ProcessStartValidation()
{
return false;
}
private void AddEmployeeToProcess()
{
UpdateProgressStatus(EnumProcessStatus.Start);
ObjectsTemplate<EmployeeCostCenter> empCostCenters = EmployeeCostCenter.Get();
ObjectsTemplate<Category> categories = Category.Get();
ObjectsTemplate<Department> departments = Department.Get();
_isDesignationFromDescriptionText = ConfigurationManager.GetBoolValue("designation", "desigfromdescriptiontext", EnumConfigurationType.Logic);
foreach (Employee employee in _employees)
{
UpdateProgressStatus(EnumProcessStatus.PerformStep);
this.UpdateprocessStatus(" Collecting information for the employee " + employee.Name + " ( " + employee.EmployeeNo + ")");
SalaryMonthly salary = new SalaryMonthly();
salary.EmployeeID = employee.ID;
salary.EmployeeNo = employee.EmployeeNo;
salary.CategoryID = employee.CategoryID;
if (employee.CategoryID == null)
{
AddProcessStatus(employee, "Category not yet assingned");
}
else
{
salary.Category = categories.Find(delegate(Category detail) { return (detail.ID.Integer == employee.CategoryID.Integer); });
}
salary.Gender = employee.Gender;
salary.SalaryMonth = _processMonth;
if (employee.GradeID.IsUnassigned == true) AddProcessStatus(employee, "grade not yet assingned");
else salary.GradeID = employee.GradeID;
if (employee.DepartmentID.IsUnassigned == true) AddProcessStatus(employee, "Department not yet assingned");
// else if (departments.FirstOrDefault(o => o.ID == employee.DepartmentID).RCCode == "") AddProcessStatus(employee, "RC Code missing in Department");
else
salary.DepartmentID = employee.DepartmentID;
string rccode = "";
if (salary.DepartmentID == null)
salary.RCCode = "";
else
{
Department dep = departments.Find(x => x.ID == salary.DepartmentID);
salary.RCCode= GlobalFunctions.FindRCCode2(dep, departments);
if(salary.RCCode=="")
AddProcessStatus(employee, "RC Code missing in Department");
}
if (_isDesignationFromDescriptionText)
{
if (employee.DescriptionText == "")
AddProcessStatus(employee, "Designation not yet assingned");
}
else
{
if (employee.DesignationID.IsUnassigned == true)
AddProcessStatus(employee, "Designation not yet assingned");
else salary.DesignationID = employee.DesignationID;
}
if (employee.LocationID.IsUnassigned) AddProcessStatus(employee, "Loacation not yet assingned");
else salary.LocationID = employee.LocationID;
salary.DesignationID = employee.DesignationID;
salary.DesignationText = employee.DescriptionText;
if (employee.PaymentMode == EnumPaymentMode.BankTransfer)
{
if (employee.BranchID == null || employee.BranchID.IsUnassigned) AddProcessStatus(employee, "Employee payment mode is diclared"
+ " to bank transfer, but no bank/account information found");
else
{
salary.BranchID = employee.BranchID;
salary.AccountNo = employee.AccountNo;
}
}
salary.ThisMonthBasic = employee.BasicSalary;
salary.ThisMonthGross = employee.GrossSalary;
salary.PayrollTypeID = employee.PayrollTypeID;
salary.ReligionID = employee.ReligionID;
salary.Employee = employee;
if (employee.EndOfContractDate != null)
if (employee.EndOfContractDate >= GlobalFunctions.FirstDateOfMonth(_processMonth) &&
employee.EndOfContractDate <= GlobalFunctions.LastDateOfMonth(_processMonth))
{
if (employee.Status == EnumEmployeeStatus.Live && employee.MonthStatusUpdate == EnumEmployeeStatus.Live)
AddProcessStatus(employee, "Employee end_of_contact_date defined but not yet discontinued from discontinue module." + " ");
}
bool bfixedAmount = ConfigurationManager.GetBoolValue("costcenter", "manadatoryinsalary", EnumConfigurationType.Logic);
if (bfixedAmount == true)
{
ObjectsTemplate<EmployeeCostCenter> empinvolments = EmployeeCostCenter.Get(empCostCenters, salary.EmployeeID);
if (empinvolments == null || empinvolments.Count == 0) AddProcessStatus(employee, "Cost-Center not yet assingned");
}
_salaryMonthlys.Add(salary);
}
UpdateProgressStatus(EnumProcessStatus.End);
}
private void AddProcessStatus(Employee employee, string remarks)
{
SalaryProcessStatus status = new SalaryProcessStatus();
status.EmployeeNo = employee.EmployeeNo;
status.Name = employee.Name;
status.Remarks = remarks;
_processStatuses.Add(status);
}
private void NetIncome()
{
string sPosItems = "Positive Items:";
string sNegItems = "Negative Items:";
UpdateProgressStatus(EnumProcessStatus.Start);
foreach (SalaryMonthly salary in _salaryMonthlys)
{
UpdateProgressStatus(EnumProcessStatus.PerformStep);
double netAmount = 0;
sPosItems = "Positive Items:";
sNegItems = "Negative Items:";
foreach (SalaryMonthlyDetail detail in salary.Details)
{
if (detail.itemGroupCode == EnumSalaryGroup.Gross || detail.itemGroupCode == EnumSalaryGroup.Arrear)
{
netAmount = netAmount + detail.ChangedAmount;
sPosItems = sPosItems + detail.Description + ":" + detail.ChangedAmount.ToString() + ", ";
}
else if (detail.itemGroupCode == EnumSalaryGroup.Deductions || detail.itemGroupCode == EnumSalaryGroup.UnauthLeave)
{
netAmount = netAmount - detail.ChangedAmount;
sNegItems = sNegItems + detail.Description + ":" + detail.ChangedAmount.ToString() + ", ";
}
}
this.AddDetail(salary, EnumSalaryGroup.OtherItem, EnumSalaryItemCode.Net_Payable, (int)EnumSalaryItemCode.Net_Payable, 0, "Net Amount", GlobalFunctions.Round(netAmount));
if (netAmount <= 0)
{
sPosItems = sPosItems.Substring(0, sPosItems.Length - 2);
sNegItems = sNegItems.Substring(0, sNegItems.Length - 2);
this.AddProcessStatus(salary.Employee, "Net amount can't be Zero or less than zero. Components:" + sPosItems + " " + sNegItems);
}
}
UpdateProgressStatus(EnumProcessStatus.End);
}
public SalaryMonthlyDetail AddDetail(SalaryMonthly salarymonthly, EnumSalaryGroup group, EnumSalaryItemCode itemcode, int itemId
, int supportId, string description, double nAmount)
{
SalaryMonthlyDetail detail = new SalaryMonthlyDetail();
ProcessItem pitem = _processItems.Find(delegate(ProcessItem item)
{ return item.ItemCode == (int)itemcode; });
if (pitem == null)
{
this.AddProcessStatus(salarymonthly.Employee, "Salary process item code not found in the process"
+ " collection; Item Code:" + itemcode.ToString());
return null;
}
detail = new SalaryMonthlyDetail();
detail.ItemID = itemId;
detail.itemGroupCode = group;
detail.ItemCode = itemcode;
detail.SupportID = ID.FromInteger(supportId);
detail.Position = GetMaxPostion(salarymonthly, group);
detail.Description = description.Length > 0 ? description : pitem.UserDescription;
detail.CalculatedAmount = nAmount;
detail.ChangedAmount = detail.CalculatedAmount;
salarymonthly.Details.Add(detail);
return detail;
}
public int GetMaxPostion(SalaryMonthly osalary, EnumSalaryGroup group)
{
int maxPos = 0;
foreach (SalaryMonthlyDetail item in osalary.Details)
{
//if(item.itemGroupCode == group)
//{
if (item.Position > maxPos)
{
maxPos = item.Position;
//}
}
}
maxPos = maxPos + 1;
return maxPos;
}
private void BasicSalary()
{
UpdateProgressStatus(EnumProcessStatus.Start);
//GetCurrentMonthSalaryItems function return current month's employee grade, salary and effect date.
//effect date must sorted, otherwise error will be generated from next function.
#region Calculate Normal Salary
ObjectsTemplate<EmployeeGradeSalary> gradeSalaryItems = EmployeeGradeSalary.Service.GetCurrMonthSalaryItems(SystemInformation.CurrentSysInfo.NextPayProcessDate);
double basicSalary = 0;
SalaryMonthlyDetail basicDetail = null;
if (_workingHours == null) _workingHours = MonthlyWorkingHour.Get(_processMonth);
#region Remove Employee from salary process
if (Payroll.BO.SystemInformation.CurrentSysInfo.PayrollTypeID.Integer == 2)
{
List<SalaryMonthly> osals = new List<SalaryMonthly>();
foreach (SalaryMonthly salary in _salaryMonthlys)
{
MonthlyWorkingHour whour = _workingHours.Find(delegate(MonthlyWorkingHour wh) { return (wh.EmployeeID.Integer == salary.EmployeeID.Integer); });
if (whour == null)
{
osals.Add(salary);
}
else if (whour.RegularHour == 0)
{
osals.Add(salary);
}
}
foreach (SalaryMonthly salary in osals)
{
_salaryMonthlys.Remove(salary);
}
}
#endregion
foreach (SalaryMonthly salary in _salaryMonthlys)
{
UpdateProgressStatus(EnumProcessStatus.PerformStep);
//salary.GradeSalaries = EmployeeGradeSalary.Get(gradeSalaryItems, salary.EmployeeID);
salary.GradeSalaries = gradeSalaryItems.FindAll(x => x.EmployeeID == salary.EmployeeID).ToObjectsTemplate();
if (salary.GradeSalaries.Count == 0) continue;
if (salary.Category.WagesType != EnumWagesType.Monthly)
{
foreach (EmployeeGradeSalary esal in salary.GradeSalaries)
{
MonthlyWorkingHour whour = _workingHours.Find(wh => wh.EmployeeID.Integer == salary.EmployeeID.Integer);
if (whour != null)
{
esal.BasicSalary = esal.BasicSalary * whour.RegularHour;
}
esal.ActualBasicSalary = esal.BasicSalary;
}
}
EmployeeGradeSalary.PrepareDataForCurrentSalary(salary.Employee, salary.GradeSalaries);
basicSalary = 0;
if (salary.Category.WagesType != EnumWagesType.Monthly)
{
if (_workingHours == null) _workingHours = MonthlyWorkingHour.Get(_processMonth);
salary.ThisMonthBasic = salary.Employee.BasicSalary;
MonthlyWorkingHour whour = _workingHours.Find(delegate(MonthlyWorkingHour wh) { return (wh.EmployeeID.Integer == salary.EmployeeID.Integer); });
if (whour != null)
{
salary.HoursOrDaysNDF = whour.RegularHour;
basicSalary = salary.ThisMonthBasic * whour.RegularHour;
}
else
basicSalary = salary.ThisMonthBasic;
}
else
{
basicSalary = 0;
//salary.GradeSalaries[0].FractionofFromTo = 1; // for redisha back process
if (salary.GradeSalaries.Count > 0)
{
salary.ThisMonthBasic = salary.GradeSalaries[salary.GradeSalaries.Count - 1].BasicSalary;
salary.ThisMonthBasic = salary.ThisMonthBasic;
salary.ThisMonthGross = salary.GradeSalaries[salary.GradeSalaries.Count - 1].GrossSalary;
salary.ThisMonthGross = salary.ThisMonthGross;
}
foreach (EmployeeGradeSalary item in salary.GradeSalaries)
{
item.BasicSalary = item.BasicSalary * item.FractionofFromTo;
item.BasicSalary =item.BasicSalary;
item.GrossSalary = item.GrossSalary * item.FractionofFromTo;
item.GrossSalary = item.GrossSalary;
basicSalary = basicSalary + item.BasicSalary;
}
}
basicDetail = this.AddDetail(salary, EnumSalaryGroup.Gross, EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary, 0, "Basic",basicSalary);
if (salary.PayrollTypeID.Integer == (int)EnumPayrollType.Appentis)
{
basicDetail.Description = "Allowance";
}
}
#endregion Calculate Normal Salary
#region calculate arrear amount
double arrearAmount = 0;
if (Payroll.BO.SystemInformation.CurrentSysInfo.PayrollTypeID.Integer == 1)
{
ObjectsTemplate<EmployeeGradeSalary> arrearItems = EmployeeGradeSalary.Service.GetArrearItems();
foreach (SalaryMonthly salary in _salaryMonthlys)
{
arrearAmount = 0;
salary.ArrearGradeSalaries = EmployeeGradeSalary.Get(arrearItems, salary.EmployeeID);
foreach (EmployeeGradeSalary arrearItem in salary.ArrearGradeSalaries)
{
arrearItem.BasicSalary = arrearItem.BasicSalary * GlobalFunctions.GetFraction(arrearItem.EffectDate, (DateTime)arrearItem.TillDate);
arrearItem.BasicSalary = GlobalFunctions.Round(arrearItem.BasicSalary);
arrearItem.GrossSalary = arrearItem.GrossSalary * GlobalFunctions.GetFraction(arrearItem.EffectDate, (DateTime)arrearItem.TillDate);
arrearItem.GrossSalary = GlobalFunctions.Round(arrearItem.GrossSalary);
arrearItem.FractionofFromTo = GlobalFunctions.GetFraction(arrearItem.EffectDate, (DateTime)arrearItem.TillDate);
arrearAmount = (arrearAmount + arrearItem.BasicSalary) - salary.GetAmountOnRange(salary.Employee, arrearItem.EffectDate, (DateTime)arrearItem.TillDate, EnumSalaryGroup.Gross,
EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary, arrearItem, null);
arrearAmount = arrearAmount - salary.GetUnAuthorizeAmount(arrearItem.BasicSalary, salary.Employee,
arrearItem.EffectDate, (DateTime)arrearItem.TillDate, EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary);
arrearAmount = GlobalFunctions.Round(arrearAmount);
}
if (salary.ArrearGradeSalaries.Count > 0)
{
DateTime arrearPaidFrom = salary.ArrearGradeSalaries[0].EffectDate;
salary.ArrearPaidGradeSalaries = EmployeeGradeSalary.Service.GetArrearPaidItems(salary.EmployeeID, arrearPaidFrom);
// salary.ArrearPaidGradeSalaries = gradeSalaryItems.FindAll(x => x.EmployeeID == salary.EmployeeID && x.TillDate >= arrearPaidFrom && x.ArrearType == EnumArrearType.Paid).ToObjectsTemplate();
//if (salary.ArrearPaidGradeSalaries.Count > 0)
//{
// if (salary.ArrearPaidGradeSalaries[0].EffectDate < arrearPaidFrom)
// salary.ArrearPaidGradeSalaries[0].EffectDate = arrearPaidFrom;
//}
foreach (EmployeeGradeSalary paidarrearItem in salary.ArrearPaidGradeSalaries)
{
paidarrearItem.BasicSalary = paidarrearItem.BasicSalary * GlobalFunctions.GetFraction(paidarrearItem.EffectDate, (DateTime)paidarrearItem.TillDate);
paidarrearItem.BasicSalary = GlobalFunctions.Round(paidarrearItem.BasicSalary);
paidarrearItem.GrossSalary = paidarrearItem.GrossSalary * GlobalFunctions.GetFraction(paidarrearItem.EffectDate, (DateTime)paidarrearItem.TillDate);
paidarrearItem.GrossSalary = GlobalFunctions.Round(paidarrearItem.GrossSalary);
paidarrearItem.FractionofFromTo = GlobalFunctions.GetFraction(paidarrearItem.EffectDate, (DateTime)paidarrearItem.TillDate);
SalaryMonthlyDetail odtail = SalaryMonthly.Service.GetDetail(salary.EmployeeID, GlobalFunctions.LastDateOfMonth(((DateTime)paidarrearItem.TillDate).AddMonths(1)), EnumSalaryGroup.Arrear, EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary);
double paidAmount = 0;
if (odtail != null)
{
if (salary.ArrearPaidGradeSalaries[0].EffectDate < arrearPaidFrom)
paidAmount = (odtail.ChangedAmount * GlobalFunctions.GetFraction(arrearPaidFrom, (DateTime)paidarrearItem.TillDate)) / GlobalFunctions.GetFraction(paidarrearItem.EffectDate, (DateTime)paidarrearItem.TillDate);
else paidAmount = odtail.ChangedAmount;
}
//arrearAmount = arrearAmount - (salary.GetAmountOnRange(salary.Employee, paidarrearItem.EffectDate, (DateTime)paidarrearItem.TillDate, EnumSalaryGroup.Arrear,
// EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary));
arrearAmount = GlobalFunctions.Round(arrearAmount) - GlobalFunctions.Round(paidAmount);
}
if (arrearAmount != 0)
{
SalaryMonthlyDetail detail = this.AddDetail(salary, EnumSalaryGroup.Arrear, EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary, 0, "Basic", GlobalFunctions.Round(arrearAmount));
detail.Position = basicDetail.Position;
}
}
}
}
#endregion calculate arrear amount
UpdateProgressStatus(EnumProcessStatus.End);
}
private void PF()
{
int nn = 1;
UpdateProgressStatus(EnumProcessStatus.Start);
try
{
bool earnedBasic = ConfigurationManager.GetBoolValue("pf", "earnedbasic", EnumConfigurationType.Logic);
//bool earnedBasic = true;
double pfPercent = (SystemInformation.CurrentSysInfo.pFContriCompany / 100);
List<PFException> oPfExceptions = PFException.Get();
foreach (SalaryMonthly salary in _salaryMonthlys)
{
//if (nn == 143)
// nn = 143;
UpdateProgressStatus(EnumProcessStatus.PerformStep);
if (salary.Employee.CategoryID.Integer != 1) continue;
SalaryMonthlyDetail pfDetail = null;
pfDetail = this.AddDetail(salary, EnumSalaryGroup.Deductions, EnumSalaryItemCode.PF_Contribution, (int)EnumSalaryItemCode.PF_Contribution, 0, "PF", 0);
SalaryMonthlyDetail basic = salary.Details.Find(delegate(SalaryMonthlyDetail detail) { return (detail.ItemCode == EnumSalaryItemCode.Basic_Salary && detail.itemGroupCode == EnumSalaryGroup.Gross); });
SalaryMonthlyDetail basicarrear = salary.Details.Find(delegate(SalaryMonthlyDetail detail) { return (detail.ItemCode == EnumSalaryItemCode.Basic_Salary && detail.itemGroupCode == EnumSalaryGroup.Arrear); });
if (basic == null) continue;
if (basicarrear == null) basicarrear = new SalaryMonthlyDetail();
if (salary.Employee.PFMemberType == EnumPFMembershipType.Live)
{
if (salary.Employee.PFMemberShiptDate >= GlobalExtensions.FirstDateOfMonth(SystemInformation.CurrentSysInfo.NextPayProcessDate))
{
pfDetail.CalculatedAmount = (((basic.CalculatedAmount * GlobalFunctions.GetFraction(salary.Employee.PFMemberShiptDate, SystemInformation.CurrentSysInfo.NextPayProcessDate))));
}
else
{
pfDetail.CalculatedAmount = basic.CalculatedAmount;
}
//else
//{
// if ((_PrvMonthsalary.Exists(x => x.EmployeeID.Integer == salary.EmployeeID.Integer && x.PFMembershipType == EnumPFMembershipType.Live) == true))
// {
// pfDetail.CalculatedAmount = (basic.ChangedAmount + basicarrear.ChangedAmount) * pfPercent;
// }
// else
// {
// if (salary.ArrearGradeSalaries.Count == 0)
// {
// pfDetail.CalculatedAmount = basic.ChangedAmount;
// if (basicarrear != null) pfDetail.CalculatedAmount = pfDetail.CalculatedAmount + basicarrear.ChangedAmount;
// pfDetail.CalculatedAmount = pfDetail.CalculatedAmount * pfPercent;
// }
// else
// {
// if (salary.ArrearGradeSalaries[0].EffectDate <= salary.Employee.PFMemberShiptDate)
// {
// double pfarrear = salary.ArrearGradeSalaries[0].BasicSalary * GlobalFunctions.GetFraction(salary.Employee.PFMemberShiptDate, (DateTime)
// salary.ArrearGradeSalaries[salary.ArrearGradeSalaries.Count - 1].TillDate);
// pfDetail.CalculatedAmount = (basic.ChangedAmount + pfarrear) * pfPercent; ;
// }
// else
// {
// EmployeeGradeSalary gradesl = EmployeeGradeSalary.GetBasicOnDate(salary.EmployeeID, salary.Employee.PFMemberShiptDate);
// if (gradesl == null) continue;
// double pfarrear = basic.CalculatedAmount + gradesl.BasicSalary * GlobalFunctions.GetFraction(salary.Employee.PFMemberShiptDate, (DateTime)
// salary.ArrearGradeSalaries[salary.ArrearGradeSalaries.Count - 1].TillDate);
// pfDetail.CalculatedAmount = pfarrear * pfPercent;
// }
// }
// }
//}
// pfDetail.ChangedAmount = pfDetail.CalculatedAmount;
if (salary.Employee.PFMemberType != EnumPFMembershipType.Live) continue;
if (earnedBasic == false)
{
//pfDetail = this.AddDetail(salary, EnumSalaryGroup.Deductions,
//EnumSalaryItemCode.PF_Contribution, (int)EnumSalaryItemCode.PF_Contribution, 0, "PF", GlobalFunctions.Round(salary.ThisMonthBasic * pfPercent));
}
else
{
if (basic != null && pfDetail != null)
{
pfDetail.CalculatedAmount = GlobalFunctions.Round(pfDetail.CalculatedAmount * pfPercent);
}
//if (basic != null && pfDetail==null)
//{
// pfDetail = this.AddDetail(salary, EnumSalaryGroup.Deductions,
// EnumSalaryItemCode.PF_Contribution, (int)EnumSalaryItemCode.PF_Contribution, 0, "PF", GlobalFunctions.Round(basic.CalculatedAmount * pfPercent));
//}
//basic = salary.Details.Find(delegate(SalaryMonthlyDetail detail) { return (detail.ItemCode == EnumSalaryItemCode.Basic_Salary && detail.itemGroupCode == EnumSalaryGroup.Arrear); });
//if (basic != null)
//{
// pfDetail.CalculatedAmount = pfDetail.CalculatedAmount + GlobalFunctions.Round(basic.CalculatedAmount * pfPercent);
//}
basic = salary.GetDetail(EnumSalaryGroup.UnauthLeave, EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary);
if (basic != null)
{
pfDetail.CalculatedAmount = pfDetail.CalculatedAmount - GlobalFunctions.Round(basic.CalculatedAmount * pfPercent);
}
if (basicarrear != null)
{
pfDetail.CalculatedAmount = pfDetail.CalculatedAmount + GlobalFunctions.Round(basicarrear.CalculatedAmount * pfPercent);
}
if (pfDetail != null)
pfDetail.ChangedAmount = pfDetail.CalculatedAmount;
}
#region Exception PF
//PFException oEmpPFException = oPfExceptions.FirstOrDefault(x => x.EmployeeID == salary.Employee.ID);
//if (oEmpPFException != null) // && oEmpPFException.StartDate <= salary.SalaryMonth)
//{
// if (pfDetail != null)
// {
// pfDetail.CalculatedAmount = oEmpPFException.EPFPercent == 0 ? oEmpPFException.EPFAmount : GlobalFunctions.Round(salary.ThisMonthBasic * (oEmpPFException.EPFPercent / 100));
// pfDetail.ChangedAmount = pfDetail.CalculatedAmount;
// }
//}
#endregion
}
UpdateProgressStatus(EnumProcessStatus.End);
nn++;
}
}
catch (Exception exp)
{
throw new Exception(exp.Message);
}
}
private void AllowanceDeduction()
{
UpdateProgressStatus(EnumProcessStatus.Start);
_allowdeducitons = Payroll.BO.AllowanceDeduction.Get(EnumStatus.Regardless);
_adParameters = ADParameter.Get(EnumStatus.Active);
if (_adParameters == null || _adParameters.Count == 0)
{
return;
}
ObjectsTemplate<ADParameterEmployee> indvAllowances = ADParameterEmployee.Get(
GlobalFunctions.FirstDateOfMonth(_processMonth),
GlobalFunctions.LastDateOfMonth(_processMonth));
foreach (SalaryMonthly salary in _salaryMonthlys)
{
UpdateProgressStatus(EnumProcessStatus.PerformStep);
ADParameter.ApplicableParameters(salary.Employee, salary, _adParameters);
this.GradeDefinedAllowDeduct(salary, salary.GradeSalaries, EnumSalaryGroup.Gross, indvAllowances, EnumSide.Add);
if (Payroll.BO.SystemInformation.CurrentSysInfo.PayrollTypeID.Integer != 2)
{
this.GradeDefinedAllowDeduct(salary, salary.ArrearGradeSalaries, EnumSalaryGroup.Arrear, indvAllowances, EnumSide.Add);
}
// this.GradeDefinedAllowDeduct(salary, salary.ArrearPaidGradeSalaries, EnumSalaryGroup.Arrear, indvAllowances, EnumSide.Deduct);
this.IndividualAllowDeduct(salary, indvAllowances);
}
}
private void IndividualAllowDeduct(SalaryMonthly salary, ObjectsTemplate<ADParameterEmployee> indvAllowances)
{
double amount = 0;
EnumSalaryGroup groupCode = EnumSalaryGroup.Gross;
#region Individual Allowance
List<ADParameterEmployee> items = indvAllowances.FindAll(delegate(ADParameterEmployee item)
{
return item.EmployeeID.Integer == salary.Employee.ID.Integer && item.ADEmpType == EnumADEmpType.AppliedToIndividual;
});
foreach (ADParameterEmployee item in items)
{
amount = 0;
ADParameter parameter = _adParameters.GetItem(item.ADParameterID);
amount = parameter.GetIndividualAmount(salary.Employee, _processMonth, item,
salary.Employee.GrossSalary, salary.GetGrossAmount(EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary), salary);
EnumSalaryItemCode itemCode = EnumSalaryItemCode.Allowance;
groupCode = EnumSalaryGroup.Gross;
if (parameter.AllowOrDeductType == EnumAllowOrDeduct.Deduction)
{
itemCode = EnumSalaryItemCode.Deduction;
groupCode = EnumSalaryGroup.Deductions;
}
if (item.Arreartype == EnumArrearType.ToCalculate) groupCode = EnumSalaryGroup.Arrear;
if (groupCode == EnumSalaryGroup.Arrear)
{
amount = amount - salary.GetUnAuthorizeAmount(amount, salary.Employee,
item.FormDate, (DateTime)item.TillDate, itemCode, parameter.AllowDeductID.Integer);
EnumSalaryGroup arrgCode = (parameter.AllowanceDeduction.AllowOrDeductType == EnumAllowOrDeduct.Allowance) ? EnumSalaryGroup.Gross : EnumSalaryGroup.Deductions;
amount = amount - salary.GetAmountOnRange(salary.Employee, item.FormDate, (DateTime)item.TillDate, arrgCode, itemCode, parameter.AllowDeductID.Integer, parameter.ID.Integer);
if (amount == 0) continue;
}
//if (parameter.AllowanceDeduction.Code == "027")
// amount = amount * 6;
SalaryMonthlyDetail detail = salary.GetDetail(groupCode, itemCode, parameter.AllowDeductID.Integer);
if (detail == null)
detail = this.AddDetail(salary, groupCode, itemCode, parameter.AllowDeductID.Integer, parameter.ID.Integer, parameter.AllowanceDeduction.Name, GlobalFunctions.Round(amount));
else
{
detail.CalculatedAmount = detail.CalculatedAmount + amount;
detail.CalculatedAmount = GlobalFunctions.Round(detail.CalculatedAmount);
detail.ChangedAmount = detail.CalculatedAmount;
detail.SupportID = parameter.ID;
}
detail.Position = item.AllowDeduct.Sequence + 1;
}
#endregion Individual Allowance
}
private void GradeDefinedAllowDeduct(SalaryMonthly salary, ObjectsTemplate<EmployeeGradeSalary> gradeSalaries,
EnumSalaryGroup gCode, ObjectsTemplate<ADParameterEmployee> indvAllowances, EnumSide side)
{
double amount = 0;
EnumSalaryGroup GroupCode = gCode;
foreach (EmployeeGradeSalary empGradeSalary in gradeSalaries)
{
foreach (ADParameter parameter in empGradeSalary.ADParameters)
{
GroupCode = gCode;
parameter.AllowanceDeduction = _allowdeducitons.GetItem(parameter.AllowDeductID);
if (parameter.AllowanceDeduction.AllowOrDeductType == EnumAllowOrDeduct.Deduction && GroupCode == EnumSalaryGroup.Gross)
GroupCode = EnumSalaryGroup.Deductions;
amount = 0;
if (parameter.EntitleType == EnumEntitleType.Grade)
{
if (salary.Category.WagesType != EnumWagesType.Monthly)
{
empGradeSalary.FractionofFromTo = 1;
amount = parameter.GetGradeDefinedAmount(salary.Employee, empGradeSalary.BasicSalary, empGradeSalary.GrossSalary, empGradeSalary);
int nonRegularSpecialAllow = ConfigurationManager.GetIntValue("adparameter", "specialallowance", EnumConfigurationType.Logic);
if (nonRegularSpecialAllow == parameter.ID.Integer)
{
MonthlyWorkingHour whour = _workingHours.Find(delegate(MonthlyWorkingHour wh) { return (wh.EmployeeID.Integer == salary.EmployeeID.Integer); });
if (whour != null)
{
double nActualBasic = amount * whour.SpecialHour;
amount = nActualBasic;
}
}
}
else
{
amount = parameter.GetGradeDefinedAmount(salary.Employee, empGradeSalary.BasicSalary, empGradeSalary.GrossSalary, empGradeSalary);
}
}
else continue;
//if (parameter.IsFlatAmount == true)
// amount = amount + parameter.FlatAmount * empGradeSalary.FractionofFromTo;
//if (parameter.IsFlatAmount == true) amount = amount * empGradeSalary.FractionofFromTo;
EnumSalaryItemCode itemCode = (parameter.AllowOrDeductType == EnumAllowOrDeduct.Allowance) ? EnumSalaryItemCode.Allowance : EnumSalaryItemCode.Deduction;
if (GroupCode == EnumSalaryGroup.Arrear && salary.PayrollTypeID.Integer != 2)
{
amount = amount - salary.GetUnAuthorizeAmount(amount, salary.Employee,
empGradeSalary.EffectDate, (DateTime)empGradeSalary.TillDate, itemCode, parameter.AllowDeductID.Integer);
EnumSalaryGroup arrgCode = (parameter.AllowanceDeduction.AllowOrDeductType == EnumAllowOrDeduct.Allowance) ? EnumSalaryGroup.Gross : EnumSalaryGroup.Deductions;
amount = amount - salary.GetAmountOnRange(salary.Employee, empGradeSalary.EffectDate, (DateTime)empGradeSalary.TillDate, arrgCode, itemCode, parameter.AllowDeductID.Integer, parameter.ID.Integer, empGradeSalary, parameter);
foreach (EmployeeGradeSalary paidarrearItem in salary.ArrearPaidGradeSalaries)
{
SalaryMonthlyDetail odtail = SalaryMonthly.Service.GetDetail(salary.EmployeeID,
GlobalFunctions.LastDateOfMonth(((DateTime)paidarrearItem.TillDate).AddMonths(1)), EnumSalaryGroup.Arrear,
itemCode, parameter.AllowDeductID.Integer);
double paidAmount = 0;
if (odtail != null)
{
if (salary.ArrearPaidGradeSalaries[0].EffectDate < empGradeSalary.EffectDate)
paidAmount = (odtail.ChangedAmount * GlobalFunctions.GetFraction(empGradeSalary.EffectDate, (DateTime)paidarrearItem.TillDate)) / GlobalFunctions.GetFraction(paidarrearItem.EffectDate, (DateTime)paidarrearItem.TillDate);
else paidAmount = odtail.ChangedAmount;
}
//arrearAmount = arrearAmount - (salary.GetAmountOnRange(salary.Employee, paidarrearItem.EffectDate, (DateTime)paidarrearItem.TillDate, EnumSalaryGroup.Arrear,
// EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary));
amount = GlobalFunctions.Round(amount) - GlobalFunctions.Round(paidAmount);
}
if (amount == 0) continue;
}
if (GroupCode == EnumSalaryGroup.Arrear && side == EnumSide.Deduct) amount = -amount;
SalaryMonthlyDetail detail = salary.GetDetail(GroupCode, itemCode, parameter.AllowDeductID.Integer);
if (amount == 1) amount = 0;
if (detail == null)
detail = this.AddDetail(salary, GroupCode, itemCode, parameter.AllowDeductID.Integer, parameter.ID.Integer, parameter.AllowanceDeduction.Name, amount);
else
{
detail.CalculatedAmount = detail.CalculatedAmount + amount;
detail.CalculatedAmount = GlobalFunctions.Round(detail.CalculatedAmount);
detail.ChangedAmount = detail.CalculatedAmount;
detail.SupportID = parameter.ID;
}
detail.Position = parameter.AllowanceDeduction.Sequence + 1;
}
}
}
private void OverTimeProcess()
{
UpdateProgressStatus(EnumProcessStatus.Start);
TermParameter ob = new TermParameter();
Term shiftWiseOTime = null;
ObjectsTemplate<Term> _shiftWiseOTimes = Term.Get(EnumStatus.Active);
shiftWiseOTime = _shiftWiseOTimes.Where(o => o.EntityMode == EnumEntityMode.ShiftAllowance).FirstOrDefault();
ObjectsTemplate<OTProcess> otProcess = OTProcess.Get(SystemInformation.CurrentSysInfo.NextPayProcessDate);
if (otProcess == null || otProcess.Count == 0) return;
foreach (SalaryMonthly sMonthly in _salaryMonthlys)
{
UpdateProgressStatus(EnumProcessStatus.PerformStep);
List<OTProcess> empOTProcess = otProcess.Where(o => o.EmployeeID == sMonthly.EmployeeID && o.TermObj.EntityMode != EnumEntityMode.ShiftAllowance).ToObjectsTemplate();
List<OTProcess> empOTShift = otProcess.Where(o => o.EmployeeID == sMonthly.EmployeeID && o.TermObj.EntityMode == EnumEntityMode.ShiftAllowance).OrderBy(z => z.OTMonth).ToObjectsTemplate();
List<DateTime> datesOTProcess = new List<DateTime>();
List<DateTime> datesOTShift = new List<DateTime>();
datesOTProcess = empOTProcess.Select(x => x.OTMonth).Distinct().ToList();
datesOTShift = empOTShift.Select(x => x.OTMonth).Distinct().ToList();
if (empOTProcess != null)
{
//foreach (DateTime dt in datesOTProcess)
//{
// OTProcess pros = empOTProcess.Find(x => x.OTMonth == dt);
//}
foreach (OTProcess process in empOTProcess)
{
//this.AddDetail(sMonthly, EnumSalaryGroup.Miscellaneous, EnumSalaryItemCode.Over_Time_Hours, process.TermID.Integer, process.TermParameterID.Integer, process.TermObj.Name + "-" + process.OTMonth.ToString("MMM yyyy") + " hour", process.TotalHour);
this.AddDetail(sMonthly, EnumSalaryGroup.Gross, EnumSalaryItemCode.Over_Time_Amount, process.TermID.Integer, process.TermParameterID.Integer, process.TermObj.Name + "-" + process.OTMonth.ToString("MMM yyyy"), GlobalFunctions.Round(process.Amount));
}
}
if (empOTShift != null)
{
foreach (DateTime dt in datesOTShift)
{
double totalOTAmount = 0;
string description = "";
string shortCode = "";
int count = 0;
List<OTProcess> empOTShift2 = empOTShift.FindAll(x => x.OTMonth == dt).ToObjectsTemplate();
foreach (OTProcess process in empOTShift2)
{
count++;
if (process.TermObj.Code == "005")
shortCode = "E";
else if (process.TermObj.Code == "006")
shortCode = "N";
else
shortCode = "SW";
description += shortCode + " - " + process.TotalHour.ToString() + ",";
totalOTAmount += process.Amount;
if (count == empOTShift2.Count)
{
description = description.Trim(',');
description = "(" + description + ")";
if (totalOTAmount > shiftWiseOTime.MaxValue)
totalOTAmount = shiftWiseOTime.MaxValue;
this.AddDetail(sMonthly, EnumSalaryGroup.Gross, EnumSalaryItemCode.Over_Time_Amount, process.TermID.Integer, process.TermParameterID.Integer, "Shift Allowance " + process.OTMonth.ToString("MMM yyyy") + description, GlobalFunctions.Round(totalOTAmount));
}
}
}
}
}
UpdateProgressStatus(EnumProcessStatus.End);
}
private void AttendanceDayProcess()
{
UpdateProgressStatus(EnumProcessStatus.Start);
// TermParameter ob = new TermParameter();
DateTime FirstDateOfMonth = SystemInformation.CurrentSysInfo.NextPayProcessDate.FirstDateOfMonth().Date;
DateTime LastDateOfMonth = SystemInformation.CurrentSysInfo.NextPayProcessDate.LastDateOfMonth().Date;
int TotalDaysInMonth = SystemInformation.CurrentSysInfo.NextPayProcessDate.TotalDaysInMonth();
List<DailyAttnProcess> attnProcess = DailyAttnProcess.Get().Where(x => x.AttnDate >= FirstDateOfMonth && x.AttnDate <= LastDateOfMonth).ToList();
if (attnProcess == null || attnProcess.Count == 0)
{
UpdateProgressStatus(EnumProcessStatus.End);
return;
}
foreach (SalaryMonthly sMonthly in _salaryMonthlys)
{
DateTime joiningDate = DateTime.MinValue;
Employee oEmployee = _employees.FirstOrDefault(x => x.ID.Integer == sMonthly.EmployeeID.Integer);
if (oEmployee != null)
joiningDate = oEmployee.JoiningDate;
UpdateProgressStatus(EnumProcessStatus.PerformStep);
if (joiningDate < FirstDateOfMonth)
{
this.AddDetail(sMonthly, EnumSalaryGroup.Miscellaneous, EnumSalaryItemCode.Total_Days, (int)EnumSalaryItemCode.Total_Days, 0, "Working Days", TotalDaysInMonth);
}
else if (joiningDate > LastDateOfMonth)
{
this.AddDetail(sMonthly, EnumSalaryGroup.Miscellaneous, EnumSalaryItemCode.Total_Days, (int)EnumSalaryItemCode.Total_Days, 0, "Working Days", 0);
}
else
{
this.AddDetail(sMonthly, EnumSalaryGroup.Miscellaneous, EnumSalaryItemCode.Total_Days, (int)EnumSalaryItemCode.Total_Days, 0, "Working Days", (LastDateOfMonth.Subtract(joiningDate).TotalDays + 1));
}
List<DailyAttnProcess> empAttnProcess = attnProcess.Where(x => x.EmployeeID.Integer == sMonthly.EmployeeID.Integer).ToList();
if (empAttnProcess != null && empAttnProcess.Count > 0)
{
if (empAttnProcess.Any(x => x.AttenType == EnumAttendanceType.Present || x.AttenType == EnumAttendanceType.Late || x.AttenType == EnumAttendanceType.Delay))
this.AddDetail(sMonthly, EnumSalaryGroup.Miscellaneous, EnumSalaryItemCode.Tot_Attend_Days, (int)EnumSalaryItemCode.Tot_Attend_Days, 0, "Present Days", empAttnProcess.Where(x => x.AttenType == EnumAttendanceType.Present || x.AttenType == EnumAttendanceType.Late || x.AttenType == EnumAttendanceType.Delay).Count());
if (empAttnProcess.Any(x => x.AttenType == EnumAttendanceType.WeeklyHoliday || x.AttenType == EnumAttendanceType.Holiday))
this.AddDetail(sMonthly, EnumSalaryGroup.Miscellaneous, EnumSalaryItemCode.Total_HoliDays, (int)EnumSalaryItemCode.Total_HoliDays, 0, "Holidays", empAttnProcess.Where(x => x.AttenType == EnumAttendanceType.WeeklyHoliday || x.AttenType == EnumAttendanceType.Holiday).Count());
//if (empAttnProcess.Any(x => x.AttenType == EnumAttendanceType.Absent))
// this.AddDetail(sMonthly, EnumSalaryGroup.Miscellaneous, EnumSalaryItemCode.Tot_UnauthLeave_Days, 1, 0, "Absent Days", empAttnProcess.Where(x => x.AttenType == EnumAttendanceType.Absent).Count());
if (empAttnProcess.Any(x => x.AttenType == EnumAttendanceType.Delay))
this.AddDetail(sMonthly, EnumSalaryGroup.Miscellaneous, EnumSalaryItemCode.Delay_Days, (int)EnumSalaryItemCode.Delay_Days, 0, "Delay Days", empAttnProcess.Where(x => x.AttenType == EnumAttendanceType.Delay).Count());
}
}
UpdateProgressStatus(EnumProcessStatus.End);
}
private void LeaveDayProcess()
{
UpdateProgressStatus(EnumProcessStatus.Start);
// TermParameter ob = new TermParameter();
DateTime FirstDateOfMonth = SystemInformation.CurrentSysInfo.NextPayProcessDate.FirstDateOfMonth();
DateTime LastDateOfMonth = SystemInformation.CurrentSysInfo.NextPayProcessDate.LastDateOfMonth();
//int TotalDaysInMonth = SystemInformation.CurrentSysInfo.NextPayProcessDate.TotalDaysInMonth();
List<LeaveEntry> leaveEntries = LeaveEntry.Get(FirstDateOfMonth, LastDateOfMonth, EnumLeaveStatus.Approved);
List<Leave> leaves = Leave.Get();
if (leaveEntries == null || leaveEntries.Count == 0)
{
UpdateProgressStatus(EnumProcessStatus.End);
return;
}
foreach (SalaryMonthly sMonthly in _salaryMonthlys)
{
UpdateProgressStatus(EnumProcessStatus.PerformStep);
var empLeaveGroup = leaveEntries.Where(x => x.EmpID == sMonthly.EmployeeID.Integer)
.GroupBy(x => x.LeaveID)
.Select(x => new { LeaveID = x.Key, Days = x.Sum(y => y.ApprovedTotalDays) }).ToList();
foreach (var lEntry in empLeaveGroup)
{
Leave lv = leaves.FirstOrDefault(x => x.ID.Integer == lEntry.LeaveID.Integer);
this.AddDetail(sMonthly, EnumSalaryGroup.Miscellaneous, EnumSalaryItemCode.Leave_Days, lEntry.LeaveID.Integer, 0, lv != null ? lv.Code : "Unknown Leave", lEntry.Days);
}
}
UpdateProgressStatus(EnumProcessStatus.End);
}
private void OverTimeArrearProcess()
{
OvertimeProcess process = null;
ObjectsTemplate<OTProcess> otProcesses = null;
List<OTProcess> empOTProcesses = null;
Hashtable monthList = new Hashtable();
Hashtable employeeList = new Hashtable();
foreach (SalaryMonthly sMonthly in _salaryMonthlys)
{
foreach (EmployeeGradeSalary gradeSalary in sMonthly.ArrearGradeSalaries)
{
DateTime startdate = gradeSalary.EffectDate;
while (startdate <= gradeSalary.TillDate)
{
if (monthList[GlobalFunctions.LastDateOfMonth(startdate)] == null)
{
monthList.Add(GlobalFunctions.LastDateOfMonth(startdate), GlobalFunctions.LastDateOfMonth(startdate));
}
if (employeeList[gradeSalary.EmployeeID.Integer] == null)
{
employeeList.Add(gradeSalary.EmployeeID.Integer, gradeSalary.EmployeeID.Integer);
}
startdate = GlobalFunctions.LastDateOfMonth(GlobalFunctions.LastDateOfMonth(startdate).AddDays(1));
}
}
}
otProcesses = OTProcess.GetbyOtMonth(employeeList, monthList);
if (otProcesses != null && otProcesses.Count > 0)
{
process = new OvertimeProcess();
foreach (SalaryMonthly salaryMonthly in _salaryMonthlys)
{
foreach (EmployeeGradeSalary gradeSalary in salaryMonthly.ArrearGradeSalaries)
{
if (gradeSalary.GradeID.Integer == 2) continue;
empOTProcesses = otProcesses.FindAll(delegate(OTProcess prs)
{
return prs.EmployeeID == gradeSalary.EmployeeID && prs.OTMonth >= gradeSalary.EffectDate;
});
foreach (OTProcess empOTProcess in empOTProcesses)
{
if (empOTProcess.EmpOverTime == null) continue;
OTProcess prs = process.ProcessArrear(empOTProcess, salaryMonthly.ThisMonthBasic); //
SalaryMonthlyDetail basic = salaryMonthly.Details.Find(delegate(SalaryMonthlyDetail detail)
{
return (detail.ItemCode == EnumSalaryItemCode.Over_Time_Amount
&& detail.itemGroupCode == EnumSalaryGroup.Gross && detail.ItemID == empOTProcess.TermID.Integer);
});
if (basic == null)
this.AddDetail(salaryMonthly, EnumSalaryGroup.Gross, EnumSalaryItemCode.Over_Time_Amount,
empOTProcess.TermID.Integer, empOTProcess.TermParameterID.Integer, empOTProcess.TermObj.Name, 0);
SalaryMonthlyDetail arrearItem = salaryMonthly.Details.Find(delegate(SalaryMonthlyDetail detail)
{
return (detail.ItemCode == EnumSalaryItemCode.Over_Time_Amount
&& detail.itemGroupCode == EnumSalaryGroup.Arrear && detail.ItemID == empOTProcess.TermID.Integer);
});
if (arrearItem == null)
this.AddDetail(salaryMonthly, EnumSalaryGroup.Arrear, EnumSalaryItemCode.Over_Time_Amount,
empOTProcess.TermID.Integer, empOTProcess.TermParameterID.Integer, empOTProcess.TermObj.Name + "-" + empOTProcess.MonthDate.ToString("MMM yyyy"), GlobalFunctions.Round(prs.Amount));
else
{
arrearItem.CalculatedAmount = arrearItem.CalculatedAmount + Math.Round(prs.Amount, 1);
arrearItem.ChangedAmount = arrearItem.ChangedAmount + Math.Round(prs.Amount, 1);
}
}
}
}
}
}
private void CalculateBonus()
{
UpdateProgressStatus(EnumProcessStatus.Start);
DateTime dSalaryMonth = SystemInformation.CurrentSysInfo.NextPayProcessDate;
ObjectsTemplate<BonusProcess.BonusProcessDetail> bonusdetails = BonusProcess.GetBonusDetails(dSalaryMonth, true);
if (bonusdetails == null || bonusdetails.Count == 0) return;
BonusProcess bp = BonusProcess.Get(bonusdetails[0].BonusID, dSalaryMonth);
if (!bp.IsDisburseWithSalary) return;
ObjectsTemplate<Bonus> bonuses = Bonus.Get(EnumStatus.Regardless);
foreach (BonusProcess.BonusProcessDetail bonusdt in bonusdetails)
{
UpdateProgressStatus(EnumProcessStatus.PerformStep);
SalaryMonthly sMonthly = _salaryMonthlys.Find(delegate(SalaryMonthly monthly) { return monthly.EmployeeID.Integer == bonusdt.EmployeeID.Integer; });
if (sMonthly != null)
{
Bonus ob = bonuses.GetItem(bonusdt.BonusID);
this.AddDetail(sMonthly, EnumSalaryGroup.Gross, EnumSalaryItemCode.Bonus, bonusdt.BonusID.Integer, bonusdt.BonusProcessID.Integer, ob.Name, GlobalFunctions.Round(bonusdt.NetBonusAmount));
}
}
UpdateProgressStatus(EnumProcessStatus.End);
}
private void LoanProcess()
{
// UpdateProgressStatus(EnumProcessStatus.Start);
// DateTime dSalaryMonth = SystemInformation.CurrentSysInfo.NextPayProcessDate;
// ObjectsTemplate<LoanIssue> loanIssues = LoanIssue.Get(dSalaryMonth);
// if (loanIssues == null || loanIssues.Count == 0)
// {
// UpdateProgressStatus(EnumProcessStatus.End);
// return;
// }
// double loanAmounn = 0.0;
// double actuInterest = 0.0;
// double principleAmount = 0.0;
// double interest = 0.0;
// double balance = 0.0;
// double sattelmentAmount = 0.0;
// double nClosing = 0.0;
//// bool withInerest = ConfigurationManager.GetBoolValue("loan", "combineinterestinsalary", EnumConfigurationType.Logic);
// ObjectsTemplate<LoanSchedule> oLoanScheduls = new ObjectsTemplate<LoanSchedule>();
// oLoanScheduls = LoanSchedule.Get();
// foreach (LoanIssue issue in loanIssues)
// {
// UpdateProgressStatus(EnumProcessStatus.PerformStep);
// SalaryMonthly sMonthly = _salaryMonthlys.Find(delegate(SalaryMonthly monthly) { return monthly.EmployeeID.Integer == issue.EmployeeID.Integer; });
// if (sMonthly != null)
// {
// sMonthly.CalculateTotal();
// ObjectsTemplate<LoanSchedule> oschedules = issue.MonthlySchedules(dSalaryMonth);
// if (oschedules == null) continue;
// foreach (LoanSchedule schedule in oschedules)
// {
// nClosing = schedule.ClosingBalance;
// //+ " principle"
// this.AddDetail(sMonthly, EnumSalaryGroup.Deductions, EnumSalaryItemCode.Loan_Monthly_Installment, issue.LoanID.Integer, schedule.ID.Integer, issue.LoanObj.Name, GlobalFunctions.Round(schedule.InstallmentPrincipal));
// this.AddDetail(sMonthly, EnumSalaryGroup.Deductions, EnumSalaryItemCode.Loan_Monthly_Interest, issue.LoanID.Integer, schedule.ID.Integer, issue.LoanObj.Name + " interest", GlobalFunctions.Round(schedule.InstallmentInterest));
// //}
// //else
// // this.AddDetail(sMonthly, EnumSalaryGroup.Deductions, EnumSalaryItemCode.Loan_Monthly_Installment, issue.LoanID.Integer, schedule.ID.Integer, issue.LoanObj.Name + " principle", GlobalFunctions.Round(schedule.Installment));
// }
// #region For Loan Remainig Amount
// LoanIssue oLIssue = LoanIssue.GetExistingLoan(issue.LoanID, sMonthly.EmployeeID);
// List<LoanSchedule> oLSS = oLoanScheduls.FindAll(delegate(LoanSchedule oitem) { return oitem.LoanIssueID == oLIssue.ID; });
// if (oLSS.Count > 0)
// {
// loanAmounn = oLIssue.LoanAmount;
// List<LoanSchedule> oBeforeSMonths = oLSS.FindAll(delegate(LoanSchedule oitem) { return oitem.DueInstallmentDate <= GlobalFunctions.LastDateOfMonth(sMonthly.SalaryMonth); });
// actuInterest = 0.0;
// principleAmount = 0.0;
// interest = 0.0;
// balance = 0.0;
// sattelmentAmount = 0.0;
// foreach (LoanSchedule oScedule in oBeforeSMonths)
// {
// actuInterest = actuInterest + oScedule.ActualInterest;
// principleAmount = principleAmount + oScedule.InstallmentPrincipal;
// interest = interest + oScedule.InstallmentInterest;
// balance = balance + oScedule.OpeningBalance;
// }
// }
// sattelmentAmount = (loanAmounn + actuInterest) - (principleAmount + interest);
// this.AddDetail(sMonthly, EnumSalaryGroup.Miscellaneous, EnumSalaryItemCode.Loan_Remain_Balance, issue.LoanID.Integer, issue.ID.Integer, issue.LoanObj.Name + " balance", GlobalFunctions.Round(sattelmentAmount));
// #endregion
// }
// }
// UpdateProgressStatus(EnumProcessStatus.End);
DataSet oDataSet = LoanSchedule.Service.GetScheduleForSalary(_processMonth, SystemInformation.CurrentSysInfo.PayrollTypeID);
if (oDataSet == null || oDataSet.Tables[0] == null || oDataSet.Tables[0].Rows.Count == 0)
{
UpdateProgressStatus(EnumProcessStatus.End);
return;
}
foreach (DataRow oRow in oDataSet.Tables[0].Rows)
{
UpdateProgressStatus(EnumProcessStatus.PerformStep);
SalaryMonthly sMonthly = _salaryMonthlys.Find(delegate(SalaryMonthly monthly) { return monthly.EmployeeID.Integer.ToString() == oRow["EMPLOYEEID"].ToString(); });
if (sMonthly != null)
{
sMonthly.CalculateTotal();
this.AddDetail(sMonthly, EnumSalaryGroup.Deductions, EnumSalaryItemCode.Loan_Monthly_Installment, Convert.ToInt32(oRow["LOANID"].ToString()), Convert.ToInt32(oRow["LOANSCHEDULEID"].ToString()), oRow["DESCRIPTION"].ToString(), GlobalFunctions.Round(Convert.ToDouble(oRow["InstallmentPrincipal"].ToString())));
this.AddDetail(sMonthly, EnumSalaryGroup.Deductions, EnumSalaryItemCode.Loan_Monthly_Interest, Convert.ToInt32(oRow["LOANID"].ToString()), Convert.ToInt32(oRow["LOANSCHEDULEID"].ToString()), oRow["DESCRIPTION"].ToString(), GlobalFunctions.Round(Convert.ToDouble(oRow["InstallmentInterest"].ToString())));
}
}
UpdateProgressStatus(EnumProcessStatus.End);
}
private void Tax()
{
UpdateProgressStatus(EnumProcessStatus.Start);
TaxCalculator taxCalculator = new TaxCalculator();
taxCalculator.AdParameters = _adParameters;
bool bfixedAmount = ConfigurationManager.GetBoolValue("incometax", "fixedamount", EnumConfigurationType.Logic);
bool isOtherItem = ConfigurationManager.GetBoolValue("incometax", "taxissalaryotheritem", EnumConfigurationType.Logic);
EnumSalaryGroup ngroupCode = EnumSalaryGroup.Deductions;
if (isOtherItem == true) ngroupCode = EnumSalaryGroup.OtherItem;
taxCalculator.TaxParameter = TaxParameter.Get(SystemInformation.CurrentSysInfo.TaxParamID);
ObjectsTemplate<IncomeTax> taxes = IncomeTax.Get(EnumIncomeTaxDataFrom.ProcessTempData);
foreach (SalaryMonthly salary in _salaryMonthlys)
{
// if (salary.Employee.GradeID.Integer == 24 || salary.Employee.GradeID.Integer == 25) continue;
salary.Incometaxes = new ObjectsTemplate<IncomeTax>();
UpdateProgressStatus(EnumProcessStatus.PerformStep);
if (bfixedAmount == false)
{
taxCalculator.Salary = salary;
taxCalculator.Employee = salary.Employee;
taxCalculator.CurrentYearTax = IncomeTax.Get(taxes, salary.EmployeeID);
try
{
salary.Incometaxes = taxCalculator.SalaryTax();
}
catch (ServiceException sx)
{
this.AddProcessStatus(salary.Employee, sx.Message);
continue;
}
catch (Exception ex)
{
this.AddProcessStatus(salary.Employee, ex.Message);
continue;
}
#region Include tax in salary
IncomeTax taxItem = IncomeTax.Get(salary.Incometaxes, salary.EmployeeID, EnumIncomeTaxItemGroup.Tax_Deducted,
(int)EnumIncomeTaxItemGroup.Tax_Deducted);
if (taxItem != null)
{
if (taxItem.ThisMonthAmount < 0)
{
this.AddDetail(salary, ngroupCode, EnumSalaryItemCode.Inc_Tax_Deduction,
(int)EnumSalaryItemCode.Inc_Tax_Deduction, 0,
string.Empty, GlobalFunctions.Round(0));
}
else
{
//SalaryMonthly oprvsalry = _PrvMonthsalary.Find(delegate(SalaryMonthly param) { return param.EmployeeID.Integer == salary.EmployeeID.Integer; });
//if (oprvsalry != null)
//{
// SalaryMonthlyDetail odtl = oprvsalry.Details.Find(delegate(SalaryMonthlyDetail detail) { return (detail.ItemCode == EnumSalaryItemCode.Inc_Tax_Deduction && detail.itemGroupCode == EnumSalaryGroup.Deductions); });
// if (odtl != null)
// {
// if (Math.Abs(taxItem.ThisMonthAmount - odtl.ChangedAmount) <= 50)
// taxItem.ThisMonthAmount = odtl.ChangedAmount;
// }
//}
this.AddDetail(salary, ngroupCode, EnumSalaryItemCode.Inc_Tax_Deduction,
(int)EnumSalaryItemCode.Inc_Tax_Deduction, 0,
string.Empty, GlobalFunctions.Round(taxItem.ThisMonthAmount));
}
}
#endregion Include tax in salary
}
else
{
if (salary.Employee.TaxAmount > 0)
{
this.AddDetail(salary, ngroupCode, EnumSalaryItemCode.Inc_Tax_Deduction,
(int)EnumSalaryItemCode.Inc_Tax_Deduction, 0,
string.Empty, GlobalFunctions.Round(salary.Employee.TaxAmount));
}
}
}
UpdateProgressStatus(EnumProcessStatus.End);
}
private void UnAuthorizeLeave()
{
UpdateProgressStatus(EnumProcessStatus.Start);
TempUnAuthorized item = null;
List<TempUnAuthorized> items = new List<TempUnAuthorized>();
ObjectsTemplate<UnAuthorizeLeaveParam> UnLeaves = UnAuthorizeLeaveParam.Get();
ObjectsTemplate<EmployeeUnAuthorizeLeave> empUnLeaves = EmployeeUnAuthorizeLeave.Get(EnumLeaveEntryType.Normal, _processMonth);
DataSet dsAll = EmployeeUnAuthorizeLeave.GetAllUnAuthorizeLeave(_processMonth);
// DataSet dsAll = EmployeeUnAuthorizeLeave.GetAllUnAuthorizeLeave(new DateTime(_nYear,1,5));
//DataSet dsThisMonth = EmployeeUnAuthorizeLeave.GetThisMonthUnAuthorizeLeave(_processMonth);
int nTotalUnAuthorizedLeave = 0;
int nThisMonthUnAuthorizedLeave = 0;
int nTotalDays = 0;
int nUnpaidDays = 0;
//if (empUnLeaves == null || empUnLeaves.Count == 0)
//{
// UpdateProgressStatus(EnumProcessStatus.End);
// return;
//}
UnAuthorizeLeaveParamDetail unParamDetail = null;
DataSet dsUnpaidLeaves = EmployeeUnAuthorizeLeave.GetUnPaidLeave(_nYear);
foreach (DataRow dr in dsUnpaidLeaves.Tables[0].Rows)
{
TempUnAuthorized tu = new TempUnAuthorized();
tu.EmpID = Convert.ToInt16(dr[0].ToString());
tu.TotalUnAuthorizedDays = Convert.ToInt16(dr[1].ToString());
tu.BasicPaidDays = Convert.ToInt16(dr[2].ToString());
tu.OtherPaidDays = Convert.ToInt16(dr[3].ToString());
tu.BasicCurrentDeduct = Convert.ToInt16(dr[4].ToString());
tu.OtherCurrentDeduct = Convert.ToInt16(dr[5].ToString());
tu.BasicUnpaidDays = Convert.ToInt16(dr[6].ToString());
tu.OtherUnpaidDays = Convert.ToInt16(dr[7].ToString());
tu.LeaveID = Convert.ToInt16(dr[8].ToString());
tu.UnPaidLeaveYear = Convert.ToInt16(dr[9].ToString());
items.Add(tu);
}
foreach (SalaryMonthly salary in _salaryMonthlys)
{
nUnpaidDays = 0;
nTotalDays = 0;
nTotalUnAuthorizedLeave = 0;
nThisMonthUnAuthorizedLeave = 0;
TempUnAuthorized tEmp = items.Find(x => x.EmpID == salary.EmployeeID.Integer);
if (tEmp == null)
{
item = new TempUnAuthorized();
item.EmpID = salary.EmployeeID.Integer;
}
else
item = tEmp;
salary.UnAuthorizedLeaves = new List<TempUnAuthorized>();
UpdateProgressStatus(EnumProcessStatus.PerformStep);
SalaryMonthlyDetail salaryDetail = null;
double nAmount = 0;
double nBasicThisMOnthDays = 0;
if (dsAll.Tables[0] != null && dsAll.Tables[0].Rows.Count > 0)
{
DataRow dataRowAll = dsAll.Tables[0].AsEnumerable().Where(x => x.Field<int>("EmployeeID") == salary.EmployeeID.Integer).SingleOrDefault<DataRow>();
if (dataRowAll != null)
{
nTotalUnAuthorizedLeave = Convert.ToInt16(dataRowAll[1].ToString());
}
}
UnAuthorizeLeaveParam Param = new UnAuthorizeLeaveParam();
if (nTotalUnAuthorizedLeave > 30)
Param = UnLeaves[1];
else
Param = UnLeaves[0];
if (Param == null)
{
ProcessStatus("Unauthorize leave parameter not found");
continue;
}
item.TotalUnAuthorizedDays = nTotalUnAuthorizedLeave;
if (nTotalUnAuthorizedLeave > 30)
{
item.BasicCurrentDeduct = nTotalUnAuthorizedLeave - item.BasicPaidDays;
item.BasicPaidDays += item.BasicCurrentDeduct;
item.OtherCurrentDeduct = nTotalUnAuthorizedLeave - item.OtherPaidDays;
//nTotalDays = nThisMonthUnAuthorizedLeave + nUnpaidDays;
if (item.OtherCurrentDeduct > 16)
{
//nThisMonthUnAuthorizedLeave = (int)nTotalDays / 2;
nUnpaidDays = (int)item.OtherCurrentDeduct / 2;
item.OtherUnpaidDays = item.OtherCurrentDeduct - nUnpaidDays;
item.OtherPaidDays += nUnpaidDays;
item.OtherCurrentDeduct = nUnpaidDays;
//nUnpaidDays = nTotalDays - nThisMonthUnAuthorizedLeave;
//item.RemainingDays = item.TotalDays - nUnpaidDays;
}
else
{
item.OtherPaidDays += item.OtherCurrentDeduct;
item.OtherUnpaidDays = 0;
}
}
else
{
item.BasicCurrentDeduct = nTotalUnAuthorizedLeave - item.BasicPaidDays;
item.BasicPaidDays += item.BasicCurrentDeduct;
item.BasicUnpaidDays = 0;
}
foreach (UnAuthorizeLeaveParamDetail detail in Param.Details)
{
unParamDetail = detail;
salaryDetail = salary.Details.Find(delegate(SalaryMonthlyDetail dtl)
{
return IsExists(dtl, detail);
});
if (salaryDetail == null) continue;
//if (leave.LeaveMonth == _processMonth)
//{
if (salaryDetail != null)
{
nAmount = salaryDetail.CalculatedAmount;
if (salary.Employee.JoiningDate > GlobalFunctions.FirstDateOfMonth(_processMonth))
{
double ndays;
ndays = Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("d", salary.Employee.JoiningDate, _processMonth) + 1;
nAmount = nAmount / ndays;
nAmount = nAmount * _processMonth.Day;
}
}
else
{
nAmount = salary.GetAmountOnRange(salary.Employee, GlobalFunctions.FirstDateOfMonth(_processMonth),
GlobalFunctions.LastDateOfMonth(_processMonth), EnumSalaryGroup.Gross,
EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary);
}
//}
//else
//{
// nAmount = salary.GetAmountOnRange(salary.Employee, GlobalFunctions.FirstDateOfMonth(leave.LeaveMonth),
// GlobalFunctions.LastDateOfMonth(leave.LeaveMonth), EnumSalaryGroup.Gross,
// EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary);
//}
if (detail.Type == EnumSalaryComponent.Basic)
{
//nAmount = GlobalFunctions.ConevrtToDlyRateofMonth(nAmount, _processMonth) *( nBasicThisMOnthDays+item.RemainingDays);
nAmount = GlobalFunctions.ConevrtToDlyRateofMonth(nAmount, _processMonth) * item.BasicCurrentDeduct;
nAmount = nAmount * (detail.ValueInPercent / 100);
//double nBasicPaid = new SalaryMonthly().GetUnAuthorizeAmountOnDateRange(salary.EmployeeID, GlobalFunctions.FirstDateOfYear(_processMonth), _processMonth, EnumSalaryGroup.UnauthLeave, EnumSalaryItemCode.Basic_Salary);
//nAmount = nAmount - nBasicPaid;
}
else
{
// nAmount = GlobalFunctions.ConevrtToDlyRateofMonth(nAmount, _processMonth) * nThisMonthUnAuthorizedLeave;
nAmount = GlobalFunctions.ConevrtToDlyRateofMonth(nAmount, _processMonth) * item.OtherCurrentDeduct;
nAmount = nAmount * (detail.ValueInPercent / 100);
}
nAmount = GlobalFunctions.Round(nAmount);
this.AddDetail(salary, EnumSalaryGroup.UnauthLeave,
detail.Type == EnumSalaryComponent.Basic ? EnumSalaryItemCode.Basic_Salary : EnumSalaryItemCode.Allowance,
detail.Type == EnumSalaryComponent.Basic ? (int)EnumSalaryItemCode.Basic_Salary : detail.AllowanceID.Integer,
salaryDetail.SupportID.Integer, salaryDetail.Description, GlobalFunctions.Round(nAmount));
this.AddDetail(salary, EnumSalaryGroup.Miscellaneous, EnumSalaryItemCode.Tot_UnauthLeave_Days, Param.UnAhuthorizeLeaveID.Integer, 0, "UnAuthorized Leave Days", nThisMonthUnAuthorizedLeave);
//if(nUnpaidDays>0)
//{
// }
}
//}
//item.currentDeduct = nUnpaidDays;
//item.TotalDays = nTotalUnAuthorizedLeave;
//if (nTotalUnAuthorizedLeave > 30)
//{
// item.PaidDays += item.currentDeduct;
// //item.RemainingDays = nUnpaidDays;
//}
//else
//{
// item.PaidDays += item.currentDeduct;
//}
if (item.TotalUnAuthorizedDays > 0)
salary.UnAuthorizedLeaves.Add(item);
}
UpdateProgressStatus(EnumProcessStatus.End);
}
private bool IsExists(SalaryMonthlyDetail dtl, UnAuthorizeLeaveParamDetail detail)
{
switch (detail.Type)
{
case EnumSalaryComponent.Basic:
return dtl.ItemCode == EnumSalaryItemCode.Basic_Salary && dtl.itemGroupCode == EnumSalaryGroup.Gross;
case EnumSalaryComponent.Allowance:
return (dtl.ItemCode == EnumSalaryItemCode.Allowance && dtl.itemGroupCode == EnumSalaryGroup.Gross
&& dtl.ItemID == detail.AllowanceID.Integer);
default: return false;
}
}
private void PrepareCostcenterData()
{
UpdateProgressStatus(EnumProcessStatus.Start);
ObjectsTemplate<EmployeeCostCenter> empCostCenters = EmployeeCostCenter.Get();
foreach (SalaryMonthly salary in _salaryMonthlys)
{
UpdateProgressStatus(EnumProcessStatus.PerformStep);
ObjectsTemplate<EmployeeCostCenter> empinvolments = EmployeeCostCenter.Get(empCostCenters, salary.EmployeeID);
if (empCostCenters == null) continue;
salary.CostCentersInvolments = new ObjectsTemplate<SalaryEmpCostCenter>();
if (empinvolments != null)
{
foreach (EmployeeCostCenter item in empinvolments)
{
SalaryEmpCostCenter Semp = new SalaryEmpCostCenter();
Semp.CostCenterID = item.CostCenterID;
Semp.Percentage = item.Percentage;
Semp.EmployeeID = salary.EmployeeID;
salary.CostCentersInvolments.Add(Semp);
}
}
}
UpdateProgressStatus(EnumProcessStatus.End);
}
}
public class SalaryProcessStatus
{
public SalaryProcessStatus()
{
_employeeNo = "";
_name = "";
_remarks = "";
}
#region EmployeeNo : Employee No
private string _employeeNo;
public string EmployeeNo
{
get { return _employeeNo; }
set
{
_employeeNo = value;
}
}
#endregion
#region Employee Name : Employee Name
private string _name;
public string Name
{
get { return _name; }
set
{
_name = value;
}
}
#endregion
#region remaks : remarks
private string _remarks;
public string Remarks
{
get { return _remarks; }
set
{
_remarks = value;
}
}
#endregion
}
}
Reference in New Issue Copy Permalink