862 lines
28 KiB
C#
862 lines
28 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
|
|
{
|
|
#region EmployeeGradeSalary
|
|
|
|
[Serializable]
|
|
public class EmployeeGradeSalary : AuditTrailBase
|
|
{
|
|
#region Cache Store
|
|
private static Cache _cache = new Cache(typeof(EmployeeGradeSalary));
|
|
#endregion
|
|
|
|
#region Constructor
|
|
|
|
public EmployeeGradeSalary()
|
|
{
|
|
_employeeID = null;
|
|
_tillDate = DateTime.MinValue;
|
|
_effectDate = DateTime.MinValue;
|
|
_basicSalary = 0;
|
|
_gradeID = null;
|
|
_grossSalary = 0;
|
|
_payScaleDetailID = null;
|
|
_arrearType = EnumArrearType.NotPresent;
|
|
_gradeSalaryTypeID = null;
|
|
_employee = null;
|
|
_grade = null;
|
|
_PayScaleDetail = null;
|
|
_fractionofFromTo = 1;
|
|
_actualbasicSalary = 0;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
#region EmployeeID : ID
|
|
|
|
private ID _employeeID;
|
|
public ID EmployeeID
|
|
{
|
|
get { return _employeeID; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<ID>("EmployeeID", _employeeID, value);
|
|
_employeeID = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region tillDate : DateTime
|
|
|
|
private DateTime? _tillDate;
|
|
public DateTime? TillDate
|
|
{
|
|
get { return _tillDate; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<DateTime>("tillDate", _tillDate, value);
|
|
_tillDate = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region effectDate : DateTime
|
|
|
|
private DateTime _effectDate;
|
|
public DateTime EffectDate
|
|
{
|
|
get { return _effectDate; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<DateTime>("effectDate", _effectDate, value);
|
|
_effectDate = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region basicSalary : double
|
|
|
|
private double _basicSalary;
|
|
public double BasicSalary
|
|
{
|
|
get { return _basicSalary; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<double>("basicSalary", _basicSalary, value);
|
|
_basicSalary = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region basicSalary : double
|
|
|
|
private double _actualbasicSalary;
|
|
public double ActualBasicSalary
|
|
{
|
|
get { return _actualbasicSalary; }
|
|
set
|
|
{
|
|
_actualbasicSalary = 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 grossSalary : double
|
|
|
|
private double _grossSalary;
|
|
public double GrossSalary
|
|
{
|
|
get { return _grossSalary; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<double>("grossSalary", _grossSalary, value);
|
|
_grossSalary = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PayScaleID : ID
|
|
|
|
private ID _payScaleDetailID;
|
|
public ID PayScaleDetailID
|
|
{
|
|
get { return _payScaleDetailID; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<ID>("PayScaleDetailID", _payScaleDetailID, value);
|
|
_payScaleDetailID = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region arrearType : EnumArrearType
|
|
|
|
private EnumArrearType _arrearType;
|
|
public EnumArrearType ArrearType
|
|
{
|
|
get { return _arrearType; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<short>("arrearType",(short) _arrearType, (short)value);
|
|
_arrearType = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GradeSalaryTypeID : ID
|
|
|
|
private ID _gradeSalaryTypeID;
|
|
public ID GradeSalaryTypeID
|
|
{
|
|
get { return _gradeSalaryTypeID; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<ID>("GradeSalaryTypeID", _gradeSalaryTypeID, value);
|
|
_gradeSalaryTypeID = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region Grade Salary Type
|
|
|
|
private GradeSalaryChangeType _gradeSalaryType;
|
|
public GradeSalaryChangeType gradeSalaryType
|
|
{
|
|
get
|
|
{
|
|
if (_gradeSalaryTypeID.Integer > 0 && _gradeSalaryType == null)
|
|
{
|
|
_gradeSalaryType = new GradeSalaryChangeType();
|
|
_gradeSalaryType = GradeSalaryChangeType.Get(_gradeSalaryTypeID);
|
|
}
|
|
return this._gradeSalaryType;
|
|
}
|
|
set
|
|
{
|
|
_gradeSalaryType = value;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region from & To date Fractionate : double
|
|
|
|
private double _fractionofFromTo;
|
|
public double FractionofFromTo
|
|
{
|
|
get { return _fractionofFromTo; }
|
|
set { _fractionofFromTo = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ArrearAmount : double
|
|
|
|
private int _employeeSerial;
|
|
public int EmployeeSerial
|
|
{
|
|
get { return _employeeSerial; }
|
|
set
|
|
{
|
|
base.OnPropertyChange<double>("EmployeeSerial", _employeeSerial, value);
|
|
_employeeSerial = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region employee : Employee
|
|
|
|
private Employee _employee;
|
|
public Employee Employee
|
|
{
|
|
get
|
|
{
|
|
if (_employeeID.Integer > 0 && _employee == null)
|
|
{
|
|
_employee = new Employee();
|
|
_employee = Employee.Get(_employeeID);
|
|
}
|
|
return this._employee;
|
|
}
|
|
set
|
|
{
|
|
_employee = value;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region grade : Grade
|
|
|
|
private Grade _grade;
|
|
public Grade Grade
|
|
{
|
|
get
|
|
{
|
|
if (_gradeID.Integer > 0 && _grade == null)
|
|
{
|
|
_grade = new Grade();
|
|
_grade = Grade.Get(_gradeID);
|
|
}
|
|
return this._grade;
|
|
}
|
|
set
|
|
{
|
|
_grade = value;
|
|
}
|
|
}
|
|
private EmpLifeCycle _EmpLifeCycle;
|
|
public EmpLifeCycle EmpLifeCycle
|
|
{
|
|
get
|
|
{
|
|
|
|
return this._EmpLifeCycle;
|
|
}
|
|
set
|
|
{
|
|
_EmpLifeCycle = value;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
private ObjectsTemplate<RegularDataUpload> _errorList;
|
|
public ObjectsTemplate<RegularDataUpload> ErrorList
|
|
{
|
|
get { return _errorList; }
|
|
set { _errorList = value; }
|
|
}
|
|
|
|
#region Allowance Deduction Parameter : ADParameters
|
|
private ObjectsTemplate<ADParameter> _adPrameters;
|
|
public ObjectsTemplate<ADParameter> ADParameters
|
|
{
|
|
get
|
|
{
|
|
if (_adPrameters == null)
|
|
{
|
|
throw new ServiceException("Allowance Deduction Parameter Not yet set");
|
|
}
|
|
return _adPrameters;
|
|
}
|
|
set
|
|
{
|
|
_adPrameters = value;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region PayScaleDetail : PayScaleDetail
|
|
|
|
private PayScaleDetail _PayScaleDetail;
|
|
public PayScaleDetail PayScaleDetail
|
|
{
|
|
get
|
|
{
|
|
if ( _PayScaleDetail == null && !this._payScaleDetailID.IsUnassigned)
|
|
{
|
|
_PayScaleDetail = new PayScaleDetail();
|
|
_PayScaleDetail = PayScaleDetail.Get(_payScaleDetailID);
|
|
}
|
|
return this._PayScaleDetail;
|
|
}
|
|
set
|
|
{
|
|
_PayScaleDetail = value;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
//#region OPI Parameter : OpiParameters
|
|
//private ObjectsTemplate<OpiParameter> _opiParameter;
|
|
//public ObjectsTemplate<OpiParameter> OpiParameters
|
|
//{
|
|
// get
|
|
// {
|
|
// if (_opiParameter == null)
|
|
// {
|
|
// throw new ServiceException("OPI Parameter Not yet set");
|
|
// }
|
|
// return _opiParameter;
|
|
// }
|
|
// set
|
|
// {
|
|
// _opiParameter = value;
|
|
// }
|
|
//}
|
|
//#endregion
|
|
|
|
//#region gradeSalaryChangeType : GradeSalaryChangeType
|
|
|
|
//private GradeSalaryChangeType _gradeSalaryChangeType;
|
|
//public GradeSalaryChangeType GradeSalaryChangeType
|
|
//{
|
|
// get
|
|
// {
|
|
// if (_GradeSalaryChangeTypeID.Integer > 0 && _GradeSalaryChangeType == null)
|
|
// {
|
|
// _GradeSalaryChangeType = new GradeSalaryChangeType();
|
|
// _GradeSalaryChangeType = _GradeSalaryChangeType.Get(_GradeSalaryChangeTypeID.Integer);
|
|
// }
|
|
// return this._gradeSalaryChangeType;
|
|
// }
|
|
// set
|
|
// {
|
|
// _GradeSalaryChangeType = value;
|
|
// }
|
|
//}
|
|
//#endregion
|
|
|
|
#region Service Factory IEmployeeGradeSalaryService : IEmployeeGradeSalaryService
|
|
|
|
internal static IEmployeeGradeSalaryService Service
|
|
{
|
|
get { return Services.Factory.CreateService<IEmployeeGradeSalaryService>(typeof(IEmployeeGradeSalaryService)); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Functions
|
|
|
|
public static EmployeeGradeSalary Get(ID employeeid, DateTime effectdate, EnumArrearType type)
|
|
{
|
|
EmployeeGradeSalary oEmployeeGradeSalary = null;
|
|
|
|
oEmployeeGradeSalary = EmployeeGradeSalary.Service.Get(employeeid, effectdate, type);
|
|
|
|
return oEmployeeGradeSalary;
|
|
}
|
|
|
|
public static EmployeeGradeSalary Get(ID employeeid, DateTime effectdate)
|
|
{
|
|
EmployeeGradeSalary oEmployeeGradeSalary = null;
|
|
|
|
oEmployeeGradeSalary = EmployeeGradeSalary.Service.Get(employeeid, effectdate,Payroll.BO.SystemInformation.CurrentSysInfo.PayrollTypeID.Integer);
|
|
|
|
return oEmployeeGradeSalary;
|
|
}
|
|
|
|
public static EmployeeGradeSalary GetBasicOnDate(ID employeeid, DateTime effectdate)
|
|
{
|
|
EmployeeGradeSalary oEmployeeGradeSalary = null;
|
|
|
|
oEmployeeGradeSalary = EmployeeGradeSalary.Service.Get(employeeid, effectdate, EnumArrearType.NotPresent);
|
|
|
|
return oEmployeeGradeSalary;
|
|
}
|
|
public static ObjectsTemplate<EmployeeGradeSalary> GetBasicOnDate(DateTime effectdate)
|
|
{
|
|
ObjectsTemplate<EmployeeGradeSalary> oEmployeeGradeSalary = null;
|
|
|
|
oEmployeeGradeSalary = EmployeeGradeSalary.Service.Get(effectdate, EnumArrearType.NotPresent);
|
|
|
|
return oEmployeeGradeSalary;
|
|
}
|
|
|
|
public static DataSet GetEmpBasicGrade(DateTime dEffectDate, DateTime dEffectDate2)
|
|
{
|
|
DataSet ds = null;
|
|
|
|
try
|
|
{
|
|
ds = Service.GetEmpBasicGrade(dEffectDate, dEffectDate2,Payroll.BO.SystemInformation.CurrentSysInfo.PayrollTypeID.Integer);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
|
|
return ds;
|
|
}
|
|
|
|
public static DataSet GetmultipleTilldatedemp()
|
|
{
|
|
DataSet ds = null;
|
|
|
|
try
|
|
{
|
|
ds = Service.GetmultipleTilldatedemp();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
return ds;
|
|
}
|
|
public static DataSet GetmultipleTilldatedemp(string sEmpIDs)
|
|
{
|
|
DataSet ds = null;
|
|
|
|
try
|
|
{
|
|
ds = Service.GetmultipleTilldatedemp(sEmpIDs);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
return ds;
|
|
}
|
|
public static DataSet GetOldGrd(string sEmpIDs)
|
|
{
|
|
DataSet ds = null;
|
|
|
|
try
|
|
{
|
|
ds = Service.GetOldGrd(sEmpIDs);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
return ds;
|
|
}
|
|
|
|
public static DataSet GetEmpPrvBasicGrade(DateTime effectDate)
|
|
{
|
|
DataSet ds = null;
|
|
|
|
try
|
|
{
|
|
ds = Service.GetEmpPrvBasicGrade(effectDate,Payroll.BO.SystemInformation.CurrentSysInfo.PayrollTypeID.Integer);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
|
|
|
|
return ds;
|
|
}
|
|
|
|
|
|
public void SetObjectID(int IdValue)
|
|
{
|
|
this.SetID(ID.FromInteger(IdValue));
|
|
}
|
|
|
|
/// <summary>
|
|
/// retrive grade salary data from data base
|
|
/// </summary>
|
|
/// <param name="employeeID">int</param>
|
|
/// <returns>effect date wise max grade salary</returns>
|
|
|
|
public static EmployeeGradeSalary GetMax(int employeeID, EnumArrearType type)
|
|
{
|
|
EmployeeGradeSalary oEmployeeGradeSalary = null;
|
|
oEmployeeGradeSalary = EmployeeGradeSalary.Service.GetMax(employeeID, type);
|
|
return oEmployeeGradeSalary;
|
|
}
|
|
/// <summary>
|
|
/// retrive grade salary data from data base
|
|
/// </summary>
|
|
/// <param name="employeeID">int, employeeid </param>
|
|
/// <param name="effectDate">datetime</param>
|
|
/// <returns>effect date wise max grade salary</returns>
|
|
public static ObjectsTemplate<EmployeeGradeSalary> Get(int employeeId)
|
|
{
|
|
ObjectsTemplate<EmployeeGradeSalary> employeeGradeSalarys = null;
|
|
|
|
try
|
|
{
|
|
employeeGradeSalarys = Service.Get(employeeId);
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
return employeeGradeSalarys;
|
|
}
|
|
|
|
public static ObjectsTemplate<EmployeeGradeSalary> GetbyEffectDate(ID employeeID, DateTime effectDateFrom, DateTime effectDateTo)
|
|
{
|
|
ObjectsTemplate<EmployeeGradeSalary> employeeGradeSalarys = null; ;
|
|
|
|
try
|
|
{
|
|
employeeGradeSalarys = Service.GetbyEffectDate(employeeID, effectDateFrom, effectDateTo);
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
return employeeGradeSalarys;
|
|
}
|
|
|
|
public static ObjectsTemplate<EmployeeGradeSalary> GetCurrMonthSalaryItems(DateTime nextPayProcessDate)
|
|
{
|
|
ObjectsTemplate<EmployeeGradeSalary> employeeGradeSalarys = null; ;
|
|
|
|
try
|
|
{
|
|
employeeGradeSalarys = Service.GetCurrMonthSalaryItems(nextPayProcessDate);
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
return employeeGradeSalarys;
|
|
}
|
|
public static ObjectsTemplate<EmployeeGradeSalary> GetArrearItems()
|
|
{
|
|
ObjectsTemplate<EmployeeGradeSalary> employeeGradeSalarys = null; ;
|
|
|
|
try
|
|
{
|
|
employeeGradeSalarys = Service.GetArrearItems();
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
return employeeGradeSalarys;
|
|
}
|
|
|
|
public static ObjectsTemplate<EmployeeGradeSalary> Get()
|
|
{
|
|
ObjectsTemplate<EmployeeGradeSalary> employeeGradeSalarys = null; ;
|
|
|
|
try
|
|
{
|
|
employeeGradeSalarys = Service.Get();
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
return employeeGradeSalarys;
|
|
}
|
|
|
|
public static ObjectsTemplate<EmployeeGradeSalary> Get(
|
|
ObjectsTemplate<EmployeeGradeSalary> gradeSalaryItems, ID employeeid)
|
|
{
|
|
ObjectsTemplate<EmployeeGradeSalary> employeeGradeSalarys = new ObjectsTemplate<EmployeeGradeSalary>();
|
|
|
|
try
|
|
{
|
|
foreach (EmployeeGradeSalary item in gradeSalaryItems)
|
|
{
|
|
if (item.EmployeeID == employeeid)
|
|
{
|
|
employeeGradeSalarys.Add(item);
|
|
}
|
|
}
|
|
}
|
|
catch (ServiceException e)
|
|
{
|
|
throw new Exception(e.Message, e);
|
|
}
|
|
return employeeGradeSalarys;
|
|
}
|
|
|
|
public void Save()
|
|
{
|
|
ObjectsTemplate<EmpLifeCycle> ocyclies = new ObjectsTemplate<EmpLifeCycle>();
|
|
ObjectsTemplate<EmployeeGradeSalary> itemsToSave= process();
|
|
if (this.EmpLifeCycle != null)
|
|
{
|
|
ID nID = this.EmpLifeCycle.StatusDetailID;
|
|
EnumEmployeeStatus eStatus = this.EmpLifeCycle.Status;
|
|
string sDescription = this.EmpLifeCycle.Description;
|
|
foreach (EmployeeGradeSalary item in itemsToSave)
|
|
{
|
|
item.EmpLifeCycle = new EmpLifeCycle();
|
|
item.EmpLifeCycle.EmployeeID = item.EmployeeID;
|
|
item.EmpLifeCycle.GradeID = item.GradeID;
|
|
item.EmpLifeCycle.EffectDate = item.EffectDate;
|
|
item.EmpLifeCycle.BasicSalary = item.BasicSalary;
|
|
item.EmpLifeCycle.Description = sDescription;
|
|
item.EmpLifeCycle.StatusDetailID = nID;
|
|
item.EmpLifeCycle.Status = eStatus;
|
|
ocyclies.Add(item.EmpLifeCycle);
|
|
}
|
|
}
|
|
EmpLifeCycle lifeCycle = new EmpLifeCycle();
|
|
lifeCycle.Save(ocyclies);
|
|
//update audit-trail
|
|
//foreach (EmployeeGradeSalary item in itemsToSave)
|
|
// item.SetAuditTrailProperties();
|
|
|
|
//EmployeeGradeSalary.Service.Save(itemsToSave);
|
|
}
|
|
|
|
public ObjectsTemplate<EmployeeGradeSalary> process()
|
|
{
|
|
ObjectsTemplate<EmployeeGradeSalary> itemstoSave = new ObjectsTemplate<EmployeeGradeSalary>();
|
|
EmployeeGradeSalary item;
|
|
GradeSalaryChangeType effecttype = GradeSalaryChangeType.Get(this.GradeSalaryTypeID);
|
|
// get the last (max on date) grade salary item grade salary item from the database
|
|
EmployeeGradeSalary lastgs = EmployeeGradeSalary.GetMax(this.EmployeeID.Integer, EnumArrearType.NotPresent);
|
|
|
|
if (lastgs == null) // true is first time entry for the employee
|
|
{
|
|
// if effect date befor the last payprocess date, a arrear item need to prepare
|
|
if (this.EffectDate <= SystemInformation.CurrentSysInfo.LastPayProcessDate)
|
|
{
|
|
//Create an arrear item
|
|
item = (EmployeeGradeSalary)this.Clone();
|
|
item.ArrearType = EnumArrearType.ToCalculate;
|
|
// arrear item till date must be last payprocess date
|
|
item.TillDate = SystemInformation.CurrentSysInfo.LastPayProcessDate;
|
|
itemstoSave.Add(item);
|
|
|
|
item = (EmployeeGradeSalary)this.Clone();
|
|
//Normal item effect-date should be first date of the month and it will continue to next change
|
|
item.EffectDate =GlobalFunctions.FirstDateOfMonth(SystemInformation.CurrentSysInfo.NextPayProcessDate);
|
|
item.TillDate = null;
|
|
item.ArrearType = EnumArrearType.NotPresent;
|
|
itemstoSave.Add(item);
|
|
}
|
|
else itemstoSave.Add(this);
|
|
}
|
|
else
|
|
{
|
|
if (this.EffectDate > SystemInformation.CurrentSysInfo.LastPayProcessDate)
|
|
{
|
|
lastgs.TillDate = this.EffectDate.AddDays(-1);
|
|
itemstoSave.Add(lastgs);
|
|
itemstoSave.Add(this);
|
|
}
|
|
else
|
|
{
|
|
#region do reverse process
|
|
// // do reverse engineering
|
|
// ObjectsTemplate<EmployeeGradeSalary> savedItems =
|
|
// EmployeeGradeSalary.Service.GetbyTillDate(this.EmployeeID.Integer, this.EffectDate, SystemInformation.CurrentSysInfo.LastPayProcessDate);
|
|
// DateTime tempEffectDate = this.EffectDate;
|
|
|
|
// #region Do reverse engineering
|
|
// int count = 1;
|
|
// foreach (EmployeeGradeSalary arrerItem in savedItems)
|
|
// {
|
|
// //do not consider arrear to calculate item
|
|
// // because current save process will delete arrear calculate items first.
|
|
// if (arrerItem.ArrearType == EnumArrearType.ToCalculate) continue;
|
|
//// if (arrerItem.ArrearType == EnumArrearType.Paid) continue;
|
|
// if (arrerItem.EffectDate >= SystemInformation.CurrentSysInfo.LastPayProcessDate) continue;
|
|
// item =(EmployeeGradeSalary) arrerItem.Clone();
|
|
// item.SetState(ObjectState.New);
|
|
// item.EffectDate = (this.EffectDate >arrerItem.EffectDate)? this.EffectDate : arrerItem.EffectDate;
|
|
// item.ArrearType = EnumArrearType.ToCalculate;
|
|
// item.GradeID = this.GradeID;
|
|
// item.BasicSalary = this.BasicSalary;
|
|
// item.GrossSalary = this.GrossSalary;
|
|
// item.PayScaleDetailID = this.PayScaleDetailID;
|
|
// item.GradeSalaryTypeID = this.GradeSalaryTypeID;
|
|
|
|
// item.TillDate = (arrerItem.TillDate == null) ?
|
|
// SystemInformation.CurrentSysInfo.LastPayProcessDate : (DateTime)arrerItem.TillDate;
|
|
// if (arrerItem.TillDate == null)
|
|
// {
|
|
// arrerItem.TillDate = SystemInformation.CurrentSysInfo.LastPayProcessDate;
|
|
// itemstoSave.Add(arrerItem);
|
|
// }
|
|
// itemstoSave.Add(item);
|
|
// count = count + 1;
|
|
|
|
// }
|
|
// #endregion
|
|
|
|
// if (itemstoSave.Count == 0)
|
|
// {
|
|
// item = (EmployeeGradeSalary)this.Clone();
|
|
// item.ArrearType = EnumArrearType.ToCalculate;
|
|
// // arrear item till date must be last payprocess date
|
|
// item.TillDate = SystemInformation.CurrentSysInfo.LastPayProcessDate;
|
|
// itemstoSave.Add(item);
|
|
// }
|
|
|
|
lastgs.TillDate = SystemInformation.CurrentSysInfo.LastPayProcessDate;
|
|
itemstoSave.Add(lastgs);
|
|
item = (EmployeeGradeSalary)this.Clone();
|
|
item.ArrearType = EnumArrearType.ToCalculate;
|
|
item.TillDate = SystemInformation.CurrentSysInfo.LastPayProcessDate;
|
|
itemstoSave.Add(item);
|
|
// update current item effect date
|
|
this.EffectDate = SystemInformation.CurrentSysInfo.LastPayProcessDate.AddDays(1);
|
|
itemstoSave.Add(this);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
foreach (EmployeeGradeSalary oitem in itemstoSave)
|
|
oitem.SetAuditTrailProperties();
|
|
return itemstoSave;
|
|
}
|
|
|
|
public static void PrepareDataForCurrentSalary(Employee employee,
|
|
ObjectsTemplate<EmployeeGradeSalary> gradeSalaries)
|
|
{
|
|
DateTime calculateMonth = SystemInformation.CurrentSysInfo.NextPayProcessDate;
|
|
|
|
DateTime Upto = GlobalFunctions.LastDateOfMonth(calculateMonth);
|
|
|
|
gradeSalaries[gradeSalaries.Count - 1].TillDate = calculateMonth;
|
|
if (employee.EndOfContractDate != null && employee.EndOfContractDate != DateTime.MinValue)
|
|
if (employee.EndOfContractDate < Upto)
|
|
gradeSalaries[gradeSalaries.Count-1].TillDate = employee.EndOfContractDate;
|
|
|
|
double total = 0;
|
|
foreach (EmployeeGradeSalary item in gradeSalaries)
|
|
{
|
|
if (item.ArrearType == EnumArrearType.NotPresent)
|
|
if(item.EffectDate < GlobalFunctions.FirstDateOfMonth(calculateMonth))
|
|
item.EffectDate = GlobalFunctions.FirstDateOfMonth(calculateMonth);
|
|
|
|
if(item.TillDate!=null)
|
|
item.FractionofFromTo = GlobalFunctions.GetFraction(item.EffectDate, (DateTime)item.TillDate);
|
|
else item.FractionofFromTo = GlobalFunctions.GetFraction(item.EffectDate, Upto);
|
|
total = total + item.FractionofFromTo;
|
|
}
|
|
}
|
|
|
|
public void Delete()
|
|
{
|
|
//EmployeeGradeSalary updatedItem = null;
|
|
//if (this.ArrearType != EnumArrearType.ToCalculate)
|
|
//{
|
|
// updatedItem = EmployeeGradeSalary.Get(this.EmployeeID,
|
|
// this.EffectDate.AddDays(-1), EnumArrearType.NotPresent);
|
|
//}
|
|
//if (updatedItem != null)
|
|
//{
|
|
// updatedItem.TillDate = null;
|
|
// updatedItem.SetAuditTrailProperties();
|
|
// EmployeeGradeSalary.Service.Delete(updatedItem, this);
|
|
//}
|
|
//else
|
|
//{
|
|
EmployeeGradeSalary.Service.Delete(this);
|
|
//}
|
|
}
|
|
|
|
|
|
|
|
public void DeleteAll()
|
|
{
|
|
EmployeeGradeSalary.Service.DeleteAll();
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region IEmployeeGradeSalary Service
|
|
|
|
public interface IEmployeeGradeSalaryService
|
|
{
|
|
ObjectsTemplate<EmployeeGradeSalary> Get();
|
|
EmployeeGradeSalary GetMax(int employeeID, EnumArrearType type);
|
|
ObjectsTemplate<EmployeeGradeSalary> Get(int employeeID);
|
|
EmployeeGradeSalary Get(ID employeeid, DateTime effectdate, EnumArrearType type);
|
|
ObjectsTemplate<EmployeeGradeSalary> Get(DateTime effectdate, EnumArrearType type);
|
|
EmployeeGradeSalary Get(ID employeeid, DateTime effectdate, int payrollTypeID);
|
|
ObjectsTemplate<EmployeeGradeSalary> GetbyTillDate(int employeeID, DateTime tillDateFrom, DateTime tillDateTo);
|
|
|
|
ObjectsTemplate<EmployeeGradeSalary> GetbyEffectDate(ID employeeID, DateTime effectDateFrom, DateTime effectDateTo);
|
|
|
|
//specially for salary process
|
|
ObjectsTemplate<EmployeeGradeSalary> GetCurrMonthSalaryItems(DateTime nextPayProcessDate);
|
|
ObjectsTemplate<EmployeeGradeSalary> GetArrearItems();
|
|
ObjectsTemplate<EmployeeGradeSalary> GetArrearPaidItems(ID employeeid, DateTime tillDateFrom);
|
|
|
|
void DeleteFrom(int employeeID, DateTime fromDate);
|
|
void Delete(EmployeeGradeSalary gradeSalary);
|
|
//void Delete(EmployeeGradeSalary updateItem, EmployeeGradeSalary deletedItem);
|
|
void DeleteAll();
|
|
|
|
void Save(ObjectsTemplate<EmployeeGradeSalary> itemsToSave);
|
|
DataSet GetEmpBasicGrade(DateTime dEffectDate, DateTime dEffectDate2, int payrollTypeID);
|
|
DataSet GetEmpPrvBasicGrade(DateTime effectDate, int payrollTypeID);
|
|
DataSet GetmultipleTilldatedemp();
|
|
DataSet GetmultipleTilldatedemp(string sEmpIDs);
|
|
DataSet GetOldGrd(string sEmpIDs);
|
|
|
|
|
|
}
|
|
|
|
#endregion
|
|
}
|