3041 lines
156 KiB
C#
3041 lines
156 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Ease.CoreV35;
|
|
using Ease.CoreV35.Model;
|
|
using Ease.CoreV35.Caching;
|
|
using System.Data.Linq.Mapping;
|
|
using Ease.CoreV35.Utility;
|
|
using System.Data;
|
|
|
|
namespace Payroll.BO
|
|
{
|
|
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 ObjectsTemplate<TaxParameterSlab> _taxSlabs;
|
|
private ObjectsTemplate<IncomeTax> _currentYearTax;
|
|
private ObjectsTemplate<IncomeTax> _prvYearTotalIncomes;
|
|
protected ObjectsTemplate<ADParameter> _adParameters;
|
|
private ObjectsTemplate<TaxMergeMaster> _mergeItems;
|
|
private ObjectsTemplate<ProcessItem> _processItems;
|
|
private ObjectsTemplate<ITEmpHead> _assignedHeads;
|
|
private ObjectsTemplate<BonusParameter> _projectionBonusParams;
|
|
protected List<BonusParameter> _ApplicableBonusParams;
|
|
protected double _projectedMonth;
|
|
protected double _onceoffAmount;
|
|
protected bool _isActualInvestment;
|
|
ObjectsTemplate<OTProcess> _oTProcesss = null;
|
|
#endregion Define Class Variable
|
|
public AbstractTaxCalculator()
|
|
{
|
|
_isActualInvestment = false;
|
|
_salary = null;
|
|
_taxSlabs = null;
|
|
TaxParameter param = TaxParameter.Get(Payroll.BO.SystemInformation.CurrentSysInfo.TaxParamID);
|
|
_mergeItems = TaxMergeMaster.GetbyTaxParameter(param.ID);
|
|
if (param != null)
|
|
_assignedHeads = ITEmpHead.Get(param.ID.Integer);
|
|
_processItems = ProcessItem.Get();
|
|
_onceoffAmount = 0;
|
|
}
|
|
|
|
public AbstractTaxCalculator(ID taxParameterID)
|
|
{
|
|
_isActualInvestment = false;
|
|
_salary = null;
|
|
_taxSlabs = null;
|
|
TaxParameter param = TaxParameter.Get(taxParameterID);
|
|
_mergeItems = TaxMergeMaster.GetbyTaxParameter(param.ID);
|
|
if (param != null)
|
|
_assignedHeads = ITEmpHead.Get(param.ID.Integer);
|
|
_processItems = ProcessItem.Get();
|
|
_onceoffAmount = 0;
|
|
}
|
|
|
|
public abstract TaxParameter TaxParameter { set; }
|
|
public abstract Employee Employee { set; }
|
|
public abstract SalaryMonthly Salary { set; }
|
|
public abstract ObjectsTemplate<ADParameter> AdParameters { set; }
|
|
public ObjectsTemplate<IncomeTax> CurrentYearTax
|
|
{
|
|
get
|
|
{
|
|
if (_currentYearTax == null)
|
|
{
|
|
_currentYearTax = IncomeTax.Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
}
|
|
return _currentYearTax;
|
|
}
|
|
set
|
|
{
|
|
_currentYearTax = value;
|
|
}
|
|
}
|
|
public BonusProcess.BonusProcessDetail Bonus
|
|
{
|
|
set
|
|
{
|
|
_bonus = value;
|
|
}
|
|
}
|
|
public ObjectsTemplate<IncomeTax> Calculate()
|
|
{
|
|
ObjectsTemplate<IncomeTax> returnedItems = new ObjectsTemplate<IncomeTax>();
|
|
return returnedItems;
|
|
}
|
|
private void EmployeeSlab()
|
|
{
|
|
//TaxParameter.Get
|
|
}
|
|
|
|
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 - (((SystemInformation.CurrentSysInfo.NextPayProcessDate.Year - SystemInformation.CurrentSysInfo.TaxYearEndDate.Year) * 12)
|
|
+ SystemInformation.CurrentSysInfo.NextPayProcessDate.Month - SystemInformation.CurrentSysInfo.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 = OTProcess.Get(SystemInformation.CurrentSysInfo.NextPayProcessDate);
|
|
|
|
|
|
//List<OTProcess> ops = _oTProcesss.FindAll(delegate(OTProcess item)
|
|
//{ return item.EmployeeID.Integer == _employee.ID.Integer; });
|
|
//if (ops == null) return;
|
|
//if (ops.Count == 0) return;
|
|
double opAmount = 0;
|
|
//foreach (OTProcess op in ops)
|
|
// opAmount += op.Amount;
|
|
foreach (SalaryMonthlyDetail smd in _salary.Details)
|
|
{
|
|
if (smd.ItemCode == EnumSalaryItemCode.Over_Time_Amount)
|
|
opAmount += smd.ChangedAmount;
|
|
}
|
|
IncomeTax otItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.TimeCard, (int)EnumIncomeTaxItemGroup.TimeCard);
|
|
if (otItem == null) otItem = this.Add(EnumIncomeTaxItemGroup.TimeCard, (int)EnumIncomeTaxItemGroup.TimeCard, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_SalaryIncome);
|
|
|
|
// update this month amount
|
|
otItem.ThisMonthAmount = opAmount;
|
|
otItem.ProjectedAmount = 0;// op.Amount* _projectedMonth;
|
|
otItem.Side = EnumIncomeTaxSide.Inc_SalaryIncome;
|
|
|
|
}
|
|
|
|
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.Round(GlobalFunctions.GetFraction(SystemInformation.CurrentSysInfo.NextPayProcessDate.AddDays(1), date));
|
|
return nFraction;
|
|
}
|
|
private double GetAmountfromSalary(SalaryMonthlyDetail detail)
|
|
{
|
|
if (detail.itemGroupCode == EnumSalaryGroup.Arrear)
|
|
_onceoffAmount = _onceoffAmount + detail.ChangedAmount;
|
|
|
|
if (detail.itemGroupCode == EnumSalaryGroup.Gross || detail.itemGroupCode == EnumSalaryGroup.Arrear)
|
|
return detail.ChangedAmount;
|
|
else return -detail.ChangedAmount;
|
|
}
|
|
private 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;
|
|
}
|
|
private IncomeTax GetTaxItem2(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 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 (annualIncome > 0)
|
|
{
|
|
exempted.ProjectedAmount = Math.Ceiling((annualIncome / 3) * 1);
|
|
if (exempted.ProjectedAmount > 450000)
|
|
{
|
|
exempted.ProjectedAmount = 450000;
|
|
}
|
|
}
|
|
|
|
exempted.TotalAmount = exempted.ProjectedAmount;
|
|
}
|
|
protected void InitializeForNextMonth()
|
|
{
|
|
//commented by ashek 15 feb 2016
|
|
//if (_currentYearTax == null || _currentYearTax.Count ==0)
|
|
//{
|
|
// _currentYearTax = new ObjectsTemplate<IncomeTax>();
|
|
// _currentYearTax = IncomeTax.Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
//}
|
|
if (_currentYearTax == null || _currentYearTax.Count == 0)
|
|
{
|
|
_currentYearTax = new ObjectsTemplate<IncomeTax>();
|
|
_currentYearTax = IncomeTax.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, ID 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;
|
|
ObjectsTemplate<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, ID.FromInteger(0), _employee.BasicSalary));
|
|
|
|
if (_adParameters == null) _adParameters = ADParameter.Get(EnumStatus.Regardless, EnumAllowOrDeduct.Allowance);
|
|
adParams = ADParameter.GetApplicableParameters(_employee, _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.Integer, adParam.ID, adParam.GetGradeDefinedAmount(_employee, _employee.BasicSalary,
|
|
_employee.GrossSalary, new EmployeeGradeSalary())));
|
|
|
|
}
|
|
}
|
|
|
|
adParamEmps = ADParameterEmployee.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.Integer, 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.GetItem(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 (IsExamptedItem(item) == false)
|
|
_onceoffAmount = _onceoffAmount + item.ThisMonthAmount;
|
|
}
|
|
else
|
|
{
|
|
if (salaryDetail.itemGroupCode == EnumSalaryGroup.Gross)
|
|
{
|
|
if (adparameter.EntitleType == EnumEntitleType.Grade)
|
|
item.ProjectedAmount = GlobalFunctions.Round(adparameter.GetGradeDefinedAmount(_employee, _employee.BasicSalary, _employee.GrossSalary, oEmpGSalary)) * _projectedMonth;
|
|
else
|
|
{
|
|
DateTime fromDate = GlobalFunctions.FirstDateOfMonth(SystemInformation.CurrentSysInfo.NextPayProcessDate);
|
|
DateTime toDate = SystemInformation.CurrentSysInfo.NextPayProcessDate;
|
|
if (salaryDetail.SupportID != null)
|
|
{
|
|
|
|
ADParameterEmployee oempadp = salaryDetail.ADParamEmployee;
|
|
if (oempadp == null)
|
|
oempadp = ADParameterEmployee.Get(_employee.ID, ID.FromInteger(salaryDetail.ItemID), salaryDetail.SupportID, EnumArrearType.NotPresent);
|
|
//ADParameterEmployee oempadp = ADParameterEmployee.Get(_employee.ID, ID.FromInteger(salaryDetail.ItemID), salaryDetail.SupportID);
|
|
if (oempadp != null)
|
|
{
|
|
|
|
fromDate = GlobalFunctions.FirstDateOfMonth(SystemInformation.CurrentSysInfo.NextPayProcessDate.AddMonths(1));
|
|
|
|
if (oempadp.TillDate == null || oempadp.TillDate == DateTime.MinValue)
|
|
toDate = _taxParameter.FiscalyearDateTo;
|
|
else toDate = (DateTime)oempadp.TillDate;
|
|
|
|
double nproject = 0;
|
|
if (fromDate > toDate) nproject = 0;
|
|
else
|
|
{
|
|
if (toDate > _taxParameter.FiscalyearDateTo) toDate = _taxParameter.FiscalyearDateTo;
|
|
nproject = GlobalFunctions.GetFraction(fromDate, toDate);
|
|
}
|
|
//if (item.ItemGroup == EnumIncomeTaxItemGroup.Other_Allowance && item.ItemID==27)
|
|
// item.ProjectedAmount = GlobalFunctions.Round(oempadp.GetAmount(_employee.BasicSalary, 0)) * 6;
|
|
//else
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
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));
|
|
this._onceoffAmount = this._onceoffAmount + item.ThisMonthAmount;
|
|
break;
|
|
case EnumSalaryItemCode.Bonus:
|
|
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));
|
|
// this._onceoffAmount = this._onceoffAmount + item.ThisMonthAmount;
|
|
break;
|
|
case EnumSalaryItemCode.Allowance:
|
|
item = this.PayslipAllowanceDeduction(salaryDetail, EnumTaxMergeType.Allowance);
|
|
if (item == null) continue;
|
|
if(item.ItemGroup==EnumIncomeTaxItemGroup.Conveyance_Allowance)
|
|
{
|
|
DataSet ds = IncomeTax.GetTaxAdj(EnumIncomeTaxItemGroup.Conveyance_Allowance, (int)EnumIncomeTaxItemGroup.Conveyance_Allowance, _employee.ID);
|
|
if (ds != null && ds.Tables.Count > 0)
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
item.ThisMonthAmount = Convert.ToDouble(dr[6].ToString());
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
case EnumSalaryItemCode.Deduction:
|
|
item = this.PayslipAllowanceDeduction(salaryDetail, EnumTaxMergeType.Deduction);
|
|
if (item == null) continue;// throw new ServiceException("Tax grouping not found for " + salaryDetail.Description);
|
|
item.ThisMonthAmount = GlobalFunctions.Round(GetAmountfromSalary(salaryDetail));
|
|
//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)
|
|
{
|
|
if (salaryDetail.itemGroupCode == EnumSalaryGroup.Deductions)
|
|
{
|
|
item.Side = EnumIncomeTaxSide.Dec_SalaryIncome;
|
|
}
|
|
else
|
|
{ item.Side = EnumIncomeTaxSide.Inc_SalaryIncome; }
|
|
}
|
|
if (item != null && item.ThisMonthAmount != 0) this.Add(item);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
bool monthlyexemption = true;// ConfigurationManager.GetBoolValue("incometax", "monthlyexemption", EnumConfigurationType.Logic);
|
|
ObjectsTemplate<EmpLifeCycle> oCycles = EmpLifeCycle.GetByEmpID(_employee.ID);
|
|
|
|
foreach (var processItem in examtionItems)
|
|
{
|
|
double tempAmount = 0;
|
|
#region House rent allowance
|
|
if (processItem.ItemCode == (int)EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance)
|
|
{
|
|
|
|
IncomeTax basicItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Basic_Salary, (int)EnumIncomeTaxItemGroup.Basic_Salary);
|
|
IncomeTax HRItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.House_Rent_Allowance, (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 = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance, (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
|
|
monthlyexemption = true;
|
|
if (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;
|
|
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 * 7 < HRItem.PreviousAmount)
|
|
{
|
|
HrExption.PreviousAmount = maxMonthlyAmount * 7;
|
|
}
|
|
else HrExption.PreviousAmount = HRItem.PreviousAmount;
|
|
}
|
|
else
|
|
{
|
|
if (HRItem.ThisMonthAmount < maxMonthlyAmount)
|
|
maxMonthlyAmount = HRItem.ThisMonthAmount;
|
|
if (_employee.JoiningDate == GlobalFunctions.FirstDateOfMonth(_employee.JoiningDate))
|
|
def = Global.DateFunctions.DateDiff("m", _employee.JoiningDate, GlobalFunctions.LastDateOfMonth(_taxParameter.FiscalyearDateTo)) + 1;
|
|
else
|
|
{
|
|
def = Global.DateFunctions.DateDiff("m", _employee.JoiningDate, GlobalFunctions.LastDateOfMonth(_taxParameter.FiscalyearDateTo));
|
|
TimeSpan ts = GlobalFunctions.LastDateOfMonth(_employee.JoiningDate) - _employee.JoiningDate;
|
|
nFracAmount = (maxMonthlyAmount / (double)DateTime.DaysInMonth(_employee.JoiningDate.Year, _employee.JoiningDate.Month)) * ((double)ts.Days + 1);
|
|
}
|
|
|
|
HrExption.PreviousAmount = (maxMonthlyAmount * def) + nFracAmount;
|
|
|
|
}
|
|
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
|
|
}
|
|
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)
|
|
{
|
|
monthlyexemption = false;
|
|
IncomeTax CnvItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Conveyance_Allowance, (int)EnumIncomeTaxItemGroup.Conveyance_Allowance);
|
|
if (CnvItem == null || CnvItem.TotalAmount == 0) continue;
|
|
|
|
IncomeTax CvExption = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance, (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);
|
|
|
|
IncomeTax taxItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Cmp_Provided_car, (int)EnumIncomeTaxItemGroup.Cmp_Provided_car);
|
|
if (taxItem != null && taxItem.TotalAmount >0)
|
|
{
|
|
CvExption.ThisMonthAmount = 0;
|
|
CvExption.ProjectedAmount = 0;
|
|
CvExption.PreviousAmount = 0;
|
|
continue;
|
|
}
|
|
|
|
|
|
if (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)
|
|
{
|
|
monthlyexemption = false;
|
|
IncomeTax MedicalItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Medical_Allowance, (int)EnumIncomeTaxItemGroup.Medical_Allowance);
|
|
if (MedicalItem == null) continue; //throw new ServiceException("Conveyance allowance not found in the collection while calculating HR Examtion");
|
|
|
|
IncomeTax mdExption = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Exemption_Medical_Allowance, (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 = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Basic_Salary, (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 ?MedicalItem.TotalAmount: GlobalFunctions.Round(nMamount) ;
|
|
//End
|
|
|
|
//mdExption.ProjectedAmount =GlobalFunctions.Round(MedicalItem.TotalAmount);
|
|
mdExption.TotalAmount = mdExption.ThisMonthAmount + mdExption.PreviousAmount + mdExption.ProjectedAmount;
|
|
if (MedicalItem.TotalAmount<mdExption.TotalAmount)
|
|
{
|
|
mdExption.PreviousAmount = MedicalItem.PreviousAmount;
|
|
mdExption.ThisMonthAmount = MedicalItem.ThisMonthAmount;
|
|
mdExption.ProjectedAmount = MedicalItem.ProjectedAmount;
|
|
}
|
|
mdExption.Side = EnumIncomeTaxSide.Dec_SalaryIncome;
|
|
// this.Add(mdExption);
|
|
}
|
|
else if (processItem.ItemCode == (int)EnumIncomeTaxItemGroup.Exemption_LFA_Allowance)
|
|
{
|
|
IncomeTax LFAItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.LFA_Allowance, (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 = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Exemption_LFA_Allowance, (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);
|
|
}
|
|
#endregion Other Allowance Examption
|
|
}
|
|
}
|
|
protected void CalculateExamtionPrev()
|
|
{
|
|
#region get Examtion items from processItem
|
|
var examtionItems = from pItem in _processItems
|
|
where pItem.ItemGroup == 7
|
|
select pItem;
|
|
#endregion
|
|
|
|
bool monthlyexemption = true;// ConfigurationManager.GetBoolValue("incometax", "monthlyexemption", EnumConfigurationType.Logic);
|
|
ObjectsTemplate<EmpLifeCycle> oCycles = EmpLifeCycle.GetByEmpID(_employee.ID);
|
|
|
|
foreach (var processItem in examtionItems)
|
|
{
|
|
double tempAmount = 0;
|
|
#region House rent allowance
|
|
if (processItem.ItemCode == (int)EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance)
|
|
{
|
|
|
|
IncomeTax basicItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Basic_Salary, (int)EnumIncomeTaxItemGroup.Basic_Salary);
|
|
IncomeTax HRItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.House_Rent_Allowance, (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 = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Exemption_House_Rent_Allowance, (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(2016, 7, 1))
|
|
{
|
|
monthlyexemption = false;
|
|
}
|
|
else
|
|
monthlyexemption = true;
|
|
if (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;
|
|
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(2016, 7, 1))
|
|
{
|
|
if (maxMonthlyAmount * 7 < HRItem.PreviousAmount)
|
|
{
|
|
HrExption.PreviousAmount = maxMonthlyAmount * 7;
|
|
}
|
|
else HrExption.PreviousAmount = HRItem.PreviousAmount;
|
|
}
|
|
else
|
|
{
|
|
if (HRItem.ThisMonthAmount < maxMonthlyAmount)
|
|
maxMonthlyAmount = HRItem.ThisMonthAmount;
|
|
if (_employee.JoiningDate == GlobalFunctions.FirstDateOfMonth(_employee.JoiningDate))
|
|
def = Global.DateFunctions.DateDiff("m", _employee.JoiningDate, GlobalFunctions.LastDateOfMonth(_taxParameter.FiscalyearDateTo)) + 1;
|
|
else
|
|
{
|
|
def = Global.DateFunctions.DateDiff("m", _employee.JoiningDate, GlobalFunctions.LastDateOfMonth(_taxParameter.FiscalyearDateTo));
|
|
TimeSpan ts = GlobalFunctions.LastDateOfMonth(_employee.JoiningDate) - _employee.JoiningDate;
|
|
nFracAmount = (maxMonthlyAmount / (double)DateTime.DaysInMonth(_employee.JoiningDate.Year, _employee.JoiningDate.Month)) * ((double)ts.Days + 1);
|
|
}
|
|
|
|
HrExption.PreviousAmount = (maxMonthlyAmount * def) + nFracAmount;
|
|
|
|
}
|
|
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
|
|
}
|
|
if (_employee.JoiningDate < new DateTime(2016, 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)
|
|
{
|
|
monthlyexemption = false;
|
|
IncomeTax CnvItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Conveyance_Allowance, (int)EnumIncomeTaxItemGroup.Conveyance_Allowance);
|
|
if (CnvItem == null || CnvItem.TotalAmount == 0) continue;
|
|
|
|
IncomeTax CvExption = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance, (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);
|
|
|
|
IncomeTax taxItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Cmp_Provided_car, (int)EnumIncomeTaxItemGroup.Cmp_Provided_car);
|
|
if (taxItem != null && taxItem.TotalAmount > 0)
|
|
{
|
|
CvExption.ThisMonthAmount = 0;
|
|
CvExption.ProjectedAmount = 0;
|
|
CvExption.PreviousAmount = 0;
|
|
continue;
|
|
}
|
|
|
|
|
|
if (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)
|
|
{
|
|
monthlyexemption = false;
|
|
IncomeTax MedicalItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Medical_Allowance, (int)EnumIncomeTaxItemGroup.Medical_Allowance);
|
|
if (MedicalItem == null) continue; //throw new ServiceException("Conveyance allowance not found in the collection while calculating HR Examtion");
|
|
|
|
IncomeTax mdExption = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Exemption_Medical_Allowance, (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 = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Basic_Salary, (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 = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.LFA_Allowance, (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 = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Exemption_LFA_Allowance, (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);
|
|
}
|
|
#endregion Other Allowance Examption
|
|
}
|
|
}
|
|
protected void CalculateCPF()
|
|
{
|
|
if (_employee.PFMemberType != EnumPFMembershipType.Live) return;
|
|
IncomeTax pfItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Company_Contri_PF, (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 = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Basic_Salary, (int)EnumIncomeTaxItemGroup.Basic_Salary);
|
|
|
|
if (_salary != null)
|
|
pfItem.ThisMonthAmount = _salary.GetDeductAmount(EnumSalaryItemCode.PF_Contribution, (int)EnumSalaryItemCode.PF_Contribution);
|
|
else
|
|
pfItem.ThisMonthAmount = (BasicItem.ThisMonthAmount
|
|
* SystemInformation.CurrentSysInfo.pFContriCompany) / 100;
|
|
|
|
pfItem.ProjectedAmount = (BasicItem.ProjectedAmount
|
|
* SystemInformation.CurrentSysInfo.pFContriCompany) / 100;
|
|
|
|
pfItem.ThisMonthAmount = GlobalFunctions.Round(pfItem.ThisMonthAmount);
|
|
pfItem.ProjectedAmount = GlobalFunctions.Round(pfItem.ProjectedAmount);
|
|
|
|
}
|
|
|
|
protected void CalculateUpdateBonusProjection(double nAmount)
|
|
{
|
|
|
|
if (_employee.ForeignExPat == true) return;
|
|
ObjectsTemplate<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()
|
|
{
|
|
|
|
List<BonusParameter> oparams = null;
|
|
if (_projectionBonusParams == null)
|
|
{
|
|
_projectionBonusParams = new ObjectsTemplate<BonusParameter>();
|
|
ObjectsTemplate<BonusParameter> ops = BonusParameter.Get(EnumStatus.Regardless);
|
|
foreach (BonusParameter oitem in ops)
|
|
|
|
if (oitem.IsFestival == true)
|
|
{
|
|
oitem.SetupDetails = BonusParameter.Service.GetSetupDetail(oitem.ID);
|
|
_projectionBonusParams.Add(oitem);
|
|
}
|
|
}
|
|
|
|
if (_projectionBonusParams == null || _projectionBonusParams.Count == 0) return;
|
|
oparams = BonusParameter.GetApplicableParametersByGrade(_employee, _employee.GradeID, _projectionBonusParams);
|
|
if (oparams == null) return;
|
|
|
|
_ApplicableBonusParams = oparams;
|
|
|
|
|
|
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);
|
|
|
|
foreach (BonusParameter item in oparams)
|
|
{
|
|
//pfItem.ProjectedAmount =0;
|
|
ObjectsTemplate<BonusParameter> paramAll = BonusParameter.Get(EnumStatus.Regardless);
|
|
List<EnmSetupManagerTranType> oSetupManagerTranTypes = SetupDetail.GetTypes(EnumParameterSetup.Bonus);
|
|
ObjectsTemplate<SetupDetail> oSetupDetails = SetupDetail.GetParameters(EnumParameterSetup.Bonus);
|
|
ObjectsTemplate<BonusParameter> oParams = BonusParameter.ApplicableParameters3(_employee, item.BonusID, oSetupManagerTranTypes, oSetupDetails, paramAll);
|
|
ObjectsTemplate<ADParameter> adParams = ADParameter.Get(_employee.GradeID, EnumEntitleType.Grade, EnumAllowOrDeduct.Allowance);
|
|
ObjectsTemplate<ADParameterEmployee> adParamEmps = ADParameterEmployee.GetByEmployee(_employee.ID, EnumAllowOrDeduct.Allowance, EnumADEmpType.AppliedToIndividual);
|
|
ObjectsTemplate<GrossDefination> grossDefinitions = GrossDefination.Get();
|
|
|
|
|
|
EmployeeGradeSalary ogs = EmployeeGradeSalary.GetBasicOnDate(_employee.ID, SystemInformation.CurrentSysInfo.NextPayProcessDate);
|
|
|
|
double bonusAmount = BonusCalculator.GetMonthlyGrossAmount(_employee, adParams, adParamEmps, grossDefinitions, SystemInformation.CurrentSysInfo.NextPayProcessDate, ogs);
|
|
|
|
double nPaid = BonusProcess.GetBonusPaidAmount(_taxParameter.FiscalyearDatefrom, _taxParameter.FiscalyearDateTo, _employee.ID, item.BonusID.Integer);
|
|
pfItem.ProjectedAmount = (bonusAmount * item.PercentOfGross)/100 - nPaid;
|
|
//DateTime oEndMonth = new DateTime(((item.TaxProjectInMonth <= 6) ? _taxParameter.FiscalyearDateTo.Year : _taxParameter.FiscalyearDatefrom.Year), item.TaxProjectInMonth, 1);
|
|
//if (item.TaxProjectInMonth != null && oEndMonth > Global.DateFunctions.FirstDateOfMonth(SystemInformation.CurrentSysInfo.NextPayProcessDate))
|
|
//{
|
|
// BonusCalculator ocal = new BonusCalculator();
|
|
|
|
// double nn=ocal.CalcluateBonus(item, _employee, _employee.BasicSalary, _employee.GrossSalary,
|
|
// Global.DateFunctions.LastDateOfYear(SystemInformation.CurrentSysInfo.NextPayProcessDate));
|
|
// if (_employee.ReligionID.Integer == 2)
|
|
// pfItem.ProjectedAmount = 0;
|
|
// else if (_employee.ReligionID.Integer == 4)
|
|
// pfItem.ProjectedAmount = _employee.BasicSalary*2;
|
|
// else
|
|
// pfItem.ProjectedAmount = _employee.BasicSalary;// *2;
|
|
// // if not religion islam
|
|
// // if thier is an amount in previous then no need to projection
|
|
// // else projected amount will be basic * 2;
|
|
// // for islam
|
|
// // Payroll month in between july to dec then
|
|
// // prevous amount =0 then basic * 2
|
|
// // else basic *1
|
|
|
|
// // else basic *1
|
|
|
|
// //pfItem.ProjectedAmount = pfItem.ProjectedAmount + ocal.CalcluateBonus(item, _employee, _employee.BasicSalary, _employee.GrossSalary,
|
|
// // Global.DateFunctions.LastDateOfYear(SystemInformation.CurrentSysInfo.NextPayProcessDate));
|
|
// //}
|
|
// //Non Muslim
|
|
// //////////if(_employee.ReligionID.Integer==2||_employee.ReligionID.Integer==3||_employee.ReligionID.Integer==4)
|
|
// //////////{
|
|
// ////////// if(pfItem.PreviousAmount==0)
|
|
// ////////// {
|
|
// ////////// pfItem.ProjectedAmount= _employee.BasicSalary * 2;
|
|
// ////////// }
|
|
// //////////}
|
|
// //////////else
|
|
// //////////{
|
|
// ////////// if (SystemInformation.CurrentSysInfo.NextPayProcessDate >= new DateTime(SystemInformation.CurrentSysInfo.NextPayProcessDate.Year, 7, 1)
|
|
// ////////// && SystemInformation.CurrentSysInfo.NextPayProcessDate >= GlobalFunctions.LastDateOfMonth(new DateTime(SystemInformation.CurrentSysInfo.NextPayProcessDate.Year, 12, 1)))
|
|
// ////////// {
|
|
// ////////// if (pfItem.PreviousAmount == 0)
|
|
// ////////// {
|
|
// ////////// pfItem.ProjectedAmount = _employee.BasicSalary * 2;
|
|
// ////////// }
|
|
// ////////// else
|
|
// ////////// {
|
|
// ////////// pfItem.ProjectedAmount = _employee.BasicSalary;
|
|
// ////////// }
|
|
// ////////// }
|
|
// ////////// else
|
|
// ////////// {
|
|
// ////////// pfItem.ProjectedAmount = _employee.BasicSalary;
|
|
// ////////// }
|
|
// //////////}
|
|
// //if (_employee.ReligionID.Integer == 2 || _employee.ReligionID.Integer == 4)
|
|
// //{
|
|
// // pfItem.ProjectedAmount = 0;
|
|
// //}
|
|
// //else if (_employee.ReligionID.Integer == 1)
|
|
// //{
|
|
// // pfItem.ProjectedAmount = _employee.BasicSalary;
|
|
// //}
|
|
// //else if (_employee.ReligionID.Integer == 3)
|
|
// //{
|
|
// // pfItem.ProjectedAmount = _employee.BasicSalary * 2;
|
|
// //}
|
|
//}
|
|
}
|
|
if (Payroll.BO.SystemInformation.CurrentSysInfo.NextPayProcessDate.Month == 6) // Forcely zero on month Jun
|
|
pfItem.ProjectedAmount = 0;
|
|
|
|
// pfItem.ProjectedAmount = pfItem.ProjectedAmount - (pfItem.PreviousAmount + pfItem.ThisMonthAmount);
|
|
if (pfItem.ProjectedAmount <= 0)
|
|
pfItem.ProjectedAmount = 0;
|
|
pfItem.ProjectedAmount =GlobalFunctions.Round(pfItem.ProjectedAmount);
|
|
|
|
|
|
}
|
|
|
|
|
|
protected void CalculateInvestment()
|
|
{
|
|
|
|
IncomeTax InvestmentItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Tax_Credit_On_Investment,
|
|
(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;
|
|
bool binvestmenton = ConfigurationManager.GetBoolValue("incometax", "investmentwithoutpf", EnumConfigurationType.Logic);
|
|
|
|
IncomeTax AnnualItem = null;
|
|
//if (binvestmenton == true)
|
|
// AnnualItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Annual_Salary_Income,
|
|
// (int)EnumIncomeTaxItemGroup.Annual_Salary_Income);
|
|
//else
|
|
AnnualItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Annual_Income,
|
|
(int)EnumIncomeTaxItemGroup.Annual_Income);
|
|
|
|
double investmentCanBeShown = ((AnnualItem.TotalAmount * _taxParameter.MaxInvestPercent) / 100);
|
|
if (investmentCanBeShown > _taxParameter.MaxInvAmount) investmentCanBeShown = _taxParameter.MaxInvAmount;
|
|
double investAmount = investmentCanBeShown;
|
|
_isActualInvestment = true;
|
|
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 <= SystemInformation.CurrentSysInfo.NextPayProcessDate)
|
|
// _isActualInvestment = true;
|
|
//}
|
|
double nPFAmount = 0;
|
|
if (_isActualInvestment == true)
|
|
{
|
|
IncomeTax ActualInvestment = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Investment_Actual,
|
|
(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 = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Company_Contri_PF,
|
|
(int)EnumIncomeTaxItemGroup.Company_Contri_PF);
|
|
investAmount = 0;
|
|
if (pfItem != null)
|
|
{
|
|
investAmount = investAmount + (pfItem.TotalAmount * 2);
|
|
nPFAmount = pfItem.TotalAmount * 2;
|
|
}
|
|
EmployeeTaxInvestment etax = new EmployeeTaxInvestment();
|
|
double nactualInvt = etax.GetAmount(_taxParameter.ID, _employee.ID);
|
|
#region Added By ashek
|
|
double nAllowedInvestment = (AnnualItem.TotalAmount * 25) / 100;
|
|
double nActual=nAllowedInvestment-nPFAmount;
|
|
if (nactualInvt > nActual)
|
|
investAmount = nActual;
|
|
else
|
|
investAmount = nactualInvt;
|
|
#endregion
|
|
//investAmount = investAmount + nactualInvt;
|
|
|
|
ActualInvestment.ProjectedAmount = investAmount;//nactualInvt;
|
|
ActualInvestment.TotalAmount = investAmount;// nactualInvt;
|
|
investAmount += nPFAmount;
|
|
}
|
|
|
|
IncomeTax InvestmentAllowed = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Investment_Allowed,
|
|
(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);
|
|
|
|
double taxCredit = 0;
|
|
taxCredit = (investAmount * _taxParameter.MaxInvExempPercent) / 100;
|
|
|
|
double nTempRebate = (investAmount * _taxParameter.MaxInvExempPercent) / 100;
|
|
if (nTempRebate > (AnnualItem.TotalAmount * .03))
|
|
nTempRebate = AnnualItem.TotalAmount * .03;
|
|
if (nTempRebate > 1000000)
|
|
nTempRebate = 1000000;
|
|
|
|
InvestmentItem.ProjectedAmount = GlobalFunctions.Round(taxCredit);
|
|
InvestmentItem.TotalAmount = GlobalFunctions.Round(taxCredit);
|
|
}
|
|
protected void PrvYearTaxRebate()
|
|
{
|
|
if (_prvYearTotalIncomes == null)
|
|
_prvYearTotalIncomes = IncomeTax.GetPrvYear(_taxParameter.ID,
|
|
EnumIncomeTaxItemGroup.Annual_Income, (int)EnumIncomeTaxItemGroup.Annual_Income);
|
|
if (_prvYearTotalIncomes == null) return;
|
|
|
|
IncomeTax prvYearIncome = IncomeTax.Get(_prvYearTotalIncomes, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Annual_Income, (int)EnumIncomeTaxItemGroup.Annual_Income);
|
|
if (prvYearIncome == null) return;
|
|
|
|
IncomeTax CurrYearIncome = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Annual_Income, (int)EnumIncomeTaxItemGroup.Annual_Income);
|
|
if (CurrYearIncome == null) return;
|
|
|
|
if (_PrvYeartaxParameter == null) _PrvYeartaxParameter = Payroll.BO.TaxParameter.Get(_taxParameter.FiscalYear);
|
|
if (_PrvYeartaxParameter == null) return;
|
|
|
|
double currAmount = CurrYearIncome.TotalAmount;
|
|
double PrvAmount = prvYearIncome.TotalAmount;
|
|
double exemptedAmount = 0;
|
|
if (PrvAmount >= _PrvYeartaxParameter.GetSlabTotal() && currAmount > _taxParameter.GetSlabTotal())
|
|
{
|
|
if (currAmount >= (PrvAmount + (PrvAmount * 10) / 100))
|
|
{
|
|
exemptedAmount = currAmount - PrvAmount;
|
|
exemptedAmount = (exemptedAmount * 25) / 100; // 25%
|
|
exemptedAmount = (exemptedAmount * 10) / 100; // 10%
|
|
|
|
IncomeTax grossRebate = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Tax_Gross_Rebate, (int)EnumIncomeTaxItemGroup.Tax_Gross_Rebate);
|
|
if (grossRebate == null) grossRebate = this.Add(EnumIncomeTaxItemGroup.Tax_Gross_Rebate, (int)EnumIncomeTaxItemGroup.Tax_Gross_Rebate, string.Empty, 0, 0, EnumIncomeTaxSide.Dec_GrossTax);
|
|
grossRebate.ProjectedAmount = GlobalFunctions.Round(exemptedAmount);
|
|
this.Add(grossRebate);
|
|
}
|
|
}
|
|
}
|
|
protected void CmpProvidedHouseAndTransport(DateTime month)
|
|
{
|
|
try
|
|
{
|
|
if (_assignedHeads == null) return;
|
|
|
|
ObjectsTemplate<ITEmpHead> Items = ITEmpHead.Get(_assignedHeads, _employee.ID);
|
|
if (Items == null || Items.Count == 0) return;
|
|
|
|
DateTime fromDate = GlobalFunctions.FirstDateOfMonth(month);
|
|
DateTime toDate = GlobalFunctions.LastDateOfMonth(month);
|
|
bool bvalid = false;
|
|
|
|
IncomeTax basicSalaryItem = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Basic_Salary,
|
|
(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) { fromDate = item.StartDate; }
|
|
if (item.EndDate <= toDate) { toDate = item.EndDate; }
|
|
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 (bvalid == false)
|
|
{
|
|
|
|
DataSet ds = IncomeTax.GetTaxAdj(EnumIncomeTaxItemGroup.Cmp_Provided_car, (int)EnumIncomeTaxItemGroup.Cmp_Provided_car, _employee.ID);
|
|
if (ds != null && ds.Tables.Count > 0)
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
taxItem = IncomeTax.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.ThisMonthAmount = Convert.ToDouble(dr[6].ToString());
|
|
taxItem.ProjectedAmount = 0;
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
//if (item.StartDate > fromDate) fromDate = item.StartDate;
|
|
//if (item.EndDate > toDate) toDate = item.EndDate;
|
|
|
|
|
|
#region Calculate Car calculation
|
|
if (item.HeadID == EnumIncomeTaxHead.Car)
|
|
{
|
|
taxItem = IncomeTax.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);
|
|
|
|
|
|
if (_salary == null)
|
|
tempAmount = basicSalaryItem.ThisMonthAmount;
|
|
else
|
|
{
|
|
SalaryMonthlyDetail detail = _salary.GetDetail(EnumSalaryGroup.Gross, EnumSalaryItemCode.Basic_Salary, (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 detail = _salary.GetDetail(EnumSalaryGroup.Gross, EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary);
|
|
SalaryMonthlyDetail arreardetail = _salary.GetDetail(EnumSalaryGroup.Arrear, EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary);
|
|
if (arreardetail != null)
|
|
{
|
|
tempAmount = tempAmount + arreardetail.ChangedAmount;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
double nTemp = tempAmount;
|
|
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);
|
|
}
|
|
}
|
|
if (tempAmount<0)
|
|
tempAmount = nTemp;
|
|
#endregion basic salary arrear effect
|
|
}
|
|
|
|
// need to fractionate if from date is not first date of month
|
|
TimeSpan ts = toDate - fromDate;
|
|
int nDaysInMonth = DateTime.DaysInMonth(fromDate.Year, fromDate.Month);
|
|
int nDays = ts.Days + 1;
|
|
if (nDays < nDaysInMonth)
|
|
{
|
|
tempAmount = (tempAmount / nDaysInMonth) * nDays;
|
|
}
|
|
taxItem.ThisMonthAmount = GlobalFunctions.Round(tempAmount * carparcent);
|
|
|
|
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;
|
|
double nFrac = 1;
|
|
if (nDays < nDaysInMonth)
|
|
{
|
|
//nFrac = (double)nDays / (double)nDaysInMonth;
|
|
//taxItem.ProjectedAmount = (tempAmount * Math.Round(nFrac, 2) * carparcent) + (basicSalaryItem.ThisMonthAmount * (_projectedMonth - 1));
|
|
taxItem.ProjectedAmount = 0;
|
|
}
|
|
else
|
|
taxItem.ProjectedAmount = (tempAmount * Math.Round(nFrac, 2) * carparcent) * _projectedMonth;
|
|
|
|
//if (toDate == GlobalFunctions.LastDateOfMonth(toDate))
|
|
//{
|
|
|
|
// taxItem.ProjectedAmount = (tempAmount * (Global.DateFunctions.DateDiff("m", GlobalFunctions.LastDateOfMonth(month).AddDays(1), toDate) + 1) * carparcent);
|
|
|
|
|
|
//}
|
|
//else
|
|
//{
|
|
// // need to fractionate last month
|
|
// taxItem.ProjectedAmount = (tempAmount * GlobalFunctions.GetFraction(GlobalFunctions.LastDateOfMonth(month).AddDays(1), toDate)) * carparcent;
|
|
//}
|
|
DataSet ds = IncomeTax.GetTaxAdj(EnumIncomeTaxItemGroup.Cmp_Provided_car, (int)EnumIncomeTaxItemGroup.Cmp_Provided_car, _employee.ID);
|
|
if (ds != null && ds.Tables.Count > 0)
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
taxItem.ThisMonthAmount = Convert.ToDouble(dr[6].ToString());
|
|
}
|
|
}
|
|
if (taxItem.TotalAmount < 60000)
|
|
taxItem.ProjectedAmount = 60000 - (taxItem.PreviousAmount + taxItem.ThisMonthAmount);
|
|
//taxItem.ProjectedAmount = 0;
|
|
if (taxItem.TotalAmount > 0)
|
|
{
|
|
IncomeTax CvExption = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance, (int)EnumIncomeTaxItemGroup.Exemption_Conveyance_Allowance);
|
|
|
|
if (CvExption !=null && CvExption.TotalAmount > 0)
|
|
{
|
|
CvExption.PreviousAmount = 0;
|
|
CvExption.ThisMonthAmount = 0;
|
|
CvExption.ProjectedAmount = 0;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
#endregion Calculate Car calculation
|
|
|
|
#region Calculate House rent calculation
|
|
if (item.HeadID == EnumIncomeTaxHead.House)
|
|
{
|
|
taxItem = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Cmp_Provided_House,
|
|
(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.GetDetail(EnumSalaryGroup.Gross, EnumSalaryItemCode.Basic_Salary, (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.GetDetail(EnumSalaryGroup.Arrear, EnumSalaryItemCode.Basic_Salary, (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 = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Annual_Salary_Income,
|
|
(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 = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Annual_Income,
|
|
(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);
|
|
}
|
|
private 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 = IncomeTax.Get(this.CurrentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Net_Payable, (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
IncomeTax oTaxDeducted = IncomeTax.Get(this.CurrentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Tax_Deducted, (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 = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Tax_Refund_On_Current_Year, (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.ProjectedAmount = GlobalFunctions.Round(oNetTaxPayable.TotalAmount - oTaxDeducted.TotalAmount);
|
|
TaxRefund.TotalAmount = TaxRefund.ProjectedAmount;
|
|
// set equal to Net_Taxable_income to Tax_deducted_current_year amount
|
|
// oTaxDeducted.TotalAmount = oNetTaxPayable.TotalAmount;
|
|
}
|
|
}
|
|
private double GetTaxonTaxAmount(double onAmount)
|
|
{
|
|
|
|
this.CalculateTotalIncome();
|
|
|
|
IncomeTax IncomeWithCar = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Annual_Salary_Income,
|
|
(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;
|
|
}
|
|
protected double GetTaxonTaxNetPayable()
|
|
{
|
|
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateNetPayable();
|
|
|
|
IncomeTax annualIncome = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Net_Payable,
|
|
(int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
|
|
double IncomeWithoutNetpayable = annualIncome.TotalAmount;
|
|
|
|
IncomeTax taxOnTax = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Tax_on_Tax_Net_Payable,
|
|
(int)EnumIncomeTaxItemGroup.Tax_on_Tax_Net_Payable);
|
|
|
|
if (taxOnTax == null) taxOnTax = this.Add(EnumIncomeTaxItemGroup.Tax_on_Tax_Net_Payable,
|
|
(int)EnumIncomeTaxItemGroup.Tax_on_Tax_Net_Payable, string.Empty, IncomeWithoutNetpayable, 0, EnumIncomeTaxSide.Inc_SalaryIncome);
|
|
else
|
|
{
|
|
taxOnTax.PreviousAmount = 0;
|
|
taxOnTax.ThisMonthAmount = IncomeWithoutNetpayable;
|
|
}
|
|
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateNetPayable();
|
|
|
|
double dif = 0;
|
|
double onlyCarTax = this.GetTaxConciderInvestment(IncomeWithoutNetpayable); ;
|
|
double taxwithCar = this.GetTaxConciderInvestment(annualIncome.TotalAmount);
|
|
|
|
dif = taxwithCar - onlyCarTax;
|
|
double addedIncome = dif + taxwithCar;
|
|
double prvTax = taxwithCar;
|
|
|
|
while (dif < 0)
|
|
{
|
|
dif = this.GetTaxConciderInvestment(addedIncome);
|
|
if (dif == 0) break;
|
|
dif = dif - prvTax;
|
|
|
|
prvTax = addedIncome;
|
|
if (dif > 0) addedIncome = addedIncome + dif;
|
|
}
|
|
|
|
dif = addedIncome - taxwithCar;
|
|
|
|
taxOnTax.ThisMonthAmount = taxOnTax.ThisMonthAmount + dif;
|
|
|
|
return dif;
|
|
}
|
|
|
|
private double GetTaxConciderInvestment(double income)
|
|
{
|
|
double taxamount = this.GetTaxAmount(income);
|
|
|
|
if (_employee.ForeignExPat == true) return taxamount;
|
|
bool binvestmenton = ConfigurationManager.GetBoolValue("incometax", "investmentwithoutpf", EnumConfigurationType.Logic);
|
|
|
|
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 <= SystemInformation.CurrentSysInfo.NextPayProcessDate)
|
|
_isActualInvestment = true;
|
|
}
|
|
if (_isActualInvestment == true)
|
|
{
|
|
IncomeTax ActualInvestment = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Investment_Actual,
|
|
(int)EnumIncomeTaxItemGroup.Investment_Actual);
|
|
investAmount = ActualInvestment.ThisMonthAmount;
|
|
}
|
|
|
|
|
|
if (investAmount > investmentCanBeShown)
|
|
investAmount = investmentCanBeShown;
|
|
double taxCredit = 0;
|
|
taxCredit = (investAmount * _taxParameter.MaxInvExempPercent) / 100;
|
|
|
|
//if (income <= 1500000)
|
|
// taxCredit = investAmount * .15;
|
|
//else taxCredit = investAmount * .10;
|
|
|
|
|
|
taxamount = taxamount - taxCredit;
|
|
return taxamount;
|
|
}
|
|
|
|
protected void CalculateNetPayable()
|
|
{
|
|
|
|
IncomeTax GrossTax = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Gross_Tax, (int)EnumIncomeTaxItemGroup.Gross_Tax);
|
|
if (GrossTax == null)
|
|
{
|
|
this.CalculateGrossTax();
|
|
GrossTax = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Gross_Tax, (int)EnumIncomeTaxItemGroup.Gross_Tax);
|
|
// this.Add(GrossTax);
|
|
}
|
|
this.CalculateGrossTax();
|
|
|
|
|
|
IncomeTax netPayable = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Net_Payable, (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 = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Tax_Credit_On_Investment, (int)EnumIncomeTaxItemGroup.Tax_Credit_On_Investment);
|
|
if (InvestItem == null) this.CalculateInvestment();
|
|
|
|
netPayable.ProjectedAmount = GrossTax.TotalAmount - InvestItem.TotalAmount;
|
|
if (netPayable.ProjectedAmount < _taxParameter.MinTaxAmount)
|
|
netPayable.ProjectedAmount = _taxParameter.MinTaxAmount;
|
|
|
|
}
|
|
IncomeTax rebet = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Tax_Gross_OtherRebate, 1);
|
|
double nAIT = 0;
|
|
if (rebet != null)
|
|
nAIT = rebet.TotalAmount;
|
|
netPayable.ProjectedAmount = netPayable.ProjectedAmount + this.GetTaxRebate() - nAIT;
|
|
netPayable.ProjectedAmount = GlobalFunctions.Round(netPayable.ProjectedAmount);
|
|
netPayable.TotalAmount = GlobalFunctions.Round(netPayable.ProjectedAmount); ;
|
|
}
|
|
|
|
protected void CalculateGrossTax()
|
|
{
|
|
|
|
IncomeTax GrossTax = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Gross_Tax, (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 = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Tax_Deducted, (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
if (TaxDeductitem != null)
|
|
{
|
|
nAmount = TaxDeductitem.ThisMonthAmount;
|
|
TaxDeductitem.ThisMonthAmount = 0;
|
|
}
|
|
|
|
this.CalculateThisMonth();
|
|
|
|
TaxDeductitem = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Tax_Deducted, (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
if (TaxDeductitem != null)
|
|
{
|
|
nTaxAmount = TaxDeductitem.ThisMonthAmount - nAmount;
|
|
}
|
|
return nTaxAmount;
|
|
}
|
|
|
|
protected void UndoDecutedAmount(double nAmount)
|
|
{
|
|
IncomeTax TaxDeductitem = IncomeTax.Get(_currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Tax_Deducted, (int)EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
if (TaxDeductitem != null)
|
|
TaxDeductitem.ThisMonthAmount = TaxDeductitem.ThisMonthAmount - nAmount;
|
|
//this.CalculateThisMonth();
|
|
}
|
|
protected double CalculateOnceOfInvestmentAmt()
|
|
{
|
|
|
|
if (_employee.ForeignExPat == true) return 0;
|
|
bool binvestmenton = ConfigurationManager.GetBoolValue("incometax", "investmentwithoutpf", EnumConfigurationType.Logic);
|
|
|
|
IncomeTax AnnItem = null;
|
|
//if (binvestmenton == true)
|
|
// AnnItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Annual_Salary_Income,
|
|
// (int)EnumIncomeTaxItemGroup.Annual_Salary_Income);
|
|
//else
|
|
AnnItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Annual_Income,
|
|
(int)EnumIncomeTaxItemGroup.Annual_Income);
|
|
|
|
double totalIncome = AnnItem.TotalAmount - _onceoffAmount;
|
|
|
|
double investmentCanBeShown = ((totalIncome * _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 <= SystemInformation.CurrentSysInfo.NextPayProcessDate)
|
|
_isActualInvestment = true;
|
|
}
|
|
if (_isActualInvestment == true)
|
|
{
|
|
IncomeTax ActualInvestment = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Investment_Actual,
|
|
(int)EnumIncomeTaxItemGroup.Investment_Actual);
|
|
investAmount = ActualInvestment.ThisMonthAmount;
|
|
}
|
|
|
|
|
|
if (investAmount > investmentCanBeShown)
|
|
investAmount = investmentCanBeShown;
|
|
double taxCredit = 0;
|
|
taxCredit = (investAmount * _taxParameter.MaxInvExempPercent) / 100;
|
|
|
|
double nTempRebate = (investAmount * _taxParameter.MaxInvExempPercent) / 100;
|
|
if (nTempRebate > (totalIncome * .03))
|
|
nTempRebate = totalIncome * .03;
|
|
if (nTempRebate > 1000000)
|
|
nTempRebate = 1000000;
|
|
//if (AnnItem.TotalAmount <= 1000000)
|
|
// taxCredit = investAmount * .15;
|
|
//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);
|
|
//}
|
|
|
|
|
|
return (taxCredit);
|
|
|
|
//if (_employee.ForeignExPat == true) return 0;
|
|
//bool binvestmenton = ConfigurationManager.GetBoolValue("incometax", "investmentwithoutpf", EnumConfigurationType.Logic);
|
|
|
|
//IncomeTax AnnItem = null;
|
|
//if (binvestmenton == true)
|
|
// AnnItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Annual_Salary_Income,
|
|
// (int)EnumIncomeTaxItemGroup.Annual_Salary_Income);
|
|
//else
|
|
// AnnItem = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Annual_Income,
|
|
// (int)EnumIncomeTaxItemGroup.Annual_Income);
|
|
|
|
//double totalIncome = AnnItem.TotalAmount - _onceoffAmount;
|
|
|
|
//double investmentCanBeShown = ((totalIncome * _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 <= SystemInformation.CurrentSysInfo.NextPayProcessDate)
|
|
// _isActualInvestment = true;
|
|
//}
|
|
//if (_isActualInvestment == true)
|
|
//{
|
|
// IncomeTax ActualInvestment = IncomeTax.Get(_currentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Investment_Actual,
|
|
// (int)EnumIncomeTaxItemGroup.Investment_Actual);
|
|
// investAmount = ActualInvestment.ThisMonthAmount;
|
|
//}
|
|
|
|
|
|
//if (investAmount > investmentCanBeShown)
|
|
// investAmount = investmentCanBeShown;
|
|
//double taxCredit = 0;
|
|
//taxCredit = (investAmount * _taxParameter.MaxInvExempPercent) / 100;
|
|
|
|
//if (AnnItem.TotalAmount <= 1000000)
|
|
// taxCredit = investAmount * .15;
|
|
//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 (InvestmentItem.TotalAmount - taxCredit);
|
|
}
|
|
protected void CalculateThisMonth()
|
|
{
|
|
IncomeTax TaxDeductitem = IncomeTax.Get(_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);
|
|
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
double onceOffTax = 0;
|
|
double netPayable = IncomeTax.Get(this._currentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Net_Payable, (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 (_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)
|
|
{
|
|
|
|
onceOffTax = this.GetTaxAmount(annualIncome - _onceoffAmount);
|
|
double invAmount = CalculateOnceOfInvestmentAmt();
|
|
onceOffTax = onceOffTax - invAmount;
|
|
onceOffTax = onceOffTax + this.GetTaxRebate();
|
|
if (_taxParameter.MinTaxAmount > onceOffTax)
|
|
onceOffTax = _taxParameter.MinTaxAmount;
|
|
|
|
double ntp = netPayable - onceOffTax;
|
|
if (ntp < 0) ntp = 0;
|
|
#region Commented by ashek
|
|
double restofMonthTax = onceOffTax - TaxDeductitem.TotalAmount; // Tax to be paid rest of the year;
|
|
if (restofMonthTax < 0)
|
|
{
|
|
restofMonthTax = 0;
|
|
ntp = ntp / _projectedMonth;
|
|
}
|
|
|
|
TaxDeductitem.ThisMonthAmount = ntp + (restofMonthTax / (_projectedMonth + 1));
|
|
#endregion
|
|
//TaxDeductitem.ThisMonthAmount = ntp;
|
|
//onceOffTax = this.GetTaxAmount(annualIncome - _onceoffAmount);
|
|
//onceOffTax = onceOffTax - CalculateOnceOfInvestmentAmt();
|
|
//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;// (netPayable - TaxDeductitem.PreviousAmount) / _projectedMonth;
|
|
}
|
|
if (TaxDeductitem.ThisMonthAmount < 0) TaxDeductitem.ThisMonthAmount = 0;
|
|
//if (_employee.GradeID.Integer == 24 || _employee.GradeID.Integer == 25)
|
|
//{
|
|
// TaxDeductitem.ThisMonthAmount = 0;
|
|
//}
|
|
//else
|
|
//{
|
|
TaxDeductitem.ThisMonthAmount = GlobalFunctions.Round(TaxDeductitem.ThisMonthAmount);
|
|
//}
|
|
TaxDeductitem.ProjectedAmount = GlobalFunctions.Round(TaxDeductitem.ProjectedAmount);
|
|
|
|
if (_salary != null && (_salary.GradeID.Integer == 25 || _salary.GradeID.Integer == 24))
|
|
|
|
{
|
|
SalaryMonthlyDetail dtl = _salary.Details.Find(delegate (SalaryMonthlyDetail detail) { return (detail.ItemCode == EnumSalaryItemCode.Basic_Salary && detail.itemGroupCode == EnumSalaryGroup.Gross); });
|
|
if (dtl != null)
|
|
{
|
|
dtl.CalculatedAmount = dtl.CalculatedAmount + TaxDeductitem.ThisMonthAmount;
|
|
dtl.ChangedAmount = dtl.CalculatedAmount;
|
|
}
|
|
}
|
|
|
|
|
|
//IncomeTax TaxDeductitem = IncomeTax.Get(_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);
|
|
|
|
//this.CalculateGrossTax();
|
|
//this.CalculateNetPayable();
|
|
//double onceOffTax = 0;
|
|
//double netPayable = IncomeTax.Get(this._currentYearTax, _employee.ID,
|
|
// EnumIncomeTaxItemGroup.Net_Payable, (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;
|
|
//}
|
|
|
|
//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.");
|
|
|
|
// TaxDeductitem.ThisMonthAmount = onceOffTax + (((netPayable - onceOffTax) - 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);
|
|
}
|
|
|
|
protected double GetTaxAmount(double TaxableIncome)
|
|
{
|
|
try
|
|
{
|
|
double taxAmount = 0;
|
|
ObjectsTemplate<TaxParameterSlab> parameterSlabs = TaxParameter.CalculateTaxOnSlab(_taxParameter, _employee, TaxableIncome);
|
|
taxAmount = TaxParameterSlab.GetTotalTaxAmount(parameterSlabs);
|
|
return taxAmount;
|
|
}
|
|
catch
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
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;
|
|
case enumIncomeTaxItemType.Other:
|
|
taxItem = GetTaxItem(EnumTaxMergeType.Other, 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.Allowance, item.ItemId, item.Description);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (taxItem != null)
|
|
{
|
|
//taxItem.ThisMonthAmount = (nSide == EnumSide.Deduct) ? -GlobalFunctions.Round(item.Amount) : GlobalFunctions.Round(item.Amount);
|
|
taxItem.ThisMonthAmount = taxItem.ThisMonthAmount + item.Amount;
|
|
if (taxItem != null) taxItem.Side = EnumIncomeTaxSide.Inc_SalaryIncome;
|
|
this.Add(taxItem);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
protected void UpdateRawItems2(List<TaxRawItem> rawItems, EnumSide nSide,int itemID)
|
|
{
|
|
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, 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);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
public interface ISalaryTax
|
|
{
|
|
SalaryMonthly Salary { set; get; }
|
|
ObjectsTemplate<IncomeTax> Calculate();
|
|
}
|
|
public interface IBonusTax
|
|
{
|
|
BonusProcess.BonusProcessDetail Bonus { set; get; }
|
|
ObjectsTemplate<IncomeTax> Calculate();
|
|
}
|
|
public interface ITaxCalculator
|
|
{
|
|
|
|
}
|
|
[Serializable]
|
|
public class TaxCalculator :AbstractTaxCalculator
|
|
{
|
|
|
|
public TaxCalculator()
|
|
{
|
|
}
|
|
public override ObjectsTemplate<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 = Payroll.BO.TaxParameter.GetEmployeeSlab(
|
|
_taxParameter, value);
|
|
|
|
_employee = value;
|
|
|
|
}
|
|
}
|
|
public override TaxParameter TaxParameter
|
|
{
|
|
set
|
|
{
|
|
_taxParameter = value;
|
|
}
|
|
}
|
|
|
|
public ObjectsTemplate<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(SystemInformation.CurrentSysInfo.NextPayProcessDate);
|
|
|
|
smessage = "CalculateBonusProjection";
|
|
this.CalculateBonusProjection();
|
|
smessage = "CalculateCPF";
|
|
this.CalculateCPF();
|
|
|
|
if (_salary != null && (_salary.GradeID.Integer == 25 || _salary.GradeID.Integer == 24))
|
|
{
|
|
smessage = "Tax On Tax";
|
|
this.GetTaxonTaxNetPayable();
|
|
}
|
|
smessage = "CalculateExamtion";
|
|
this.CalculateExamtion();
|
|
smessage = "CalculateTotalIncome";
|
|
this.CalculateTotalIncome();
|
|
smessage = "CalculateInvestment";
|
|
this.CalculateInvestment();
|
|
smessage = "CalculateGrossTax";
|
|
this.CalculateGrossTax();
|
|
smessage = "CalculateNetPayable";
|
|
this.CalculateNetPayable();
|
|
smessage = "CalculateThisMonth";
|
|
this.CalculateThisMonth();
|
|
smessage = "End";
|
|
return this.CurrentYearTax;
|
|
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message + "###" + smessage);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message + "###" + smessage);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public ObjectsTemplate<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 = 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.CurrentYearTax = new ObjectsTemplate<IncomeTax>();
|
|
this.CurrentYearTax = IncomeTax.Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
if (SystemInformation.CurrentSysInfo.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 = IncomeTax.Get(this.CurrentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Net_Payable, (int)EnumIncomeTaxItemGroup.Net_Payable);
|
|
if (netPayable != null)
|
|
nTempAmount = netPayable.TotalAmount;
|
|
ntaxAmount = 0;
|
|
this.CalculateNetPayable();
|
|
|
|
//if (_ApplicableBonusParams != null)
|
|
//{s
|
|
// BonusParameter oparam = _ApplicableBonusParams.FirstOrDefault(x => x.BonusID.Integer == 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 = 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 = IncomeTax.Get(this.CurrentYearTax, _employee.ID,
|
|
EnumIncomeTaxItemGroup.Gross_Tax, (int)EnumIncomeTaxItemGroup.Gross_Tax).TotalAmount;
|
|
_onceoffAmount = 0;
|
|
if (_onceoffAmount > 0)
|
|
{
|
|
|
|
double annualIncome = this.GetAnnualIncome();
|
|
ntaxAmount = grossTax - this.GetTaxAmount(annualIncome - _onceoffAmount);
|
|
// ntaxAmount = ntaxAmount- CalculateOnceOfInvestmentAmt();
|
|
if (ntaxAmount < 0) ntaxAmount = 0;
|
|
}
|
|
|
|
IncomeTax TaxDeductitem = IncomeTax.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);
|
|
|
|
// if (_employee.GradeID.Integer == 25)
|
|
ntaxAmount = 0;
|
|
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 ObjectsTemplate<IncomeTax> UndoBonus(List<TaxRawItem> rawItems, double taxAmount, int nItemID)
|
|
{
|
|
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.CurrentYearTax = new ObjectsTemplate<IncomeTax>();
|
|
this.CurrentYearTax = IncomeTax.Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
|
|
this.UpdateRawItems2(rawItems, EnumSide.Deduct,nItemID);
|
|
this.CalculateBonusProjection();
|
|
if(nItemID==1)
|
|
{
|
|
IncomeTax pfItem = IncomeTax.Get(this.CurrentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Bonus, (int)EnumIncomeTaxItemGroup.Bonus);
|
|
pfItem.ProjectedAmount *= 2;
|
|
}
|
|
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 = oIncomeTax.GetEnumForSalaryIT(_employee.ID);
|
|
this.CurrentYearTax = new ObjectsTemplate<IncomeTax>();
|
|
this.CurrentYearTax = IncomeTax.Get(_employee.ID, datafrom);
|
|
this.CalcualteprojectMonth();
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
this.CmpProvidedHouseAndTransport(SystemInformation.CurrentSysInfo.NextPayProcessDate);
|
|
this.CalculateExamtion();
|
|
this.CalculateBonusProjection();
|
|
this.CalculateCPF();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
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)
|
|
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 ObjectsTemplate<IncomeTax> Calculate(List<TaxRawItem> rawItems, ref double ntaxAmount)
|
|
{
|
|
try
|
|
{
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = rawItems[0].Amount;
|
|
|
|
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.CurrentYearTax = new ObjectsTemplate<IncomeTax>();
|
|
this.CurrentYearTax = IncomeTax.Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
|
|
this.CalcualteprojectMonth();
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
this.CmpProvidedHouseAndTransport(SystemInformation.CurrentSysInfo.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 ObjectsTemplate<IncomeTax> CalculateSettlementTax(List<TaxRawItem> rawItems, ref double ntaxAmount, bool isNew)
|
|
{
|
|
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.CurrentYearTax = new ObjectsTemplate<IncomeTax>();
|
|
this.CurrentYearTax = IncomeTax.Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
|
|
this._projectedMonth = 0;
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
if (isNew == true) item.PreviousAmount = item.PreviousAmount + item.ThisMonthAmount;
|
|
item.ThisMonthAmount = 0;
|
|
item.ProjectedAmount = 0;
|
|
}
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
this.CmpProvidedHouseAndTransport(_employee.DiscontinueDate);
|
|
this.CalculateExamtion();
|
|
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>
|
|
/// function will return total year tax,
|
|
/// </summary>
|
|
/// <param name="rawItems"></param>
|
|
/// <param name="ntaxAmount"></param>
|
|
/// <returns></returns>
|
|
|
|
public ObjectsTemplate<IncomeTax> CalculateYearlyTax(List<TaxRawItem> rawItems, ref double ntaxAmount)
|
|
{
|
|
try
|
|
{
|
|
this.CurrentYearTax = new ObjectsTemplate<IncomeTax>();
|
|
|
|
_isActualInvestment = false;
|
|
_projectedMonth = 0;
|
|
this._onceoffAmount = 0;
|
|
|
|
this.UpdateRawItems(rawItems, EnumSide.Add);
|
|
this.CmpProvidedHouseAndTransport(SystemInformation.CurrentSysInfo.NextPayProcessDate);
|
|
this.CalculateExamtion();
|
|
this.CalculateBonusProjection();
|
|
this.CalculateCPF();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
this.CalculateThisMonth();
|
|
ntaxAmount = IncomeTax.GetAmount(this.CurrentYearTax, _employee.ID, EnumIncomeTaxItemGroup.Tax_Deducted);
|
|
return this.CurrentYearTax;
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ServiceException(ex.Message);
|
|
}
|
|
}
|
|
|
|
public ObjectsTemplate<IncomeTax> UndoCalculate(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.CurrentYearTax = new ObjectsTemplate<IncomeTax>();
|
|
this.CurrentYearTax = IncomeTax.Get(_employee.ID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
|
|
this.CalcualteprojectMonth();
|
|
//foreach (IncomeTax item in this.CurrentYearTax)
|
|
// item.ProjectedAmount = 0;
|
|
|
|
this.UpdateRawItems(rawItems, EnumSide.Deduct);
|
|
this.CmpProvidedHouseAndTransport(SystemInformation.CurrentSysInfo.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 ObjectsTemplate<IncomeTax> DoTaxYearEnd(ID naxParameterID)
|
|
{
|
|
ObjectsTemplate<IncomeTax> empTaxCertificates = new ObjectsTemplate<IncomeTax>();
|
|
|
|
try
|
|
{
|
|
// if IncomeTax.get() function not return employee order-by wise data, rest of the function will not culculate properly.
|
|
ObjectsTemplate<IncomeTax> oTaxYearly = IncomeTax.Get(EnumIncomeTaxDataFrom.ProcessTempData);
|
|
|
|
ID nCurrEmployeeid = null;
|
|
if (oTaxYearly.Count > 0) nCurrEmployeeid = oTaxYearly[0].EmployeeID;
|
|
_taxParameter = TaxParameter.Get(naxParameterID);
|
|
while (true)
|
|
{
|
|
_employee = Employee.Get(nCurrEmployeeid);
|
|
|
|
this.CurrentYearTax = IncomeTax.Get(oTaxYearly, nCurrEmployeeid);
|
|
|
|
// Initialize the current data.
|
|
//foreach (IncomeTax item in this.CurrentYearTax)
|
|
//{
|
|
// item.DataTo = EnumIncomeTaxDataFrom.ProcessedData;
|
|
// item.TotalAmount = item.PreviousAmount + item.ProjectedAmount + item.ThisMonthAmount;
|
|
// item.TaxParameterID = _taxParameter.ID;
|
|
// item.PreviousAmount = 0;
|
|
// item.ThisMonthAmount = 0;
|
|
// item.ProjectedAmount = 0;
|
|
|
|
// oTaxYearly.Remove(item); // Remove from collection
|
|
//}
|
|
|
|
_isActualInvestment = true;
|
|
this._onceoffAmount = 0;
|
|
|
|
this.CalculateExamtion();
|
|
this.CalculateTotalIncome();
|
|
this.CalculateInvestment();
|
|
this.CalculateGrossTax();
|
|
this.CalculateNetPayable();
|
|
this.CalculateYearlyRefund();
|
|
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
item.TaxParameterID = naxParameterID;
|
|
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 ObjectsTemplate<IncomeTax> DoTaxYearEndReProcess(ID nTaxParamterID, bool isMaximumInvestment)
|
|
{
|
|
ObjectsTemplate<IncomeTax> empTaxCertificates = new ObjectsTemplate<IncomeTax>();
|
|
|
|
try
|
|
{
|
|
// if IncomeTax.get() function not return employee order-by wise data, rest of the function will not culculate properly.
|
|
ObjectsTemplate<IncomeTax> oTaxYearly = IncomeTax.GetPrvYear(nTaxParamterID);
|
|
if (SystemInformation.CurrentSysInfo.TaxParamID == nTaxParamterID)
|
|
oTaxYearly = IncomeTax.GetByYear(nTaxParamterID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
else
|
|
oTaxYearly = IncomeTax.GetPrvYear(nTaxParamterID);
|
|
ID nCurrEmployeeid = null;
|
|
if (oTaxYearly.Count > 0) nCurrEmployeeid = oTaxYearly[0].EmployeeID;
|
|
_taxParameter = TaxParameter.Get(nTaxParamterID);
|
|
while (true)
|
|
{
|
|
_employee = Employee.Get(nCurrEmployeeid);
|
|
|
|
this.CurrentYearTax = IncomeTax.Get(oTaxYearly, nCurrEmployeeid);
|
|
|
|
// Initialize the current data.
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
oTaxYearly.Remove(item); // Remove from collection
|
|
}
|
|
|
|
_isActualInvestment = !isMaximumInvestment;
|
|
|
|
//this.CalculateExamtionPrev();
|
|
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 ObjectsTemplate<IncomeTax> DoTaxYearEndReProcess(ID nTaxParamterID, bool isMaximumInvestment, Employee employee, ObjectsTemplate<IncomeTax> oTaxYearly45656)
|
|
{
|
|
ObjectsTemplate<IncomeTax> empTaxCertificates = new ObjectsTemplate<IncomeTax>();
|
|
|
|
try
|
|
{
|
|
_employee = employee;
|
|
// if IncomeTax.get() function not return employee order-by wise data, rest of the function will not culculate properly.
|
|
ObjectsTemplate<IncomeTax> oTaxYearly = IncomeTax.GetPrvYear(nTaxParamterID,_employee.ID);
|
|
//if (SystemInformation.CurrentSysInfo.TaxParamID == nTaxParamterID)
|
|
// oTaxYearly = IncomeTax.GetByYear(nTaxParamterID, EnumIncomeTaxDataFrom.ProcessTempData);
|
|
//else
|
|
// oTaxYearly = IncomeTax.GetPrvYear(nTaxParamterID);
|
|
ID nCurrEmployeeid = null;
|
|
//if (oTaxYearly.Count > 0)
|
|
nCurrEmployeeid = _employee.ID;
|
|
_taxParameter = TaxParameter.Get(nTaxParamterID);
|
|
//while (true)
|
|
//{
|
|
//_employee = Employee.Get(nEmployeeID);
|
|
|
|
this.CurrentYearTax = IncomeTax.Get(oTaxYearly, nCurrEmployeeid);
|
|
|
|
// Initialize the current data.
|
|
foreach (IncomeTax item in this.CurrentYearTax)
|
|
{
|
|
oTaxYearly.Remove(item); // Remove from collection
|
|
}
|
|
|
|
_isActualInvestment = !isMaximumInvestment;
|
|
|
|
//this.CalculateExamtionPrev();
|
|
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 class TaxProcess
|
|
{
|
|
|
|
public void CalculateTax()
|
|
{
|
|
|
|
}
|
|
|
|
#region ISalaryTax Members
|
|
|
|
|
|
public void Calculate()
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
|
|
}
|