3886 lines
202 KiB
C#
3886 lines
202 KiB
C#
using System;
|
|
using Ease.Core.Model;
|
|
using Ease.Core.DataAccess;
|
|
using HRM.BO;
|
|
using Ease.Core.Utility;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
namespace HRM.DA
|
|
{
|
|
public abstract class AbstractTaxCalculator
|
|
{
|
|
#region Define Class Variable
|
|
protected SalaryMonthly _salary;
|
|
private BonusProcess.BonusProcessDetail _bonus;
|
|
protected Employee _employee;
|
|
protected TaxParameter _taxParameter;
|
|
private TaxParameter _PrvYeartaxParameter;
|
|
protected List<TaxParameterSlab> _taxSlabs;
|
|
protected List<IncomeTax> _currentYearTax;
|
|
private List<IncomeTax> _prvYearTotalIncomes;
|
|
protected List<ADParameter> _adParameters;
|
|
protected List<TaxMergeMaster> _mergeItems;
|
|
protected List<ProcessItem> _processItems;
|
|
private List<ITEmpHead> _assignedHeads;
|
|
private List<BonusParameter> _projectionBonusParams;
|
|
protected List<BonusParameter> _ApplicableBonusParams;
|
|
protected List<BonusProcess.BonusProcessDetail> _paidBonuses;
|
|
protected List<BATBGrandFatherTaging> _bATBGrandFatherTagings;
|
|
protected List<AllowanceDeduction> _allowanceDeductions;
|
|
protected List<EmployeeTaxInvestment> _empTaxInvestments = null;
|
|
protected List<TaxInvestment> _investmentTypes =null;
|
|
protected double _projectedMonth;
|
|
protected double _onceoffAmount;
|
|
List<OTProcess> _oTProcesss = null;
|
|
private double _taxontaxamount;
|
|
public bool? _investmentwithoutpf= null;
|
|
public bool? _monthlyexemption = null;
|
|
public bool _isActualInvestment;
|
|
#endregion Define Class Variable
|
|
|
|
public AbstractTaxCalculator()
|
|
{
|
|
|
|
}
|
|
public AbstractTaxCalculator(int taxParameterID, int payrolltypeid)
|
|
{
|
|
_isActualInvestment = false;
|
|
_salary = null;
|
|
_taxSlabs = null;
|
|
TaxParameter param = new TaxParameterService().Get(taxParameterID);
|
|
_mergeItems = new TaxMergeMasterService().GetbyTaxParameter(param.ID, payrolltypeid);
|
|
if (param != null)
|
|
_assignedHeads = new ITEmpHeadService().GetWithTaxParam(param.ID);
|
|
_processItems = new ProcessItemService().Get();
|
|
_onceoffAmount = 0;
|
|
this.payrolltype = new PayrollTypeService().Get(payrolltypeid);
|
|
}
|
|
|
|
public AbstractTaxCalculator(TaxParameter taxparam, PayrollType ptype)
|
|
{
|
|
_isActualInvestment = false;
|
|
_salary = null;
|
|
_taxSlabs = null;
|
|
TaxParameter param = taxparam;
|
|
_mergeItems = new TaxMergeMasterService().GetbyTaxParameter(param.ID, ptype.ID);
|
|
this.payrolltype = ptype;
|
|
if (param != null)
|
|
_assignedHeads = new ITEmpHeadService().GetWithTaxParam(param.ID);
|
|
_processItems = new ProcessItemService().Get();
|
|
_onceoffAmount = 0;
|
|
}
|
|
|
|
public abstract TaxParameter TaxParameter { set; }
|
|
public abstract Employee Employee { set; }
|
|
public abstract SalaryMonthly Salary { set; }
|
|
public abstract List<ADParameter> AdParameters { set; }
|
|
public List<AllowanceDeduction> AllowanceDeductions
|
|
{
|
|
get
|
|
{
|
|
return _allowanceDeductions;
|
|
}
|
|
set
|
|
{
|
|
_allowanceDeductions = value;
|
|
}
|
|
}
|
|
|
|
public List<BonusProcess.BonusProcessDetail> PaidBonues
|
|
{
|
|
get
|
|
{
|
|
return _paidBonuses;
|
|
}
|
|
set
|
|
{
|
|
_paidBonuses = value;
|
|
}
|
|
}
|
|
|
|
public List<IncomeTax> CurrentYearTax
|
|
{
|
|
get
|
|
{
|
|
return _currentYearTax;
|
|
}
|
|
set { _currentYearTax = value; }
|
|
}
|
|
public BonusProcess.BonusProcessDetail Bonus
|
|
{
|
|
set
|
|
{
|
|
_bonus = value;
|
|
}
|
|
}
|
|
public List<IncomeTax> Calculate()
|
|
{
|
|
List<IncomeTax> returnedItems = new List<IncomeTax>();
|
|
return returnedItems;
|
|
}
|
|
private void EmployeeSlab()
|
|
{
|
|
//TaxParameter.Get
|
|
}
|
|
public PayrollType payrolltype { get; set; }
|
|
|
|
private void Add(IncomeTax taxItem)
|
|
{
|
|
if (taxItem.Position == 0)
|
|
{
|
|
ProcessItem pitem = _processItems.Find(delegate (ProcessItem item)
|
|
{ return item.ItemCode == (int)taxItem.ItemGroup; });
|
|
if (pitem == null) throw new ServiceException("Tax process item code not found in the process collection; Item Code:" + taxItem.ItemGroup.ToString());
|
|
taxItem.Position = pitem.Position;
|
|
}
|
|
|
|
IncomeTax existItem = _currentYearTax.Find(delegate (IncomeTax item)
|
|
{ return item.ItemGroup == taxItem.ItemGroup && item.ItemID == taxItem.ItemID; });
|
|
if (existItem == null) _currentYearTax.Add(taxItem);
|
|
else
|
|
{
|
|
existItem.PreviousAmount = existItem.PreviousAmount + taxItem.PreviousAmount;
|
|
existItem.ThisMonthAmount = existItem.ThisMonthAmount + taxItem.ThisMonthAmount;
|
|
existItem.ProjectedAmount = existItem.ProjectedAmount + taxItem.ProjectedAmount;
|
|
existItem.Position = taxItem.Position;
|
|
existItem.Description = taxItem.Description;
|
|
}
|
|
}
|
|
|
|
protected IncomeTax Add(EnumIncomeTaxItemGroup group, int itemId,
|
|
string description, double thismonthAmount,
|
|
double projectedamount, EnumIncomeTaxSide side)
|
|
{
|
|
|
|
IncomeTax existItem = _currentYearTax.Find(delegate (IncomeTax item)
|
|
{ return item.ItemGroup == group && item.ItemID == itemId; });
|
|
if (existItem == null)
|
|
{
|
|
ProcessItem pitem = _processItems.Find(delegate (ProcessItem item)
|
|
{ return item.ItemCode == (int)group; });
|
|
if (pitem == null) throw new ServiceException("Tax process item code not found in the process collection; Item Code:" + group.ToString());
|
|
|
|
IncomeTax taxItem = new IncomeTax();
|
|
taxItem.ItemGroup = group;
|
|
taxItem.ItemID = itemId;
|
|
|
|
|
|
|
|
taxItem.Description = (description == string.Empty) ? pitem.UserDescription : description;
|
|
taxItem.Position = pitem.Position;
|
|
taxItem.PreviousAmount = projectedamount;
|
|
taxItem.ThisMonthAmount = thismonthAmount;
|
|
taxItem.ProjectedAmount = projectedamount;
|
|
taxItem.EmployeeID = _employee.ID;
|
|
taxItem.Side = side;
|
|
_currentYearTax.Add(taxItem);
|
|
return taxItem;
|
|
}
|
|
else
|
|
{
|
|
if (existItem.Position == 0)
|
|
{
|
|
ProcessItem pitem = _processItems.Find(delegate (ProcessItem item)
|
|
{ return item.ItemCode == (int)group; });
|
|
if (pitem == null) throw new ServiceException("Tax process item code not found in the process collection; Item Code:" + group.ToString());
|
|
existItem.Position = pitem.Position;
|
|
}
|
|
|
|
existItem.ThisMonthAmount = existItem.ThisMonthAmount + thismonthAmount;
|
|
existItem.ProjectedAmount = existItem.ProjectedAmount + projectedamount;
|
|
existItem.Description = description;
|
|
existItem.Side = side;
|
|
return existItem;
|
|
}
|
|
}
|
|
protected void CalcualteprojectMonth()
|
|
{
|
|
//_projectedMonth = 12 - Ease.CoreV35.Utility.Global.DateFunctions.DateDiff ("m",
|
|
// SystemInformation.CurrentSysInfo.TaxYearEndDate,
|
|
// SystemInformation.CurrentSysInfo.NextPayProcessDate);
|
|
_projectedMonth = 12 - (((this.payrolltype.NextPayProcessDate.Year - this.payrolltype.TaxYearEndDate.Year) * 12)
|
|
+ this.payrolltype.NextPayProcessDate.Month - this.payrolltype.TaxYearEndDate.Month);
|
|
if (_projectedMonth < 0) _projectedMonth = 0;
|
|
|
|
//_projectedMonth= Ease.CoreV35.Utility.Global.DateFunctions.DateDiff("m",
|
|
// new DateTime(2010, 12, 31), new DateTime(2011, 6, 30));
|
|
if (_employee.EndOfContractDate != null && _employee.EndOfContractDate != DateTime.MinValue)
|
|
{
|
|
if (_employee.EndOfContractDate < _taxParameter.FiscalyearDateTo)
|
|
_projectedMonth = GetProjectionMonth((DateTime)_employee.EndOfContractDate);
|
|
}
|
|
}
|
|
protected void CalculateOT()
|
|
{
|
|
// find current month OT
|
|
|
|
|
|
if (_oTProcesss == null)
|
|
_oTProcesss = new OTProcessService().Get(this.payrolltype.NextPayProcessDate);
|
|
|
|
|
|
OTProcess op = _oTProcesss.FirstOrDefault(x => x.EmployeeID == _employee.ID);
|
|
if (op == null) return;
|
|
|
|
IncomeTax otItem = _currentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.TimeCard && x.ItemID == 2);
|
|
//if (otItem == null) otItem = this.Add(EnumIncomeTaxItemGroup.TimeCard, (int)EnumIncomeTaxItemGroup.TimeCard, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
|
|
if (otItem == null) otItem = this.Add(EnumIncomeTaxItemGroup.TimeCard, (int)EnumIncomeTaxItemGroup.TimeCard, "Time Card", 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
|
|
// update this month amount
|
|
otItem.ThisMonthAmount = op.Amount;
|
|
otItem.ProjectedAmount = op.Amount * _projectedMonth;
|
|
|
|
}
|
|
|
|
private double GetProjectionMonth(DateTime date)
|
|
{
|
|
double nFraction;
|
|
//If Month is July then no need for Projection
|
|
if (date.Month == 7)
|
|
nFraction = Convert.ToDouble(0);
|
|
else
|
|
nFraction = GlobalFunctions.GetFraction(this.payrolltype.NextPayProcessDate.AddDays(1), date);
|
|
return nFraction;
|
|
}
|
|
private double GetAmountfromSalary(SalaryMonthlyDetail detail)
|
|
{
|
|
if (detail.itemGroupCode == EnumSalaryGroup.Arrear)
|
|
_onceoffAmount = _onceoffAmount + detail.ChangedAmount;
|
|
if (detail.itemGroupCode == EnumSalaryGroup.Miscellaneous || detail.itemGroupCode == EnumSalaryGroup.OtherItem) return 0;
|
|
if (detail.itemGroupCode == EnumSalaryGroup.Gross || detail.itemGroupCode == EnumSalaryGroup.Arrear)
|
|
return detail.ChangedAmount;
|
|
else return -detail.ChangedAmount;
|
|
}
|
|
protected IncomeTax GetTaxItem(EnumTaxMergeType type, int ItemId, string itemName)
|
|
{
|
|
IncomeTax taxItem = TaxMergeMaster.Extract(
|
|
_mergeItems, type, ItemId);
|
|
if (taxItem == null) throw new ServiceException("Tax setup not found for the Item :" + itemName);
|
|
if (taxItem != null)
|
|
taxItem.EmployeeID = _employee.ID;
|
|
return taxItem;
|
|
}
|
|
|
|
protected void InitializeForNextMonth()
|
|
{
|
|
if (_currentYearTax == null)
|
|
{
|
|
_currentYearTax = new List<IncomeTax>();
|
|
_currentYearTax = new IncomeTaxService().Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
}
|
|
foreach (IncomeTax item in _currentYearTax)
|
|
{
|
|
item.PreviousAmount = item.PreviousAmount + item.ThisMonthAmount;
|
|
item.ThisMonthAmount = 0;
|
|
item.ProjectedAmount = 0;
|
|
}
|
|
}
|
|
private SalaryMonthlyDetail CreateSalaryDetail(string description, EnumSalaryItemCode itemCode, int itemid, int supportid, double amount)
|
|
{
|
|
SalaryMonthlyDetail odetail = new SalaryMonthlyDetail();
|
|
odetail.Description = description;
|
|
odetail.itemGroupCode = EnumSalaryGroup.Gross;
|
|
odetail.ItemCode = itemCode;
|
|
odetail.ItemID = itemid;
|
|
odetail.ChangedAmount = amount;
|
|
odetail.SupportID = supportid;
|
|
return odetail;
|
|
}
|
|
protected void CalculateOnlyProjection()
|
|
{
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
item.ProjectedAmount = 0;
|
|
|
|
List<ADParameter> adParams = null;
|
|
List<ADParameterEmployee> adParamEmps = null;
|
|
EmployeeGradeSalary oEmpGSalary = new EmployeeGradeSalary();
|
|
List<TaxRawItem> rawItems = new List<TaxRawItem>();
|
|
_projectedMonth = _projectedMonth + 1;
|
|
_salary = new SalaryMonthly();
|
|
_salary.Details.Add(this.CreateSalaryDetail("Basic Salary", EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary, 0, _employee.BasicSalary));
|
|
|
|
if (_adParameters == null) _adParameters = new ADParameterService().Get(EnumStatus.Regardless, EnumAllowOrDeduct.Allowance, this.payrolltype.ID);
|
|
adParams = new ADParameterService().GetApplicableParameters(_employee, (int)_employee.GradeID, _adParameters);
|
|
if (adParams != null)
|
|
{
|
|
foreach (ADParameter adParam in adParams)
|
|
{
|
|
//if (adParam.EntitleType == EnumEntitleType.Grade)
|
|
// _salary.Details.Add(this.CreateSalaryDetail(adParam.AllowanceDeduction.Name,
|
|
// EnumSalaryItemCode.Allowance, adParam.AllowanceDeduction.ID, adParam.ID, new ADParameterService().GetGradeDefinedAmount(_employee, _employee.BasicSalary,
|
|
// _employee.GrossSalary, new EmployeeGradeSalary())));
|
|
|
|
}
|
|
}
|
|
|
|
adParamEmps = new ADParameterEmployeeService().GetByEmployee(_employee.ID, EnumAllowOrDeduct.Allowance, EnumADEmpType.AppliedToIndividual);
|
|
|
|
if (adParamEmps != null)
|
|
{
|
|
foreach (ADParameterEmployee adEmp in adParamEmps)
|
|
{
|
|
_salary.Details.Add(this.CreateSalaryDetail(adEmp.AllowDeduct.Name,
|
|
EnumSalaryItemCode.Allowance, adEmp.AllowDeduct.ID, adEmp.ID, adEmp.MonthlyAmount));
|
|
|
|
}
|
|
}
|
|
this.IncludePayslipItems();
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
item.PreviousAmount = 0;
|
|
item.ThisMonthAmount = 0;
|
|
}
|
|
}
|
|
protected void CalculateOnlyProjection(List<ADParameter> oParams)
|
|
{
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
item.ProjectedAmount = 0;
|
|
|
|
List<ADParameter> adParams = null;
|
|
List<ADParameterEmployee> adParamEmps = null;
|
|
EmployeeGradeSalary oEmpGSalary = new EmployeeGradeSalary();
|
|
List<TaxRawItem> rawItems = new List<TaxRawItem>();
|
|
// _projectedMonth = _projectedMonth + 1;
|
|
_salary = new SalaryMonthly();
|
|
_salary.Details.Add(this.CreateSalaryDetail("Basic Salary", EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary, 0, _employee.BasicSalary));
|
|
if(this._allowanceDeductions == null)
|
|
{
|
|
this._allowanceDeductions = new AllowanceDeductionService().Get(EnumStatus.Regardless, this.payrolltype.ID);
|
|
}
|
|
|
|
if (_adParameters == null) _adParameters = oParams;// ADParameter.Get(EnumStatus.Regardless, EnumAllowOrDeduct.Allowance);
|
|
adParams = new ADParameterService().GetApplicableParameters(_employee, (int)_employee.GradeID, _adParameters);
|
|
if (adParams != null)
|
|
{
|
|
foreach (ADParameter adParam in adParams)
|
|
{
|
|
adParam.AllowanceDeduction = this._allowanceDeductions.FirstOrDefault(x => x.ID == adParam.AllowDeductID);
|
|
|
|
if (adParam.EntitleType == EnumEntitleType.Grade)
|
|
_salary.Details.Add(this.CreateSalaryDetail(adParam.AllowanceDeduction.Name,
|
|
EnumSalaryItemCode.Allowance, adParam.AllowanceDeduction.ID, adParam.ID,
|
|
new ADParameterService().GetGradeDefinedAmount(_employee, _employee.BasicSalary,
|
|
_employee.GrossSalary, new EmployeeGradeSalary(), adParam)));
|
|
|
|
}
|
|
}
|
|
|
|
adParamEmps = new ADParameterEmployeeService().GetByEmployee(_employee.ID, EnumAllowOrDeduct.Allowance, EnumADEmpType.AppliedToIndividual);
|
|
|
|
if (adParamEmps != null)
|
|
{
|
|
foreach (ADParameterEmployee adEmp in adParamEmps)
|
|
{
|
|
_salary.Details.Add(this.CreateSalaryDetail(adEmp.AllowDeduct.Name,
|
|
EnumSalaryItemCode.Allowance, adEmp.AllowDeduct.ID, adEmp.ADParameterID, adEmp.MonthlyAmount));
|
|
|
|
}
|
|
}
|
|
this.IncludePayslipItems();
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
item.PreviousAmount = 0;
|
|
item.ThisMonthAmount = 0;
|
|
}
|
|
}
|
|
|
|
|
|
private bool IsExamptedItem(IncomeTax Item)
|
|
{
|
|
bool IsExamptedItem = false;
|
|
|
|
if (Item.ItemGroup == EnumIncomeTaxItemGroup.House_Rent_Allowance)
|
|
IsExamptedItem = true;
|
|
else if (Item.ItemGroup == EnumIncomeTaxItemGroup.Conveyance_Allowance)
|
|
IsExamptedItem = true;
|
|
else if (Item.ItemGroup == EnumIncomeTaxItemGroup.Medical_Allowance)
|
|
IsExamptedItem = true;
|
|
else if (Item.ItemGroup == EnumIncomeTaxItemGroup.LFA_Allowance)
|
|
IsExamptedItem = true;
|
|
|
|
return IsExamptedItem;
|
|
}
|
|
|
|
private IncomeTax PayslipAllowanceDeduction(SalaryMonthlyDetail salaryDetail, EnumTaxMergeType type)
|
|
{
|
|
EmployeeGradeSalary oEmpGSalary = new EmployeeGradeSalary();
|
|
IncomeTax item = null;
|
|
ADParameter adparameter = _adParameters.FirstOrDefault(x => x.ID == salaryDetail.SupportID);
|
|
if (adparameter == null)
|
|
throw new ServiceException("Allowance/deduction parameter not found for " + salaryDetail.Description);
|
|
if (adparameter.IsTaxable == false) return null;
|
|
|
|
item = this.GetTaxItem(type, salaryDetail.ItemID, salaryDetail.Description);
|
|
item.ThisMonthAmount = GlobalFunctions.Round(item.ThisMonthAmount + GetAmountfromSalary(salaryDetail));
|
|
|
|
|
|
|
|
if (adparameter.Periodicity == EnumPeriodicity.OneOff)
|
|
{
|
|
//if (User.CurrentUser.LogInPayrollTypeID.Integer == 1)
|
|
//{
|
|
if (IsExamptedItem(item) == false)
|
|
_onceoffAmount = _onceoffAmount + item.ThisMonthAmount;
|
|
//}
|
|
//else
|
|
//{
|
|
// if (adparameter.IsDependsOnAttendance == true)
|
|
// {
|
|
// item.ProjectedAmount = GlobalFunctions.Round(item.ThisMonthAmount) * _projectedMonth;
|
|
|
|
// }
|
|
//}
|
|
}
|
|
else
|
|
{
|
|
if (salaryDetail.itemGroupCode == EnumSalaryGroup.Gross)
|
|
{
|
|
//if (User.CurrentUser.LogInPayrollTypeID.Integer != 1 && item.ItemGroup == EnumIncomeTaxItemGroup.Conveyance_Allowance)
|
|
//{
|
|
// double conveyance = adparameter.FlatAmount;
|
|
// if (_employee.GrandFather != null) conveyance = adparameter.GFFlatAmount;
|
|
// item.ProjectedAmount = conveyance;
|
|
// item.ProjectedAmount = 26 * _projectedMonth * conveyance;
|
|
//}
|
|
//else
|
|
{
|
|
#region Management Payrol
|
|
if (adparameter.EntitleType == EnumEntitleType.Grade)
|
|
{
|
|
item.ProjectedAmount = GlobalFunctions.Round( new ADParameterService().GetGradeDefinedAmount(_employee, _employee.BasicSalary, _employee.GrossSalary, oEmpGSalary, adparameter)) * _projectedMonth;
|
|
}
|
|
else
|
|
{
|
|
DateTime fromDate = GlobalFunctions.FirstDateOfMonth(this.payrolltype.NextPayProcessDate);
|
|
DateTime toDate = this.payrolltype.NextPayProcessDate;
|
|
if (salaryDetail.SupportID != null)
|
|
{
|
|
|
|
ADParameterEmployee oempadp = salaryDetail.ADParamEmployee;
|
|
if (oempadp == null)
|
|
oempadp = new ADParameterEmployeeService().Get(_employee.ID, salaryDetail.ItemID, (int)salaryDetail.SupportID, EnumArrearType.NotPresent);
|
|
//ADParameterEmployee oempadp = ADParameterEmployee.Get(_employee.ID, ID.FromInteger(salaryDetail.ItemID), salaryDetail.SupportID);
|
|
if (oempadp != null)
|
|
{
|
|
|
|
fromDate = GlobalFunctions.FirstDateOfMonth(this.payrolltype.NextPayProcessDate.AddMonths(1));
|
|
|
|
if (oempadp.TillDate == null || oempadp.TillDate == DateTime.MinValue)
|
|
{
|
|
if (_employee.EndOfContractDate == null)
|
|
toDate = _taxParameter.FiscalyearDateTo;
|
|
else toDate = (DateTime)_employee.EndOfContractDate;
|
|
}
|
|
else
|
|
{
|
|
if (_employee.EndOfContractDate == null)
|
|
toDate = (DateTime)oempadp.TillDate;
|
|
else toDate = (DateTime)_employee.EndOfContractDate;
|
|
|
|
|
|
}
|
|
|
|
double nproject = 0;
|
|
if (fromDate > toDate) nproject = 0;
|
|
else
|
|
{
|
|
if (toDate > _taxParameter.FiscalyearDateTo) toDate = _taxParameter.FiscalyearDateTo;
|
|
nproject = GlobalFunctions.GetFraction(fromDate, toDate);
|
|
}
|
|
|
|
item.ProjectedAmount = GlobalFunctions.Round(oempadp.GetAmount(_employee.BasicSalary, 0)) * nproject;
|
|
}
|
|
else item.ProjectedAmount = GlobalFunctions.Round(item.ThisMonthAmount) * _projectedMonth;
|
|
}
|
|
else item.ProjectedAmount = GlobalFunctions.Round(item.ThisMonthAmount) * _projectedMonth;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
}
|
|
return item;
|
|
}
|
|
|
|
protected void IncludePayslipItems()
|
|
{
|
|
foreach (SalaryMonthlyDetail salaryDetail in _salary.Details)
|
|
{
|
|
IncomeTax item = null;
|
|
switch (salaryDetail.ItemCode)
|
|
{
|
|
case EnumSalaryItemCode.Basic_Salary:
|
|
|
|
item = GetTaxItem(EnumTaxMergeType.NONE, (int)EnumIncomeTaxItemGroup.Basic_Salary, salaryDetail.Description);
|
|
item.ThisMonthAmount = GlobalFunctions.Round(GetAmountfromSalary(salaryDetail));
|
|
if (salaryDetail.itemGroupCode == EnumSalaryGroup.Gross) item.ProjectedAmount = GlobalFunctions.Round(_employee.BasicSalary) * _projectedMonth;
|
|
break;
|
|
case EnumSalaryItemCode.Over_Time_Amount:
|
|
item = GetTaxItem(EnumTaxMergeType.OT, salaryDetail.ItemID, salaryDetail.Description);
|
|
if (item == null) throw new ServiceException("Tax grouping not found for " + salaryDetail.Description);
|
|
item.ThisMonthAmount = GlobalFunctions.Round(GetAmountfromSalary(salaryDetail));
|
|
break;
|
|
case EnumSalaryItemCode.Bonus:
|
|
//if (salaryDetail.ItemID == (int)EnumBATBBonusType.Management_Festival && PaidBonues != null)
|
|
//{
|
|
// BonusProcess.BonusProcessDetail obDetail = PaidBonues.FirstOrDefault(x => x.EmployeeID.Integer == _employee.ID.Integer && x.BonusID.Integer == salaryDetail.ItemID && x.IsLFA == true);
|
|
// if (obDetail != null) item = GetTaxItem(EnumTaxMergeType.NONE, (int)EnumIncomeTaxItemGroup.LFA_Allowance, salaryDetail.Description);
|
|
// else item = GetTaxItem(EnumTaxMergeType.Bonus, salaryDetail.ItemID, salaryDetail.Description);
|
|
//}
|
|
//else
|
|
item = GetTaxItem(EnumTaxMergeType.Bonus, salaryDetail.ItemID, salaryDetail.Description);
|
|
if (item == null) throw new ServiceException("Tax grouping not found for " + salaryDetail.Description);
|
|
item.ThisMonthAmount = GlobalFunctions.Round(GetAmountfromSalary(salaryDetail));
|
|
break;
|
|
case EnumSalaryItemCode.Allowance:
|
|
item = this.PayslipAllowanceDeduction(salaryDetail, EnumTaxMergeType.Allowance);
|
|
if (item == null) continue;
|
|
break;
|
|
case EnumSalaryItemCode.Deduction:
|
|
item = this.PayslipAllowanceDeduction(salaryDetail, EnumTaxMergeType.Deduction);
|
|
if (item == null) continue;
|
|
break;
|
|
//case EnumSalaryItemCode.PF_Contribution:
|
|
// item = GetTaxItem(EnumTaxMergeType.NONE, (int)EnumIncomeTaxItemGroup.Company_Contri_PF, salaryDetail.Description);
|
|
// item.ThisMonthAmount =GlobalFunctions.Round(GetAmountfromSalary(salaryDetail));
|
|
// break;
|
|
default:
|
|
break;
|
|
}
|
|
if (item != null) item.Side = EnumIncomeTaxSide.Inc_SalaryIncome;
|
|
if (item != null) this.Add(item);
|
|
}
|
|
|
|
}
|
|
|
|
protected void CalculateExemptionOnward2023()
|
|
{
|
|
|
|
double annualIncome = this.GetAnnualIncome();
|
|
|
|
IncomeTax exempted = _currentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.AnnualExemption && x.ItemID == (int)EnumIncomeTaxItemGroup.AnnualExemption);
|
|
|
|
if (exempted == null) exempted = this.Add(EnumIncomeTaxItemGroup.AnnualExemption,
|
|
(int)EnumIncomeTaxItemGroup.AnnualExemption, string.Empty, 0, 0,
|
|
EnumIncomeTaxSide.Dec_AnnualIncome);
|
|
|
|
|
|
if (_employee.ForeignExPat && (_employee.JoiningDate - payrolltype.NextPayProcessDate).TotalDays <= 183)
|
|
{
|
|
exempted.ThisMonthAmount = 0;
|
|
exempted.PreviousAmount = 0;
|
|
exempted.ProjectedAmount = 0;
|
|
return;
|
|
}
|
|
|
|
if (annualIncome > 0)
|
|
{
|
|
exempted.ProjectedAmount = Math.Ceiling( (annualIncome / 3) * 1);
|
|
if (exempted.ProjectedAmount > 450000)
|
|
{
|
|
exempted.ProjectedAmount = 450000;
|
|
}
|
|
}
|
|
|
|
exempted.TotalAmount = exempted.ProjectedAmount;
|
|
}
|
|
|
|
protected void CalculateExamtion()
|
|
{
|
|
this.CalculateExemptionOnward2023();
|
|
return;
|
|
#region get Examtion items from processItem
|
|
var examtionItems = from pItem in _processItems
|
|
where pItem.ItemGroup == 7
|
|
select pItem;
|
|
#endregion
|
|
if(this._monthlyexemption ==null)
|
|
this._monthlyexemption = new SystemConfigarationService().GetconfigBooleanValue(EnumConfigurationType.Logic, "incometax", "monthlyexemption");
|
|
|
|
foreach (var processItem in examtionItems)
|
|
{
|
|
double tempAmount = 0;
|
|
|
|
#region House rent allowance
|
|
if (processItem.ItemCode == (int)EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance)
|
|
{
|
|
//if (_employee.JoiningDate.Day > 1)
|
|
// _employee.JoiningDate = new DateTime(_employee.JoiningDate.Year, _employee.JoiningDate.Month, 1);
|
|
IncomeTax basicItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Basic_Salary && x.ItemID == (int) EnumIncomeTaxItemGroup.Basic_Salary);
|
|
|
|
IncomeTax HRItem = _currentYearTax.FirstOrDefault(x=> x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.House_Rent_Allowance && x.ItemID == (int)EnumIncomeTaxItemGroup.House_Rent_Allowance);
|
|
if (HRItem == null || HRItem.TotalAmount == 0) continue; //throw new ServiceException("House rent allowance not found in the collection while calculating HR Examtion");
|
|
//continue; //
|
|
|
|
IncomeTax HrExption = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance &&
|
|
x.ItemID == (int)EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance);
|
|
if (HrExption == null) HrExption = this.Add(EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance,
|
|
(int)EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
//if (oCycles != null && oCycles.Count>0)
|
|
//{
|
|
// EmpLifeCycle cycle = oCycles.Find(x => x.IsContinue==true);
|
|
// if (cycle != null)
|
|
// _employee.JoiningDate = cycle.EffectDate;
|
|
//}
|
|
//if (_employee.JoiningDate < new DateTime(_taxParameter.FiscalyearDatefrom.Year, 7, 1))
|
|
//{
|
|
// monthlyexemption = false;
|
|
//}
|
|
//else
|
|
this._monthlyexemption = true;
|
|
|
|
HrExption.ProjectedAmount = 0;
|
|
//HrExption.ThisMonthAmount = 0;
|
|
//HrExption.PreviousAmount = 0;
|
|
//HrExption.TotalAmount = 0;
|
|
|
|
if (this._monthlyexemption == false)
|
|
{
|
|
HrExption.ProjectedAmount = 0;
|
|
HrExption.ThisMonthAmount = 0;
|
|
HrExption.PreviousAmount = 0;
|
|
HrExption.TotalAmount = 0;
|
|
if (_taxParameter.MaxHRPercent != 0)
|
|
{
|
|
double hrAmount = (basicItem.TotalAmount * _taxParameter.MaxHRPercent) / 100;
|
|
double maxMonthlyAmount = (_taxParameter.MaxHRAmount / 12) * 12 - _projectedMonth;
|
|
|
|
if (hrAmount > _taxParameter.MaxHRAmount)
|
|
HrExption.ProjectedAmount = _taxParameter.MaxHRAmount;
|
|
else HrExption.ProjectedAmount = hrAmount;
|
|
|
|
if (HrExption.TotalAmount > HRItem.TotalAmount || Math.Abs(HrExption.TotalAmount - HRItem.TotalAmount) < 10)
|
|
HrExption.ProjectedAmount = HRItem.TotalAmount -
|
|
(HrExption.ThisMonthAmount + HrExption.PreviousAmount);
|
|
}
|
|
else
|
|
{
|
|
if (HRItem.TotalAmount > _taxParameter.MaxHRAmount)
|
|
HrExption.ProjectedAmount = _taxParameter.MaxHRAmount;
|
|
else HrExption.ProjectedAmount = HRItem.TotalAmount;
|
|
|
|
if (HrExption.TotalAmount > HRItem.TotalAmount || Math.Abs(HrExption.TotalAmount - HRItem.TotalAmount) < 10)
|
|
HrExption.ProjectedAmount = HRItem.TotalAmount -
|
|
(HrExption.ThisMonthAmount + HrExption.PreviousAmount);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//#region monthly Examption
|
|
//if (HRItem.TotalAmount > _taxParameter.MaxHRAmount)
|
|
//{
|
|
// tempAmount = _taxParameter.MaxHRAmount - HrExption.PreviousAmount;
|
|
// HrExption.ThisMonthAmount = tempAmount / (_projectedMonth + 1);
|
|
// HrExption.ProjectedAmount = _taxParameter.MaxHRAmount -
|
|
// (HrExption.ThisMonthAmount + HrExption.PreviousAmount);
|
|
// if (HrExption.TotalAmount > _taxParameter.MaxHRAmount || Math.Abs(HrExption.TotalAmount - HRItem.TotalAmount) < 10)
|
|
// HrExption.ProjectedAmount = HrExption.TotalAmount - _taxParameter.MaxHRAmount;
|
|
//}
|
|
//else
|
|
//{
|
|
|
|
double def = 0;
|
|
double nFracAmount = 0;
|
|
#region This code needed for only this month to calculate previous month
|
|
double maxMonthlyAmount = _taxParameter.MaxHRAmount / 12;
|
|
|
|
//if (HrExption.PreviousAmount == 0 && _employee.JoiningDate < new DateTime(_taxParameter.FiscalyearDatefrom.Year, 7, 1))
|
|
//{
|
|
// if (maxMonthlyAmount * (SystemInformation.CurrentSysInfo.NextPayProcessDate.Month- _taxParameter.FiscalyearDatefrom.Month) > HRItem.PreviousAmount)
|
|
// {
|
|
// HrExption.PreviousAmount = maxMonthlyAmount * (SystemInformation.CurrentSysInfo.NextPayProcessDate.Month - _taxParameter.FiscalyearDatefrom.Month);
|
|
// }
|
|
// else HrExption.PreviousAmount = HRItem.PreviousAmount;
|
|
//}
|
|
DateTime fromDate = _employee.JoiningDate;
|
|
DateTime todate = this.payrolltype.NextPayProcessDate;
|
|
if (_employee.JoiningDate < _taxParameter.FiscalyearDatefrom) fromDate = _taxParameter.FiscalyearDatefrom;
|
|
|
|
if (HrExption.PreviousAmount == 0) // that mean sytem started tax calculation middle of the fiscal year
|
|
{
|
|
if (HRItem.PreviousAmount > 0)
|
|
{
|
|
def = Global.DateFunctions.DateDiff("m", fromDate, GlobalFunctions.LastDateOfMonth(todate));
|
|
if (HRItem.PreviousAmount < maxMonthlyAmount * def)
|
|
HrExption.PreviousAmount = HRItem.PreviousAmount;
|
|
else HrExption.PreviousAmount = maxMonthlyAmount * def;
|
|
}
|
|
else if (HRItem.PreviousAmount == 0 &&
|
|
GlobalFunctions.FirstDateOfMonth(_employee.JoiningDate) < GlobalFunctions.FirstDateOfMonth(todate)) // New Joiner with Arrear
|
|
{
|
|
def = Global.DateFunctions.DateDiff("m", fromDate, GlobalFunctions.LastDateOfMonth(todate));
|
|
HrExption.PreviousAmount = maxMonthlyAmount * def;
|
|
}
|
|
}
|
|
//todate = _taxParameter.FiscalyearDateTo;
|
|
//if (_taxParameter.FiscalyearDatefrom < _employee.JoiningDate) fromDate = _employee.JoiningDate;
|
|
//if (_employee.EndOfContractDate != null && _employee.EndOfContractDate < _taxParameter.FiscalyearDateTo)
|
|
// todate = (DateTime)_employee.EndOfContractDate;
|
|
|
|
//if (fromDate == GlobalFunctions.FirstDateOfMonth(_employee.JoiningDate))
|
|
// def = Global.DateFunctions.DateDiff("m", fromDate, GlobalFunctions.LastDateOfMonth(todate)) + 1;
|
|
//else
|
|
//{
|
|
// def = Global.DateFunctions.DateDiff("m", fromDate, GlobalFunctions.LastDateOfMonth(todate));
|
|
// TimeSpan ts = GlobalFunctions.LastDateOfMonth(fromDate) - fromDate;
|
|
// nFracAmount = (maxMonthlyAmount / (double)DateTime.DaysInMonth(fromDate.Year, fromDate.Month)) * ((double)ts.Days + 1);
|
|
//}
|
|
// if(_employee.JoiningDate < new DateTime(2018, 2,1))
|
|
//HrExption.ProjectedAmount = (maxMonthlyAmount * def) + nFracAmount;
|
|
|
|
|
|
if (_employee.EndOfContractDate != null && _salary != null)
|
|
{
|
|
if (_salary.SalaryMonth > GlobalFunctions.FirstDateOfMonth((DateTime)_employee.EndOfContractDate)
|
|
&& _salary.SalaryMonth <= GlobalFunctions.LastDateOfMonth((DateTime)_employee.EndOfContractDate))
|
|
{
|
|
maxMonthlyAmount = maxMonthlyAmount * GlobalFunctions.GetFractinalOfTillDate((DateTime)_employee.EndOfContractDate);
|
|
|
|
}
|
|
}
|
|
|
|
if (HRItem.ThisMonthAmount < maxMonthlyAmount)
|
|
maxMonthlyAmount = HRItem.ThisMonthAmount;
|
|
|
|
HrExption.ThisMonthAmount = maxMonthlyAmount;
|
|
|
|
|
|
double hrAmount = (basicItem.ProjectedAmount * _taxParameter.MaxHRPercent) / 100;
|
|
|
|
if (hrAmount > _taxParameter.MaxHRAmount / 12 * _projectedMonth)
|
|
HrExption.ProjectedAmount = _taxParameter.MaxHRAmount / 12 * _projectedMonth;
|
|
else HrExption.ProjectedAmount = hrAmount;
|
|
|
|
//if (hrAmount > _taxParameter.MaxHRAmount / 12 * Math.Ceiling(_projectedMonth))
|
|
// HrExption.ProjectedAmount = _taxParameter.MaxHRAmount / 12 * Math.Ceiling(_projectedMonth);
|
|
//else HrExption.ProjectedAmount = hrAmount;
|
|
|
|
|
|
|
|
if (HrExption.TotalAmount > HRItem.TotalAmount || Math.Abs(HrExption.TotalAmount - HRItem.TotalAmount) < 10)
|
|
HrExption.ProjectedAmount = HRItem.TotalAmount -
|
|
(HrExption.ThisMonthAmount + HrExption.PreviousAmount);
|
|
|
|
if (HrExption.TotalAmount > _taxParameter.MaxHRAmount)
|
|
{
|
|
double excess = HrExption.TotalAmount - _taxParameter.MaxHRAmount;
|
|
HrExption.ProjectedAmount = HrExption.ProjectedAmount - excess;
|
|
}
|
|
|
|
|
|
|
|
//if (HRItem.ThisMonthAmount < maxMonthlyAmount)
|
|
//{
|
|
// double nBasic = basicItem.ThisMonthAmount * def;
|
|
// nBasic = (nBasic * 50) / 100;
|
|
// if (HrExption.PreviousAmount < nBasic)
|
|
// HrExption.PreviousAmount = nBasic;
|
|
//}
|
|
//#endregion
|
|
|
|
//if (maxMonthlyAmount < HRItem.ThisMonthAmount)
|
|
//{
|
|
// HrExption.ThisMonthAmount = maxMonthlyAmount;
|
|
// HrExption.ProjectedAmount = maxMonthlyAmount * _projectedMonth;
|
|
//}
|
|
//else
|
|
//{
|
|
// HrExption.ThisMonthAmount = HRItem.ThisMonthAmount;
|
|
// HrExption.ProjectedAmount = HRItem.ThisMonthAmount * _projectedMonth;
|
|
|
|
// if (_salary != null && _salary.Details.Any(x => x.itemGroupCode == EnumSalaryGroup.UnauthLeave))
|
|
// {
|
|
// double unhraount = 0;
|
|
// SalaryMonthlyDetail odt = _salary.Details.FirstOrDefault(x => x.itemGroupCode == EnumSalaryGroup.Gross
|
|
// && x.ItemCode == EnumSalaryItemCode.Allowance && x.ItemID == 1);
|
|
|
|
// if (odt != null)
|
|
// unhraount = odt.ChangedAmount;
|
|
// HrExption.ProjectedAmount = (unhraount + HRItem.ThisMonthAmount) * _projectedMonth;
|
|
// }
|
|
//}
|
|
|
|
// HrExption.ThisMonthAmount = HRItem.ThisMonthAmount;
|
|
|
|
//tempAmount = HRItem.TotalAmount - HrExption.PreviousAmount;
|
|
//HrExption.ThisMonthAmount = HRItem.ThisMonthAmount;
|
|
//HrExption.ProjectedAmount = HRItem.ProjectedAmount;
|
|
//if (HrExption.TotalAmount > HRItem.TotalAmount || Math.Abs(HrExption.TotalAmount - HRItem.TotalAmount) < 10)
|
|
// HrExption.ProjectedAmount = HRItem.TotalAmount -
|
|
// (HrExption.ThisMonthAmount + HrExption.PreviousAmount);
|
|
//}
|
|
#endregion monthly Examption
|
|
}
|
|
HrExption.ThisMonthAmount = GlobalFunctions.Round(HrExption.ThisMonthAmount);
|
|
HrExption.ProjectedAmount = GlobalFunctions.Round(HrExption.ProjectedAmount);
|
|
HrExption.TotalAmount = HrExption.ThisMonthAmount + HrExption.PreviousAmount + HrExption.ProjectedAmount;
|
|
|
|
//if (_employee.JoiningDate < new DateTime(_taxParameter.FiscalyearDatefrom.Year, 7, 1))
|
|
//{
|
|
// HrExption.ThisMonthAmount = GlobalFunctions.Round(HrExption.ThisMonthAmount);
|
|
// HrExption.ProjectedAmount = GlobalFunctions.Round(HrExption.ProjectedAmount);
|
|
// HrExption.TotalAmount = HrExption.ThisMonthAmount + HrExption.PreviousAmount + HrExption.ProjectedAmount;
|
|
|
|
//}
|
|
//else
|
|
//{
|
|
// HrExption.ThisMonthAmount = 0;
|
|
// HrExption.ProjectedAmount = 0;
|
|
|
|
//}
|
|
//DataSet ds = IncomeTax.GetTaxAdj(EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance, (int)EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance, _employee.ID);
|
|
//if (ds != null && ds.Tables.Count > 0)
|
|
//{
|
|
// foreach (DataRow dr in ds.Tables[0].Rows)
|
|
// {
|
|
// HrExption.PreviousAmount = Convert.ToDouble(dr[4].ToString());
|
|
// }
|
|
//}
|
|
//HrExption.TotalAmount = HrExption.PreviousAmount;
|
|
}
|
|
#endregion House rent allowance
|
|
|
|
#region Conveyance Allowance Examtion
|
|
else if (processItem.ItemCode == (int)EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance)
|
|
{
|
|
IncomeTax CnvItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID== _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Conveyance_Allowance && x.ItemID == (int)EnumIncomeTaxItemGroup.Conveyance_Allowance);
|
|
if (CnvItem == null || CnvItem.TotalAmount == 0) continue;
|
|
|
|
IncomeTax CvExption = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance && x.ItemID == (int)EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance);
|
|
if (CvExption == null) CvExption = this.Add(EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance, (int)EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
|
|
if (this._monthlyexemption == false)
|
|
{
|
|
CvExption.TotalAmount = 0;
|
|
CvExption.ProjectedAmount = 0;
|
|
CvExption.PreviousAmount = 0;
|
|
CvExption.ThisMonthAmount = 0;
|
|
if (CnvItem.TotalAmount > _taxParameter.MaxConvAmount || Math.Abs(CnvItem.TotalAmount - _taxParameter.MaxConvAmount) < 10)
|
|
CvExption.ProjectedAmount = _taxParameter.MaxConvAmount;
|
|
else CvExption.ProjectedAmount = CnvItem.TotalAmount;
|
|
|
|
}
|
|
else
|
|
{
|
|
if (CnvItem.TotalAmount > _taxParameter.MaxConvAmount)
|
|
CvExption.ThisMonthAmount = _taxParameter.MaxConvAmount / 12;
|
|
else CvExption.ThisMonthAmount = CnvItem.ThisMonthAmount;
|
|
if (CnvItem.TotalAmount > _taxParameter.MaxConvAmount || Math.Abs(CnvItem.TotalAmount - _taxParameter.MaxConvAmount) < 10)
|
|
{
|
|
CvExption.ProjectedAmount = _taxParameter.MaxConvAmount - (
|
|
CvExption.ThisMonthAmount + CvExption.PreviousAmount);
|
|
}
|
|
else
|
|
{
|
|
CvExption.ProjectedAmount = CnvItem.TotalAmount - (
|
|
CvExption.ThisMonthAmount + CvExption.PreviousAmount);
|
|
}
|
|
}
|
|
CvExption.Side = EnumIncomeTaxSide.Dec_SalaryIncome;
|
|
CvExption.ThisMonthAmount = GlobalFunctions.Round(CvExption.ThisMonthAmount);
|
|
CvExption.ProjectedAmount = GlobalFunctions.Round(CvExption.ProjectedAmount);
|
|
|
|
CvExption.TotalAmount = CvExption.ThisMonthAmount + CvExption.PreviousAmount + CvExption.ProjectedAmount;
|
|
|
|
}
|
|
#endregion Conveyance Allowance Examtion
|
|
|
|
#region Other Allowance Examption
|
|
else if (processItem.ItemCode == (int)EnumIncomeTaxItemGroup.Exemption_Medical_Allowance)
|
|
{
|
|
IncomeTax MedicalItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Medical_Allowance && x.ItemID == (int)EnumIncomeTaxItemGroup.Medical_Allowance);
|
|
if (MedicalItem == null) continue; //throw new ServiceException("Conveyance allowance not found in the collection while calculating HR Examtion");
|
|
|
|
IncomeTax mdExption = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Exemption_Medical_Allowance && x.ItemID == (int)EnumIncomeTaxItemGroup.Exemption_Medical_Allowance);
|
|
if (mdExption == null) mdExption = this.Add(EnumIncomeTaxItemGroup.Exemption_Medical_Allowance, (int)EnumIncomeTaxItemGroup.Exemption_Medical_Allowance, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
|
|
IncomeTax basicItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Basic_Salary && x.ItemID == (int)EnumIncomeTaxItemGroup.Basic_Salary);
|
|
|
|
//Sumon on 24 June 2014
|
|
double nMamount = 0;
|
|
if (basicItem != null) nMamount = basicItem.TotalAmount *
|
|
(double)((_taxParameter.MaxMedicalPercent != 0) ? _taxParameter.MaxMedicalPercent / 100 : 0);
|
|
|
|
if (MedicalItem == null || MedicalItem.TotalAmount == 0)
|
|
mdExption.ProjectedAmount = 0.00;
|
|
else if (nMamount > _taxParameter.MaxMedicalAmount)
|
|
mdExption.ProjectedAmount = MedicalItem.TotalAmount < _taxParameter.MaxMedicalAmount ? MedicalItem.TotalAmount : GlobalFunctions.Round(_taxParameter.MaxMedicalAmount);
|
|
else
|
|
mdExption.ProjectedAmount = MedicalItem.TotalAmount > nMamount ? GlobalFunctions.Round(nMamount) : MedicalItem.TotalAmount;
|
|
//End
|
|
|
|
//mdExption.ProjectedAmount =GlobalFunctions.Round(MedicalItem.TotalAmount);
|
|
mdExption.TotalAmount = mdExption.ThisMonthAmount + mdExption.PreviousAmount + mdExption.ProjectedAmount;
|
|
mdExption.Side = EnumIncomeTaxSide.Dec_SalaryIncome;
|
|
// this.Add(mdExption);
|
|
}
|
|
else if (processItem.ItemCode == (int)EnumIncomeTaxItemGroup.Exemption_LFA_Allowance)
|
|
{
|
|
IncomeTax LFAItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.LFA_Allowance && x.ItemID == (int)EnumIncomeTaxItemGroup.LFA_Allowance);
|
|
if (LFAItem == null) continue;// throw new ServiceException("LFA allowance not found in the collection while calculating HR Examtion");
|
|
//continue; //
|
|
IncomeTax lfaExption = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Exemption_LFA_Allowance && x.ItemID == (int)EnumIncomeTaxItemGroup.Exemption_LFA_Allowance);
|
|
if (lfaExption == null) lfaExption = this.Add(EnumIncomeTaxItemGroup.Exemption_LFA_Allowance, (int)EnumIncomeTaxItemGroup.Exemption_LFA_Allowance, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
|
|
lfaExption.ProjectedAmount = GlobalFunctions.Round(LFAItem.TotalAmount);
|
|
lfaExption.TotalAmount = lfaExption.ThisMonthAmount + lfaExption.PreviousAmount + lfaExption.ProjectedAmount;
|
|
|
|
lfaExption.Side = EnumIncomeTaxSide.Dec_SalaryIncome;
|
|
// this.Add(mdExption);
|
|
}
|
|
else if (processItem.ItemCode == (int)EnumIncomeTaxItemGroup.WPPF_Examption)
|
|
{
|
|
IncomeTax wppfItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID ==_employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.WPPF_Allowance && x.ItemID == (int)EnumIncomeTaxItemGroup.WPPF_Allowance);
|
|
if (wppfItem == null) continue;// throw new ServiceException("LFA allowance not found in the collection while calculating HR Examtion");
|
|
//continue; //
|
|
IncomeTax wppfExption = _currentYearTax.FirstOrDefault(x=>x.EmployeeID== _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.WPPF_Examption && x.ItemID == (int)EnumIncomeTaxItemGroup.WPPF_Examption);
|
|
if (wppfExption == null) wppfExption = this.Add(EnumIncomeTaxItemGroup.WPPF_Examption, (int)EnumIncomeTaxItemGroup.WPPF_Examption, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
|
|
double exception = wppfItem.TotalAmount;
|
|
if (wppfItem.TotalAmount > 50000) exception = 50000;
|
|
|
|
wppfExption.ProjectedAmount = GlobalFunctions.Round(exception);
|
|
//wppfExption.ThisMonthAmount = 0; // need to remove
|
|
//wppfExption.PreviousAmount = 0;// need to remove
|
|
wppfExption.TotalAmount = wppfExption.ProjectedAmount;
|
|
wppfExption.Side = EnumIncomeTaxSide.Dec_SalaryIncome;
|
|
}
|
|
#endregion Other Allowance Examption
|
|
}
|
|
}
|
|
protected void CalculateCPF()
|
|
{
|
|
if (_employee.PFMemberType != EnumPFMembershipType.Live) return;
|
|
IncomeTax pfItem = _currentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Company_Contri_PF && x.ItemID == (int)EnumIncomeTaxItemGroup.Company_Contri_PF);
|
|
if (pfItem == null) pfItem = this.Add(EnumIncomeTaxItemGroup.Company_Contri_PF, (int)EnumIncomeTaxItemGroup.Company_Contri_PF, string.Empty, 0, 0, EnumIncomeTaxSide.Inc_AnnualIncome);
|
|
|
|
IncomeTax BasicItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Basic_Salary && x.ItemID == (int)EnumIncomeTaxItemGroup.Basic_Salary);
|
|
|
|
if (BasicItem == null) return;
|
|
|
|
if (_salary != null)
|
|
pfItem.ThisMonthAmount = _salary.GetDeductAmount(EnumSalaryItemCode.PF_Contribution, (int)EnumSalaryItemCode.PF_Contribution);
|
|
else
|
|
{
|
|
pfItem.ThisMonthAmount = (BasicItem.ThisMonthAmount
|
|
* this.payrolltype.pFContriCompany) / 100;
|
|
}
|
|
|
|
pfItem.ProjectedAmount = (BasicItem.ProjectedAmount
|
|
* this.payrolltype.pFContriCompany) / 100;
|
|
|
|
pfItem.ThisMonthAmount = GlobalFunctions.Round(pfItem.ThisMonthAmount);
|
|
pfItem.ProjectedAmount = GlobalFunctions.Round(pfItem.ProjectedAmount);
|
|
|
|
}
|
|
|
|
//protected void CalculateUpdateBonusProjection(double nAmount)
|
|
//{
|
|
|
|
// if (_employee.ForeignExPat == true) return;
|
|
// List<FestivalBonusProjection> taxProjections = FestivalBonusProjection.Get(EnumStatus.Active);
|
|
|
|
// IncomeTax pfItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Bonus, (int)EnumIncomeTaxItemGroup.Bonus);
|
|
// if (pfItem == null) pfItem = this.Add(EnumIncomeTaxItemGroup.Bonus, (int)EnumIncomeTaxItemGroup.Bonus, "Festival Bonus", 0, 0, EnumIncomeTaxSide.Inc_SalaryIncome);
|
|
// pfItem.ProjectedAmount = nAmount + pfItem.ProjectedAmount;
|
|
// if (pfItem.ProjectedAmount <= 0)
|
|
// pfItem.ProjectedAmount = 0;
|
|
// pfItem.ProjectedAmount = GlobalFunctions.Round(pfItem.ProjectedAmount);
|
|
|
|
//}
|
|
|
|
protected void CalculateBonusProjection()
|
|
{
|
|
|
|
#region Bonus projetion Management
|
|
List<BonusParameter> oparams = null;
|
|
if (_projectionBonusParams == null)
|
|
{
|
|
_projectionBonusParams = new List<BonusParameter>();
|
|
List<BonusParameter> ops = new BonusParameterService().Get(EnumStatus.Active, this.payrolltype.ID);
|
|
foreach (BonusParameter oitem in ops)
|
|
|
|
if (oitem.IsProjectInTaxCalculation == true)
|
|
{
|
|
_projectionBonusParams.Add(oitem);
|
|
}
|
|
}
|
|
|
|
if (_projectionBonusParams == null || _projectionBonusParams.Count == 0) return;
|
|
oparams = new BonusParameterService().GetApplicableParameters(_employee, (int) _employee.GradeID, _projectionBonusParams);
|
|
if (oparams == null) return;
|
|
|
|
_ApplicableBonusParams = oparams;
|
|
|
|
|
|
|
|
foreach (BonusParameter item in oparams)
|
|
{
|
|
IncomeTax pfItem = GetTaxItem(EnumTaxMergeType.Bonus, item.BonusID, item.BonusName);
|
|
pfItem.Side = EnumIncomeTaxSide.Inc_SalaryIncome;
|
|
|
|
if (pfItem == null) pfItem = this.Add(EnumIncomeTaxItemGroup.Bonus,
|
|
(int)EnumIncomeTaxItemGroup.Bonus, item.BonusName, 0, 0, EnumIncomeTaxSide.Inc_SalaryIncome);
|
|
|
|
|
|
// pfItem = _currentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID &&
|
|
//x.ItemGroup == EnumIncomeTaxItemGroup.Bonus && x.ItemID == item.BonusID);
|
|
|
|
//if (pfItem == null) pfItem = this.Add(EnumIncomeTaxItemGroup.Bonus,
|
|
// (int)EnumIncomeTaxItemGroup.Bonus, item.BonusName , 0, 0, EnumIncomeTaxSide.Inc_SalaryIncome);
|
|
|
|
BonusCalculator ocal = new BonusCalculator();
|
|
double bonusAmount = pfItem.ProjectedAmount + ocal.CalcluateBonus(item, _employee, _employee.BasicSalary, _employee.GrossSalary,
|
|
Global.DateFunctions.LastDateOfYear(payrolltype.NextPayProcessDate));
|
|
|
|
pfItem.ProjectedAmount = 0;
|
|
//First Project Month
|
|
if (bonusAmount >0 && item.firstProjectMonth != null && item.firstProjectMonth > payrolltype.NextPayProcessDate)
|
|
{
|
|
if(item.secondProjectMonth !=null)
|
|
pfItem.ProjectedAmount = bonusAmount / 2;
|
|
else pfItem.ProjectedAmount = bonusAmount;
|
|
}
|
|
if (bonusAmount > 0 && item.secondProjectMonth != null && item.secondProjectMonth > payrolltype.NextPayProcessDate)
|
|
{
|
|
pfItem.ProjectedAmount = pfItem.ProjectedAmount + bonusAmount / 2;
|
|
}
|
|
|
|
if (payrolltype.NextPayProcessDate.Month == 6) // Forcely zero on month Jun
|
|
pfItem.ProjectedAmount = 0;
|
|
|
|
if (pfItem.ProjectedAmount <= 0)
|
|
pfItem.ProjectedAmount = 0;
|
|
|
|
pfItem.ProjectedAmount = GlobalFunctions.Round(pfItem.ProjectedAmount);
|
|
|
|
this.Add(pfItem);
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
}
|
|
|
|
protected void CalculateInvestment()
|
|
{
|
|
|
|
IncomeTax InvestmentItem = _currentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Credit_On_Investment && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Credit_On_Investment);
|
|
if (InvestmentItem == null) InvestmentItem = this.Add(EnumIncomeTaxItemGroup.Tax_Credit_On_Investment, (int)EnumIncomeTaxItemGroup.Tax_Credit_On_Investment, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_GrossTax);
|
|
|
|
if (_employee.ForeignExPat == true) return;
|
|
|
|
if (this._investmentwithoutpf == null)
|
|
this._investmentwithoutpf = new SystemConfigarationService().GetconfigBooleanValue(EnumConfigurationType.Logic, "incometax", "investmentwithoutpf");
|
|
|
|
IncomeTax AnnualItem = null;
|
|
double nExemptedAmount = 0;
|
|
//if (this._investmentwithoutpf==true)
|
|
//{
|
|
// AnnualItem = _currentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID && x.ItemGroup == EnumIncomeTaxItemGroup.Annual_Salary_Income
|
|
// && x.ItemID == (int)EnumIncomeTaxItemGroup.Annual_Salary_Income);
|
|
|
|
// IncomeTax ExemptedItem = _currentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID && x.ItemGroup == EnumIncomeTaxItemGroup.AnnualExemption
|
|
// && x.ItemID == (int)EnumIncomeTaxItemGroup.AnnualExemption);
|
|
// if (ExemptedItem != null)
|
|
// {
|
|
// nExemptedAmount = ExemptedItem.TotalAmount;
|
|
// }
|
|
|
|
//}
|
|
//else
|
|
AnnualItem = _currentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID && x.ItemGroup == EnumIncomeTaxItemGroup.Annual_Income
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Annual_Income);
|
|
|
|
double investmentCanBeShown = (((AnnualItem.TotalAmount - nExemptedAmount) * _taxParameter.MaxInvestPercent) / 100);
|
|
|
|
|
|
if (investmentCanBeShown > _taxParameter.MaxInvAmount) investmentCanBeShown = _taxParameter.MaxInvAmount;
|
|
double investAmount = investmentCanBeShown;
|
|
_isActualInvestment = false;
|
|
if (this.payrolltype.ActualTaxInvestment == true)
|
|
{
|
|
_taxParameter.InvestmentActiveMonth = _taxParameter.FiscalyearDatefrom;
|
|
_isActualInvestment = true;
|
|
}
|
|
|
|
if (_isActualInvestment == false && _taxParameter.InvestmentActiveMonth == null) _isActualInvestment = false;
|
|
else
|
|
{
|
|
DateTime investmonth = new DateTime(_taxParameter.FiscalyearDatefrom.Year, ((DateTime)_taxParameter.InvestmentActiveMonth).Month, 1);
|
|
investmonth = GlobalFunctions.LastDateOfMonth(investmonth);
|
|
if (investmonth <= this.payrolltype.NextPayProcessDate)
|
|
_isActualInvestment = true;
|
|
}
|
|
|
|
if (_isActualInvestment == true) // payroll type wise Actual investment date is different, so this done in temporary basis
|
|
{
|
|
IncomeTax ActualInvestment = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Investment_Actual && x.ItemID == (int)EnumIncomeTaxItemGroup.Investment_Actual);
|
|
|
|
if (ActualInvestment == null)
|
|
ActualInvestment = this.Add(EnumIncomeTaxItemGroup.Investment_Actual, (int)EnumIncomeTaxItemGroup.Investment_Actual, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_Info_Item);
|
|
|
|
IncomeTax pfItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID && x.ItemGroup == EnumIncomeTaxItemGroup.Company_Contri_PF
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Company_Contri_PF);
|
|
investAmount = 0;
|
|
if (pfItem != null)
|
|
investAmount = investAmount + (pfItem.TotalAmount * 2);
|
|
if (this._investmentTypes == null) this._investmentTypes = new TaxInvestmentService().Get(EnumStatus.Regardless);
|
|
if (this._empTaxInvestments == null) this._empTaxInvestments = new EmployeeTaxInvestmentService().GetByTaxParamID(this._taxParameter.ID);
|
|
double nactualInvt = EmployeeTaxInvestment.GetAmount(this._employee.ID, _empTaxInvestments, _investmentTypes);
|
|
investAmount = investAmount + nactualInvt;
|
|
|
|
ActualInvestment.ProjectedAmount = nactualInvt;
|
|
ActualInvestment.TotalAmount = nactualInvt;
|
|
}
|
|
|
|
IncomeTax InvestmentAllowed = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID && x.ItemGroup == EnumIncomeTaxItemGroup.Investment_Allowed
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Investment_Allowed);
|
|
if (InvestmentAllowed == null) InvestmentAllowed = this.Add(EnumIncomeTaxItemGroup.Investment_Allowed,
|
|
(int)EnumIncomeTaxItemGroup.Investment_Allowed, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_Info_Item);
|
|
|
|
InvestmentAllowed.ProjectedAmount = GlobalFunctions.Round(investmentCanBeShown);
|
|
InvestmentAllowed.TotalAmount = GlobalFunctions.Round(investmentCanBeShown);
|
|
|
|
if (investAmount > investmentCanBeShown)
|
|
investAmount = investmentCanBeShown;
|
|
|
|
#region Rebate
|
|
double taxCredit = 0;
|
|
double nTempRebate = (investAmount * _taxParameter.MaxInvExempPercent) / 100;
|
|
if (nTempRebate > (AnnualItem.TotalAmount * .03))
|
|
nTempRebate = AnnualItem.TotalAmount * .03;
|
|
if (nTempRebate > 1000000)
|
|
nTempRebate = 1000000;
|
|
taxCredit = nTempRebate;
|
|
#endregion
|
|
|
|
InvestmentItem.ProjectedAmount = GlobalFunctions.Round(taxCredit);
|
|
InvestmentItem.TotalAmount = GlobalFunctions.Round(taxCredit);
|
|
}
|
|
|
|
protected void CmpProvidedHouseAndTransport(DateTime month)
|
|
{
|
|
try
|
|
{
|
|
if (_assignedHeads == null) return;
|
|
|
|
List<ITEmpHead> Items = _assignedHeads.FindAll(x=>x.EmployeeID == _employee.ID);
|
|
if (Items == null || Items.Count == 0) return;
|
|
|
|
DateTime fromDate = GlobalFunctions.FirstDateOfMonth(month);
|
|
DateTime toDate = GlobalFunctions.LastDateOfMonth(month);
|
|
bool bvalid = false;
|
|
|
|
IncomeTax basicSalaryItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Basic_Salary
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Basic_Salary);
|
|
|
|
if (basicSalaryItem == null) throw new ServiceException("Basic salary item not found in the collection on "
|
|
+ " calculating Company provided Car/HouseRent of the Employee No:" + _employee.EmployeeNo);
|
|
double tempAmount = 0;
|
|
double carparcent = ((double)5 / (double)100);
|
|
double hrPercent = ((double)25 / (double)100);
|
|
foreach (ITEmpHead item in Items)
|
|
{
|
|
IncomeTax taxItem;
|
|
bvalid = false;
|
|
if (item.StartDate <= fromDate && item.EndDate >= fromDate) bvalid = true;
|
|
else bvalid = false;
|
|
if (item.StartDate <= toDate && item.EndDate >= toDate) bvalid = true;
|
|
else bvalid = false;
|
|
if (item.StartDate >= fromDate) { fromDate = item.StartDate; }
|
|
if (item.EndDate <= toDate) { toDate = item.EndDate; }
|
|
|
|
if (bvalid == false) continue;
|
|
#region Calculate Car calculation
|
|
if (item.HeadID == EnumIncomeTaxHead.Car)
|
|
{
|
|
taxItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Cmp_Provided_car
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Cmp_Provided_car);
|
|
if (taxItem == null) taxItem = this.Add(EnumIncomeTaxItemGroup.Cmp_Provided_car,
|
|
(int)EnumIncomeTaxItemGroup.Cmp_Provided_car, "Company provided car", 0, 0, EnumIncomeTaxSide.Inc_SalaryIncome);
|
|
|
|
tempAmount = item.HouseRent;
|
|
if (item.EndDate >= _taxParameter.FiscalyearDateTo) toDate = _taxParameter.FiscalyearDateTo;
|
|
taxItem.ThisMonthAmount = tempAmount;
|
|
|
|
toDate = item.EndDate;
|
|
if (item.EndDate > _taxParameter.FiscalyearDateTo) toDate = _taxParameter.FiscalyearDateTo;
|
|
|
|
if (_employee.EndOfContractDate != null && _employee.EndOfContractDate < toDate)
|
|
toDate = Convert.ToDateTime(_employee.EndOfContractDate);
|
|
|
|
|
|
//if (_projectedMonth == 0) tempAmount = basicSalaryItem.ProjectedAmount;
|
|
//else tempAmount = basicSalaryItem.ProjectedAmount / _projectedMonth;
|
|
|
|
if (toDate == GlobalFunctions.LastDateOfMonth(toDate))
|
|
taxItem.ProjectedAmount = (tempAmount * (Global.DateFunctions.DateDiff("m", GlobalFunctions.LastDateOfMonth(month).AddDays(1), toDate) + 1) );
|
|
else
|
|
taxItem.ProjectedAmount = (tempAmount * GlobalFunctions.GetFraction(GlobalFunctions.LastDateOfMonth(month).AddDays(1), toDate)) ;
|
|
|
|
taxItem.ProjectedAmount = GlobalFunctions.Round(taxItem.ProjectedAmount);
|
|
|
|
if(taxItem.TotalAmount <120000)
|
|
{
|
|
taxItem.ProjectedAmount = 120000 - (taxItem.PreviousAmount + taxItem.ThisMonthAmount);
|
|
}
|
|
}
|
|
#endregion Calculate Car calculation
|
|
|
|
#region Calculate House rent calculation
|
|
if (item.HeadID == EnumIncomeTaxHead.House)
|
|
{
|
|
taxItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Cmp_Provided_House
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Cmp_Provided_House);
|
|
if (taxItem == null) taxItem = this.Add(EnumIncomeTaxItemGroup.Cmp_Provided_House,
|
|
(int)EnumIncomeTaxItemGroup.Cmp_Provided_House, "Company provided House", 0, 0, EnumIncomeTaxSide.Inc_SalaryIncome);
|
|
|
|
|
|
if (item.HouseRent == 0)
|
|
{
|
|
if (_salary == null)
|
|
tempAmount = basicSalaryItem.ThisMonthAmount;
|
|
else
|
|
{
|
|
SalaryMonthlyDetail detail = _salary.Details.FirstOrDefault(x=>x.itemGroupCode == EnumSalaryGroup.Gross
|
|
&& x.ItemCode == EnumSalaryItemCode.Basic_Salary && x.ItemID == (int)EnumSalaryItemCode.Basic_Salary);
|
|
if (detail == null) continue;
|
|
tempAmount = detail.ChangedAmount;
|
|
#region basic salary arrear effect
|
|
foreach (EmployeeGradeSalary gse in _salary.ArrearGradeSalaries)
|
|
{
|
|
if (gse.TillDate > item.StartDate)
|
|
{
|
|
if (item.StartDate > gse.EffectDate)
|
|
tempAmount = tempAmount + gse.BasicSalary *
|
|
GlobalFunctions.GetFraction(item.StartDate, (DateTime)gse.TillDate);
|
|
else
|
|
{
|
|
SalaryMonthlyDetail arreardetail = _salary.Details.FirstOrDefault(x=>x.itemGroupCode == EnumSalaryGroup.Arrear
|
|
&& x.ItemCode == EnumSalaryItemCode.Basic_Salary && x.ItemID == (int)EnumSalaryItemCode.Basic_Salary);
|
|
if (arreardetail != null)
|
|
{
|
|
tempAmount = tempAmount + arreardetail.ChangedAmount;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (EmployeeGradeSalary gse in _salary.ArrearPaidGradeSalaries)
|
|
{
|
|
if (gse.TillDate > item.StartDate)
|
|
{
|
|
if (item.StartDate > gse.EffectDate)
|
|
tempAmount = tempAmount - gse.BasicSalary *
|
|
GlobalFunctions.GetFraction(item.StartDate, (DateTime)gse.TillDate);
|
|
else
|
|
tempAmount = tempAmount - gse.BasicSalary *
|
|
GlobalFunctions.GetFraction(gse.EffectDate, (DateTime)gse.TillDate);
|
|
}
|
|
}
|
|
#endregion basic salary arrear effect
|
|
}
|
|
taxItem.ThisMonthAmount = GlobalFunctions.Round(tempAmount * hrPercent);
|
|
}
|
|
else
|
|
taxItem.ThisMonthAmount = GlobalFunctions.Round(GlobalFunctions.GetFraction(fromDate, toDate) * item.HouseRent);
|
|
|
|
//if (item.EndDate <= toDate) continue;
|
|
//toDate = item.EndDate;
|
|
if (item.EndDate >= _taxParameter.FiscalyearDateTo) toDate = _taxParameter.FiscalyearDateTo;
|
|
if (item.HouseRent == 0)
|
|
{
|
|
if (_projectedMonth == 0)
|
|
tempAmount = basicSalaryItem.ProjectedAmount;
|
|
else tempAmount = basicSalaryItem.ProjectedAmount / _projectedMonth;
|
|
|
|
if (toDate == GlobalFunctions.LastDateOfMonth(toDate))
|
|
taxItem.ProjectedAmount = (tempAmount * (Global.DateFunctions.DateDiff("m", GlobalFunctions.LastDateOfMonth(month).AddDays(1), toDate) + 1) * hrPercent);
|
|
else
|
|
taxItem.ProjectedAmount = (tempAmount * GlobalFunctions.GetFraction(GlobalFunctions.LastDateOfMonth(month).AddDays(1), toDate)) * hrPercent;
|
|
|
|
taxItem.ProjectedAmount = GlobalFunctions.Round(taxItem.ProjectedAmount);
|
|
}
|
|
else
|
|
{
|
|
taxItem.ProjectedAmount = GlobalFunctions.GetFraction(
|
|
GlobalFunctions.LastDateOfMonth(month).AddDays(1), toDate) * item.HouseRent;
|
|
taxItem.ProjectedAmount = GlobalFunctions.Round(taxItem.ProjectedAmount);
|
|
}
|
|
|
|
taxItem.Side = EnumIncomeTaxSide.Inc_SalaryIncome;
|
|
}
|
|
#endregion Calculate Car calculation
|
|
}
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
|
|
}
|
|
private double GetTotalSalary()
|
|
{
|
|
double TotGross;
|
|
double TotExemp;
|
|
TotGross = 0; TotExemp = 0;
|
|
foreach (IncomeTax item in _currentYearTax)
|
|
{
|
|
if (item.Side == EnumIncomeTaxSide.Dec_SalaryIncome)
|
|
TotExemp = TotExemp + item.TotalAmount;
|
|
else if (item.Side == EnumIncomeTaxSide.Inc_SalaryIncome)
|
|
TotGross = TotGross + item.TotalAmount;
|
|
}
|
|
return TotGross - TotExemp;
|
|
}
|
|
|
|
protected double GetAnnualIncome()
|
|
{
|
|
double TotIncome = 0;
|
|
foreach (IncomeTax item in _currentYearTax)
|
|
{
|
|
if (item.Side == EnumIncomeTaxSide.Inc_AnnualIncome)
|
|
TotIncome = TotIncome + item.TotalAmount;
|
|
else if (item.Side == EnumIncomeTaxSide.Dec_AnnualIncome)
|
|
TotIncome = TotIncome - item.TotalAmount;
|
|
}
|
|
TotIncome = this.GetTotalSalary() + TotIncome;
|
|
return TotIncome;
|
|
}
|
|
|
|
protected void CalculateTotalIncome()
|
|
{
|
|
IncomeTax salaryIncome = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Annual_Salary_Income && x.ItemID == (int)EnumIncomeTaxItemGroup.Annual_Salary_Income);
|
|
if (salaryIncome == null) salaryIncome = this.Add(EnumIncomeTaxItemGroup.Annual_Salary_Income,
|
|
(int)EnumIncomeTaxItemGroup.Annual_Salary_Income, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
salaryIncome.TotalAmount = 0;
|
|
salaryIncome.PreviousAmount = 0;
|
|
salaryIncome.ThisMonthAmount = 0;
|
|
salaryIncome.ProjectedAmount = 0;
|
|
foreach (IncomeTax item in _currentYearTax)
|
|
{
|
|
if (item.Side == EnumIncomeTaxSide.Inc_SalaryIncome)
|
|
{
|
|
salaryIncome.PreviousAmount = salaryIncome.PreviousAmount + item.PreviousAmount;
|
|
salaryIncome.ThisMonthAmount = salaryIncome.ThisMonthAmount + item.ThisMonthAmount;
|
|
salaryIncome.ProjectedAmount = salaryIncome.ProjectedAmount + item.ProjectedAmount;
|
|
salaryIncome.TotalAmount = salaryIncome.TotalAmount + item.TotalAmount;
|
|
}
|
|
else if (item.Side == EnumIncomeTaxSide.Dec_SalaryIncome)
|
|
{
|
|
salaryIncome.PreviousAmount = salaryIncome.PreviousAmount - item.PreviousAmount;
|
|
salaryIncome.ThisMonthAmount = salaryIncome.ThisMonthAmount - item.ThisMonthAmount;
|
|
salaryIncome.ProjectedAmount = salaryIncome.ProjectedAmount - item.ProjectedAmount;
|
|
salaryIncome.TotalAmount = salaryIncome.TotalAmount - item.TotalAmount;
|
|
}
|
|
}
|
|
|
|
salaryIncome.PreviousAmount = GlobalFunctions.Round(salaryIncome.PreviousAmount);
|
|
salaryIncome.ThisMonthAmount = GlobalFunctions.Round(salaryIncome.ThisMonthAmount);
|
|
salaryIncome.ProjectedAmount = GlobalFunctions.Round(salaryIncome.ProjectedAmount);
|
|
|
|
IncomeTax annualIncome = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Annual_Income && x.ItemID == (int)EnumIncomeTaxItemGroup.Annual_Income);
|
|
if (annualIncome == null) annualIncome = this.Add(EnumIncomeTaxItemGroup.Annual_Income,
|
|
(int)EnumIncomeTaxItemGroup.Annual_Income, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
|
|
annualIncome.TotalAmount = 0;
|
|
annualIncome.PreviousAmount = 0;
|
|
annualIncome.ThisMonthAmount = 0;
|
|
annualIncome.ProjectedAmount = 0;
|
|
foreach (IncomeTax item in _currentYearTax)
|
|
{
|
|
if (item.Side == EnumIncomeTaxSide.Inc_AnnualIncome)
|
|
{
|
|
annualIncome.PreviousAmount = annualIncome.PreviousAmount + item.PreviousAmount;
|
|
annualIncome.ThisMonthAmount = annualIncome.ThisMonthAmount + item.ThisMonthAmount;
|
|
annualIncome.ProjectedAmount = annualIncome.ProjectedAmount + item.ProjectedAmount;
|
|
annualIncome.TotalAmount = annualIncome.TotalAmount + item.TotalAmount;
|
|
}
|
|
else if (item.Side == EnumIncomeTaxSide.Dec_AnnualIncome)
|
|
{
|
|
annualIncome.PreviousAmount = annualIncome.PreviousAmount - item.PreviousAmount;
|
|
annualIncome.ThisMonthAmount = annualIncome.ThisMonthAmount - item.ThisMonthAmount;
|
|
annualIncome.ProjectedAmount = annualIncome.ProjectedAmount - item.ProjectedAmount;
|
|
annualIncome.TotalAmount = annualIncome.TotalAmount - item.TotalAmount;
|
|
|
|
}
|
|
}
|
|
|
|
annualIncome.PreviousAmount = annualIncome.PreviousAmount + salaryIncome.PreviousAmount;
|
|
annualIncome.ThisMonthAmount = annualIncome.ThisMonthAmount + salaryIncome.ThisMonthAmount;
|
|
annualIncome.ProjectedAmount = annualIncome.ProjectedAmount + salaryIncome.ProjectedAmount;
|
|
annualIncome.TotalAmount = annualIncome.TotalAmount + salaryIncome.TotalAmount;
|
|
|
|
annualIncome.PreviousAmount = GlobalFunctions.Round(annualIncome.PreviousAmount);
|
|
annualIncome.ThisMonthAmount = GlobalFunctions.Round(annualIncome.ThisMonthAmount);
|
|
annualIncome.ProjectedAmount = GlobalFunctions.Round(annualIncome.ProjectedAmount);
|
|
}
|
|
protected double GetTaxRebate()
|
|
{
|
|
double TotIncome = 0;
|
|
foreach (IncomeTax item in _currentYearTax)
|
|
{
|
|
if (item.ItemGroup == EnumIncomeTaxItemGroup.Tax_Gross_Rebate ||
|
|
item.ItemGroup == EnumIncomeTaxItemGroup.Tax_Gross_Refund ||
|
|
item.ItemGroup == EnumIncomeTaxItemGroup.Tax_Gross_OtherRebate ||
|
|
item.ItemGroup == EnumIncomeTaxItemGroup.Tax_Gross_OtherAddable )
|
|
{
|
|
if (item.Side == EnumIncomeTaxSide.Inc_GrossTax)
|
|
TotIncome = TotIncome + item.TotalAmount;
|
|
else if (item.Side == EnumIncomeTaxSide.Dec_GrossTax)
|
|
TotIncome = TotIncome - item.TotalAmount;
|
|
}
|
|
}
|
|
return TotIncome;
|
|
}
|
|
|
|
/// <summary>
|
|
/// follwing function equal the net tax payable and tax deducted amount. Adjusted amount stores in Tax refund item.
|
|
/// </summary>
|
|
protected void CalculateYearlyRefund()
|
|
{
|
|
IncomeTax oNetTaxPayable = this.CurrentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
IncomeTax oTaxDeducted = this.CurrentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
|
|
|
|
if (oNetTaxPayable == null) oNetTaxPayable = this.Add(EnumIncomeTaxItemGroup.Net_Payable,
|
|
(int)EnumIncomeTaxItemGroup.Net_Payable, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
|
|
if (oTaxDeducted == null) oTaxDeducted = this.Add(EnumIncomeTaxItemGroup.Tax_Deducted,
|
|
(int)EnumIncomeTaxItemGroup.Tax_Deducted, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
|
|
if ((oNetTaxPayable.TotalAmount - oTaxDeducted.TotalAmount) != 0)
|
|
{
|
|
|
|
IncomeTax TaxRefund = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Refund_On_Current_Year && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Refund_On_Current_Year);
|
|
if (TaxRefund == null) TaxRefund = this.Add(EnumIncomeTaxItemGroup.Tax_Refund_On_Current_Year,
|
|
(int)EnumIncomeTaxItemGroup.Tax_Refund_On_Current_Year, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
TaxRefund.ThisMonthAmount = 0;
|
|
TaxRefund.PreviousAmount = 0;
|
|
TaxRefund.ProjectedAmount = 0;
|
|
TaxRefund.TotalAmount = 0;
|
|
|
|
|
|
TaxRefund.TotalAmount = GlobalFunctions.Round(oNetTaxPayable.TotalAmount - oTaxDeducted.TotalAmount);
|
|
|
|
// set equal to Net_Taxable_income to Tax_deducted_current_year amount
|
|
// oTaxDeducted.TotalAmount = oNetTaxPayable.TotalAmount;
|
|
}
|
|
}
|
|
protected void CalculateNetPayable()
|
|
{
|
|
|
|
IncomeTax GrossTax = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Gross_Tax && x.ItemID == (int)EnumIncomeTaxItemGroup.Gross_Tax);
|
|
if (GrossTax == null)
|
|
{
|
|
this.Add(GrossTax);
|
|
}
|
|
this.CalculateGrossTax();
|
|
|
|
|
|
IncomeTax netPayable = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
if (netPayable == null) netPayable = this.Add(EnumIncomeTaxItemGroup.Net_Payable,
|
|
(int)EnumIncomeTaxItemGroup.Net_Payable, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
netPayable.TotalAmount = 0;
|
|
netPayable.PreviousAmount = 0;
|
|
netPayable.ThisMonthAmount = 0;
|
|
netPayable.ProjectedAmount = 0;
|
|
if (GrossTax.TotalAmount > 0)
|
|
{
|
|
|
|
IncomeTax InvestItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Credit_On_Investment && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Credit_On_Investment);
|
|
if (InvestItem == null) this.CalculateInvestment();
|
|
|
|
netPayable.ProjectedAmount = netPayable.ProjectedAmount + GrossTax.TotalAmount - InvestItem.TotalAmount;
|
|
if (netPayable.ProjectedAmount < _taxParameter.MinTaxAmount)
|
|
netPayable.ProjectedAmount = _taxParameter.MinTaxAmount;
|
|
|
|
}
|
|
|
|
netPayable.ProjectedAmount = netPayable.ProjectedAmount + this.GetTaxRebate();
|
|
|
|
// netPayable.ProjectedAmount = netPayable.ProjectedAmount>=5000?GlobalFunctions.Round(netPayable.ProjectedAmount):5000;
|
|
netPayable.TotalAmount = GlobalFunctions.Round(netPayable.ProjectedAmount);
|
|
}
|
|
|
|
protected void CalculateGrossTax()
|
|
{
|
|
|
|
IncomeTax GrossTax = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Gross_Tax && x.ItemID == (int)EnumIncomeTaxItemGroup.Gross_Tax);
|
|
if (GrossTax == null) GrossTax = this.Add(EnumIncomeTaxItemGroup.Gross_Tax,
|
|
(int)EnumIncomeTaxItemGroup.Gross_Tax, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
double annualIncome = this.GetAnnualIncome();
|
|
double yearlyTax = this.GetTaxAmount(annualIncome);
|
|
GrossTax.TotalAmount = 0;
|
|
GrossTax.PreviousAmount = 0;
|
|
GrossTax.ThisMonthAmount = 0;
|
|
GrossTax.ProjectedAmount = GlobalFunctions.Round(yearlyTax);
|
|
GrossTax.TotalAmount = GlobalFunctions.Round(yearlyTax);
|
|
}
|
|
|
|
protected double CalculateDecutedAmount()
|
|
{
|
|
double nAmount = 0;
|
|
double nTaxAmount = 0;
|
|
IncomeTax TaxDeductitem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
if (TaxDeductitem != null)
|
|
{
|
|
nAmount = TaxDeductitem.ThisMonthAmount;
|
|
TaxDeductitem.ThisMonthAmount = 0;
|
|
}
|
|
|
|
this.CalculateThisMonth();
|
|
|
|
TaxDeductitem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
if (TaxDeductitem != null)
|
|
{
|
|
nTaxAmount = TaxDeductitem.ThisMonthAmount - nAmount;
|
|
}
|
|
return nTaxAmount;
|
|
}
|
|
|
|
protected void UndoDecutedAmount(double nAmount)
|
|
{
|
|
IncomeTax TaxDeductitem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
if (TaxDeductitem != null)
|
|
TaxDeductitem.ThisMonthAmount = TaxDeductitem.ThisMonthAmount - nAmount;
|
|
//this.CalculateThisMonth();
|
|
}
|
|
protected double CalculateOnceOfInvestmentAmt(double IncomeAmount)
|
|
{
|
|
|
|
|
|
if (_employee.ForeignExPat == true) return 0;
|
|
if(this._investmentwithoutpf ==null)
|
|
this._investmentwithoutpf = new SystemConfigarationService().GetconfigBooleanValue(EnumConfigurationType.Logic, "incometax", "investmentwithoutpf");
|
|
|
|
IncomeTax AnnItem = null;
|
|
AnnItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID== _employee.ID && x.ItemGroup == EnumIncomeTaxItemGroup.Annual_Income
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Annual_Income);
|
|
|
|
double totalIncome = IncomeAmount; //AnnItem.TotalAmount - _onceoffAmount;
|
|
|
|
double investmentCanBeShown = ((totalIncome * _taxParameter.MaxInvestPercent) / 100);
|
|
if (investmentCanBeShown > _taxParameter.MaxInvAmount) investmentCanBeShown = _taxParameter.MaxInvAmount;
|
|
double investAmount = investmentCanBeShown;
|
|
_isActualInvestment = false;
|
|
|
|
|
|
if (payrolltype.ActualTaxInvestment == true)
|
|
{
|
|
_taxParameter.InvestmentActiveMonth = _taxParameter.FiscalyearDatefrom;
|
|
_isActualInvestment = true;
|
|
}
|
|
|
|
if (_isActualInvestment == false && _taxParameter.InvestmentActiveMonth == null) _isActualInvestment = false;
|
|
else
|
|
{
|
|
DateTime investmonth = new DateTime(_taxParameter.FiscalyearDatefrom.Year, ((DateTime)_taxParameter.InvestmentActiveMonth).Month, 1);
|
|
investmonth = GlobalFunctions.LastDateOfMonth(investmonth);
|
|
if (investmonth <= payrolltype.NextPayProcessDate)
|
|
_isActualInvestment = true;
|
|
}
|
|
if (_isActualInvestment == true)
|
|
{
|
|
IncomeTax ActualInvestment = _currentYearTax.FirstOrDefault(x=>x.EmployeeID== _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Investment_Actual && x.ItemID == (int)EnumIncomeTaxItemGroup.Investment_Actual);
|
|
|
|
if (ActualInvestment == null)
|
|
ActualInvestment = this.Add(EnumIncomeTaxItemGroup.Investment_Actual, (int)EnumIncomeTaxItemGroup.Investment_Actual, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_Info_Item);
|
|
|
|
IncomeTax pfItem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID && x.ItemGroup == EnumIncomeTaxItemGroup.Company_Contri_PF
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Company_Contri_PF);
|
|
investAmount = 0;
|
|
if (pfItem != null)
|
|
investAmount = investAmount + (pfItem.TotalAmount * 2);
|
|
//EmployeeTaxInvestment etax = new EmployeeTaxInvestment();
|
|
//double nactualInvt = new EmployeeTaxInvestmentService().GetAmount(_taxParameter.ID, _employee.ID);
|
|
if (this._investmentTypes == null) this._investmentTypes = new TaxInvestmentService().Get(EnumStatus.Regardless);
|
|
if (this._empTaxInvestments == null) this._empTaxInvestments = new EmployeeTaxInvestmentService().GetByTaxParamID(this._taxParameter.ID);
|
|
double nactualInvt = EmployeeTaxInvestment.GetAmount(this._employee.ID, _empTaxInvestments, _investmentTypes);
|
|
|
|
|
|
investAmount = investAmount + nactualInvt;
|
|
}
|
|
|
|
|
|
if (investAmount > investmentCanBeShown)
|
|
investAmount = investmentCanBeShown;
|
|
double taxCredit = 0;
|
|
taxCredit = (investAmount * _taxParameter.MaxInvExempPercent) / 100;
|
|
|
|
//if (totalIncome <= 1500000)
|
|
// taxCredit = investAmount * .15;
|
|
//else taxCredit = investAmount * .10;
|
|
|
|
//if (AnnItem.TotalAmount > 1000000 && AnnItem.TotalAmount <= 3000000)
|
|
// taxCredit = (investAmount > 250000) ? (250000 * .15) + (investAmount - 250000) * .12 : investAmount * .15;
|
|
//if (AnnItem.TotalAmount > 3000000)
|
|
//{
|
|
// taxCredit = (investAmount > 250000) ? (250000 * .15) : investAmount * .15;
|
|
// investAmount = investAmount - 250000;
|
|
// if (investAmount > 0)
|
|
// taxCredit = taxCredit + ((investAmount > 500000) ? (500000 * .12) + (investAmount - 500000) * .10 : investAmount * .12);
|
|
//}
|
|
|
|
//IncomeTax InvestmentItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Tax_Credit_On_Investment,
|
|
// (int)EnumIncomeTaxItemGroup.Tax_Credit_On_Investment);
|
|
return (taxCredit);
|
|
}
|
|
protected void CalculateThisMonth()
|
|
{
|
|
|
|
IncomeTax TaxDeductitem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
if (TaxDeductitem == null) TaxDeductitem = this.Add(EnumIncomeTaxItemGroup.Tax_Deducted,
|
|
(int)EnumIncomeTaxItemGroup.Tax_Deducted, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
double onceOffTax = 0;
|
|
double netPayable = this._currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable).TotalAmount;
|
|
double annualIncome = this.GetAnnualIncome();
|
|
//double grossTax = IncomeTax.Get(this._currentYearTax, _employee.ID,
|
|
// EnumIncomeTaxItemGroup.Gross_Tax, (int)EnumIncomeTaxItemGroup.Gross_Tax).TotalAmount;
|
|
|
|
//if (_onceoffAmount > 0)
|
|
//{
|
|
// onceOffTax = grossTax - this.GetTaxAmount(annualIncome - _onceoffAmount);
|
|
// onceOffTax = onceOffTax - CalculateOnceOfInvestmentAmt();
|
|
// if (onceOffTax < 0) onceOffTax = 0;
|
|
//}
|
|
double exptionAmount = 0;
|
|
var expItem = this._currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.AnnualExemption && x.ItemID ==
|
|
(int)EnumIncomeTaxItemGroup.AnnualExemption);
|
|
if (expItem != null) exptionAmount = expItem.TotalAmount;
|
|
|
|
if (_employee.Status == EnumEmployeeStatus.Discontinued)
|
|
TaxDeductitem.ThisMonthAmount = netPayable - TaxDeductitem.TotalAmount;
|
|
else
|
|
{
|
|
|
|
if (_projectedMonth < 0)
|
|
throw new ServiceException("Projected month can't be less then Zero.");
|
|
|
|
if (_onceoffAmount > 0 && netPayable >= _taxParameter.MinTaxAmount)
|
|
{
|
|
double onceofIncome = annualIncome - _onceoffAmount + exptionAmount;
|
|
double Onceexemption = (onceofIncome / 3) * 1;
|
|
if (Onceexemption > 450000)
|
|
{
|
|
onceofIncome = onceofIncome - 450000;
|
|
}
|
|
else onceofIncome = onceofIncome - Onceexemption;
|
|
|
|
onceOffTax = this.GetTaxAmount(onceofIncome);
|
|
double invAmount = CalculateOnceOfInvestmentAmt(onceofIncome);
|
|
onceOffTax = onceOffTax - invAmount;
|
|
onceOffTax = onceOffTax + this.GetTaxRebate();
|
|
if (_taxParameter.MinTaxAmount > onceOffTax)
|
|
onceOffTax = _taxParameter.MinTaxAmount;
|
|
|
|
double ntp = netPayable - onceOffTax;
|
|
if (ntp < 0) ntp = 0;
|
|
onceOffTax = onceOffTax - TaxDeductitem.TotalAmount; // Tax to be paid rest of the year;
|
|
TaxDeductitem.ThisMonthAmount = ntp + (onceOffTax / (_projectedMonth + 1));
|
|
}
|
|
else TaxDeductitem.ThisMonthAmount = ((netPayable - TaxDeductitem.TotalAmount) / (_projectedMonth + 1));
|
|
|
|
if (TaxDeductitem.TotalAmount > netPayable)
|
|
TaxDeductitem.ThisMonthAmount = netPayable - TaxDeductitem.PreviousAmount;
|
|
}
|
|
|
|
if (TaxDeductitem.ThisMonthAmount < 0)
|
|
{
|
|
TaxDeductitem.ThisMonthAmount = GlobalFunctions.Round(0);
|
|
}
|
|
else
|
|
{
|
|
TaxDeductitem.ThisMonthAmount = GlobalFunctions.Round(TaxDeductitem.ThisMonthAmount);
|
|
}
|
|
TaxDeductitem.ProjectedAmount = GlobalFunctions.Round(TaxDeductitem.ProjectedAmount);
|
|
|
|
if (this.payrolltype.NextPayProcessDate.Month != 6 && _employee.JoiningDate > GlobalFunctions.FirstDateOfMonth(this.payrolltype.NextPayProcessDate) && _employee.JoiningDate <= this.payrolltype.NextPayProcessDate)
|
|
{
|
|
double fraction = GlobalFunctions.GetFraction(_employee.JoiningDate, this.payrolltype.NextPayProcessDate);
|
|
double thismonthtemp = TaxDeductitem.ThisMonthAmount;
|
|
TaxDeductitem.ThisMonthAmount = GlobalFunctions.Round(TaxDeductitem.ThisMonthAmount * fraction);
|
|
TaxDeductitem.ProjectedAmount = TaxDeductitem.ProjectedAmount + (thismonthtemp - GlobalFunctions.Round(TaxDeductitem.ThisMonthAmount * fraction));
|
|
}
|
|
}
|
|
|
|
protected double GetTaxAmount(double TaxableIncome)
|
|
{
|
|
|
|
double taxAmount = 0;
|
|
if (_employee.ForeignExPat == true)
|
|
{
|
|
if ((_employee.JoiningDate - payrolltype.NextPayProcessDate).TotalDays <= 183) return TaxableIncome * .3;
|
|
}
|
|
List<TaxParameterSlab> parameterSlabs = new TaxParameterService().CalculateTaxOnSlab(payrolltype, _taxParameter, _employee, TaxableIncome);
|
|
taxAmount = TaxParameterSlab.GetTotalTaxAmount(parameterSlabs);
|
|
return taxAmount;
|
|
|
|
}
|
|
|
|
//protected void UpdateRawItems(List<TaxRawItem> rawItems, EnumSide nSide)
|
|
//{
|
|
//foreach (TaxRawItem item in rawItems)
|
|
//{
|
|
// if (item.Amount == 0) continue;
|
|
// IncomeTax taxItem = null;
|
|
// switch (item.ItemType)
|
|
// {
|
|
// case enumIncomeTaxItemType.Basic_Salary:
|
|
// taxItem = GetTaxItem(EnumTaxMergeType.NONE, (int)EnumIncomeTaxItemGroup.Basic_Salary, item.Description);
|
|
// break;
|
|
// case enumIncomeTaxItemType.Allowance:
|
|
// taxItem = GetTaxItem(EnumTaxMergeType.Allowance, item.ItemId, item.Description);
|
|
// break;
|
|
// case enumIncomeTaxItemType.Deduction:
|
|
// taxItem = GetTaxItem(EnumTaxMergeType.Allowance, item.ItemId, item.Description);
|
|
// break;
|
|
// case enumIncomeTaxItemType.OT:
|
|
// taxItem = GetTaxItem(EnumTaxMergeType.OT, item.ItemId, item.Description);
|
|
// break;
|
|
// case enumIncomeTaxItemType.Bonus:
|
|
// taxItem = GetTaxItem(EnumTaxMergeType.Bonus, item.ItemId, item.Description);
|
|
// break;
|
|
// case enumIncomeTaxItemType.FinalSettlement:
|
|
// taxItem = GetTaxItem(EnumTaxMergeType.Settlement, item.ItemId, item.Description);
|
|
// break;
|
|
// break;
|
|
// case enumIncomeTaxItemType.OPI:
|
|
// //taxItem = GetTaxItem(EnumTaxMergeType.Bonus, item.ItemId, item.Description);
|
|
// //taxItem.ThisMonthAmount = GlobalFunctions.Round(item.Amount);
|
|
// break;
|
|
// case enumIncomeTaxItemType.AdjustItem:
|
|
// taxItem = GetTaxItem(EnumTaxMergeType.TaxAdjustItem, item.ItemId, item.Description);
|
|
// break;
|
|
// case enumIncomeTaxItemType.Earned_Leave:
|
|
// taxItem = GetTaxItem(EnumTaxMergeType.NONE, (int)EnumIncomeTaxItemGroup.Earned_Leave, item.Description);
|
|
// break;
|
|
|
|
// default:
|
|
// break;
|
|
// }
|
|
|
|
// if (taxItem != null)
|
|
// {
|
|
// taxItem.ThisMonthAmount = (nSide == EnumSide.Deduct) ? -GlobalFunctions.Round(item.Amount) : GlobalFunctions.Round(item.Amount);
|
|
// if (taxItem != null) taxItem.Side = EnumIncomeTaxSide.Inc_SalaryIncome;
|
|
// this.Add(taxItem);
|
|
// }
|
|
//}
|
|
protected void UpdateRawItems(List<TaxRawItem> rawItems, EnumSide nSide)
|
|
{
|
|
foreach (TaxRawItem item in rawItems)
|
|
{
|
|
if (item.Amount == 0) continue;
|
|
IncomeTax taxItem = null;
|
|
switch (item.ItemType)
|
|
{
|
|
case enumIncomeTaxItemType.Basic_Salary:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.NONE, (int)EnumIncomeTaxItemGroup.Basic_Salary, item.Description);
|
|
taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + item.Amount;
|
|
if (item.ChangePrgAmount == true) taxItem.ProjectedAmount = (_employee.BasicSalary * _projectedMonth);
|
|
|
|
break;
|
|
case enumIncomeTaxItemType.Allowance:
|
|
if (item.ChangePrgAmount == true)
|
|
{
|
|
SalaryMonthlyDetail odtl = new SalaryMonthlyDetail();
|
|
odtl.CalculatedAmount = item.Amount;
|
|
odtl.ChangedAmount = item.Amount;
|
|
odtl.Description = item.Description;
|
|
odtl.itemGroupCode = EnumSalaryGroup.Gross;
|
|
odtl.ItemCode = EnumSalaryItemCode.Allowance;
|
|
odtl.ItemID = item.ItemId;
|
|
odtl.SupportID = item.SupportID;
|
|
|
|
//taxItem = GetTaxItem(EnumTaxMergeType.Allowance, item.ItemId, item.Description);
|
|
//double namount = taxItem.ThisMonthAmount;
|
|
taxItem = this.PayslipAllowanceDeduction(odtl, EnumTaxMergeType.Allowance);
|
|
//taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + namount;
|
|
}
|
|
else
|
|
{
|
|
taxItem = GetTaxItem(EnumTaxMergeType.Allowance, item.ItemId, item.Description);
|
|
taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + item.Amount;
|
|
}
|
|
break;
|
|
case enumIncomeTaxItemType.Deduction:
|
|
if (item.ChangePrgAmount == true)
|
|
{
|
|
SalaryMonthlyDetail odtl = new SalaryMonthlyDetail();
|
|
odtl.CalculatedAmount = item.Amount;
|
|
odtl.ChangedAmount = item.Amount;
|
|
odtl.Description = item.Description;
|
|
odtl.itemGroupCode = EnumSalaryGroup.Deductions;
|
|
odtl.ItemCode = EnumSalaryItemCode.Deduction;
|
|
odtl.ItemID = item.ItemId;
|
|
odtl.SupportID = item.SupportID;
|
|
|
|
//taxItem = GetTaxItem(EnumTaxMergeType.Allowance, item.ItemId, item.Description);
|
|
//double namount = taxItem.ThisMonthAmount;
|
|
taxItem = this.PayslipAllowanceDeduction(odtl, EnumTaxMergeType.Deduction);
|
|
//taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + namount;
|
|
}
|
|
else
|
|
{
|
|
taxItem = GetTaxItem(EnumTaxMergeType.Allowance, item.ItemId, item.Description);
|
|
taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + item.Amount;
|
|
}
|
|
//taxItem = GetTaxItem(EnumTaxMergeType.Allowance, item.ItemId, item.Description);
|
|
break;
|
|
case enumIncomeTaxItemType.OT:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.OT, item.ItemId, item.Description);
|
|
taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + item.Amount;
|
|
break;
|
|
case enumIncomeTaxItemType.Bonus:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.Bonus, item.ItemId, item.Description);
|
|
if (taxItem == null)
|
|
taxItem = GetTaxItem(EnumTaxMergeType.NONE, (int)EnumIncomeTaxItemGroup.Bonus, item.Description);
|
|
|
|
taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + item.Amount;
|
|
break;
|
|
case enumIncomeTaxItemType.FinalSettlement:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.Settlement, item.ItemId, item.Description);
|
|
taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + item.Amount;
|
|
break;
|
|
case enumIncomeTaxItemType.OPI:
|
|
//taxItem = GetTaxItem(EnumTaxMergeType.Bonus, item.ItemId, item.Description);
|
|
//taxItem.ThisMonthAmount = GlobalFunctions.Round(item.Amount);
|
|
break;
|
|
case enumIncomeTaxItemType.AdjustItem:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.TaxAdjustItem, item.ItemId, item.Description);
|
|
taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + item.Amount;
|
|
break;
|
|
case enumIncomeTaxItemType.Earned_Leave:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.NONE, (int)EnumIncomeTaxItemGroup.Earned_Leave, item.Description);
|
|
taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + item.Amount;
|
|
break;
|
|
case enumIncomeTaxItemType.LFA:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.NONE, (int)EnumIncomeTaxItemGroup.LFA_Allowance, item.Description);
|
|
taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + item.Amount;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (taxItem != null)
|
|
{
|
|
// taxItem.ThisMonthAmount = (nSide == EnumSide.Deduct) ? -GlobalFunctions.Round(item.Amount) : GlobalFunctions.Round(item.Amount);
|
|
if (taxItem != null) taxItem.Side = EnumIncomeTaxSide.Inc_SalaryIncome;
|
|
this.Add(taxItem);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
private double GetTaxConciderInvestment(double income)
|
|
{
|
|
double taxamount = this.GetTaxAmount(income);
|
|
|
|
if (_employee.ForeignExPat == true) return 0;
|
|
if(this._investmentwithoutpf ==null)
|
|
this._investmentwithoutpf = new SystemConfigarationService().GetconfigBooleanValue( EnumConfigurationType.Logic, "incometax", "investmentwithoutpf");
|
|
|
|
double investmentCanBeShown = ((taxamount * _taxParameter.MaxInvestPercent) / 100);
|
|
if (investmentCanBeShown > _taxParameter.MaxInvAmount) investmentCanBeShown = _taxParameter.MaxInvAmount;
|
|
double investAmount = investmentCanBeShown;
|
|
_isActualInvestment = false;
|
|
if (_taxParameter.InvestmentActiveMonth == null) _isActualInvestment = false;
|
|
else
|
|
{
|
|
DateTime investmonth = new DateTime(_taxParameter.FiscalyearDatefrom.Year, ((DateTime)_taxParameter.InvestmentActiveMonth).Month, 1);
|
|
investmonth = GlobalFunctions.LastDateOfMonth(investmonth);
|
|
if (investmonth <= payrolltype.NextPayProcessDate)
|
|
_isActualInvestment = true;
|
|
}
|
|
if (_isActualInvestment == true)
|
|
{
|
|
IncomeTax ActualInvestment = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Investment_Actual && x.ItemID == (int)EnumIncomeTaxItemGroup.Investment_Actual);
|
|
investAmount = ActualInvestment.ThisMonthAmount;
|
|
}
|
|
|
|
|
|
if (investAmount > investmentCanBeShown)
|
|
investAmount = investmentCanBeShown;
|
|
double taxCredit = 0;
|
|
taxCredit = (investAmount * _taxParameter.MaxInvExempPercent) / 100;
|
|
taxamount = taxamount - taxCredit;
|
|
return taxamount;
|
|
}
|
|
|
|
private double GetTaxonTaxAmount(double onAmount)
|
|
{
|
|
|
|
//IncomeTax carIncome = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
// EnumIncomeTaxItemGroup.Cmp_Provided_car,
|
|
// (int)EnumIncomeTaxItemGroup.Cmp_Provided_car);
|
|
this.CalculateTotalIncome();
|
|
|
|
IncomeTax IncomeWithCar = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Annual_Salary_Income && x.ItemID == (int)EnumIncomeTaxItemGroup.Annual_Salary_Income);
|
|
|
|
double dif = 0;
|
|
double onlyCarTax = this.GetTaxConciderInvestment(IncomeWithCar.TotalAmount - onAmount); ;
|
|
double taxwithCar = this.GetTaxConciderInvestment(IncomeWithCar.TotalAmount);
|
|
|
|
dif = taxwithCar - onlyCarTax;
|
|
double addedIncome = dif + taxwithCar;
|
|
double prvTax = taxwithCar;
|
|
|
|
while (dif < 0)
|
|
{
|
|
dif = this.GetTaxConciderInvestment(addedIncome);
|
|
dif = dif - prvTax;
|
|
prvTax = addedIncome;
|
|
if (dif > 0) addedIncome = addedIncome + dif;
|
|
}
|
|
|
|
dif = addedIncome - taxwithCar;
|
|
|
|
return dif;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find the gross tax
|
|
/// include gross tax in total salary income
|
|
/// calculate salary income, annual income
|
|
/// </summary>
|
|
|
|
|
|
protected double CulculateArrearOnMonth()
|
|
{
|
|
double nAmount = 0;
|
|
double nTaxAmount = 0;
|
|
IncomeTax TaxDeductitem = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
|
|
if (TaxDeductitem == null) TaxDeductitem = this.Add(EnumIncomeTaxItemGroup.Tax_Deducted,
|
|
(int)EnumIncomeTaxItemGroup.Tax_Deducted, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
|
|
IncomeTax onetTax = _currentYearTax.FirstOrDefault(x=>x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
|
|
if (onetTax != null)
|
|
{
|
|
nAmount = onetTax.TotalAmount;
|
|
nAmount = nAmount / (double)12;
|
|
int arrMonth = 12 - (int)_projectedMonth;
|
|
nAmount = nAmount * arrMonth;
|
|
if (TaxDeductitem != null)
|
|
{
|
|
nAmount = nAmount - TaxDeductitem.TotalAmount;
|
|
if (nAmount < 0) nAmount = 0;
|
|
TaxDeductitem.ThisMonthAmount = nAmount;
|
|
nTaxAmount = nAmount;
|
|
}
|
|
}
|
|
|
|
//this.CalculateThisMonth();
|
|
|
|
//TaxDeductitem = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
// EnumIncomeTaxItemGroup.Tax_Deducted, (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
//if (TaxDeductitem != null)
|
|
//{
|
|
// nTaxAmount = TaxDeductitem.ThisMonthAmount - nAmount;
|
|
//}
|
|
return nTaxAmount;
|
|
}
|
|
}
|
|
public interface ISalaryTax
|
|
{
|
|
SalaryMonthly Salary { set; get; }
|
|
List<IncomeTax> Calculate();
|
|
}
|
|
public interface IBonusTax
|
|
{
|
|
BonusProcess.BonusProcessDetail Bonus { set; get; }
|
|
List<IncomeTax> Calculate();
|
|
}
|
|
public interface ITaxCalculator
|
|
{
|
|
|
|
}
|
|
public class TaxCalculator : AbstractTaxCalculator
|
|
{
|
|
public TaxCalculator(int taxparamid, int payrolltypeid):base(taxparamid, payrolltypeid)
|
|
{
|
|
|
|
}
|
|
public TaxCalculator() : base()
|
|
{
|
|
|
|
}
|
|
public override List<ADParameter> AdParameters
|
|
{
|
|
set { _adParameters = value; }
|
|
}
|
|
public override SalaryMonthly Salary
|
|
{
|
|
set { _salary = value; }
|
|
}
|
|
public override Employee Employee
|
|
{
|
|
set
|
|
{
|
|
if (_taxParameter == null) throw new ServiceException("Taxparameter must set before Employee");
|
|
_taxSlabs = new TaxParameterService().GetEmployeeSlab( payrolltype,
|
|
_taxParameter, value);
|
|
TaxParameter.SetMinimumTax(value, _taxParameter);
|
|
|
|
_employee = value;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
public override TaxParameter TaxParameter
|
|
{
|
|
set
|
|
{
|
|
_taxParameter = value;
|
|
}
|
|
}
|
|
|
|
public List<IncomeTax> SalaryTax()
|
|
{
|
|
string smessage = "";
|
|
try
|
|
{
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = 0;
|
|
|
|
smessage = "InitiazedNextMonth";
|
|
this.InitializeForNextMonth();
|
|
smessage = "CalcualteprojectMonth";
|
|
this.CalcualteprojectMonth();
|
|
smessage = "IncludePayslipItems";
|
|
this.IncludePayslipItems();
|
|
//smessage = "Calculate OT";
|
|
//this.CalculateOT();
|
|
smessage = "CmpProvidedHouseAndTransport";
|
|
this.CmpProvidedHouseAndTransport(payrolltype.NextPayProcessDate);
|
|
smessage = "Calculate-Bonus-Projection";
|
|
this.CalculateBonusProjection();
|
|
smessage = "CalculateCPF";
|
|
this.CalculateCPF();
|
|
//this.CalculateTaxOnTax();
|
|
//smessage = "Calculate tax on tax";
|
|
smessage = "Calculate-Exemption";
|
|
this.CalculateExemptionOnward2023();
|
|
smessage = "Calculate-Total-Income";
|
|
this.CalculateTotalIncome();
|
|
smessage = "CalculateInvestment";
|
|
this.CalculateInvestment();
|
|
smessage = "CalculateGrossTax";
|
|
this.CalculateGrossTax();
|
|
smessage = "CalculateNetPayable";
|
|
this.CalculateNetPayable();
|
|
smessage = "CalculateThisMonth";
|
|
this.CalculateThisMonth();
|
|
smessage = "Trade of tool calculation";
|
|
// this.ToolOfTradeCalculation();
|
|
smessage = "End";
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message + "###" + smessage);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message + "###" + smessage);
|
|
}
|
|
}
|
|
|
|
public List<IncomeTax> RecalculateTax(int nTaxParamterID)
|
|
{
|
|
List<IncomeTax> empTaxCertificates = new List<IncomeTax>();
|
|
|
|
try
|
|
{
|
|
// if IncomeTax.get() function not return employee order-by wise data, rest of the function will not culculate properly.
|
|
List<IncomeTax> oTaxYearly = new IncomeTaxService().GetPrvYear(nTaxParamterID, this.payrolltype.ID);
|
|
if (this.payrolltype.TaxParamID == nTaxParamterID)
|
|
oTaxYearly = new IncomeTaxService().GetByYear(nTaxParamterID, EnumIncomeTaxDataFrom.ProcessTempData, this.payrolltype.ID);
|
|
else
|
|
oTaxYearly = new IncomeTaxService().GetPrvYear(nTaxParamterID,payrolltype.ID);
|
|
int? nCurrEmployeeid = null;
|
|
if (oTaxYearly.Count > 0) nCurrEmployeeid = oTaxYearly[0].EmployeeID;
|
|
_taxParameter = new TaxParameterService().Get((int)nTaxParamterID);
|
|
this.payrolltype.ActualTaxInvestment = true;
|
|
List<Employee> oemps = new EmployeeService().GetAllEmps();
|
|
while (true)
|
|
{
|
|
_employee = oemps.FirstOrDefault(x => x.ID == nCurrEmployeeid);
|
|
if(_employee == null) _employee = new EmployeeService().Get((int)nCurrEmployeeid);
|
|
|
|
_isActualInvestment = true;
|
|
this.CurrentYearTax = oTaxYearly.FindAll(x=>x.EmployeeID == nCurrEmployeeid);
|
|
// Initialize the current data.
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
oTaxYearly.Remove(item); // Remove from collection
|
|
|
|
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
item.EmployeeID = _employee.ID;
|
|
item.TaxParameterID = nTaxParamterID;
|
|
empTaxCertificates.Add(item);
|
|
}
|
|
|
|
if (oTaxYearly.Count > 0) nCurrEmployeeid = oTaxYearly[0].EmployeeID;
|
|
else break;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
|
|
return empTaxCertificates;
|
|
}
|
|
|
|
//public List<IncomeTax> CalculateBonus(List<TaxRawItem> rawItems, ref double ntaxAmount)
|
|
//{
|
|
// try
|
|
// {
|
|
// double nTempAmount = 0;
|
|
// bool bStartMonth = false;
|
|
// _isActualInvestment = true;
|
|
// this._onceoffAmount = rawItems.Sum(x => x.Amount);
|
|
|
|
// IncomeTax oIncomeTax = new IncomeTax();
|
|
// EnumIncomeTaxDataFrom datafrom = new IncomeTaxService().GetEnumForSalaryIT(_employee.ID);
|
|
// if (datafrom == EnumIncomeTaxDataFrom.SalaryITTempData)
|
|
// {
|
|
// throw new ServiceException("Current month salary is processed and not yet finalized. Tax calculation "
|
|
// + " is not allowed middle of this process. You have to Undo or finalize the salary to calculate tax.");
|
|
// }
|
|
// this.CurrentYearTax = new List<IncomeTax>();
|
|
// this.CurrentYearTax = new IncomeTaxService().Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
// if (this.payrolltype.NextPayProcessDate.Month == 7) // if month is july and salary not yet processed then, clear all tax data
|
|
// {
|
|
// bStartMonth = true;
|
|
// this.CalcualteprojectMonth();
|
|
// this.CalculateOnlyProjection();
|
|
// }
|
|
// this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
// this.CalculateExamtion();
|
|
// this.CalculateBonusProjection();
|
|
// this.CalculateCPF();
|
|
// this.CalculateTotalIncome();
|
|
// this.CalculateInvestment();
|
|
// this.CalculateGrossTax();
|
|
|
|
|
|
// double totalAmount = 0;
|
|
// IncomeTax netPayable = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
// && x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
// if (netPayable != null)
|
|
// nTempAmount = netPayable.TotalAmount;
|
|
// ntaxAmount = 0;
|
|
// this.CalculateNetPayable();
|
|
|
|
// if (_ApplicableBonusParams != null)
|
|
// {
|
|
// BonusParameter oparam = _ApplicableBonusParams.FirstOrDefault(x => x.BonusID == rawItems[0].ItemId);
|
|
// if (oparam != null && oparam.IsFestival == true) // isFestival mean bonus is projected for tax. So no need to deduct tax in bonus process
|
|
// return this.CurrentYearTax;
|
|
// }
|
|
|
|
// ntaxAmount = nTempAmount;
|
|
// netPayable = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
// && x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
// if (netPayable != null)
|
|
// if (totalAmount > 0)
|
|
// ntaxAmount = netPayable.TotalAmount - totalAmount;
|
|
// else
|
|
// ntaxAmount = (-totalAmount - netPayable.TotalAmount) > 0 ? 0 : netPayable.TotalAmount;
|
|
|
|
// double grossTax = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
// && x.ItemGroup == EnumIncomeTaxItemGroup.Gross_Tax && x.ItemID == (int)EnumIncomeTaxItemGroup.Gross_Tax).TotalAmount;
|
|
|
|
// if (_onceoffAmount > 0)
|
|
// {
|
|
|
|
// double annualIncome = this.GetAnnualIncome();
|
|
// ntaxAmount = grossTax - this.GetTaxAmount(annualIncome - _onceoffAmount);
|
|
// ntaxAmount = ntaxAmount - CalculateOnceOfInvestmentAmt();
|
|
// if (ntaxAmount < 0) ntaxAmount = 0;
|
|
// }
|
|
|
|
// IncomeTax TaxDeductitem = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID &&
|
|
// x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
// if (TaxDeductitem == null) TaxDeductitem = this.Add(EnumIncomeTaxItemGroup.Tax_Deducted,
|
|
// (int)EnumIncomeTaxItemGroup.Tax_Deducted, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
|
|
// TaxDeductitem.ThisMonthAmount = TaxDeductitem.ThisMonthAmount + ntaxAmount;
|
|
|
|
|
|
// return this.CurrentYearTax;
|
|
// }
|
|
// catch (ServiceException ex)
|
|
// {
|
|
// throw new ServiceException(ex.Message);
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// throw new ServiceException(ex.Message);
|
|
// }
|
|
//}
|
|
public List<IncomeTax> CalculateBonus(List<TaxRawItem> rawItems, BonusParameter bonusParam, ref double ntaxAmount, List<ADParameter> oParams, List<IncomeTax> oTaxes)
|
|
{
|
|
try
|
|
{
|
|
double nTempAmount = 0;
|
|
bool bStartMonth = false;
|
|
_isActualInvestment = false;
|
|
this._onceoffAmount = rawItems.Sum(x => x.Amount);
|
|
|
|
IncomeTax oIncomeTax = new IncomeTax();
|
|
|
|
this.CurrentYearTax = new List<IncomeTax>();
|
|
foreach (IncomeTax item in oTaxes)
|
|
{
|
|
if (item.EmployeeID == _employee.ID)
|
|
this.CurrentYearTax.Add(item);
|
|
}
|
|
if (this.payrolltype.NextPayProcessDate.Month == 7 && this.CurrentYearTax.Count ==0) // if month is july and salary not yet processed then, clear all tax data
|
|
{
|
|
bStartMonth = true;
|
|
_projectedMonth = 12;
|
|
if (_projectedMonth < 0) _projectedMonth = 0;
|
|
if (_employee.EndOfContractDate != null && _employee.EndOfContractDate != DateTime.MinValue)
|
|
{
|
|
if (_employee.EndOfContractDate < _taxParameter.FiscalyearDateTo)
|
|
_projectedMonth = 0;
|
|
}
|
|
this.CalculateOnlyProjection(oParams);
|
|
}
|
|
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
this.CalculateBonusProjection();
|
|
this.CalculateExemptionOnward2023();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
|
|
if (bonusParam.IsProjectInTaxCalculation == true)
|
|
{
|
|
this.CalculateNetPayable();
|
|
return this.CurrentYearTax;
|
|
}
|
|
|
|
|
|
IncomeTax ntpBeforeBonus = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
|
|
this.CalculateNetPayable();
|
|
|
|
//if (_ApplicableBonusParams != null)
|
|
//{
|
|
// BonusParameter oparam = _ApplicableBonusParams.FirstOrDefault(x => x.BonusID == rawItems[0].ItemId);
|
|
// if (oparam != null && oparam.IsFestival == true) // isFestival mean bonus is projected for tax. So no need to deduct tax in bonus process
|
|
// return this.CurrentYearTax;
|
|
//}
|
|
|
|
|
|
|
|
//netPayable = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID &&
|
|
// x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
//if (netPayable != null)
|
|
// if (totalAmount > 0)
|
|
// ntaxAmount = netPayable.TotalAmount - totalAmount;
|
|
// else
|
|
// ntaxAmount = (-totalAmount - netPayable.TotalAmount) > 0 ? 0 : netPayable.TotalAmount;
|
|
|
|
IncomeTax netPayable = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
if (netPayable != null)
|
|
{
|
|
|
|
|
|
double annualIncome = this.GetAnnualIncome();
|
|
double newGross = this.GetTaxAmount(annualIncome - _onceoffAmount);
|
|
ntaxAmount = newGross - CalculateOnceOfInvestmentAmt(annualIncome - _onceoffAmount);
|
|
|
|
if (newGross >0 && ntaxAmount < _taxParameter.MinTaxAmount)
|
|
ntaxAmount = _taxParameter.MinTaxAmount;
|
|
|
|
ntaxAmount = ntaxAmount + this.GetTaxRebate();
|
|
if (ntaxAmount < 0) ntaxAmount = 0;
|
|
if (ntpBeforeBonus != null && ntpBeforeBonus.TotalAmount < _taxParameter.MinTaxAmount &&
|
|
ntaxAmount >= _taxParameter.MinTaxAmount) // before bonus tax amount was zero,
|
|
// now eligible for tax
|
|
{
|
|
ntaxAmount = netPayable.TotalAmount;
|
|
}
|
|
else if (ntpBeforeBonus != null && ntpBeforeBonus.TotalAmount == _taxParameter.MinTaxAmount
|
|
&& ntaxAmount == _taxParameter.MinTaxAmount) // tax amount was min_tax
|
|
{
|
|
ntaxAmount = 0;
|
|
//IncomeTax ditem = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID &&
|
|
// x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
//if (ditem != null)
|
|
//{
|
|
// ntaxAmount = ntpBeforeBonus.TotalAmount - ditem.TotalAmount;
|
|
//}
|
|
//else ntaxAmount = _taxParameter.MinTaxAmount;
|
|
}
|
|
else
|
|
{
|
|
ntaxAmount = netPayable.TotalAmount - ntaxAmount;
|
|
}
|
|
if (ntaxAmount < 0) ntaxAmount = 0;
|
|
ntaxAmount = GlobalFunctions.Round(ntaxAmount);
|
|
}
|
|
|
|
if(ntaxAmount> this._onceoffAmount) // if tax amount greater than bonus amount
|
|
{
|
|
ntaxAmount = this._onceoffAmount;
|
|
}
|
|
|
|
IncomeTax TaxDeductitem = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
if (TaxDeductitem == null) TaxDeductitem = this.Add(EnumIncomeTaxItemGroup.Tax_Deducted,
|
|
(int)EnumIncomeTaxItemGroup.Tax_Deducted, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
|
|
TaxDeductitem.PreviousAmount = TaxDeductitem.PreviousAmount + TaxDeductitem.ThisMonthAmount ;
|
|
TaxDeductitem.ThisMonthAmount = ntaxAmount;
|
|
|
|
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
public List<IncomeTax> UndoBonus(List<TaxRawItem> rawItems, double taxAmount)
|
|
{
|
|
try
|
|
{
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = 0;
|
|
|
|
IncomeTax oIncomeTax = new IncomeTax();
|
|
//EnumIncomeTaxDataFrom datafrom = oIncomeTax.GetEnumForSalaryIT(_employee.ID);
|
|
//if (datafrom == EnumIncomeTaxDataFrom.SalaryITTempData)
|
|
//{
|
|
// throw new ServiceException("Current month salary is processed and not yet finalized. Tax calculation "
|
|
// + " is not allowed middle of this process. You have to Undo or finalize the salary to calculate tax.");
|
|
//}
|
|
|
|
|
|
|
|
|
|
this.UpdateRawItems(rawItems, EnumSide.Deduct);
|
|
this.CalculateBonusProjection();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
this.UndoDecutedAmount(taxAmount);
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="rawItems"></param>
|
|
/// <returns></returns>
|
|
|
|
|
|
|
|
public double Calculate(List<TaxRawItem> rawItems)
|
|
{
|
|
try
|
|
{
|
|
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = 0;
|
|
|
|
IncomeTax oIncomeTax = new IncomeTax();
|
|
EnumIncomeTaxDataFrom datafrom = new IncomeTaxService().GetEnumForSalaryIT(_employee.ID);
|
|
this.CurrentYearTax = new List<IncomeTax>();
|
|
this.CurrentYearTax = new IncomeTaxService().Get(_employee.ID, datafrom);
|
|
this.CalcualteprojectMonth();
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
this.CmpProvidedHouseAndTransport(this.payrolltype.NextPayProcessDate);
|
|
this.CalculateExamtion();
|
|
this.CalculateBonusProjection();
|
|
this.CalculateCPF();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
double totalAmount = 0;
|
|
IncomeTax netPayable = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
if (netPayable != null)
|
|
totalAmount = netPayable.TotalAmount;
|
|
this.CalculateNetPayable();
|
|
|
|
netPayable = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID &&
|
|
x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
|
|
|
|
if (netPayable != null)
|
|
totalAmount = netPayable.TotalAmount - totalAmount;
|
|
|
|
// if the amount is equal to yearly netpayable, the amount should be dsitributed next of the projected month
|
|
if (totalAmount == netPayable.TotalAmount && netPayable.TotalAmount == _taxParameter.MinTaxAmount && _projectedMonth > 0)
|
|
totalAmount = totalAmount / _projectedMonth;
|
|
return totalAmount;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
//End OPI Calculation
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="rawItem"></param>
|
|
/// <param name="taxAmount"></param>
|
|
/// <returns></returns>
|
|
public List<IncomeTax> Calculate(List<TaxRawItem> rawItems, ref double ntaxAmount)
|
|
{
|
|
try
|
|
{
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = rawItems[0].Amount;
|
|
|
|
IncomeTax oIncomeTax = new IncomeTax();
|
|
EnumIncomeTaxDataFrom datafrom = new IncomeTaxService().GetEnumForSalaryIT(_employee.ID);
|
|
if (datafrom == EnumIncomeTaxDataFrom.SalaryITTempData)
|
|
{
|
|
throw new ServiceException("Current month salary is processed and not yet finalized. Tax calculation "
|
|
+ " is not allowed middle of this process. You have to Undo or finalize the salary to calculate tax.");
|
|
}
|
|
this.CurrentYearTax = new List<IncomeTax>();
|
|
this.CurrentYearTax = new IncomeTaxService().Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
|
|
this.CalcualteprojectMonth();
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
this.CmpProvidedHouseAndTransport(this.payrolltype.NextPayProcessDate);
|
|
this.CalculateExamtion();
|
|
this.CalculateBonusProjection();
|
|
this.CalculateCPF();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
ntaxAmount = this.CalculateDecutedAmount();
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="rawItem"></param>
|
|
/// <param name="taxAmount"></param>
|
|
/// <returns></returns>
|
|
public List<IncomeTax> CalculateSettlementTax(List<TaxRawItem> rawItems)
|
|
{
|
|
try
|
|
{
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = 0;
|
|
|
|
IncomeTax oIncomeTax = new IncomeTax();
|
|
EnumIncomeTaxDataFrom datafrom = new IncomeTaxService().GetEnumForSalaryIT(_employee.ID);
|
|
if (datafrom == EnumIncomeTaxDataFrom.SalaryITTempData)
|
|
{
|
|
throw new ServiceException("Current month salary is processed and not yet finalized. Tax calculation "
|
|
+ " is not allowed middle of this process. You have to Undo or finalize the salary to calculate tax.");
|
|
}
|
|
this.CurrentYearTax = new List<IncomeTax>();
|
|
this.CurrentYearTax = new IncomeTaxService().Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
|
|
this._projectedMonth = 0;
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
item.PreviousAmount = item.PreviousAmount + item.ThisMonthAmount;
|
|
item.ThisMonthAmount = 0;
|
|
item.ProjectedAmount = 0;
|
|
}
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
this.CmpProvidedHouseAndTransport((DateTime)_employee.DiscontinueDate);
|
|
this.CalculateExamtion();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
|
|
IncomeTax TaxDeductitem = _currentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted && x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
IncomeTax netPayable = _currentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable && x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
|
|
TaxDeductitem.ThisMonthAmount = netPayable.TotalAmount - TaxDeductitem.TotalAmount;
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// function will return total year tax,
|
|
/// </summary>
|
|
/// <param name="rawItems"></param>
|
|
/// <param name="ntaxAmount"></param>
|
|
/// <returns></returns>
|
|
|
|
public List<IncomeTax> CalculateYearlyTax(List<TaxRawItem> rawItems, ref double ntaxAmount)
|
|
{
|
|
try
|
|
{
|
|
this.CurrentYearTax = new List<IncomeTax>();
|
|
|
|
_isActualInvestment = false;
|
|
_projectedMonth = 0;
|
|
this._onceoffAmount = 0;
|
|
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
this.CmpProvidedHouseAndTransport(this.payrolltype.NextPayProcessDate);
|
|
this.CalculateExamtion();
|
|
this.CalculateBonusProjection();
|
|
this.CalculateCPF();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
this.CalculateThisMonth();
|
|
ntaxAmount = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID && x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted).TotalAmount;
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
|
|
public List<IncomeTax> UndoCalculate(List<TaxRawItem> rawItems, double taxAmount)
|
|
{
|
|
try
|
|
{
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = 0;
|
|
|
|
IncomeTax oIncomeTax = new IncomeTax();
|
|
EnumIncomeTaxDataFrom datafrom = new IncomeTaxService().GetEnumForSalaryIT(_employee.ID);
|
|
if (datafrom == EnumIncomeTaxDataFrom.SalaryITTempData)
|
|
{
|
|
throw new ServiceException("Current month salary is processed and not yet finalized. Tax calculation "
|
|
+ " is not allowed middle of this process. You have to Undo or finalize the salary to calculate tax.");
|
|
}
|
|
|
|
this.CurrentYearTax = new List<IncomeTax>();
|
|
this.CurrentYearTax = new IncomeTaxService().Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
|
|
this.CalcualteprojectMonth();
|
|
//foreach (IncomeTax item in this.CurrentYearTax)
|
|
// item.ProjectedAmount = 0;
|
|
|
|
this.UpdateRawItems(rawItems, EnumSide.Deduct);
|
|
this.CmpProvidedHouseAndTransport(this.payrolltype.NextPayProcessDate);
|
|
this.CalculateExamtion();
|
|
this.CalculateBonusProjection();
|
|
this.CalculateCPF();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
this.UndoDecutedAmount(taxAmount);
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="naxParameterID"></param>
|
|
public List<IncomeTax> DoTaxYearEnd(int payrolltypeid)
|
|
{
|
|
List<IncomeTax> empTaxCertificates = new List<IncomeTax>();
|
|
PayrollType ptyp = new PayrollTypeService().Get(payrolltypeid);
|
|
List<Employee> employess = new EmployeeService().GetAllEmps();
|
|
try
|
|
{
|
|
// if IncomeTax.get() function not return employee order-by wise data, rest of the function will not culculate properly.
|
|
List<IncomeTax> oTaxYearly = new IncomeTaxService().Get(EnumIncomeTaxDataFrom.ProcessTempData, ptyp.ID);
|
|
oTaxYearly = oTaxYearly.OrderBy(x=>x.EmployeeID).ToList();
|
|
int? nCurrEmployeeid = null;
|
|
if (oTaxYearly.Count > 0) nCurrEmployeeid = oTaxYearly[0].EmployeeID;
|
|
_taxParameter = new TaxParameterService().Get((int)ptyp.TaxParamID);
|
|
this.payrolltype = ptyp;
|
|
while (true)
|
|
{
|
|
_employee = employess.FirstOrDefault(x => x.ID == oTaxYearly[0].EmployeeID);
|
|
this.CurrentYearTax = oTaxYearly.FindAll(x => x.EmployeeID == nCurrEmployeeid);
|
|
if (this.CurrentYearTax == null) continue;
|
|
if (_employee.Status != EnumEmployeeStatus.Live)
|
|
{
|
|
foreach (IncomeTax item in this.CurrentYearTax) item.ProjectedAmount = 0;
|
|
|
|
_isActualInvestment = false;
|
|
this._onceoffAmount = 0;
|
|
this.CalculateExamtion();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
this.CalculateYearlyRefund();
|
|
}
|
|
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
item.TaxParameterID = (int)ptyp.TaxParamID;
|
|
empTaxCertificates.Add(item);
|
|
oTaxYearly.Remove(item);
|
|
}
|
|
|
|
|
|
if (oTaxYearly.Count > 0) nCurrEmployeeid = oTaxYearly[0].EmployeeID;
|
|
else break;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
return empTaxCertificates;
|
|
}
|
|
//public List<IncomeTax> DoTaxYearEndReProcess(int nTaxParamterID, bool isMaximumInvestment)
|
|
//{
|
|
// List<IncomeTax> empTaxCertificates = new List<IncomeTax>();
|
|
|
|
// try
|
|
// {
|
|
// // if IncomeTax.get() function not return employee order-by wise data, rest of the function will not culculate properly.
|
|
// List<IncomeTax> oTaxYearly = new IncomeTaxService().GetPrvYear(nTaxParamterID, this.payrolltype.ID);
|
|
// if (this.payrolltype.TaxParamID == nTaxParamterID)
|
|
// oTaxYearly = new IncomeTaxService().GetByYear(nTaxParamterID, EnumIncomeTaxDataFrom.ProcessTempData, this.payrolltype.ID);
|
|
// else
|
|
// oTaxYearly = new IncomeTaxService().GetPrvYear(nTaxParamterID, this.payrolltype.ID);
|
|
// int? nCurrEmployeeid = null;
|
|
// if (oTaxYearly.Count > 0) nCurrEmployeeid = oTaxYearly[0].EmployeeID;
|
|
// _taxParameter = new TaxParameterService().Get(nTaxParamterID);
|
|
// while (true)
|
|
// {
|
|
// _employee = new EmployeeService().Get((int)nCurrEmployeeid);
|
|
|
|
|
|
// this.CurrentYearTax = oTaxYearly.FindAll(x => x.EmployeeID == nCurrEmployeeid);
|
|
|
|
// // Initialize the current data.
|
|
// foreach (IncomeTax item in this.CurrentYearTax)
|
|
// {
|
|
// item.ProjectedAmount = 0;
|
|
// oTaxYearly.Remove(item); // Remove from collection
|
|
// }
|
|
|
|
// _isActualInvestment = !isMaximumInvestment;
|
|
|
|
// IncomeTax car = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
// && x.ItemGroup == EnumIncomeTaxItemGroup.Cmp_Provided_car && x.ItemID == (int)EnumIncomeTaxItemGroup.Cmp_Provided_car);
|
|
// if (car != null)
|
|
// {
|
|
// if (car.TotalAmount < 60000)
|
|
// car.TotalAmount = 60000;
|
|
// }
|
|
|
|
// this.CalculateExamtion();
|
|
|
|
// this.CalculateTotalIncome();
|
|
// this.CalculateInvestment();
|
|
// this.CalculateGrossTax();
|
|
// this.CalculateNetPayable();
|
|
// this.CalculateYearlyRefund();
|
|
|
|
// foreach (IncomeTax item in this.CurrentYearTax)
|
|
// {
|
|
// item.EmployeeID = _employee.ID;
|
|
// item.TaxParameterID = nTaxParamterID;
|
|
// empTaxCertificates.Add(item);
|
|
// }
|
|
|
|
|
|
// if (oTaxYearly.Count > 0) nCurrEmployeeid = oTaxYearly[0].EmployeeID;
|
|
// else break;
|
|
// }
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// throw new ServiceException(ex.Message);
|
|
// }
|
|
// return empTaxCertificates;
|
|
//}
|
|
|
|
public List<IncomeTax> CalculateLTATax(List<TaxRawItem> rawItems, ref double ntaxAmount)
|
|
{
|
|
double namount = rawItems.Select(c => c.Amount).Sum(); ;
|
|
return this.CalculateLTATax(rawItems, namount, ref ntaxAmount);
|
|
}
|
|
public List<IncomeTax> CalculateLTATax(List<TaxRawItem> rawItems, double onceoffAmount, ref double ntaxAmount)
|
|
{
|
|
try
|
|
{
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = onceoffAmount;
|
|
|
|
IncomeTax oIncomeTax = new IncomeTax();
|
|
EnumIncomeTaxDataFrom datafrom = new IncomeTaxService().GetEnumForSalaryIT(_employee.ID);
|
|
if (datafrom == EnumIncomeTaxDataFrom.SalaryITTempData)
|
|
{
|
|
throw new ServiceException("Current month salary is processed and not yet finalized. Tax calculation "
|
|
+ " is not allowed middle of this process. You have to Undo or finalize the salary to calculate tax.");
|
|
}
|
|
this.CurrentYearTax = new List<IncomeTax>();
|
|
this.CurrentYearTax = new IncomeTaxService().Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
|
|
|
|
this.CalcualteprojectMonth();
|
|
_projectedMonth = _projectedMonth + 1;
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
item.PreviousAmount = item.PreviousAmount + item.ThisMonthAmount;
|
|
item.ThisMonthAmount = 0;
|
|
//if (item.ItemGroup != EnumIncomeTaxItemGroup.Other_Allowance)
|
|
// item.ProjectedAmount = 0;
|
|
}
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
// this.CmpProvidedHouseAndTransport(SystemInformation.CurrentSysInfo.LastPayProcessDate.AddMonths(-1));
|
|
this.CalculateExamtion();
|
|
// this.CalculateBonusProjection();
|
|
this.CalculateCPF();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
ntaxAmount = this.CulculateArrearOnMonth();
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
|
|
public List<IncomeTax> UndoEncashAmount(List<TaxRawItem> oTaxRowItems, double nTaxAmount)
|
|
{
|
|
try
|
|
{
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = 0;
|
|
|
|
IncomeTaxService tempIncomeTaxService = new IncomeTaxService();
|
|
|
|
EnumIncomeTaxDataFrom datafrom = tempIncomeTaxService.GetEnumForSalaryIT(_employee.ID);
|
|
if (datafrom == EnumIncomeTaxDataFrom.SalaryITTempData)
|
|
{
|
|
throw new ServiceException("Current month salary is processed and not yet finalized. Tax calculation "
|
|
+ " is not allowed middle of this process. You have to Undo or finalize the salary to calculate tax.");
|
|
}
|
|
|
|
this.CurrentYearTax = new List<IncomeTax>();
|
|
this.CurrentYearTax = tempIncomeTaxService.Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
|
|
this.UpdateRawItemsForEncash(oTaxRowItems, EnumSide.Deduct);
|
|
//this.CalculateBonusProjection();
|
|
IncomeTax taxitem = this.CurrentYearTax.Find(x => x.Description == "Leave Encashment" && x.ItemGroup == EnumIncomeTaxItemGroup.Earned_Leave && x.ItemID == 100);
|
|
if (taxitem != null)
|
|
taxitem.ThisMonthAmount = 0;
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
this.UndoDecutedAmount(nTaxAmount);
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
protected void UpdateRawItemsForEncash(List<TaxRawItem> rawItems, EnumSide nSide)
|
|
{
|
|
foreach (TaxRawItem item in rawItems)
|
|
{
|
|
if (item.Amount == 0) continue;
|
|
IncomeTax taxItem = null;
|
|
//nSide = EnumSide.Add;
|
|
switch (item.ItemType)
|
|
{
|
|
case enumIncomeTaxItemType.Basic_Salary:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.NONE, (int)EnumIncomeTaxItemGroup.Basic_Salary, item.Description);
|
|
break;
|
|
case enumIncomeTaxItemType.Allowance:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.Allowance, item.ItemId, item.Description);
|
|
break;
|
|
case enumIncomeTaxItemType.Deduction:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.Allowance, item.ItemId, item.Description);
|
|
break;
|
|
case enumIncomeTaxItemType.OT:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.OT, item.ItemId, item.Description);
|
|
break;
|
|
case enumIncomeTaxItemType.Bonus:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.Bonus, item.ItemId, item.Description);
|
|
break;
|
|
case enumIncomeTaxItemType.FinalSettlement:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.Settlement, item.ItemId, item.Description);
|
|
break;
|
|
case enumIncomeTaxItemType.OPI:
|
|
//taxItem = GetTaxItem(EnumTaxMergeType.Bonus, item.ItemId, item.Description);
|
|
//taxItem.ThisMonthAmount = GlobalFunctions.Round(item.Amount);
|
|
break;
|
|
case enumIncomeTaxItemType.AdjustItem:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.TaxAdjustItem, item.ItemId, item.Description);
|
|
break;
|
|
case enumIncomeTaxItemType.Earned_Leave:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.LeaveEncashment, 100, item.Description);
|
|
break;
|
|
case enumIncomeTaxItemType.Compensation:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.Compensation, 0, item.Description);
|
|
break;
|
|
case enumIncomeTaxItemType.NoticePay:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.NoticePayDeduction, 0, item.Description);
|
|
nSide = EnumSide.Deduct;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (taxItem != null)
|
|
{
|
|
taxItem.ThisMonthAmount = 0;
|
|
if (taxItem != null) taxItem.Side = nSide == EnumSide.Add ? EnumIncomeTaxSide.Inc_SalaryIncome : EnumIncomeTaxSide.Dec_SalaryIncome;
|
|
this.Add(taxItem);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private void Add(IncomeTax taxItem)
|
|
{
|
|
if (taxItem.Position == 0)
|
|
{
|
|
ProcessItem pitem = _processItems.Find(delegate (ProcessItem item)
|
|
{ return item.ItemCode == (int)taxItem.ItemGroup; });
|
|
if (pitem == null) throw new ServiceException("Tax process item code not found in the process collection; Item Code:" + taxItem.ItemGroup.ToString());
|
|
taxItem.Position = pitem.Position;
|
|
}
|
|
|
|
IncomeTax existItem = _currentYearTax.Find(delegate (IncomeTax item)
|
|
{ return item.ItemGroup == taxItem.ItemGroup && item.ItemID == taxItem.ItemID; });
|
|
if (existItem == null) _currentYearTax.Add(taxItem);
|
|
else
|
|
{
|
|
existItem.PreviousAmount = existItem.PreviousAmount + taxItem.PreviousAmount;
|
|
existItem.ThisMonthAmount = existItem.ThisMonthAmount + taxItem.ThisMonthAmount;
|
|
existItem.ProjectedAmount = existItem.ProjectedAmount + taxItem.ProjectedAmount;
|
|
existItem.Position = taxItem.Position;
|
|
existItem.Description = taxItem.Description;
|
|
}
|
|
}
|
|
|
|
public List<IncomeTax> CalculateEncashAmount(List<TaxRawItem> rawItems, ref double ntaxAmount, DateTime nextPayProcessDate)
|
|
{
|
|
try
|
|
{
|
|
double nTempAmount = 0;
|
|
bool bStartMonth = false;
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = rawItems.Sum(x => x.Amount);
|
|
|
|
IncomeTaxService tempIncomeTaxService = new IncomeTaxService();
|
|
EnumIncomeTaxDataFrom datafrom = tempIncomeTaxService.GetEnumForSalaryIT(_employee.ID);
|
|
if (datafrom == EnumIncomeTaxDataFrom.SalaryITTempData)
|
|
{
|
|
throw new ServiceException("Current month salary is processed and not yet finalized. Tax calculation "
|
|
+ " is not allowed middle of this process. You have to Undo or finalize the salary to calculate tax.");
|
|
}
|
|
if (this.CurrentYearTax == null)
|
|
{
|
|
this.CurrentYearTax = new List<IncomeTax>();
|
|
this.CurrentYearTax = tempIncomeTaxService.Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
}
|
|
|
|
if (nextPayProcessDate.Month == 7) // if month is july and salary not yet processed then, clear all tax data
|
|
{
|
|
bStartMonth = true;
|
|
this.CalcualteprojectMonth();
|
|
this.CalculateOnlyProjection();
|
|
}
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
IncomeTax taxitem = this.CurrentYearTax.Find(x => x.Description == "Leave Encashment" && x.ItemGroup == EnumIncomeTaxItemGroup.Earned_Leave && x.ItemID == 100);
|
|
if (taxitem != null)
|
|
taxitem.Side = EnumIncomeTaxSide.Inc_SalaryIncome;
|
|
this.CalculateExamtion();
|
|
//this.CalculateBonusProjection();
|
|
this.CalculateCPF();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
|
|
|
|
double totalAmount = 0;
|
|
IncomeTax netPayable = tempIncomeTaxService.Get(this.CurrentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Net_Payable, (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
if (netPayable != null)
|
|
nTempAmount = netPayable.TotalAmount;
|
|
ntaxAmount = 0;
|
|
this.CalculateNetPayable();
|
|
|
|
|
|
|
|
ntaxAmount = nTempAmount;
|
|
//netPayable = IncomeTax.Get(this.CurrentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Net_Payable, (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
if (netPayable != null)
|
|
if (totalAmount > 0)
|
|
ntaxAmount = netPayable.TotalAmount - totalAmount;
|
|
else
|
|
ntaxAmount = (-totalAmount - netPayable.TotalAmount) > 0 ? 0 : netPayable.TotalAmount;
|
|
|
|
double grossTax = tempIncomeTaxService.Get(this.CurrentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Gross_Tax, (int)EnumIncomeTaxItemGroup.Gross_Tax).TotalAmount;
|
|
|
|
if (_onceoffAmount > 0)
|
|
{
|
|
|
|
double annualIncome = this.GetAnnualIncome();
|
|
ntaxAmount = grossTax - this.GetTaxAmount(annualIncome - _onceoffAmount);
|
|
ntaxAmount = ntaxAmount - CalculateOnceOfInvestmentAmt(annualIncome - _onceoffAmount);
|
|
if (ntaxAmount < 0) ntaxAmount = 0;
|
|
}
|
|
|
|
IncomeTax TaxDeductitem = tempIncomeTaxService.Get(this.CurrentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Tax_Deducted, (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
if (TaxDeductitem == null) TaxDeductitem = this.Add(EnumIncomeTaxItemGroup.Tax_Deducted,
|
|
(int)EnumIncomeTaxItemGroup.Tax_Deducted, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
|
|
TaxDeductitem.ThisMonthAmount = TaxDeductitem.ThisMonthAmount + ntaxAmount;
|
|
|
|
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
|
|
public double getSalaryAmount(List<SalaryMonthly> salareis, int employeeid, EnumSalaryItemCode ItemCode, int ItemID)
|
|
{
|
|
double aAmount = 0;
|
|
|
|
List<SalaryMonthly> empsalareis = salareis.FindAll(x => x.EmployeeID == employeeid).ToList();
|
|
if (empsalareis != null)
|
|
{
|
|
empsalareis.ForEach(x =>
|
|
{
|
|
x.Details.ForEach(y =>
|
|
{
|
|
if (ItemCode == EnumSalaryItemCode.PF_Contribution || ItemCode == EnumSalaryItemCode.Inc_Tax_Deduction)
|
|
{
|
|
if (y.ItemCode == ItemCode && (y.itemGroupCode == EnumSalaryGroup.Deductions) && y.ItemID == ItemID)
|
|
{
|
|
aAmount = aAmount + y.ChangedAmount;
|
|
}
|
|
}
|
|
else if (ItemCode == EnumSalaryItemCode.Deduction && ItemCode != EnumSalaryItemCode.PF_Contribution)
|
|
{
|
|
if (y.ItemCode == ItemCode && (y.itemGroupCode == EnumSalaryGroup.Deductions) && y.ItemID == ItemID)
|
|
{
|
|
aAmount = aAmount - y.ChangedAmount;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (y.ItemCode == ItemCode && (y.itemGroupCode == EnumSalaryGroup.Gross
|
|
|| y.itemGroupCode == EnumSalaryGroup.Arrear) && y.ItemID == ItemID)
|
|
{
|
|
aAmount = aAmount + y.ChangedAmount;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
}
|
|
return aAmount;
|
|
}
|
|
|
|
public double GetConvertedAmount(EnumIncomeTaxItemGroup taxGroup, int taxItemID, string name,
|
|
List<TaxMergeMaster> taxmergs, List<SalaryMonthly> salareis,
|
|
List<BonusProcess.BonusProcessDetail> BonusPayments, EnumSalaryItemCode? ItemCode)
|
|
{
|
|
double Amount = 0;
|
|
List<TaxMergeMaster> txgs = taxmergs.Where(x => x.ItemGroup == taxGroup && x.ItemID == taxItemID).ToList();
|
|
if (txgs != null)
|
|
{
|
|
foreach (TaxMergeMaster master in txgs)
|
|
{
|
|
if (master.Description != name) continue;
|
|
foreach (TaxMergeMaster.TaxMergeDetail mergeDetail in master.TaxMergeDetails)
|
|
{
|
|
|
|
if (mergeDetail.Type == EnumTaxMergeType.Allowance)
|
|
{
|
|
Amount = Amount + this.getSalaryAmount(salareis, _employee.ID,
|
|
EnumSalaryItemCode.Allowance, mergeDetail.ItemID);
|
|
}
|
|
else if (mergeDetail.Type == EnumTaxMergeType.Deduction)
|
|
{
|
|
Amount = Amount + this.getSalaryAmount(salareis, _employee.ID,
|
|
EnumSalaryItemCode.Deduction, mergeDetail.ItemID);
|
|
}
|
|
else if (mergeDetail.Type == EnumTaxMergeType.OT)
|
|
{
|
|
Amount = Amount + this.getSalaryAmount(salareis, _employee.ID,
|
|
EnumSalaryItemCode.Over_Time_Amount, mergeDetail.ItemID);
|
|
}
|
|
else if (mergeDetail.Type == EnumTaxMergeType.Bonus)
|
|
{
|
|
Amount = Amount + BonusPayments.Where(x => x.EmployeeID == _employee.ID
|
|
&& x.BonusID == mergeDetail.ItemID).Sum(x => x.ChangeBonusAmount);
|
|
|
|
}
|
|
else if (ItemCode != null)
|
|
{
|
|
Amount = Amount + this.getSalaryAmount(salareis, _employee.ID,
|
|
(EnumSalaryItemCode)ItemCode, (int)ItemCode);
|
|
|
|
}
|
|
else
|
|
{
|
|
/// throw new Exception("Merge head not found");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ItemCode != null)
|
|
{
|
|
Amount = Amount + this.getSalaryAmount(salareis, _employee.ID,
|
|
(EnumSalaryItemCode)ItemCode, (int)ItemCode);
|
|
|
|
}
|
|
}
|
|
return Amount;
|
|
}
|
|
public List<IncomeTax> TaxReconsiliation(int payrolltypeid, List<Employee> emps,
|
|
int nTaxParamterID, EnumIncomeTaxDataFrom datafrom)
|
|
{
|
|
List<SalaryMonthly> salareis = null;
|
|
List<BonusProcess.BonusProcessDetail> bonuspaments = null;
|
|
List<IncomeTax> empTaxCertificates = new List<IncomeTax>();
|
|
List<IncomeTax> oTaxYearly = null;
|
|
string inSQL = Employee.getEmpID(emps);
|
|
List<ITEmpHead> assignedHeads = new ITEmpHeadService().GetWithTaxParam(nTaxParamterID);
|
|
PayrollType ptype = new PayrollTypeService().Get(payrolltypeid);
|
|
List<EmployeeTaxInvestment> empInvestments = new EmployeeTaxInvestmentService().GetAllUsersInfo(nTaxParamterID);
|
|
double ProjectedMonths = 0;
|
|
bool isExemptionYearly = new SystemConfigarationService().GetconfigBooleanValue(EnumConfigurationType.Logic, "incometax", "monthlyexemption");
|
|
bool IsmaximumInvestment = new SystemConfigarationService().GetconfigBooleanValue(EnumConfigurationType.Logic, "incometax", "investmentwithoutpf");
|
|
this._processItems = new ProcessItemService().Get();
|
|
this.payrolltype = ptype;
|
|
bool binvestmenton = new SystemConfigarationService().GetconfigBooleanValue(EnumConfigurationType.Logic, "incometax", "investmentwithoutpf");
|
|
|
|
try
|
|
{
|
|
if (ptype.TaxParamID == nTaxParamterID)
|
|
{
|
|
oTaxYearly = new IncomeTaxService().Get(datafrom, inSQL, payrolltypeid, null);
|
|
}
|
|
else
|
|
oTaxYearly = new IncomeTaxService().Get(datafrom, inSQL, payrolltypeid, nTaxParamterID);
|
|
|
|
_taxParameter = new TaxParameterService().Get(nTaxParamterID);
|
|
|
|
|
|
if (emps != null)
|
|
{
|
|
salareis = new SalaryMonthlyService().Get(inSQL, _taxParameter.FiscalyearDatefrom, _taxParameter.FiscalyearDateTo, payrolltypeid);
|
|
bonuspaments = new BonusProcessService().GetBonusDetailsByEmps(inSQL, _taxParameter.FiscalyearDatefrom, _taxParameter.FiscalyearDateTo, payrolltypeid);
|
|
}
|
|
else
|
|
{
|
|
List<Employee> allemp = new EmployeeService().GetAllEmps(payrolltypeid);
|
|
salareis = new SalaryMonthlyService().GetByDateRange(_taxParameter.FiscalyearDatefrom, _taxParameter.FiscalyearDateTo, payrolltypeid);
|
|
|
|
emps = new List<BO.Employee>();
|
|
foreach (Employee item in allemp)
|
|
{
|
|
var isexist = salareis.FirstOrDefault(x => x.EmployeeID == item.ID);
|
|
if (isexist != null)
|
|
{
|
|
emps.Add(item);
|
|
}
|
|
}
|
|
bonuspaments = new BonusProcessService().GetBonusDetailsByEmps(inSQL, _taxParameter.FiscalyearDatefrom, _taxParameter.FiscalyearDateTo, payrolltypeid);
|
|
}
|
|
|
|
List<TaxMergeMaster> taxMerges = new TaxMergeMasterService().GetbyTaxParameter(_taxParameter.ID, payrolltypeid);
|
|
foreach (Employee emp in emps)
|
|
{
|
|
_employee = emp; //employees.FirstOrDefault(x => x.ID.Integer == nCurrEmployeeid.Integer);
|
|
_isActualInvestment = true;
|
|
_projectedMonth = 12 - (((ptype.NextPayProcessDate.Year - ptype.TaxYearEndDate.Year) * 12)
|
|
+ ptype.NextPayProcessDate.Month - ptype.TaxYearEndDate.Month);
|
|
if (ProjectedMonths < 0) ProjectedMonths = 0;
|
|
|
|
if (emp.EndOfContractDate != null && emp.EndOfContractDate != DateTime.MinValue)
|
|
{
|
|
if (emp.EndOfContractDate < _taxParameter.FiscalyearDateTo)
|
|
if (((DateTime)emp.EndOfContractDate).Month == 7)
|
|
ProjectedMonths = Convert.ToDouble(0);
|
|
else
|
|
ProjectedMonths = GlobalFunctions.GetFraction(this.payrolltype.NextPayProcessDate.AddDays(1), (DateTime)emp.EndOfContractDate);
|
|
|
|
}
|
|
|
|
|
|
this.CurrentYearTax =oTaxYearly.FindAll(x=>x.EmployeeID== _employee.ID);
|
|
|
|
#region Calculate From Salary & Bonus
|
|
double basicSalary = 0;
|
|
IncomeTax HrExption = this.CurrentYearTax.FirstOrDefault(x=>x.EmployeeID== _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance);
|
|
|
|
if (HrExption == null) HrExption = this.Add(EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance,
|
|
(int)EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
HrExption.Description = "HR Exemption";
|
|
|
|
IncomeTax convExption = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance);
|
|
if (convExption == null) convExption = this.Add(EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance,
|
|
(int)EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
convExption.Description = "Transport Exemption";
|
|
|
|
IncomeTax mdExption = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Exemption_Medical_Allowance
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Exemption_Medical_Allowance);
|
|
if (mdExption == null) mdExption = this.Add(EnumIncomeTaxItemGroup.Exemption_Medical_Allowance, (int)EnumIncomeTaxItemGroup.Exemption_Medical_Allowance, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
mdExption.Description = "Medical Exemption";
|
|
|
|
IncomeTax lfaExption = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Exemption_LFA_Allowance
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Exemption_LFA_Allowance);
|
|
if (lfaExption == null) lfaExption = this.Add(EnumIncomeTaxItemGroup.Exemption_LFA_Allowance, (int)EnumIncomeTaxItemGroup.Exemption_LFA_Allowance, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
mdExption.Description = "LFA Exemption";
|
|
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
if (item.Side != EnumIncomeTaxSide.Inc_SalaryIncome &&
|
|
item.Side != EnumIncomeTaxSide.Inc_AnnualIncome)
|
|
continue;
|
|
|
|
if (ProjectedMonths == 0) item.ProjectedAmount = 0;
|
|
double salaryCount = salareis.Count(x => x.EmployeeID == _employee.ID);
|
|
double reAmount = 0;
|
|
item.ThisMonthAmount = item.PreviousAmount + item.ThisMonthAmount + item.ProjectedAmount;
|
|
item.PreviousAmount = item.ProjectedAmount;
|
|
|
|
|
|
switch (item.ItemGroup)
|
|
{
|
|
case EnumIncomeTaxItemGroup.None:
|
|
break;
|
|
case EnumIncomeTaxItemGroup.Basic_Salary:
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.Basic_Salary, item.ItemID, item.Description, taxMerges, salareis, bonuspaments, EnumSalaryItemCode.Basic_Salary);
|
|
basicSalary = reAmount + item.ProjectedAmount;
|
|
break;
|
|
case EnumIncomeTaxItemGroup.House_Rent_Allowance:
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.House_Rent_Allowance, item.ItemID, item.Description, taxMerges,
|
|
salareis, bonuspaments, null);
|
|
|
|
List<SalaryMonthly> empsalareis = salareis.FindAll(x => x.EmployeeID == _employee.ID).ToList();
|
|
|
|
if (isExemptionYearly == false)
|
|
{
|
|
TaxMergeMaster txg = taxMerges.FirstOrDefault(x => x.ItemGroup == EnumIncomeTaxItemGroup.House_Rent_Allowance);
|
|
double HRexemptedAmount = 0;
|
|
double LasHRExemptedAmount = 0;
|
|
if (empsalareis != null)
|
|
{
|
|
empsalareis.ForEach(x =>
|
|
{
|
|
double monthlyBasic = 0;
|
|
double monthlyHouserent = 0;
|
|
x.Details.ForEach(y =>
|
|
{
|
|
if (y.ItemCode == EnumSalaryItemCode.Basic_Salary && (y.itemGroupCode == EnumSalaryGroup.Gross
|
|
|| y.itemGroupCode == EnumSalaryGroup.Arrear) && y.ItemID == (int)EnumSalaryItemCode.Basic_Salary)
|
|
{
|
|
monthlyBasic = monthlyBasic + y.ChangedAmount;
|
|
}
|
|
|
|
|
|
foreach (TaxMergeMaster.TaxMergeDetail mergeDetail in txg.TaxMergeDetails)
|
|
{
|
|
if (y.ItemCode == EnumSalaryItemCode.Allowance && (y.itemGroupCode == EnumSalaryGroup.Gross
|
|
|| y.itemGroupCode == EnumSalaryGroup.Arrear) && y.ItemID == mergeDetail.ItemID)
|
|
{
|
|
monthlyHouserent = monthlyHouserent + y.ChangedAmount;
|
|
}
|
|
}
|
|
});
|
|
|
|
double basicPercent = monthlyBasic * _taxParameter.MaxHRPercent / 100;
|
|
if (monthlyHouserent > _taxParameter.MaxHRAmount / 12) monthlyHouserent = _taxParameter.MaxHRAmount / 12;
|
|
|
|
if (monthlyHouserent > basicPercent)
|
|
{
|
|
HRexemptedAmount = HRexemptedAmount + basicPercent;
|
|
LasHRExemptedAmount = basicPercent;
|
|
}
|
|
else
|
|
{
|
|
HRexemptedAmount = HRexemptedAmount + monthlyHouserent;
|
|
LasHRExemptedAmount = monthlyHouserent;
|
|
}
|
|
|
|
});
|
|
}
|
|
HRexemptedAmount = HRexemptedAmount + LasHRExemptedAmount * ProjectedMonths;
|
|
HrExption.ThisMonthAmount = HrExption.ThisMonthAmount + HrExption.ProjectedAmount + HrExption.PreviousAmount;
|
|
|
|
HrExption.PreviousAmount = HRexemptedAmount;
|
|
}
|
|
else
|
|
{
|
|
double yearlyHR = basicSalary * _taxParameter.MaxHRPercent / 100;
|
|
if (yearlyHR > _taxParameter.MaxHRAmount) yearlyHR = _taxParameter.MaxHRAmount;
|
|
if (yearlyHR > reAmount) yearlyHR = reAmount;
|
|
HrExption.ThisMonthAmount = HrExption.ThisMonthAmount + HrExption.ProjectedAmount + HrExption.PreviousAmount;
|
|
HrExption.PreviousAmount = yearlyHR;
|
|
}
|
|
//HrExption.Description = "HR Exemption";
|
|
break;
|
|
case EnumIncomeTaxItemGroup.Conveyance_Allowance:
|
|
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.Conveyance_Allowance, item.ItemID, item.Description, taxMerges,
|
|
salareis, bonuspaments, null);
|
|
|
|
//if (isExemptionYearly == false)
|
|
//{
|
|
|
|
// convExption.ThisMonthAmount = convExption.ThisMonthAmount + convExption.ProjectedAmount + convExption.PreviousAmount;
|
|
// double convAmount = (salaryCount + ProjectedMonths) * (_taxParameter.MaxConvAmount / 12);
|
|
// if (reAmount + item.ProjectedAmount > convAmount)
|
|
// convExption.PreviousAmount = convAmount;
|
|
// else convExption.PreviousAmount = reAmount + item.ProjectedAmount;
|
|
//}
|
|
//else
|
|
//{
|
|
convExption.ThisMonthAmount = convExption.ThisMonthAmount + convExption.ProjectedAmount + convExption.PreviousAmount;
|
|
if (reAmount + item.ProjectedAmount > _taxParameter.MaxConvAmount)
|
|
convExption.PreviousAmount = _taxParameter.MaxConvAmount;
|
|
else convExption.PreviousAmount = reAmount + +item.ProjectedAmount;
|
|
//}
|
|
//convExption.Description = "Transport Exemption";
|
|
break;
|
|
|
|
case EnumIncomeTaxItemGroup.Medical_Allowance:
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.Medical_Allowance, item.ItemID, item.Description, taxMerges,
|
|
salareis, bonuspaments, null);
|
|
|
|
mdExption.ThisMonthAmount = mdExption.ThisMonthAmount + mdExption.ProjectedAmount + mdExption.PreviousAmount;
|
|
double nconvAmount = basicSalary * _taxParameter.MaxMedicalPercent / 100;
|
|
if (nconvAmount > _taxParameter.MaxMedicalAmount)
|
|
nconvAmount = _taxParameter.MaxMedicalAmount;
|
|
if (reAmount + item.ProjectedAmount < nconvAmount)
|
|
nconvAmount = reAmount + item.ProjectedAmount;
|
|
mdExption.PreviousAmount = nconvAmount;
|
|
|
|
|
|
//mdExption.Description = item.Description + " Exemption";
|
|
break;
|
|
case EnumIncomeTaxItemGroup.Company_Contri_PF:
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.Company_Contri_PF, item.ItemID, item.Description, taxMerges,
|
|
salareis, bonuspaments, EnumSalaryItemCode.PF_Contribution);
|
|
item.Description = "PF";
|
|
break;
|
|
case EnumIncomeTaxItemGroup.Bonus:
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.Bonus, item.ItemID, item.Description, taxMerges,
|
|
salareis, bonuspaments, null);
|
|
//if (isLFAInBonus == true)
|
|
//{
|
|
// double lfaAmount = 0;
|
|
// //bonuspaments.Where(x => x.EmployeeID == _employee.ID && x.IsLFA == true
|
|
// // ).Sum(y => y.ChangeBonusAmount);
|
|
// reAmount = reAmount - lfaAmount;
|
|
|
|
// lfaExption.ThisMonthAmount = lfaExption.ProjectedAmount;
|
|
// lfaExption.PreviousAmount = lfaAmount;
|
|
//}
|
|
break;
|
|
case EnumIncomeTaxItemGroup.Earned_Leave:
|
|
break;
|
|
case EnumIncomeTaxItemGroup.Other_Cash_Benefits:
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.Other_Cash_Benefits, item.ItemID, item.Description, taxMerges,
|
|
salareis, bonuspaments, null);
|
|
break;
|
|
case EnumIncomeTaxItemGroup.Tax_Deducted:
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.Tax_Deducted, item.ItemID, item.Description, taxMerges,
|
|
salareis, bonuspaments, EnumSalaryItemCode.Inc_Tax_Deduction);
|
|
|
|
reAmount = reAmount + bonuspaments.Where(x => x.EmployeeID == _employee.ID).Sum(x => x.ChangeTaxAmount);
|
|
break;
|
|
case EnumIncomeTaxItemGroup.LFA_Allowance:
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.LFA_Allowance, item.ItemID, item.Description, taxMerges,
|
|
salareis, bonuspaments, null);
|
|
break;
|
|
case EnumIncomeTaxItemGroup.WPPF_Allowance:
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.WPPF_Allowance, item.ItemID, item.Description, taxMerges,
|
|
salareis, bonuspaments, null);
|
|
break;
|
|
case EnumIncomeTaxItemGroup.Other_Allowance:
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.Other_Allowance, item.ItemID, item.Description, taxMerges,
|
|
salareis, bonuspaments, null);
|
|
break;
|
|
case EnumIncomeTaxItemGroup.TimeCard:
|
|
reAmount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.TimeCard, item.ItemID, item.Description, taxMerges,
|
|
salareis, bonuspaments, null);
|
|
break;
|
|
case EnumIncomeTaxItemGroup.Cmp_Provided_car:
|
|
List<ITEmpHead> cars = assignedHeads.Where(x => x.EmployeeID == _employee.ID && x.HeadID == EnumIncomeTaxHead.Car).ToList();
|
|
double carAmount = 0;
|
|
foreach (ITEmpHead car in cars)
|
|
{
|
|
List<SalaryMonthly> empcarsalarys = salareis.Where(x => x.Employee.ID == _employee.ID).ToList();
|
|
if (empcarsalarys != null)
|
|
{
|
|
while (GlobalFunctions.LastDateOfMonth(car.StartDate) <= GlobalFunctions.LastDateOfMonth(car.EndDate))
|
|
{
|
|
var carsalary = empcarsalarys.FirstOrDefault(x => x.SalaryMonth == GlobalFunctions.LastDateOfMonth(car.StartDate));
|
|
if (carsalary != null)
|
|
{
|
|
double tempcarAmount = carsalary.Details.Where(x => x.ItemCode == EnumSalaryItemCode.Basic_Salary).Sum(y => y.ChangedAmount)
|
|
;
|
|
carAmount = carAmount + tempcarAmount;
|
|
}
|
|
car.StartDate = GlobalFunctions.FirstDateOfMonth(car.StartDate.AddMonths(1));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
carAmount = carAmount * .05 + item.PreviousAmount;
|
|
if (carAmount == 0) carAmount = 0;
|
|
else if (carAmount < 60000) carAmount = 60000;
|
|
reAmount = carAmount;
|
|
item.PreviousAmount = 0;
|
|
//item.Description = "Car";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
item.PreviousAmount = item.PreviousAmount + reAmount;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region Calculate Annual Income & Salary Income
|
|
|
|
IncomeTax annualIncome = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Annual_Income
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Annual_Income);
|
|
IncomeTax salaryIncome = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Annual_Salary_Income
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Annual_Salary_Income);
|
|
|
|
if (annualIncome == null) annualIncome = this.Add(EnumIncomeTaxItemGroup.Annual_Income,
|
|
(int)EnumIncomeTaxItemGroup.Annual_Income, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
if (salaryIncome == null) salaryIncome = this.Add(EnumIncomeTaxItemGroup.Annual_Salary_Income,
|
|
(int)EnumIncomeTaxItemGroup.Annual_Salary_Income, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
|
|
if (annualIncome != null && salaryIncome != null)
|
|
{
|
|
salaryIncome.ThisMonthAmount = salaryIncome.PreviousAmount + salaryIncome.ThisMonthAmount + salaryIncome.ProjectedAmount;
|
|
annualIncome.ThisMonthAmount = annualIncome.PreviousAmount + annualIncome.ThisMonthAmount + annualIncome.ProjectedAmount;
|
|
salaryIncome.PreviousAmount = this.CurrentYearTax.Where(x => x.Side == EnumIncomeTaxSide.Inc_SalaryIncome).Sum(y => y.PreviousAmount)
|
|
- this.CurrentYearTax.Where(x => x.Side == EnumIncomeTaxSide.Dec_SalaryIncome).Sum(y => y.PreviousAmount);
|
|
|
|
|
|
annualIncome.PreviousAmount = salaryIncome.PreviousAmount + this.CurrentYearTax.Where(x => x.Side == EnumIncomeTaxSide.Inc_AnnualIncome).Sum(y => y.PreviousAmount)
|
|
- this.CurrentYearTax.Where(x => x.Side == EnumIncomeTaxSide.Dec_AnnualIncome).Sum(y => y.PreviousAmount);
|
|
}
|
|
#endregion
|
|
|
|
#region Calculate Investment
|
|
IncomeTax investment = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Annual_Salary_Income
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Annual_Salary_Income);
|
|
|
|
double taxCredit = 0;
|
|
if (investment != null)
|
|
{
|
|
double investmentCanBeShown = 0;
|
|
if (binvestmenton == true)
|
|
investmentCanBeShown = ((salaryIncome.PreviousAmount * _taxParameter.MaxInvestPercent) / 100);
|
|
else
|
|
investmentCanBeShown = ((annualIncome.PreviousAmount * _taxParameter.MaxInvestPercent) / 100);
|
|
|
|
if (_employee.Gender == EnumGender.Male && salaryIncome.PreviousAmount <= 400000)
|
|
{
|
|
investmentCanBeShown = 0;
|
|
}
|
|
else if (_employee.Gender == EnumGender.Female && salaryIncome.PreviousAmount <= 450000)
|
|
{
|
|
investmentCanBeShown = 0;
|
|
}
|
|
|
|
if (investmentCanBeShown > _taxParameter.MaxInvAmount) investmentCanBeShown = _taxParameter.MaxInvAmount;
|
|
double investAmount = investmentCanBeShown;
|
|
if (IsmaximumInvestment == false)
|
|
{
|
|
IncomeTax ActualInvestment = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Investment_Actual
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Investment_Actual);
|
|
|
|
|
|
if (ActualInvestment == null)
|
|
ActualInvestment = this.Add(EnumIncomeTaxItemGroup.Investment_Actual, (int)EnumIncomeTaxItemGroup.Investment_Actual, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_Info_Item);
|
|
IncomeTax pfItem = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Company_Contri_PF
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Company_Contri_PF);
|
|
|
|
investAmount = 0;
|
|
if (pfItem != null)
|
|
investAmount = investAmount + (pfItem.PreviousAmount * 2);
|
|
double nactualInvt = 0;
|
|
nactualInvt = empInvestments.Where(x => x.EmployeeID == _employee.ID).Sum(y => y.Amount);
|
|
investAmount = investAmount + nactualInvt;
|
|
|
|
ActualInvestment.ThisMonthAmount = ActualInvestment.ProjectedAmount;
|
|
ActualInvestment.PreviousAmount = nactualInvt;
|
|
}
|
|
|
|
IncomeTax InvestmentAllowed = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Investment_Allowed
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Investment_Allowed);
|
|
|
|
|
|
if (InvestmentAllowed == null) InvestmentAllowed = this.Add(EnumIncomeTaxItemGroup.Investment_Allowed,
|
|
(int)EnumIncomeTaxItemGroup.Investment_Allowed, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_Info_Item);
|
|
|
|
InvestmentAllowed.PreviousAmount = GlobalFunctions.Round(investmentCanBeShown);
|
|
InvestmentAllowed.ThisMonthAmount = InvestmentAllowed.ProjectedAmount;
|
|
|
|
|
|
if (investAmount > investmentCanBeShown)
|
|
investAmount = investmentCanBeShown;
|
|
taxCredit = (investAmount * _taxParameter.MaxInvExempPercent) / 100;
|
|
|
|
//if (annualIncome.PreviousAmount <= 1500000)
|
|
// taxCredit = investAmount * .15;
|
|
//else taxCredit = investAmount * .10;
|
|
|
|
IncomeTax InvestmentItem = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Credit_On_Investment
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Credit_On_Investment);
|
|
|
|
if (InvestmentItem == null) InvestmentItem = this.Add(EnumIncomeTaxItemGroup.Tax_Credit_On_Investment, (int)EnumIncomeTaxItemGroup.Tax_Credit_On_Investment, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_GrossTax);
|
|
|
|
InvestmentItem.ThisMonthAmount = InvestmentItem.ProjectedAmount;
|
|
InvestmentItem.PreviousAmount = GlobalFunctions.Round(taxCredit);
|
|
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region Calculate Gross Tax
|
|
IncomeTax GrossTax = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Gross_Tax
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Gross_Tax);
|
|
|
|
|
|
if (GrossTax == null) GrossTax = this.Add(EnumIncomeTaxItemGroup.Gross_Tax,
|
|
(int)EnumIncomeTaxItemGroup.Gross_Tax, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
GrossTax.ThisMonthAmount = GrossTax.ProjectedAmount;
|
|
GrossTax.PreviousAmount = this.GetTaxAmount(annualIncome.PreviousAmount);
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
#region Calculate net Tax
|
|
IncomeTax NetTax = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Net_Payable
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
|
|
if (NetTax == null) NetTax = this.Add(EnumIncomeTaxItemGroup.Net_Payable,
|
|
(int)EnumIncomeTaxItemGroup.Net_Payable, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
|
|
|
|
NetTax.ThisMonthAmount = NetTax.ProjectedAmount;
|
|
NetTax.PreviousAmount = GrossTax.PreviousAmount -
|
|
(this.CurrentYearTax.Where(x => x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Gross_Rebate).Sum(x => x.ProjectedAmount)
|
|
+ taxCredit);
|
|
if (GrossTax.PreviousAmount > 0 && NetTax.PreviousAmount < _taxParameter.MinTaxAmount)
|
|
{
|
|
NetTax.PreviousAmount = _taxParameter.MinTaxAmount;
|
|
}
|
|
else if (GrossTax.PreviousAmount <= 0)
|
|
{
|
|
NetTax.PreviousAmount = 0;
|
|
}
|
|
#endregion
|
|
|
|
IncomeTax taxdeducted = this.CurrentYearTax.FirstOrDefault(x => x.EmployeeID == _employee.ID
|
|
&& x.ItemGroup == EnumIncomeTaxItemGroup.Tax_Deducted
|
|
&& x.ItemID == (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
|
|
if (taxdeducted == null) taxdeducted = this.Add(EnumIncomeTaxItemGroup.Tax_Deducted,
|
|
(int)EnumIncomeTaxItemGroup.Tax_Deducted, string.Empty, 0, 0, EnumIncomeTaxSide.Tax_fixed_Item);
|
|
|
|
taxdeducted.ThisMonthAmount = taxdeducted.PreviousAmount + taxdeducted.ThisMonthAmount + taxdeducted.ProjectedAmount;
|
|
double taxdeductedamount = this.GetConvertedAmount(EnumIncomeTaxItemGroup.Tax_Deducted, (int)EnumIncomeTaxItemGroup.Tax_Deducted, taxdeducted.Description, taxMerges,
|
|
salareis, bonuspaments, EnumSalaryItemCode.Inc_Tax_Deduction);
|
|
|
|
taxdeductedamount = taxdeductedamount + bonuspaments.Where(x => x.EmployeeID == _employee.ID).Sum(x => x.ChangeTaxAmount);
|
|
taxdeducted.PreviousAmount = taxdeductedamount;
|
|
|
|
foreach (IncomeTax ot in this.CurrentYearTax)
|
|
{
|
|
ot.EmployeeID = _employee.ID;
|
|
ot.TaxParameterID = nTaxParamterID;
|
|
empTaxCertificates.Add(ot);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
|
|
this.PaidBonues = bonuspaments;
|
|
return empTaxCertificates;
|
|
|
|
}
|
|
|
|
public List<IncomeTax> MaternityLeaveCalculate(List<TaxRawItem> rawItems, CurrentUser currentUser, ref double ntaxAmount)
|
|
{
|
|
try
|
|
{
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = rawItems[0].Amount;
|
|
|
|
IncomeTax oIncomeTax = new IncomeTax();
|
|
EnumIncomeTaxDataFrom datafrom = new IncomeTaxService().GetEnumForSalaryIT(_employee.ID);
|
|
if (datafrom == EnumIncomeTaxDataFrom.SalaryITTempData)
|
|
{
|
|
throw new ServiceException("Current month salary is processed and not yet finalized. Tax calculation "
|
|
+ " is not allowed middle of this process. You have to Undo or finalize the salary to calculate tax.");
|
|
}
|
|
this.CurrentYearTax = new List<IncomeTax>();
|
|
this.CurrentYearTax = new IncomeTaxService().Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
|
|
this.CalcualteprojectMonth();
|
|
_projectedMonth = _projectedMonth - (double)2;
|
|
|
|
if ((_projectedMonth) < 0) _projectedMonth = 0;
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
if ((item.Side == EnumIncomeTaxSide.Inc_SalaryIncome || item.Side == EnumIncomeTaxSide.Inc_AnnualIncome)
|
|
&& item.ThisMonthAmount > 0 && item.ProjectedAmount > 0)
|
|
{
|
|
item.ProjectedAmount = item.ThisMonthAmount * _projectedMonth;
|
|
}
|
|
}
|
|
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
this.CmpProvidedTransport(currentUser);
|
|
this.CalculateExamtion();
|
|
this.CalculateBonusProjection();
|
|
this.CalculateCPF();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
//ntaxAmount = this.CalculateDecutedAmount();
|
|
|
|
//double totalAmount = 0;
|
|
//IncomeTax netPayable = IncomeTax.Get(this.CurrentYearTax, _employee.ID,
|
|
// EnumIncomeTaxItemGroup.Net_Payable, (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
//if (netPayable != null)
|
|
// totalAmount = netPayable.TotalAmount;
|
|
//this.CalculateNetPayable();
|
|
|
|
//netPayable = IncomeTax.Get(this.CurrentYearTax, _employee.ID,
|
|
// EnumIncomeTaxItemGroup.Net_Payable, (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
//if (netPayable != null)
|
|
// ntaxAmount = netPayable.TotalAmount - totalAmount;
|
|
|
|
//// if the amount is equal to yearly netpayable, the amount should be dsitributed next of the projected month
|
|
//// following if logic is required while employee taxable for this bonus amount
|
|
//if (ntaxAmount == netPayable.TotalAmount && netPayable.TotalAmount == _taxParameter.MinTaxAmount && _projectedMonth > 0)
|
|
// ntaxAmount = ntaxAmount / _projectedMonth;
|
|
////this.CalculateNetPayable();
|
|
double netPayable = new IncomeTaxService().Get(this.CurrentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Net_Payable, (int)EnumIncomeTaxItemGroup.Net_Payable).TotalAmount;
|
|
double annualIncome = this.GetAnnualIncome();
|
|
double grossTax = new IncomeTaxService().Get(this.CurrentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Gross_Tax, (int)EnumIncomeTaxItemGroup.Gross_Tax).TotalAmount;
|
|
if (_onceoffAmount > 0)
|
|
{
|
|
ntaxAmount = grossTax - this.GetTaxAmount(annualIncome - _onceoffAmount);
|
|
ntaxAmount = ntaxAmount - CalculateOnceOfInvestmentAmt(annualIncome - _onceoffAmount);
|
|
}
|
|
if (ntaxAmount < 0)
|
|
ntaxAmount = 0;
|
|
|
|
IncomeTax TaxDeductitem = new IncomeTaxService().Get(this.CurrentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Tax_Deducted,
|
|
(int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
if (TaxDeductitem != null)
|
|
TaxDeductitem.ThisMonthAmount = TaxDeductitem.ThisMonthAmount + ntaxAmount;
|
|
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
protected void CmpProvidedTransport(CurrentUser currentUser)
|
|
{
|
|
try
|
|
{
|
|
DateTime month = (DateTime)currentUser.NextPayProcessDate;
|
|
|
|
List<ITEmpHead> assignedHeads = new ITEmpHeadService().GetWithTaxParam((int)currentUser.TaxParamID);
|
|
if (assignedHeads.Count == 0) return;
|
|
|
|
List<ITEmpHead> ItemsAll = new ITEmpHeadService().Get(assignedHeads, _employee.ID);
|
|
if (ItemsAll == null) return;
|
|
List<ITEmpHead> Items = ItemsAll.FindAll(x => x.HeadID == EnumIncomeTaxHead.Car);
|
|
if (Items == null) return;
|
|
|
|
DateTime fromDate = GlobalFunctions.FirstDateOfMonth(month);
|
|
DateTime toDate = GlobalFunctions.LastDateOfMonth(month);
|
|
bool bvalid = false;
|
|
|
|
double tempAmount = 0;
|
|
|
|
foreach (ITEmpHead item in Items)
|
|
{
|
|
if (item.HouseRent == 0) continue;
|
|
IncomeTax taxItem;
|
|
bvalid = false;
|
|
if (item.StartDate <= fromDate || item.EndDate >= fromDate) bvalid = true;
|
|
if (item.StartDate <= toDate || item.EndDate >= toDate) bvalid = true;
|
|
if (item.StartDate >= fromDate) { fromDate = item.StartDate; bvalid = true; }
|
|
if (item.EndDate <= toDate) { toDate = item.EndDate; bvalid = true; }
|
|
|
|
if (bvalid == false) continue;
|
|
#region Calculate Car calculation
|
|
if (item.HeadID == EnumIncomeTaxHead.Car)
|
|
{
|
|
taxItem = new IncomeTaxService().Get(CurrentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Cmp_Provided_car,
|
|
(int)EnumIncomeTaxItemGroup.Cmp_Provided_car);
|
|
if (taxItem == null) taxItem = this.Add(EnumIncomeTaxItemGroup.Cmp_Provided_car,
|
|
(int)EnumIncomeTaxItemGroup.Cmp_Provided_car, "Company provided car", 0, 0, EnumIncomeTaxSide.Inc_SalaryIncome);
|
|
|
|
taxItem.PreviousAmount = item.HouseRent * GlobalFunctions.GetFraction(item.StartDate, GlobalFunctions.LastDateOfMonth(month.AddMonths(-1)));
|
|
taxItem.ThisMonthAmount = item.HouseRent;
|
|
if (item.StartDate.Month == month.Month && item.StartDate.Year == month.Year)
|
|
{
|
|
int nDays = 30 - item.StartDate.Day + 1;
|
|
taxItem.ThisMonthAmount = (item.HouseRent / 30) * nDays;
|
|
}
|
|
else if (item.EndDate.Month == month.Month && item.EndDate.Year == month.Year)
|
|
{
|
|
int nDays = (item.EndDate - GlobalFunctions.FirstDateOfMonth(month)).Days + 1;
|
|
taxItem.ThisMonthAmount = (item.HouseRent / 30) * nDays;
|
|
}
|
|
else
|
|
{
|
|
taxItem.ThisMonthAmount = item.HouseRent * GlobalFunctions.GetFraction(fromDate, GlobalFunctions.LastDateOfMonth(month));
|
|
}
|
|
toDate = item.EndDate;
|
|
if (item.EndDate >= _taxParameter.FiscalyearDateTo)
|
|
{
|
|
toDate = _taxParameter.FiscalyearDateTo;
|
|
}
|
|
if (_employee.EndOfContractDate != null && _employee.EndOfContractDate < toDate)
|
|
{
|
|
toDate = Convert.ToDateTime(_employee.EndOfContractDate);
|
|
}
|
|
|
|
if (toDate == GlobalFunctions.LastDateOfMonth(toDate))
|
|
{
|
|
taxItem.ProjectedAmount = (item.HouseRent * Math.Abs((double)(((toDate.Year - month.Year) * 12) + toDate.Month - month.Month)));
|
|
}
|
|
else
|
|
{
|
|
taxItem.ProjectedAmount = (item.HouseRent * GlobalFunctions.GetFraction(GlobalFunctions.LastDateOfMonth(month).AddDays(1), toDate));
|
|
}
|
|
|
|
taxItem.ThisMonthAmount = GlobalFunctions.Round(taxItem.ThisMonthAmount);
|
|
taxItem.ProjectedAmount = GlobalFunctions.Round(taxItem.ProjectedAmount);
|
|
|
|
}
|
|
#endregion Calculate Car calculation
|
|
|
|
}
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
public class TaxProcess
|
|
{
|
|
|
|
public void CalculateTax()
|
|
{
|
|
|
|
}
|
|
|
|
#region ISalaryTax Members
|
|
|
|
|
|
public void Calculate()
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
|
|
}
|