924 lines
34 KiB
C#
924 lines
34 KiB
C#
using HRM.BO;
|
|
using Ease.Core.DataAccess;
|
|
using Ease.Core.Model;
|
|
using Ease.Core.Utility;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using Microsoft.Data.SqlClient;
|
|
|
|
namespace HRM.DA
|
|
{
|
|
#region OTProcess Service
|
|
|
|
public class OTProcessService : ServiceTemplate, IOTProcessService
|
|
{
|
|
#region Private functions and declaration
|
|
|
|
#endregion
|
|
private List<EmployeeOverTime> _EmpOvertimes = null;
|
|
private List<OTProcess> _OtProcess = null;
|
|
private List<TermParameter> _termParameters = null;
|
|
private int _hoursInMonth = 0;
|
|
|
|
public OTProcessService()
|
|
{
|
|
}
|
|
|
|
private void MapObject(OTProcess oOTProcess, DataReader oReader)
|
|
{
|
|
base.SetObjectID(oOTProcess, oReader.GetInt32("ProcessId").Value);
|
|
oOTProcess.MonthDate = oReader.GetDateTime("ProcessMonth").Value;
|
|
oOTProcess.EmployeeID = oReader.GetString("empID") == null ? 0 : oReader.GetInt32("empID").Value;
|
|
oOTProcess.Amount = oReader.GetDouble("amount").Value;
|
|
oOTProcess.ArrearAmount = oReader.GetDouble("ArrearAmount").Value;
|
|
oOTProcess.TermID = oReader.GetString("termID") == null ? 0 : oReader.GetInt32("termID").Value;
|
|
oOTProcess.TermParameterID = oReader.GetString("TermParameterID") == null
|
|
? 0
|
|
: oReader.GetInt32("TermParameterID").Value;
|
|
oOTProcess.EmpOverTimeID =
|
|
oReader.GetString("EmpOverTimeID") == null ? 0 : oReader.GetInt32("EmpOverTimeID").Value;
|
|
oOTProcess.TotalHour = oReader.GetDouble("Hours").Value;
|
|
oOTProcess.CreatedBy = oReader.GetString("CreatedBy") == null ? 0 : oReader.GetInt32("CreatedBy").Value;
|
|
oOTProcess.CreatedDate = oReader.GetDateTime("CreationDate").Value;
|
|
oOTProcess.ModifiedBy = oReader.GetString("ModifiedBy") == null ? 0 : oReader.GetInt32("ModifiedBy").Value;
|
|
oOTProcess.ModifiedDate = oReader.GetDateTime("ModifiedDate");
|
|
oOTProcess.OTMonth = oReader.GetDateTime("OTMonth").Value;
|
|
this.SetObjectState(oOTProcess, Ease.Core.ObjectState.Saved);
|
|
}
|
|
|
|
protected override T CreateObject<T>(DataReader oReader)
|
|
{
|
|
OTProcess oOTProcess = new OTProcess();
|
|
MapObject(oOTProcess, oReader);
|
|
return oOTProcess as T;
|
|
}
|
|
|
|
protected OTProcess CreateObject(DataReader oReader)
|
|
{
|
|
OTProcess oOTProcess = new OTProcess();
|
|
MapObject(oOTProcess, oReader);
|
|
return oOTProcess;
|
|
}
|
|
|
|
#region Service implementation
|
|
|
|
public List<OTProcess> Get(DateTime dMonthDate)
|
|
{
|
|
List<OTProcess> oTProcess = new List<OTProcess>();
|
|
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
|
|
DataReader dr = new DataReader(OTProcessDA.Get(tc, dMonthDate));
|
|
oTProcess = this.CreateObjects<OTProcess>(dr);
|
|
dr.Close();
|
|
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
|
|
return oTProcess;
|
|
}
|
|
|
|
public List<OTProcess> GetOTProcessDataByMonthAndDeptID(DateTime Month, string deptID)
|
|
{
|
|
List<OTProcess> oTProcess = new List<OTProcess>();
|
|
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
|
|
DataReader dr = new DataReader(OTProcessDA.GetOTProcessDataByMonthAndDeptID(tc, Month, deptID));
|
|
oTProcess = this.CreateObjects<OTProcess>(dr);
|
|
dr.Close();
|
|
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
|
|
return oTProcess;
|
|
}
|
|
|
|
public OTProcess Get(int id)
|
|
{
|
|
OTProcess oOTProcess = new OTProcess();
|
|
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
DataReader oreader = new DataReader(OTProcessDA.Get(tc, id));
|
|
if (oreader.Read())
|
|
{
|
|
oOTProcess = this.CreateObject<OTProcess>(oreader);
|
|
}
|
|
|
|
oreader.Close();
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
|
|
return oOTProcess;
|
|
}
|
|
|
|
public bool IsProcessed(DateTime dMonthDate, int payrollTypeID)
|
|
{
|
|
bool isProcessed = false;
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
DataReader dr = new DataReader(OTProcessDA.IsProcessed(tc, dMonthDate, payrollTypeID));
|
|
if (dr.Read())
|
|
{
|
|
isProcessed = Convert.ToBoolean(dr.GetInt32(0));
|
|
}
|
|
|
|
dr.Close();
|
|
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
|
|
return isProcessed;
|
|
}
|
|
|
|
public List<OTProcess> Get()
|
|
{
|
|
List<OTProcess> oTProcess = new List<OTProcess>();
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
|
|
DataReader dr = new DataReader(OTProcessDA.Get(tc));
|
|
oTProcess = this.CreateObjects<OTProcess>(dr);
|
|
dr.Close();
|
|
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
|
|
return oTProcess;
|
|
}
|
|
|
|
public DataSet GetOTProcessData(DateTime Month, string sEmpID)
|
|
{
|
|
DataSet oTProcess = null;
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
oTProcess = OTProcessDA.GetOTProcessData(tc, Month, sEmpID);
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
|
|
return oTProcess;
|
|
}
|
|
|
|
public DataSet GetOTMonthRangeData(DateTime FDate, DateTime TDate)
|
|
{
|
|
DataSet oTProcess = null;
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
oTProcess = OTProcessDA.GetOTMonthRangeData(tc, FDate, TDate);
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
|
|
return oTProcess;
|
|
}
|
|
|
|
public DataSet GetBranchWiseOT(DateTime Month)
|
|
{
|
|
DataSet oTProcess = null;
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
oTProcess = OTProcessDA.GetBranchWiseOT(tc, Month);
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
|
|
return oTProcess;
|
|
}
|
|
|
|
public DataSet GetCostCenterWiseOT(DateTime dateTime, string sEmpID)
|
|
{
|
|
DataSet oTProcess = null;
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
oTProcess = OTProcessDA.GetCostCenterWiseOT(tc, dateTime, sEmpID);
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
|
|
return oTProcess;
|
|
}
|
|
|
|
public DataSet GetLocationWiseOT(DateTime FDate, DateTime TDate)
|
|
{
|
|
DataSet oTProcess = null;
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
oTProcess = OTProcessDA.GetLocationWiseOT(tc, FDate, TDate);
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
|
|
return oTProcess;
|
|
}
|
|
|
|
public List<OTProcess> GetbyOtMonth(string sEmpIDs, string sMonths)
|
|
{
|
|
List<OTProcess> oTProcess = new List<OTProcess>();
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
|
|
DataReader dr = new DataReader(OTProcessDA.GetbyOtMonth(tc, sEmpIDs, sMonths));
|
|
oTProcess = this.CreateObjects<OTProcess>(dr);
|
|
dr.Close();
|
|
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
|
|
return oTProcess;
|
|
}
|
|
|
|
public int Save(OTProcess oOTProcess)
|
|
{
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin(true);
|
|
if (oOTProcess.IsNew)
|
|
{
|
|
int id = tc.GenerateID("OTProcess", "ProcessId");
|
|
base.SetObjectID(oOTProcess, id);
|
|
OTProcessDA.Insert(tc, oOTProcess);
|
|
}
|
|
else
|
|
{
|
|
OTProcessDA.Update(tc, oOTProcess);
|
|
}
|
|
|
|
tc.End();
|
|
return oOTProcess.ID;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
public int Save(TransactionContext tc, OTProcess oOTProcess)
|
|
{
|
|
try
|
|
{
|
|
if (oOTProcess.IsNew)
|
|
{
|
|
int id = tc.GenerateID("OTProcess", "ProcessId");
|
|
base.SetObjectID(oOTProcess, id);
|
|
OTProcessDA.Insert(tc, oOTProcess);
|
|
}
|
|
else
|
|
{
|
|
OTProcessDA.Update(tc, oOTProcess);
|
|
}
|
|
|
|
return oOTProcess.ID;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
public void Save(List<OTProcess> oOTProcesss)
|
|
{
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin(true);
|
|
foreach (OTProcess process in oOTProcesss)
|
|
{
|
|
Save(tc, process);
|
|
}
|
|
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
public void BulkSave(List<OTProcess> items)
|
|
{
|
|
int id = 0;
|
|
List<ADParameterEmployee> newitems = new List<ADParameterEmployee>();
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
|
|
tc = TransactionContext.Begin(true);
|
|
id = tc.GenerateID("OTProcess", "ProcessId");
|
|
|
|
DataTable attnProcessEntryTable = new DataTable("OTProcess");
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("PROCESSID", typeof(int)));
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("PROCESSMONTH", typeof(DateTime)));
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("EMPID", typeof(int)));
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("AMOUNT", typeof(double))); // NULL
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("TERMID", typeof(int))); // NULL
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("HOURS", typeof(double))); // NULL
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("CREATEDBY", typeof(int)));
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("CREATIONDATE", typeof(DateTime)));
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("MODIFIEDBY", typeof(int)));
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("MODIFIEDDATE", typeof(DateTime)));
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("TERMPARAMETERID", typeof(int)));
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("EMPOVERTIMEID", typeof(int)));
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("ARREARAMOUNT", typeof(double))); // NULL
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("OTMONTH", typeof(DateTime))); // NULL,
|
|
attnProcessEntryTable.Columns.Add(new DataColumn("PAYROLLTYPEID", typeof(int))); // NULL,
|
|
|
|
foreach (OTProcess item in items)
|
|
{
|
|
id = id + 1;
|
|
attnProcessEntryTable.Rows.Add(
|
|
id,
|
|
item.MonthDate,
|
|
item.EmployeeID,
|
|
item.Amount,
|
|
item.TermID,
|
|
item.TotalHour,
|
|
item.CreatedBy,
|
|
item.CreatedDate,
|
|
item.ModifiedBy,
|
|
item.ModifiedDate,
|
|
item.TermParameterID,
|
|
item.EmpOverTimeID,
|
|
item.ArrearAmount,
|
|
item.OTMonth,
|
|
item.PayrollTypeID
|
|
);
|
|
|
|
}
|
|
|
|
using (SqlBulkCopy bulkCopy = new SqlBulkCopy((SqlConnection)tc.Connection, SqlBulkCopyOptions.Default, (SqlTransaction)tc.Transaction))
|
|
{
|
|
bulkCopy.BulkCopyTimeout = 6000; // in seconds
|
|
|
|
bulkCopy.ColumnMappings.Add("PROCESSID", "PROCESSID");
|
|
bulkCopy.ColumnMappings.Add("PROCESSMONTH", "PROCESSMONTH");
|
|
bulkCopy.ColumnMappings.Add("EMPID", "EMPID");
|
|
bulkCopy.ColumnMappings.Add("AMOUNT", "AMOUNT");
|
|
bulkCopy.ColumnMappings.Add("TERMID", "TERMID");
|
|
bulkCopy.ColumnMappings.Add("HOURS", "HOURS");
|
|
bulkCopy.ColumnMappings.Add("CREATEDBY", "CREATEDBY");
|
|
bulkCopy.ColumnMappings.Add("CREATIONDATE", "CREATIONDATE");
|
|
bulkCopy.ColumnMappings.Add("MODIFIEDBY", "MODIFIEDBY");
|
|
bulkCopy.ColumnMappings.Add("MODIFIEDDATE", "MODIFIEDDATE");
|
|
bulkCopy.ColumnMappings.Add("TERMPARAMETERID", "TERMPARAMETERID");
|
|
bulkCopy.ColumnMappings.Add("EMPOVERTIMEID", "EMPOVERTIMEID");
|
|
bulkCopy.ColumnMappings.Add("ARREARAMOUNT", "ARREARAMOUNT");
|
|
bulkCopy.ColumnMappings.Add("OTMONTH", "OTMONTH");
|
|
bulkCopy.ColumnMappings.Add("PAYROLLTYPEID", "PAYROLLTYPEID");
|
|
|
|
bulkCopy.DestinationTableName = "OTProcess";
|
|
|
|
|
|
bulkCopy.WriteToServer(attnProcessEntryTable);
|
|
}
|
|
|
|
tc.End();
|
|
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
|
|
public void Delete(DateTime dMonthDate, int nPayrollTypeID)
|
|
{
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin(true);
|
|
OTProcessDA.Delete(tc, dMonthDate, nPayrollTypeID);
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
public void Delete(int id)
|
|
{
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin(true);
|
|
OTProcessDA.Delete(tc, id);
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OT Process/Calculator
|
|
public void Process(List<Employee> emps, int userid, int payrolltypeid)
|
|
{
|
|
|
|
// TermParameter.EntryType = ConfigurationManager.GetStringValue("overtime", "entrytype", EnumConfigurationType.Logic);
|
|
bool calOnEarnedBasic = new SystemConfigarationService().GetconfigBooleanValue(EnumConfigurationType.Logic, "overtime", "earnedbasic");
|
|
int basicOnMonth = Convert.ToInt32(new SystemConfigarationService().GetconfigValue(EnumConfigurationType.Logic, "overtime", "basicondate"));
|
|
bool fixedotmonth = new SystemConfigarationService().GetconfigBooleanValue(EnumConfigurationType.Logic, "overtime", "fixedotmonth");
|
|
if (basicOnMonth == 0) basicOnMonth = 1;
|
|
_hoursInMonth = Convert.ToInt32(new SystemConfigarationService().GetconfigValue(EnumConfigurationType.Logic, "overtime", "hoursonmonth"));
|
|
|
|
PayrollType ptype = new PayrollTypeService().Get(payrolltypeid);
|
|
List<Employee> omployees = emps;
|
|
if (emps == null) omployees = new EmployeeService().Get(EnumEmployeeStatus.Live, payrolltypeid);
|
|
_OtProcess = new List<OTProcess>();
|
|
_EmpOvertimes = new EmployeeOverTimeService().Get(ptype.NextPayProcessDate, payrolltypeid);
|
|
double basicSalary = 0;
|
|
_termParameters = new TermParameterService().GetwithDetail(payrolltypeid);
|
|
if (_EmpOvertimes != null && _EmpOvertimes.Count > 0)
|
|
{
|
|
////ForTest
|
|
//_EmpOvertimes = _EmpOvertimes.Where(e => e.EmployeeID == 599).ToList();//March to apr salary change
|
|
|
|
foreach (EmployeeOverTime ot in _EmpOvertimes)
|
|
{
|
|
|
|
basicSalary = 0;
|
|
ot.PayrollTypeID = payrolltypeid;
|
|
DateTime basicDate = new DateTime(ot.OTMonth.Year, ot.OTMonth.Month, basicOnMonth);
|
|
if (calOnEarnedBasic == false)
|
|
{
|
|
Employee omp = omployees.FirstOrDefault(x => x.ID == ot.EmployeeID);
|
|
ot.Employee = omp;
|
|
if (omp != null)
|
|
basicSalary = omp.BasicSalary;
|
|
if(omp == null || omp.GradeID ==null)
|
|
{
|
|
//Employee oemp = new EmployeeService().Get(ot.EmployeeID);
|
|
//throw new Exception("Employee: " + oemp.EmployeeNo + " is not live or Grade not yet assiged");
|
|
continue;
|
|
}
|
|
|
|
#region Old
|
|
//EmployeeGradeSalary gs = EmployeeGradeSalary.Get(ot.EmployeeID,
|
|
// basicDate, EnumArrearType.NotPresent);
|
|
//if (gs == null) gs = EmployeeGradeSalary.Get(ot.EmployeeID,
|
|
// PayrollPayrollGlobalFunctions.PayrollLastDateOfMonth(ot.OTMonth), EnumArrearType.ToCalculate);
|
|
|
|
//if (gs == null)
|
|
//{
|
|
// if (ot.Employee.BasicSalary == 0)
|
|
// {
|
|
// throw new ServiceException(" Basic salary not found for the employee:" + ot.Employee.Name
|
|
// + "( " + ot.Employee.EmployeeNo + ") on month" + ot.OTMonth.ToString("MMM yyyy"));
|
|
// }
|
|
// else
|
|
// {
|
|
// //DateTime dMonth = SystemInformation.CurrentSysInfo.NextPayProcessDate;
|
|
// //if(ot.Employee.JoiningDate.Month == SystemInformation.CurrentSysInfo.NextPayProcessDate.Month &&
|
|
// // ot.Employee.JoiningDate.Month == SystemInformation.CurrentSysInfo.NextPayProcessDate.Month)
|
|
// // dMonth =ot.Employee.JoiningDate;
|
|
// basicSalary = ot.Employee.BasicSalary;
|
|
// }
|
|
//}
|
|
////else basicSalary = gs.BasicSalary * PayrollPayrollGlobalFunctions.GetFractinalOfMonth(gs.EffectDate);
|
|
//// doesn't need to fractionate, cause it is not base on earned basic;
|
|
//else basicSalary = gs.BasicSalary ;
|
|
//else basicSalary = ot.Employee.BasicSalary; // for redisha back process
|
|
#endregion Old
|
|
|
|
if (!fixedotmonth)
|
|
{
|
|
EmployeeGradeSalary gs = new EmployeeGradeSalaryService().Get(ot.EmployeeID,
|
|
GlobalFunctions.LastDateOfMonth(ot.OTMonth), EnumArrearType.NotPresent);
|
|
if (gs == null) gs = new EmployeeGradeSalaryService().Get(ot.EmployeeID,
|
|
GlobalFunctions.LastDateOfMonth(ot.OTMonth), EnumArrearType.ToCalculate);
|
|
|
|
if (gs == null)
|
|
{
|
|
if (ot.Employee.BasicSalary == 0)
|
|
{
|
|
throw new ServiceException(" Basic salary not found for the employee:" + ot.Employee.Name
|
|
+ "( " + ot.Employee.EmployeeNo + ") on month" + ot.OTMonth.ToString("MMM yyyy"));
|
|
}
|
|
else basicSalary = ot.Employee.BasicSalary;//* PayrollPayrollGlobalFunctions.GetFractinalOfMonth(ot.Employee.JoiningDate);
|
|
}
|
|
else basicSalary = gs.BasicSalary * GlobalFunctions.GetFractinalOfMonth(gs.EffectDate);
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SalaryMonthly salary = new SalaryMonthlyService().Get(ot.EmployeeID, GlobalFunctions.LastDateOfMonth(ot.OTMonth));
|
|
if (salary == null)
|
|
{
|
|
EmployeeGradeSalary gs = new EmployeeGradeSalaryService().Get(ot.EmployeeID,
|
|
GlobalFunctions.LastDateOfMonth(ot.OTMonth), EnumArrearType.NotPresent);
|
|
|
|
if (gs == null) gs = new EmployeeGradeSalaryService().Get(ot.EmployeeID,
|
|
GlobalFunctions.LastDateOfMonth(ot.OTMonth), EnumArrearType.ToCalculate);
|
|
|
|
if (gs == null)
|
|
{
|
|
if (ot.Employee.BasicSalary == 0)
|
|
{
|
|
throw new ServiceException(" Basic salary not found for the employee:" + ot.Employee.Name
|
|
+ "( " + ot.Employee.EmployeeNo + ") on month" + ot.OTMonth.ToString("MMM yyyy"));
|
|
}
|
|
else basicSalary = ot.Employee.BasicSalary;//* PayrollPayrollGlobalFunctions.GetFractinalOfMonth(ot.Employee.JoiningDate);
|
|
}
|
|
else basicSalary = gs.BasicSalary * GlobalFunctions.GetFractinalOfMonth(gs.EffectDate);
|
|
}
|
|
else
|
|
{
|
|
basicSalary = salary.GetGrossAmount(EnumSalaryItemCode.Basic_Salary, (int)EnumSalaryItemCode.Basic_Salary);
|
|
}
|
|
|
|
}
|
|
_OtProcess.Add(CreateObject(ot, basicSalary));
|
|
}
|
|
}
|
|
_OtProcess.ForEach(x =>
|
|
{
|
|
x.CreatedBy = userid;
|
|
x.CreatedDate = DateTime.Today;
|
|
});
|
|
|
|
new OTProcessService().BulkSave(_OtProcess);
|
|
}
|
|
|
|
public double ConvertToDailyRate(double nBasic, DateTime dMonthDate)
|
|
{
|
|
double amount = 0;
|
|
amount = nBasic / Convert.ToDouble(DateTime.DaysInMonth(dMonthDate.Year, dMonthDate.Month));
|
|
return amount;
|
|
}
|
|
|
|
public DataSet GetCCWiseOTSummary(DateTime dateTime, string sEmpID)
|
|
{
|
|
DataSet oTProcess = null;
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin();
|
|
oTProcess = OTProcessDA.GetCCWiseOTSummary(tc, dateTime, sEmpID);
|
|
tc.End();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
|
|
throw new ServiceException(e.Message, e);
|
|
|
|
#endregion
|
|
}
|
|
return oTProcess;
|
|
}
|
|
|
|
public double ConvertToHourlyRate(double nBasic, DateTime dMonthDate, int hoursinMonth)
|
|
{
|
|
double amount = 0;
|
|
double hours = Convert.ToDouble( hoursinMonth);
|
|
// if (hours <= 0) hours = GlobalFunctions.defaultConfigVal.roundOfDigit;
|
|
double doubleHOur = Convert.ToDouble(hours);
|
|
amount = nBasic / doubleHOur;
|
|
return amount;
|
|
|
|
}
|
|
public double Calculate(TermParameter param, double nHour, double nBasic, DateTime month)
|
|
{
|
|
switch (TermParameter.EntryType.ToUpper())
|
|
{
|
|
case "MINUTE":
|
|
nHour = Math.Floor(nHour);
|
|
nHour += (nHour - nHour) * 100 / 60;
|
|
break;
|
|
}
|
|
switch (param.Type)
|
|
{
|
|
case EnumOverTimeType.AnyAmount:
|
|
return nHour;
|
|
case EnumOverTimeType.DailyBasicPercent:
|
|
return (GlobalFunctions.ConvertToDailyRate(nBasic, month) * nHour * param.Amount / 100);
|
|
case EnumOverTimeType.DailyFlatAmount:
|
|
return nHour;
|
|
case EnumOverTimeType.FixedAmount:
|
|
return nHour;
|
|
case EnumOverTimeType.HourlyBasicPercent:
|
|
return this.ConvertToHourlyRate(nBasic, month, param.housInMonth) * nHour * param.Amount / 100;
|
|
case EnumOverTimeType.HourlyFlatAmount:
|
|
return nHour * param.Amount;
|
|
case EnumOverTimeType.HoursOfMonth:
|
|
break;
|
|
//case EnumOverTimeType.Slab:
|
|
// ObjectsTemplate<OTSlab> slabs = OTSlab.GetByTermID(this.TermID);
|
|
// double amount = 0;
|
|
// if (slabs != null)
|
|
// {
|
|
// for (int i = 1; i < slabs.Count; i++)
|
|
// {
|
|
// amount = slabs[i].Amount;
|
|
// if (slabs[i].Hours > Math.Round(nHour, 0))
|
|
// {
|
|
// amount = slabs[i - 1].Amount;
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// return amount;
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
public double GetPayableAmount(EmployeeOverTime ot, double nBasic)
|
|
{
|
|
TermParameter tparam = TermParameter.GetParameter(this._termParameters, (int)ot.Employee.GradeID, ot.TermID);
|
|
if (tparam == null) throw new Exception("OT parameter/Policy not found for the employee:"
|
|
+ ot.Employee.EmployeeNo + " " + ot.Employee.Name);
|
|
double nHour = ot.OTHours;
|
|
//if ((ot.OTHours - nHour) == 0)
|
|
//{
|
|
// throw new Exception("Monthly OT hours can be zero");
|
|
//}
|
|
nHour = Math.Floor(ot.OTHours);
|
|
nHour += (ot.OTHours - nHour) * 100 / 60;
|
|
switch (tparam.Type)
|
|
{
|
|
case EnumOverTimeType.AnyAmount:
|
|
return ot.OTHours;
|
|
case EnumOverTimeType.DailyBasicPercent:
|
|
return (this.ConvertToDailyRate(nBasic, ot.OTMonth) * ot.OTHours ) * (tparam.Amount / 100);
|
|
case EnumOverTimeType.DailyFlatAmount:
|
|
return ot.OTHours * tparam.Amount;
|
|
case EnumOverTimeType.FixedAmount:
|
|
return ot.OTHours ;
|
|
case EnumOverTimeType.HourlyBasicPercent:
|
|
return this.ConvertToHourlyRate(nBasic, ot.OTMonth, tparam.housInMonth) * ot.OTHours * (tparam.Amount/100);
|
|
case EnumOverTimeType.HourlyFlatAmount:
|
|
return ot.OTHours * tparam.Amount;
|
|
case EnumOverTimeType.HoursOfMonth:
|
|
break;
|
|
//case EnumOverTimeType.Slab:
|
|
// List<OTSlab> slabs = OTSlab.GetByTermID(ot.TermID);
|
|
// double amount = 0;
|
|
// if (slabs != null)
|
|
// {
|
|
// for (int i = 1; i < slabs.Count; i++)
|
|
// {
|
|
// amount = slabs[i].Amount;
|
|
// if (slabs[i].Hours > Math.Round(ot.OTHours, 0))
|
|
// {
|
|
// amount = slabs[i - 1].Amount;
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// return amount;
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//public List<OTProcess> Process(Employee oEmp)
|
|
//{
|
|
// _OtProcess = new List<OTProcess>();
|
|
// _EmpOvertimes = EmployeeOverTime.GetByEmpID(oEmp.ID, SystemInformation.CurrentSysInfo.NextPayProcessDate);
|
|
// if (_EmpOvertimes != null && _EmpOvertimes.Count > 0)
|
|
// {
|
|
// foreach (EmployeeOverTime ot in _EmpOvertimes)
|
|
// {
|
|
// _OtProcess.Add(CreateObject(ot, ot.Employee.BasicSalary));
|
|
// }
|
|
// OTProcess.Insert(_OtProcess);
|
|
// }
|
|
// return _OtProcess;
|
|
//}
|
|
|
|
public OTProcess ProcessArrear(OTProcess process, Double nBasic)
|
|
{
|
|
|
|
OTProcess oNewProcess = CreateObject(process.EmpOverTime, nBasic);
|
|
process.Amount = oNewProcess.Amount - process.Amount;
|
|
return process;
|
|
}
|
|
|
|
private OTProcess CreateObject(EmployeeOverTime ot, Double nBasic)
|
|
{
|
|
OTProcess process = new OTProcess();
|
|
process.EmployeeID = ot.EmployeeID;
|
|
process.EmpOverTimeID = ot.ID;
|
|
process.MonthDate = GlobalFunctions.LastDateOfMonth(ot.MonthDate);
|
|
process.OTMonth = GlobalFunctions.LastDateOfMonth(ot.OTMonth);
|
|
process.TermID = ot.TermID;
|
|
process.TermParameterID = ot.TermParameterID;
|
|
process.TotalHour = ot.OTHours;
|
|
process.Amount = this.GetPayableAmount(ot, nBasic);
|
|
process.PayrollTypeID = ot.PayrollTypeID;
|
|
|
|
return process;
|
|
}
|
|
#endregion OT Process/Calculator
|
|
}
|
|
|
|
#endregion
|
|
} |