1308 lines
46 KiB
C#
1308 lines
46 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;
|
|
|
|
namespace Payroll.BO
|
|
{
|
|
#region ADParameter
|
|
|
|
[Serializable]
|
|
public class ADParameter : AuditTrailBase
|
|
{
|
|
#region Cache Store
|
|
|
|
private static Cache _cache = new Cache(typeof(ADParameter));
|
|
|
|
#endregion
|
|
|
|
#region Constructor
|
|
|
|
public ADParameter()
|
|
{
|
|
_allowDeductID = null;
|
|
_isForConfirmOnly = false;
|
|
_flatAmount = 0;
|
|
_percentOfBasic = 0;
|
|
_percentOfGross = 0;
|
|
_minAmount = 0;
|
|
_maxAmount = 0;
|
|
_isCurrentlyActive = false;
|
|
_taxablePercentage = 100;
|
|
_isTaxable = true;
|
|
_isTaxProjection = true;
|
|
_isDependsOnAttendance = false;
|
|
_isDependsOnOTHour = false;
|
|
_isWithException = false;
|
|
_periodicity = EnumPeriodicity.Monthly;
|
|
_allowOrDeductType = EnumAllowOrDeduct.Allowance;
|
|
_gender = EnumGender.None;
|
|
_allowanceDeduction = null;
|
|
_ISDEPENDSONSPECIALHOUR = false;
|
|
_entitleType = EnumEntitleType.Grade;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Internal Class
|
|
[Serializable]
|
|
public class ADParameterGrade : AuditTrailBase
|
|
{
|
|
#region Cache Store
|
|
|
|
private static Cache _cache = new Cache(typeof(ADParameterGrade));
|
|
|
|
#endregion
|
|
|
|
#region Constructor
|
|
|
|
public ADParameterGrade()
|
|
{
|
|
_aDParameterID = null;
|
|
_gradeID = null;
|
|
_allowDeductID = null;
|
|
_garde = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
#region ADParameterID : ID
|
|
|
|
private ID _aDParameterID;
|
|
public ID ADParameterID
|
|
{
|
|
get { return _aDParameterID; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<ID>("ADParameterID", _aDParameterID, value);
|
|
_aDParameterID = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GradeID : ID
|
|
|
|
private ID _gradeID;
|
|
public ID GradeID
|
|
{
|
|
get { return _gradeID; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<ID>("GradeID", _gradeID, value);
|
|
_gradeID = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AllowDeductID : ID
|
|
|
|
private ID _allowDeductID;
|
|
public ID AllowDeductID
|
|
{
|
|
get { return _allowDeductID; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<ID>("AllowDeductID", _allowDeductID, value);
|
|
_allowDeductID = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region garde : Grade
|
|
|
|
private Grade _garde;
|
|
public Grade Garde
|
|
{
|
|
get
|
|
{
|
|
if (_gradeID.Integer > 0 && _garde == null)
|
|
{
|
|
_garde = Grade.Get(_gradeID);
|
|
}
|
|
return this._garde;
|
|
}
|
|
set
|
|
{
|
|
_garde = value;
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
#region AllowDeductID : ID
|
|
|
|
private ID _allowDeductID;
|
|
public ID AllowDeductID
|
|
{
|
|
get { return _allowDeductID; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<ID>("AllowDeductID", _allowDeductID, value);
|
|
_allowDeductID = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region isForConfirmOnly : bool
|
|
|
|
private bool _isForConfirmOnly = false;
|
|
public bool IsForConfirmOnly
|
|
{
|
|
get { return _isForConfirmOnly; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<bool>("isForConfirmOnly", _isForConfirmOnly, value);
|
|
_isForConfirmOnly = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region isFractionateApplicable : bool
|
|
|
|
private bool _isFractionateApplicable = false;
|
|
public bool IsFractionateApplicable
|
|
{
|
|
get { return _isFractionateApplicable; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<bool>("isFractionateApplicable", _isFractionateApplicable, value);
|
|
_isFractionateApplicable = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region flatAmount : double
|
|
|
|
private double _flatAmount=0;
|
|
public double FlatAmount
|
|
{
|
|
get { return _flatAmount; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<double>("flatAmount", _flatAmount, value);
|
|
_flatAmount = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region percentOfBasic : double
|
|
|
|
private double _percentOfBasic=0;
|
|
public double PercentOfBasic
|
|
{
|
|
get { return _percentOfBasic; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<double>("percentOfBasic", _percentOfBasic, value);
|
|
_percentOfBasic = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region percentOfEarnedBasic : double
|
|
|
|
private double _percentOfEarnedBasic=0;
|
|
public double PercentOfEarnedBasic
|
|
{
|
|
get { return _percentOfEarnedBasic; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<double>("percentOfEarnedBasic", _percentOfEarnedBasic, value);
|
|
_percentOfEarnedBasic = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region percentOfGross : double
|
|
|
|
private double _percentOfGross=0;
|
|
public double PercentOfGross
|
|
{
|
|
get { return _percentOfGross; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<double>("percentOfGross", _percentOfGross, value);
|
|
_percentOfGross = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region minAmount : double
|
|
|
|
private double _minAmount=0;
|
|
public double MinAmount
|
|
{
|
|
get { return _minAmount; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<double>("minAmount", _minAmount, value);
|
|
_minAmount = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region maxAmount : double
|
|
|
|
private double _maxAmount=0;
|
|
public double MaxAmount
|
|
{
|
|
get { return _maxAmount; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<double>("maxAmount", _maxAmount, value);
|
|
_maxAmount = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region isCurrentlyActive : bool
|
|
|
|
private bool _isCurrentlyActive;
|
|
public bool IsCurrentlyActive
|
|
{
|
|
get { return _isCurrentlyActive; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<bool>("isCurrentlyActive", _isCurrentlyActive, value);
|
|
_isCurrentlyActive = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region taxablePercentage : double
|
|
|
|
private double _taxablePercentage=100;
|
|
public double TaxablePercentage
|
|
{
|
|
get { return _taxablePercentage; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<double>("taxablePercentage", _taxablePercentage, value);
|
|
_taxablePercentage = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region isTaxable : bool
|
|
|
|
private bool _isTaxable;
|
|
public bool IsTaxable
|
|
{
|
|
get { return _isTaxable; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<bool>("isTaxable", _isTaxable, value);
|
|
_isTaxable = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region isFlatAmount : bool
|
|
|
|
public bool IsFlatAmount
|
|
{
|
|
get
|
|
{
|
|
if (_flatAmount != 0)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region isTaxProjection : bool
|
|
|
|
private bool _isTaxProjection;
|
|
public bool IsTaxProjection
|
|
{
|
|
get { return _isTaxProjection; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<bool>("isTaxProjection", _isTaxProjection, value);
|
|
_isTaxProjection = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region isDependsOnAttendance : bool
|
|
|
|
private bool _isDependsOnAttendance;
|
|
public bool IsDependsOnAttendance
|
|
{
|
|
get { return _isDependsOnAttendance; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<bool>("isDependsOnAttendance", _isDependsOnAttendance, value);
|
|
_isDependsOnAttendance = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region isDependsOnOTlHour : bool
|
|
|
|
private bool _ISDEPENDSONSPECIALHOUR;
|
|
public bool ISDEPENDSONSPECIALHOUR
|
|
{
|
|
get { return _ISDEPENDSONSPECIALHOUR; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<bool>("ISDEPENDSONSPECIALHOUR", _ISDEPENDSONSPECIALHOUR, value);
|
|
_ISDEPENDSONSPECIALHOUR = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region isDependsOnOTlHour : bool
|
|
|
|
private bool _isDependsOnOTHour;
|
|
public bool IsDependsOnOTHour
|
|
{
|
|
get { return _isDependsOnOTHour; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<bool>("isDependsOnOTlHour", _isDependsOnOTHour, value);
|
|
_isDependsOnOTHour = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region isWithException : bool
|
|
|
|
private bool _isWithException;
|
|
public bool IsWithException
|
|
{
|
|
get { return _isWithException; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<bool>("isWithException", _isWithException, value);
|
|
_isWithException = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region periodicity : EnumPeriodicity
|
|
|
|
private EnumPeriodicity _periodicity;
|
|
public EnumPeriodicity Periodicity
|
|
{
|
|
get { return _periodicity; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<short>("periodicity",(short) _periodicity, (short)value);
|
|
_periodicity = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region periodicity : EnumPeriodicity
|
|
|
|
private EnumEntitleType _entitleType;
|
|
public EnumEntitleType EntitleType
|
|
{
|
|
get { return _entitleType; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<short>("entitletype", (short)_entitleType, (short)value);
|
|
_entitleType = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region allowOrDeductType : EnumADType
|
|
|
|
private EnumAllowOrDeduct _allowOrDeductType;
|
|
public EnumAllowOrDeduct AllowOrDeductType
|
|
{
|
|
get { return _allowOrDeductType; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<short>("allowOrDeductType",(short) _allowOrDeductType,(short) value);
|
|
_allowOrDeductType = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region gender : EnumGender
|
|
|
|
private EnumGender _gender;
|
|
public EnumGender Gender
|
|
{
|
|
get { return _gender; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<short>("gender",(short) _gender, (short)value);
|
|
_gender = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region allowanceDeduction : AllowanceDeduction
|
|
|
|
private AllowanceDeduction _allowanceDeduction;
|
|
public AllowanceDeduction AllowanceDeduction
|
|
{
|
|
get
|
|
{
|
|
if (_allowDeductID.Integer > 0 && _allowanceDeduction == null)
|
|
{
|
|
_allowanceDeduction = new AllowanceDeduction();
|
|
_allowanceDeduction = AllowanceDeduction.Get(_allowDeductID);
|
|
}
|
|
return this._allowanceDeduction;
|
|
}
|
|
set
|
|
{
|
|
_allowanceDeduction = value;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region ADParamEmployee : ADParameterEmployee
|
|
|
|
private ObjectsTemplate<ADParameterEmployee> _ADParameterEmployee = null;
|
|
public ObjectsTemplate<ADParameterEmployee> ADParameterEmployees
|
|
{
|
|
get
|
|
{
|
|
if (_ADParameterEmployee == null && !this.ID.IsUnassigned && this.ID.Integer > 0)
|
|
{
|
|
_ADParameterEmployee = ADParameterEmployee.GetbyParameter(this.ID);
|
|
}
|
|
return this._ADParameterEmployee;
|
|
}
|
|
set
|
|
{
|
|
_ADParameterEmployee = value;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Exception : ADParameterEmployee
|
|
|
|
private ObjectsTemplate<ADParameterEmployee> _Exception = null;
|
|
public ObjectsTemplate<ADParameterEmployee> Exception
|
|
{
|
|
get
|
|
{
|
|
if (_Exception == null && !this.ID.IsUnassigned && this.ID.Integer > 0)
|
|
{
|
|
_Exception = ADParameterEmployee.GetbyParameter(this.ID,EnumADEmpType.Exception);
|
|
}
|
|
return this._Exception;
|
|
}
|
|
set
|
|
{
|
|
this._Exception = value;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region NotApplicable : ADParameterEmployee
|
|
|
|
private ObjectsTemplate<ADParameterEmployee> _NotApplicable = null;
|
|
public ObjectsTemplate<ADParameterEmployee> NotApplicable
|
|
{
|
|
get
|
|
{
|
|
if (_NotApplicable == null && !this.ID.IsUnassigned && this.ID.Integer > 0)
|
|
{
|
|
_NotApplicable = ADParameterEmployee.GetbyParameter(this.ID, EnumADEmpType.NotApplicable);
|
|
}
|
|
return this._NotApplicable;
|
|
}
|
|
set
|
|
{
|
|
this._NotApplicable = value;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region ADParamGrade : ADParameterGrade
|
|
|
|
private ObjectsTemplate<ADParameter.ADParameterGrade> _ADParameterGrades = null;
|
|
public ObjectsTemplate<ADParameter.ADParameterGrade> ADParameterGrades
|
|
{
|
|
get
|
|
{
|
|
if (_ADParameterGrades == null && !this.ID.IsUnassigned && this.ID.Integer > 0)
|
|
{
|
|
_ADParameterGrades = ADParameter.GetGrades(this.ID);
|
|
}
|
|
return this._ADParameterGrades;
|
|
}
|
|
set
|
|
{
|
|
_ADParameterGrades = value;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Service Factory IADParameterService : IADParameterService
|
|
|
|
internal static IADParameterService Service
|
|
{
|
|
get { return Services.Factory.CreateService<IADParameterService>(typeof(IADParameterService)); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Functions
|
|
|
|
public static ADParameter Get(ID nID)
|
|
{
|
|
ADParameter oADParameter = null;
|
|
#region Cache Header
|
|
oADParameter = (ADParameter)_cache["Get", nID];
|
|
if (oADParameter != null)
|
|
return oADParameter;
|
|
#endregion
|
|
oADParameter = ADParameter.Service.Get(nID, SystemInformation.CurrentSysInfo.PayrollTypeID);
|
|
#region Cache Footer
|
|
_cache.Add(oADParameter, "Get", nID);
|
|
#endregion
|
|
return oADParameter;
|
|
}
|
|
public static List<ADParameter> GetApplicableParameters(Employee employee,
|
|
ID graId, ObjectsTemplate<ADParameter> parameters)
|
|
{
|
|
List<ADParameter> applicableParams = parameters.FindAll(delegate(ADParameter param) { return IsApplicable(param, graId, employee) ;});
|
|
|
|
return applicableParams;
|
|
}
|
|
|
|
//public static ADParameter GetApplicableParameter(Employee employee,
|
|
// ID graId, ObjectsTemplate<ADParameter> parameters)
|
|
//{
|
|
// foreach (ADParameter item in parameters)
|
|
// {
|
|
// if (IsApplicable(item, graId, employee) == true)
|
|
// return item;
|
|
// }
|
|
// return null;
|
|
//}
|
|
|
|
public static ADParameter GetApplicableParameter(Employee employee,
|
|
ID graId, ObjectsTemplate<ADParameter> parameters, ID allowdeductID)
|
|
{
|
|
foreach (ADParameter item in parameters)
|
|
{
|
|
if (item.AllowDeductID == allowdeductID)
|
|
{
|
|
if (IsApplicable(item, graId, employee) == true)
|
|
return item;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static bool IsApplicable(ADParameter param, ID graid, Employee employee)
|
|
{
|
|
bool isApplicable = false;
|
|
|
|
foreach (ADParameterGrade adgrade in param.ADParameterGrades)
|
|
{
|
|
if (adgrade.GradeID.Integer == graid.Integer)
|
|
{
|
|
isApplicable = true;
|
|
}
|
|
}
|
|
if (!isApplicable) return false;
|
|
|
|
if (param.Gender != EnumGender.None
|
|
&& param.Gender != employee.Gender)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (param.IsForConfirmOnly && !employee.IsConfirmed)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public double CalculateAmount(Employee oEmp)
|
|
{
|
|
double amount = 0;
|
|
|
|
if (this.PercentOfBasic > 0)
|
|
{
|
|
amount = this.FlatAmount + (this.PercentOfBasic * oEmp.BasicSalary)/100;
|
|
}
|
|
else if (this.PercentOfGross > 0)
|
|
{
|
|
amount = this.FlatAmount + (this.PercentOfGross * oEmp.GrossSalary)/100;
|
|
}
|
|
else
|
|
{
|
|
amount = this.FlatAmount;
|
|
}
|
|
return amount;
|
|
}
|
|
|
|
public static ObjectsTemplate<ADParameter> Get(EnumStatus status)
|
|
{
|
|
#region Cache Header
|
|
|
|
ObjectsTemplate<ADParameter> aDParameters = _cache["Get"] as ObjectsTemplate<ADParameter>;
|
|
if (aDParameters != null)
|
|
return aDParameters;
|
|
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
aDParameters = Service.GetByPayrolltypeid(status, Payroll.BO.SystemInformation.CurrentSysInfo.PayrollTypeID);
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
|
|
#region Cache Footer
|
|
|
|
_cache.Add(aDParameters, "Get",status);
|
|
|
|
#endregion
|
|
|
|
return aDParameters;
|
|
}
|
|
public static ObjectsTemplate<ADParameter> GetWithDetail(EnumStatus status)
|
|
{
|
|
#region Cache Header
|
|
|
|
ObjectsTemplate<ADParameter> aDParameters = _cache["Get"] as ObjectsTemplate<ADParameter>;
|
|
if (aDParameters != null)
|
|
return aDParameters;
|
|
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
aDParameters = Service.GetWithDetail(status, Payroll.BO.SystemInformation.CurrentSysInfo.PayrollTypeID);
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
|
|
#region Cache Footer
|
|
|
|
_cache.Add(aDParameters, "Get", status);
|
|
|
|
#endregion
|
|
|
|
return aDParameters;
|
|
}
|
|
|
|
|
|
public static ObjectsTemplate<ADParameter> Get(EnumStatus status, EnumAllowOrDeduct type)
|
|
{
|
|
#region Cache Header
|
|
|
|
ObjectsTemplate<ADParameter> aDParameters = _cache["Get", type] as ObjectsTemplate<ADParameter>;
|
|
if (aDParameters != null)
|
|
return aDParameters;
|
|
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
aDParameters = Service.Get(status, type, SystemInformation.CurrentSysInfo.PayrollTypeID);
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
|
|
#region Cache Footer
|
|
|
|
_cache.Add(aDParameters, "Get", status, type);
|
|
|
|
#endregion
|
|
|
|
return aDParameters;
|
|
}
|
|
|
|
public static ObjectsTemplate<ADParameter> Get(EnumStatus status, ID nAllowDeducID)
|
|
{
|
|
#region Cache Header
|
|
|
|
ObjectsTemplate<ADParameter> aDParameters = _cache["Get", nAllowDeducID] as ObjectsTemplate<ADParameter>;
|
|
if (aDParameters != null)
|
|
return aDParameters;
|
|
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
aDParameters = Service.Get(status, nAllowDeducID);
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
|
|
#region Cache Footer
|
|
|
|
_cache.Add(aDParameters, "Get", status, nAllowDeducID);
|
|
|
|
#endregion
|
|
|
|
return aDParameters;
|
|
}
|
|
|
|
public static ObjectsTemplate<ADParameter> Get(ID gradeID, EnumEntitleType nADEmpType, EnumAllowOrDeduct nType)
|
|
{
|
|
#region Cache Header
|
|
|
|
ObjectsTemplate<ADParameter> aDParameters = _cache["Get", gradeID, nADEmpType, nType] as ObjectsTemplate<ADParameter>;
|
|
if (aDParameters != null)
|
|
return aDParameters;
|
|
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
aDParameters = Service.Get(gradeID, nADEmpType, nType, SystemInformation.CurrentSysInfo.PayrollTypeID);
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
|
|
#region Cache Footer
|
|
|
|
_cache.Add(aDParameters, "Get", gradeID, nADEmpType, nType);
|
|
|
|
#endregion
|
|
|
|
return aDParameters;
|
|
}
|
|
|
|
public static ADParameter GetADParamByGradeAndAD(ID gradeID, ID nAllowdeducID)
|
|
{
|
|
#region Cache Header
|
|
|
|
ADParameter aDParameter = null;
|
|
|
|
try
|
|
{
|
|
aDParameter = Service.GetADParamByGradeAndAD(gradeID, nAllowdeducID);
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
|
|
return aDParameter;
|
|
}
|
|
public static ObjectsTemplate<ADParameter.ADParameterGrade> GetGrades(ID adID)
|
|
{
|
|
#region Cache Header
|
|
|
|
ObjectsTemplate<ADParameter.ADParameterGrade> aDParameterGrades = _cache["Get", adID] as ObjectsTemplate<ADParameter.ADParameterGrade>;
|
|
if (aDParameterGrades != null)
|
|
return aDParameterGrades;
|
|
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
aDParameterGrades = Service.GetGrades(adID);
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
|
|
#region Cache Footer
|
|
|
|
_cache.Add(aDParameterGrades, "Get", adID);
|
|
|
|
#endregion
|
|
|
|
return aDParameterGrades;
|
|
}
|
|
|
|
public ID Save()
|
|
{
|
|
base.SetAuditTrailProperties();
|
|
return ADParameter.Service.Save(this,SystemInformation.CurrentSysInfo.PayrollTypeID);
|
|
}
|
|
|
|
public void Delete()
|
|
{
|
|
ADParameter.Service.Delete(ID);
|
|
}
|
|
|
|
public void ChangeStatus(EnumStatus enumStatus)
|
|
{
|
|
ADParameter.Service.ChangeStatus(this.ID,enumStatus);
|
|
}
|
|
private ObjectsTemplate<ADParameter> GetParametes(Employee employee,
|
|
ID gradeId, ObjectsTemplate<ADParameter> allparameters)
|
|
{
|
|
ObjectsTemplate<ADParameter> parameters = new ObjectsTemplate<ADParameter>();
|
|
return parameters;
|
|
}
|
|
public static void ApplicableParameters(Employee emlpoyee,
|
|
SalaryMonthly salary, ObjectsTemplate<ADParameter> allAdparameters)
|
|
{
|
|
foreach (EmployeeGradeSalary gs in salary.GradeSalaries)
|
|
{
|
|
List<ADParameter> lparameter = ADParameter.GetApplicableParameters(emlpoyee, gs.GradeID, allAdparameters);
|
|
gs.ADParameters = new ObjectsTemplate<ADParameter>();
|
|
foreach (ADParameter item in lparameter)
|
|
gs.ADParameters.Add(item);
|
|
}
|
|
|
|
foreach (EmployeeGradeSalary gs in salary.ArrearGradeSalaries)
|
|
{
|
|
List<ADParameter> alparameter = ADParameter.GetApplicableParameters(emlpoyee, gs.GradeID, allAdparameters);
|
|
gs.ADParameters = new ObjectsTemplate<ADParameter>();
|
|
foreach (ADParameter item in alparameter)
|
|
gs.ADParameters.Add(item);
|
|
}
|
|
|
|
foreach (EmployeeGradeSalary gs in salary.ArrearPaidGradeSalaries)
|
|
{
|
|
List<ADParameter> aplparameter = ADParameter.GetApplicableParameters(emlpoyee, gs.GradeID, allAdparameters);
|
|
gs.ADParameters = new ObjectsTemplate<ADParameter>();
|
|
foreach (ADParameter item in aplparameter)
|
|
gs.ADParameters.Add(item);
|
|
}
|
|
|
|
}
|
|
|
|
public double GetGradeDefinedAmount(Employee employee, double basicSalary,
|
|
double grossSalary)
|
|
{
|
|
ADParameterEmployee adEmp = null;
|
|
double nAmount = 0.0;
|
|
switch (this.EntitleType)
|
|
{
|
|
case EnumEntitleType.Grade:
|
|
if (this.PercentOfBasic > 0)
|
|
nAmount = basicSalary * this.PercentOfBasic / 100.0 + this.FlatAmount;
|
|
else if (this.PercentOfGross > 0)
|
|
nAmount = grossSalary * this.PercentOfGross / 100.0 + this.FlatAmount;
|
|
else
|
|
nAmount = this.FlatAmount;
|
|
|
|
if (this.NotApplicable.Exists(delegate(ADParameterEmployee adEmployee) { return adEmployee.EmployeeID.Integer == employee.ID.Integer; }))
|
|
{
|
|
nAmount = 0;
|
|
}
|
|
else
|
|
{
|
|
adEmp = this.Exception.Find(delegate(ADParameterEmployee adEmployee) { return adEmployee.EmployeeID.Integer == employee.ID.Integer; });
|
|
if (adEmp != null)
|
|
{
|
|
switch (adEmp.ValueType)
|
|
{
|
|
case EnumValueType.Amount:
|
|
nAmount = adEmp.MonthlyAmount;
|
|
break;
|
|
case EnumValueType.Other:
|
|
if (this.PercentOfBasic > 0)
|
|
nAmount = basicSalary * adEmp.MonthlyAmount / 100.0 + this.FlatAmount;
|
|
else if (this.PercentOfGross > 0)
|
|
nAmount = grossSalary * adEmp.MonthlyAmount / 100.0 + this.FlatAmount;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case EnumEntitleType.Individual:
|
|
throw new ServiceException("You have choosed the wrong overloaded function to calculate"
|
|
+ " Individual Allowance" + " Employee:(" + employee.EmployeeNo + ")" + employee.Name + "; Item Name:" + this.AllowanceDeduction.Name);
|
|
}
|
|
if (this.MinAmount != 0 || this.MaxAmount != 0)
|
|
{
|
|
if (nAmount < this.MinAmount)
|
|
{
|
|
nAmount = this.MinAmount;
|
|
}
|
|
if (nAmount > this.MaxAmount)
|
|
{
|
|
nAmount = this.MaxAmount;
|
|
}
|
|
}
|
|
return nAmount;
|
|
}
|
|
public double GetGradeDefinedAmount(Employee employee, double basicSalary,
|
|
double grossSalary,EmployeeGradeSalary oEmpGradeSalary)
|
|
{
|
|
ADParameterEmployee adEmp = null;
|
|
double nAmount = 0.0;
|
|
switch (this.EntitleType)
|
|
{
|
|
case EnumEntitleType.Grade:
|
|
if (this.PercentOfBasic > 0)
|
|
nAmount = nAmount + this.FlatAmount * oEmpGradeSalary.FractionofFromTo + basicSalary * this.PercentOfBasic / 100.0;
|
|
//nAmount = basicSalary * this.PercentOfBasic / 100.0;// + this.FlatAmount;
|
|
else if (this.PercentOfGross > 0)
|
|
nAmount = nAmount + this.FlatAmount * oEmpGradeSalary.FractionofFromTo + grossSalary * this.PercentOfGross / 100.0;
|
|
//nAmount = grossSalary * this.PercentOfGross / 100.0;// + this.FlatAmount;
|
|
else
|
|
nAmount = this.FlatAmount * oEmpGradeSalary.FractionofFromTo;
|
|
|
|
if (this.NotApplicable.Exists(delegate(ADParameterEmployee adEmployee) { return adEmployee.EmployeeID.Integer == employee.ID.Integer; }))
|
|
{
|
|
nAmount = 0;
|
|
}
|
|
else
|
|
{
|
|
adEmp = this.Exception.Find(delegate(ADParameterEmployee adEmployee) { return adEmployee.EmployeeID.Integer == employee.ID.Integer; });
|
|
if (adEmp != null)
|
|
{
|
|
switch (adEmp.ValueType)
|
|
{
|
|
case EnumValueType.Amount:
|
|
nAmount = adEmp.MonthlyAmount * oEmpGradeSalary.FractionofFromTo;
|
|
break;
|
|
case EnumValueType.Other:
|
|
if (this.PercentOfBasic > 0 || adEmp.MonthlyAmount>0)
|
|
nAmount = basicSalary * adEmp.MonthlyAmount / 100.0;//* oEmpGradeSalary.FractionofFromTo; //+ this.FlatAmount;
|
|
else if (this.PercentOfGross > 0 || adEmp.MonthlyAmount>0)
|
|
nAmount = grossSalary * adEmp.MonthlyAmount / 100.0;//* oEmpGradeSalary.FractionofFromTo; //+ this.FlatAmount;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case EnumEntitleType.Individual:
|
|
throw new ServiceException("You have choosed the wrong overloaded function to calculate"
|
|
+ " Individual Allowance" + " Employee:(" + employee.EmployeeNo + ")" + employee.Name +"; Item Name:" + this.AllowanceDeduction.Name);
|
|
}
|
|
if (this.MinAmount != 0 || this.MaxAmount != 0)
|
|
{
|
|
if (nAmount < this.MinAmount)
|
|
{
|
|
nAmount = this.MinAmount;
|
|
}
|
|
if (nAmount > this.MaxAmount)
|
|
{
|
|
nAmount = this.MaxAmount;
|
|
}
|
|
}
|
|
return nAmount;
|
|
}
|
|
public double GetGradeDefinedAmountTrainee(Employee employee, double basicSalary,
|
|
double grossSalary, EmployeeGradeSalary oEmpGradeSalary)
|
|
{
|
|
ADParameterEmployee adEmp = null;
|
|
double nAmount = 0.0;
|
|
oEmpGradeSalary.FractionofFromTo = 1;
|
|
switch (this.EntitleType)
|
|
{
|
|
case EnumEntitleType.Grade:
|
|
if (this.PercentOfBasic > 0)
|
|
nAmount = nAmount + this.FlatAmount * oEmpGradeSalary.FractionofFromTo + basicSalary * this.PercentOfBasic / 100.0;
|
|
//nAmount = basicSalary * this.PercentOfBasic / 100.0;// + this.FlatAmount;
|
|
else if (this.PercentOfGross > 0)
|
|
nAmount = nAmount + this.FlatAmount * oEmpGradeSalary.FractionofFromTo + grossSalary * this.PercentOfGross / 100.0;
|
|
//nAmount = grossSalary * this.PercentOfGross / 100.0;// + this.FlatAmount;
|
|
else
|
|
nAmount = this.FlatAmount * oEmpGradeSalary.FractionofFromTo;
|
|
|
|
if (this.NotApplicable.Exists(delegate(ADParameterEmployee adEmployee) { return adEmployee.EmployeeID.Integer == employee.ID.Integer; }))
|
|
{
|
|
nAmount = 0;
|
|
}
|
|
else
|
|
{
|
|
adEmp = this.Exception.Find(delegate(ADParameterEmployee adEmployee) { return adEmployee.EmployeeID.Integer == employee.ID.Integer; });
|
|
if (adEmp != null)
|
|
{
|
|
switch (adEmp.ValueType)
|
|
{
|
|
case EnumValueType.Amount:
|
|
nAmount = adEmp.MonthlyAmount * oEmpGradeSalary.FractionofFromTo;
|
|
break;
|
|
case EnumValueType.Other:
|
|
if (this.PercentOfBasic > 0 || adEmp.MonthlyAmount > 0)
|
|
nAmount = basicSalary * adEmp.MonthlyAmount / 100.0;//* oEmpGradeSalary.FractionofFromTo; //+ this.FlatAmount;
|
|
else if (this.PercentOfGross > 0 || adEmp.MonthlyAmount > 0)
|
|
nAmount = grossSalary * adEmp.MonthlyAmount / 100.0;//* oEmpGradeSalary.FractionofFromTo; //+ this.FlatAmount;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case EnumEntitleType.Individual:
|
|
throw new ServiceException("You have choosed the wrong overloaded function to calculate"
|
|
+ " Individual Allowance" + " Employee:(" + employee.EmployeeNo + ")" + employee.Name + "; Item Name:" + this.AllowanceDeduction.Name);
|
|
}
|
|
if (this.MinAmount != 0 || this.MaxAmount != 0)
|
|
{
|
|
if (nAmount < this.MinAmount)
|
|
{
|
|
nAmount = this.MinAmount;
|
|
}
|
|
if (nAmount > this.MaxAmount)
|
|
{
|
|
nAmount = this.MaxAmount;
|
|
}
|
|
}
|
|
return nAmount;
|
|
}
|
|
public double GetIndividualAmount(Employee employee, DateTime fortheMonth,
|
|
ADParameterEmployee ademployee, double grossSalary, double basicSalary)
|
|
{
|
|
double nAmount = 0.0;
|
|
switch (this.EntitleType)
|
|
{
|
|
case EnumEntitleType.Grade:
|
|
throw new ServiceException("You have choosed the wrong overloaded function to calculate"
|
|
+ " Grade defined Allowance" + " Employee:(" + employee.EmployeeNo + ")" + employee.Name + "; Item Name:" + this.AllowanceDeduction.Name);
|
|
case EnumEntitleType.Individual:
|
|
|
|
if (this.IsDependsOnAttendance)
|
|
{
|
|
nAmount = this.FlatAmount * ademployee.MonthlyAmount;
|
|
}
|
|
else if (ademployee.Arreartype == EnumArrearType.NotPresent)
|
|
{
|
|
DateTime fromDate = GlobalFunctions.FirstDateOfMonth(SystemInformation.CurrentSysInfo.NextPayProcessDate);
|
|
DateTime toDate = SystemInformation.CurrentSysInfo.NextPayProcessDate;
|
|
|
|
|
|
if (ademployee.FormDate < GlobalFunctions.FirstDateOfMonth(fortheMonth))
|
|
fromDate = GlobalFunctions.FirstDateOfMonth(fortheMonth);
|
|
else fromDate = ademployee.FormDate;
|
|
if (ademployee.TillDate == null || ademployee.TillDate == DateTime.MinValue)
|
|
toDate = GlobalFunctions.LastDateOfMonth(fortheMonth);
|
|
else toDate = (DateTime)ademployee.TillDate;
|
|
|
|
if (toDate > GlobalFunctions.LastDateOfMonth(fortheMonth))
|
|
toDate = GlobalFunctions.LastDateOfMonth(fortheMonth);
|
|
|
|
if (this.Periodicity != EnumPeriodicity.OneOff)
|
|
if (employee.EndOfContractDate != null || employee.EndOfContractDate != DateTime.MinValue)
|
|
if (employee.EndOfContractDate < toDate)
|
|
toDate = (DateTime)employee.EndOfContractDate;
|
|
if (ademployee.ValueType == EnumValueType.Other)
|
|
{
|
|
//while percent of basic then not required to do fractionate of date basis
|
|
//if (this.PercentOfBasic > 0 || ademployee.MonthlyAmount >0 )
|
|
// nAmount = (basicSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(ademployee.FormDate, toDate);
|
|
//else if (this.PercentOfGross > 0 || ademployee.MonthlyAmount > 0)
|
|
// nAmount = (grossSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(ademployee.FormDate, toDate);
|
|
|
|
if (this.PercentOfBasic > 0 || ademployee.MonthlyAmount > 0)
|
|
nAmount = (employee.BasicSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(fromDate, toDate);
|
|
else if (this.PercentOfGross > 0 || ademployee.MonthlyAmount > 0)
|
|
nAmount = (employee.GrossSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(fromDate, toDate);
|
|
|
|
}
|
|
else nAmount = ademployee.MonthlyAmount * GlobalFunctions.GetFraction(fromDate, toDate);
|
|
}
|
|
else if (ademployee.Arreartype == EnumArrearType.ToCalculate)
|
|
{
|
|
if (ademployee.ValueType == EnumValueType.Other)
|
|
{
|
|
if (this.PercentOfBasic > 0 || ademployee.MonthlyAmount > 0)
|
|
nAmount = (employee.BasicSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(ademployee.FormDate, (DateTime)ademployee.TillDate);
|
|
else if (this.PercentOfGross > 0 || ademployee.MonthlyAmount > 0)
|
|
nAmount = (employee.GrossSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(ademployee.FormDate, (DateTime)ademployee.TillDate);
|
|
}
|
|
else nAmount = ademployee.MonthlyAmount *
|
|
GlobalFunctions.GetFraction(ademployee.FormDate, (DateTime)ademployee.TillDate);
|
|
}
|
|
|
|
break;
|
|
}
|
|
return nAmount;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public double GetIndividualAmount(Employee employee, DateTime fortheMonth,
|
|
ADParameterEmployee ademployee, double grossSalary, double basicSalary,SalaryMonthly salary)
|
|
{
|
|
double nAmount = 0.0;
|
|
switch (this.EntitleType)
|
|
{
|
|
case EnumEntitleType.Grade:
|
|
throw new ServiceException("You have choosed the wrong overloaded function to calculate"
|
|
+ " Grade defined Allowance" + " Employee:(" + employee.EmployeeNo + ")" + employee.Name + "; Item Name:" + this.AllowanceDeduction.Name);
|
|
case EnumEntitleType.Individual:
|
|
|
|
if (this.IsDependsOnAttendance)
|
|
{
|
|
nAmount = this.FlatAmount * ademployee.MonthlyAmount;
|
|
}
|
|
else if (ademployee.Arreartype == EnumArrearType.NotPresent)
|
|
{
|
|
DateTime fromDate = GlobalFunctions.FirstDateOfMonth(SystemInformation.CurrentSysInfo.NextPayProcessDate);
|
|
DateTime toDate = SystemInformation.CurrentSysInfo.NextPayProcessDate;
|
|
if (ademployee.FormDate < GlobalFunctions.FirstDateOfMonth(fortheMonth))
|
|
fromDate = GlobalFunctions.FirstDateOfMonth(fortheMonth);
|
|
else fromDate = ademployee.FormDate;
|
|
if (ademployee.TillDate == null || ademployee.TillDate == DateTime.MinValue)
|
|
toDate = GlobalFunctions.LastDateOfMonth(fortheMonth);
|
|
else toDate = (DateTime)ademployee.TillDate;
|
|
|
|
|
|
if (toDate > GlobalFunctions.LastDateOfMonth(fortheMonth))
|
|
toDate = GlobalFunctions.LastDateOfMonth(fortheMonth);
|
|
|
|
if (this.Periodicity != EnumPeriodicity.OneOff)
|
|
if (employee.EndOfContractDate != null || employee.EndOfContractDate != DateTime.MinValue)
|
|
if (employee.EndOfContractDate < toDate)
|
|
toDate = (DateTime)employee.EndOfContractDate;
|
|
if (ademployee.ValueType == EnumValueType.Other)
|
|
{
|
|
//while percent of basic then not required to do fractionate of date basis
|
|
//if (this.PercentOfBasic > 0 || ademployee.MonthlyAmount >0 )
|
|
// nAmount = (basicSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(ademployee.FormDate, toDate);
|
|
//else if (this.PercentOfGross > 0 || ademployee.MonthlyAmount > 0)
|
|
// nAmount = (grossSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(ademployee.FormDate, toDate);
|
|
|
|
if (this.PercentOfBasic > 0 || ademployee.MonthlyAmount > 0)
|
|
nAmount = (employee.BasicSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(fromDate, toDate);
|
|
else if (this.PercentOfGross > 0 || ademployee.MonthlyAmount > 0)
|
|
nAmount = (employee.GrossSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(fromDate, toDate);
|
|
|
|
}
|
|
else nAmount = ademployee.MonthlyAmount * GlobalFunctions.GetFraction(fromDate, toDate);
|
|
}
|
|
else if (ademployee.Arreartype == EnumArrearType.ToCalculate)
|
|
{
|
|
if (ademployee.ValueType == EnumValueType.Other)
|
|
{
|
|
if (this.PercentOfBasic > 0 || ademployee.MonthlyAmount > 0)
|
|
nAmount = (employee.BasicSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(ademployee.FormDate, (DateTime)ademployee.TillDate);
|
|
else if (this.PercentOfGross > 0 || ademployee.MonthlyAmount > 0)
|
|
nAmount = (employee.GrossSalary * ademployee.MonthlyAmount) / 100 * GlobalFunctions.GetFraction(ademployee.FormDate, (DateTime)ademployee.TillDate);
|
|
}
|
|
else nAmount = ademployee.MonthlyAmount *
|
|
GlobalFunctions.GetFraction(ademployee.FormDate, (DateTime)ademployee.TillDate);
|
|
}
|
|
|
|
break;
|
|
}
|
|
return nAmount;
|
|
}
|
|
public double GetAmount(Employee oEmp)
|
|
{
|
|
ADParameterEmployee adEmp = null;
|
|
double nAmount = 0.0;
|
|
switch (this.EntitleType)
|
|
{
|
|
case EnumEntitleType.Grade:
|
|
if (this.PercentOfBasic > 0)
|
|
nAmount = oEmp.BasicSalary * this.PercentOfBasic / 100.0 + this.FlatAmount;
|
|
else if (this.PercentOfGross > 0)
|
|
nAmount = oEmp.GrossSalary * this.PercentOfBasic / 100.0 + this.FlatAmount;
|
|
else
|
|
nAmount = this.FlatAmount;
|
|
break;
|
|
case EnumEntitleType.Individual:
|
|
adEmp = ADParameterEmployee.Get(oEmp.ID, this.AllowDeductID, this.ID);
|
|
if (adEmp != null)
|
|
nAmount = adEmp.MonthlyAmount;
|
|
else
|
|
{
|
|
if (this.PercentOfBasic > 0)
|
|
nAmount = oEmp.BasicSalary * this.PercentOfBasic / 100.0 + this.FlatAmount;
|
|
else if (this.PercentOfGross > 0)
|
|
nAmount = oEmp.GrossSalary * this.PercentOfBasic / 100.0 + this.FlatAmount;
|
|
else
|
|
nAmount = this.FlatAmount;
|
|
}
|
|
break;
|
|
}
|
|
if (this.MinAmount != 0 || this.MaxAmount != 0)
|
|
{
|
|
if (nAmount < this.MinAmount)
|
|
{
|
|
nAmount = this.MinAmount;
|
|
}
|
|
if (nAmount > this.MaxAmount)
|
|
{
|
|
nAmount = this.MaxAmount;
|
|
}
|
|
}
|
|
return nAmount;
|
|
}
|
|
#endregion
|
|
|
|
|
|
#endregion
|
|
}
|
|
|
|
|
|
#region IADParameter Service
|
|
|
|
public interface IADParameterService
|
|
{
|
|
ADParameter Get(ID id, ID PayrolltypeID);
|
|
ObjectsTemplate<ADParameter.ADParameterGrade> GetGrades(ID adID);
|
|
ObjectsTemplate<ADParameter> GetByPayrolltypeid(EnumStatus status, ID PayrolltypeID);
|
|
ObjectsTemplate<ADParameter> Get(EnumStatus status, EnumAllowOrDeduct nType, ID PayrolltypeID);
|
|
ObjectsTemplate<ADParameter> Get(EnumStatus status, ID nAllowDeducID);
|
|
|
|
ID Save(ADParameter item, ID PayrolltypeID);
|
|
|
|
void Delete(ID id);
|
|
void ChangeStatus(ID id, EnumStatus enumStatus);
|
|
ObjectsTemplate<ADParameter> Get(ID gradeID, EnumEntitleType nADEmpType, EnumAllowOrDeduct nType,ID PayrolltypeID);
|
|
|
|
ADParameter GetADParamByGradeAndAD(ID gradeID, ID nAllowdeducID);
|
|
ObjectsTemplate<ADParameter> GetWithDetail(EnumStatus status, ID PayrolltypeID);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
#endregion |