1619 lines
86 KiB
C#
1619 lines
86 KiB
C#
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
|
|
|
|
}
|
|
} |