EchoTex_Payroll/HRM.DA/Service/UnAuthLeave/EmployeeUnAuthorizeLeaveService.cs

876 lines
29 KiB
C#
Raw Permalink Normal View History

2024-10-14 10:01:49 +06:00
using System;
using System.Data;
using Ease.Core.Model;
using Ease.Core.DataAccess;
using Ease.Core;
using System.Collections.Generic;
using Ease.Core.Utility;
using HRM.BO;
using System.Linq;
using Microsoft.Data.SqlClient;
namespace HRM.DA
{
#region EmployeeUnAuthorizeLeave Service
public class EmployeeUnAuthorizeLeaveService : ServiceTemplate, IEmployeeUnAuthorizeLeaveService
{
#region Private functions and declaration
#endregion
public EmployeeUnAuthorizeLeaveService()
{
}
private void MapObject(EmployeeUnAuthorizeLeave oEmployeeUnAuthorizeLeave, DataReader oReader)
{
base.SetObjectID(oEmployeeUnAuthorizeLeave, (oReader.GetInt32("EmpLeaveID", 0)));
oEmployeeUnAuthorizeLeave.EmployeeID = oReader.GetInt32("EmployeeID", 0);
oEmployeeUnAuthorizeLeave.UnAuthorizeleaveID = oReader.GetInt32("LeaveID", 0);
oEmployeeUnAuthorizeLeave.MonthDate = oReader.GetDateTime("MonthDate").Value;
oEmployeeUnAuthorizeLeave.LeaveDays = oReader.GetDouble("LEAVEDAY").Value;
oEmployeeUnAuthorizeLeave.LeaveMonth = oReader.GetDateTime("LEAVEMONTH").Value;
//oEmployeeUnAuthorizeLeave.IsLateAttendanceRelated = oReader.GetBoolean("IsLateAttendanceRelated", false);
oEmployeeUnAuthorizeLeave.FromDate = oReader.GetDateTime("FROMDATE").Value;
oEmployeeUnAuthorizeLeave.ToDate = oReader.GetDateTime("TODATE").Value;
oEmployeeUnAuthorizeLeave.CreatedBy = oReader.GetInt32("CreatedBy", true, 0);
oEmployeeUnAuthorizeLeave.CreatedDate =
oReader.GetDateTime("CreatedDate", true,
DateTime.MinValue); //.HasValue ? oReader.GetDateTime("CreatedDate").Value : DateTime.MinValue;
oEmployeeUnAuthorizeLeave.ModifiedBy = oReader.GetInt32("ModifiedBy", 0);
oEmployeeUnAuthorizeLeave.ModifiedDate =
oReader.GetDateTime("ModifiedDate", true,
DateTime.MinValue); //.HasValue ? oReader.GetDateTime("ModifiedDate").Value : (DateTime?)null;
oEmployeeUnAuthorizeLeave.Type = (EnumLeaveEntryType)oReader.GetInt32("Type").Value;
oEmployeeUnAuthorizeLeave.ReferenceID = oReader.GetInt32("ReferenceID", 0);
oEmployeeUnAuthorizeLeave.ParamID = oReader.GetInt32("ParamID", 0);
oEmployeeUnAuthorizeLeave.employeeNoView = oReader.GetString("EmployeeNo", true, string.Empty);
oEmployeeUnAuthorizeLeave.employeeNameView = oReader.GetString("EmployeeName", true, string.Empty);
oEmployeeUnAuthorizeLeave.leaveNameView = oReader.GetString("leaveName", true, string.Empty);
this.SetObjectState(oEmployeeUnAuthorizeLeave, Ease.Core.ObjectState.Saved);
}
protected override T CreateObject<T>(DataReader oReader)
{
EmployeeUnAuthorizeLeave oEmployeeUnAuthorizeLeave = new EmployeeUnAuthorizeLeave();
MapObject(oEmployeeUnAuthorizeLeave, oReader);
return oEmployeeUnAuthorizeLeave as T;
}
protected EmployeeUnAuthorizeLeave CreateObject(DataReader oReader)
{
EmployeeUnAuthorizeLeave oEmployeeUnAuthorizeLeave = new EmployeeUnAuthorizeLeave();
MapObject(oEmployeeUnAuthorizeLeave, oReader);
return oEmployeeUnAuthorizeLeave;
}
#region Service implementation
public EmployeeUnAuthorizeLeave Get(int id)
{
EmployeeUnAuthorizeLeave oEmployeeUnAuthorizeLeave = new EmployeeUnAuthorizeLeave();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeUnAuthorizeLeaveDA.Get(tc, id));
if (oreader.Read())
{
oEmployeeUnAuthorizeLeave = this.CreateObject<EmployeeUnAuthorizeLeave>(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 oEmployeeUnAuthorizeLeave;
}
public List<EmployeeUnAuthorizeLeave> Get(EnumLeaveEntryType type, DateTime month)
{
List<EmployeeUnAuthorizeLeave> employeeUnAuthorizeLeaves = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeUnAuthorizeLeaveDA.Get(tc, type, month));
employeeUnAuthorizeLeaves = this.CreateObjects<EmployeeUnAuthorizeLeave>(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 employeeUnAuthorizeLeaves;
}
public List<EmployeeUnAuthorizeLeave> Get(DateTime fromDate, DateTime toDate,
EnumLeaveEntryType type)
{
List<EmployeeUnAuthorizeLeave> employeeUnAuthorizeLeaves = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeUnAuthorizeLeaveDA.Get(tc, fromDate, toDate, type));
employeeUnAuthorizeLeaves = this.CreateObjects<EmployeeUnAuthorizeLeave>(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 employeeUnAuthorizeLeaves;
}
public List<EmployeeUnAuthorizeLeave> Get()
{
List<EmployeeUnAuthorizeLeave> employeeUnAuthorizeLeaves = new List<EmployeeUnAuthorizeLeave>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeUnAuthorizeLeaveDA.Get(tc));
employeeUnAuthorizeLeaves = this.CreateObjects<EmployeeUnAuthorizeLeave>(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 employeeUnAuthorizeLeaves;
}
public List<EmployeeUnAuthorizeLeave> GetByEmployeeAfter(int nEmpID, EnumLeaveEntryType type,
DateTime lastmonth)
{
List<EmployeeUnAuthorizeLeave> employeeUnAuthorizeLeaves = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr =
new DataReader(EmployeeUnAuthorizeLeaveDA.GetByEmployeeAfter(tc, nEmpID, type, lastmonth));
employeeUnAuthorizeLeaves = this.CreateObjects<EmployeeUnAuthorizeLeave>(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 employeeUnAuthorizeLeaves;
}
public List<EmployeeUnAuthorizeLeave> GetByEmployeeID(int nEmpID)
{
List<EmployeeUnAuthorizeLeave> employeeUnAuthorizeLeaves = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeUnAuthorizeLeaveDA.GetByEmployeeID(tc, nEmpID));
employeeUnAuthorizeLeaves = this.CreateObjects<EmployeeUnAuthorizeLeave>(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 employeeUnAuthorizeLeaves;
}
public List<EmployeeUnAuthorizeLeave> GetBySalaryMonth(DateTime salaryMonth)
{
List<EmployeeUnAuthorizeLeave> employeeUnAuthorizeLeaves = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeUnAuthorizeLeaveDA.GetBySalaryMonth(tc, salaryMonth));
employeeUnAuthorizeLeaves = this.CreateObjects<EmployeeUnAuthorizeLeave>(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 employeeUnAuthorizeLeaves;
}
//public EmployeeUnAuthorizeLeave GetLeaveTypeByEmployee(int nEmpID, DateTime dMonth, EnumLeaveEntryType type)
//{
// EmployeeUnAuthorizeLeave employeeUnAuthorizeLeave = null;
// TransactionContext tc = null;
// try
// {
// tc = TransactionContext.Begin();
// DataReader oreader =
// new DataReader(EmployeeUnAuthorizeLeaveDA.GetLeaveTypeByEmployee(tc, nEmpID, dMonth, type));
// if (oreader.Read())
// {
// employeeUnAuthorizeLeave = this.CreateObject<EmployeeUnAuthorizeLeave>(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 employeeUnAuthorizeLeave;
//}
public List<EmployeeUnAuthorizeLeave> GetByEmployee(int nEmpID, int leaveid, DateTime leaveMonth, EnumLeaveEntryType type)
{
List<EmployeeUnAuthorizeLeave> items = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader =
new DataReader(EmployeeUnAuthorizeLeaveDA.GetByEmployee(tc, nEmpID, leaveid, leaveMonth, type));
items = this.CreateObjects<EmployeeUnAuthorizeLeave>(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 items;
}
public int AdjustedDays(int nID)
{
int nAjustedDays = 0;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
nAjustedDays = EmployeeUnAuthorizeLeaveDA.GetAdjustedDays(tc, nID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return nAjustedDays;
}
public int AdjustedDays(int nID, DateTime month)
{
int nAjustedDays = 0;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
nAjustedDays = EmployeeUnAuthorizeLeaveDA.GetAdjustedDays(tc, nID, 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 nAjustedDays;
}
//public List<EmployeeUnAuthorizeLeave> GetDeductedLeaves(int nEmpID, int nLeaveID, EnumLeaveEntryType type,
// DateTime nextPayProcessDate)
//{
// List<EmployeeUnAuthorizeLeave> employeeUnAuthorizeLeaves = null;
// TransactionContext tc = null;
// try
// {
// tc = TransactionContext.Begin();
// DataReader dr =
// new DataReader(
// EmployeeUnAuthorizeLeaveDA.GetDeductedLeave(tc, nEmpID, nLeaveID, type, nextPayProcessDate));
// employeeUnAuthorizeLeaves = this.CreateObjects<EmployeeUnAuthorizeLeave>(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 employeeUnAuthorizeLeaves;
//}
public List<EmployeeUnAuthorizeLeave> Get(int payrollTypeID, DateTime? salaryMonth, int? empid)
{
List<EmployeeUnAuthorizeLeave> employeeUnAuthorizeLeaves = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr =
new DataReader(EmployeeUnAuthorizeLeaveDA.Get(tc, payrollTypeID, empid, salaryMonth));
employeeUnAuthorizeLeaves = this.CreateObjects<EmployeeUnAuthorizeLeave>(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 employeeUnAuthorizeLeaves;
}
public List<EmployeeUnAuthorizeLeave> GetByEmployee(int nEmpID, DateTime dMonth, EnumLeaveEntryType type,
int payrolltypeid)
{
List<EmployeeUnAuthorizeLeave> employeeUnAuthorizeLeaves = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr =
new DataReader(EmployeeUnAuthorizeLeaveDA.GetByEmployee(tc, nEmpID, dMonth, type, payrolltypeid));
employeeUnAuthorizeLeaves = this.CreateObjects<EmployeeUnAuthorizeLeave>(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 employeeUnAuthorizeLeaves;
}
//public List<EmployeeUnAuthorizeLeave> GetByEmployeeAfter(int nEmpID, int nLeaveID, EnumLeaveEntryType type,
// DateTime LastPayProcessMonth)
//{
// List<EmployeeUnAuthorizeLeave> employeeUnAuthorizeLeaves = null;
// TransactionContext tc = null;
// try
// {
// tc = TransactionContext.Begin();
// DataReader dr =
// new DataReader(EmployeeUnAuthorizeLeaveDA.GetByEmployeeAfter(tc, nEmpID, nLeaveID, type,
// LastPayProcessMonth));
// employeeUnAuthorizeLeaves = this.CreateObjects<EmployeeUnAuthorizeLeave>(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 employeeUnAuthorizeLeaves;
//}
public int Save(EmployeeUnAuthorizeLeave oEmployeeUnAuthorizeLeave)
{
if(oEmployeeUnAuthorizeLeave.Type == EnumLeaveEntryType.PaidLeave)
{
oEmployeeUnAuthorizeLeave.LeaveMonth = GlobalFunctions.LastDateOfMonth(oEmployeeUnAuthorizeLeave.LeaveMonth);
List<EmployeeUnAuthorizeLeave> items = this.GetByEmployee(oEmployeeUnAuthorizeLeave.EmployeeID,
oEmployeeUnAuthorizeLeave.UnAuthorizeleaveID, oEmployeeUnAuthorizeLeave.LeaveMonth,
EnumLeaveEntryType.Normal);
int sumLeave = Convert.ToInt32( items.Sum(x => x.LeaveDays));
if (sumLeave ==0)
{
throw new Exception("There was no LWP on that month.");
}
if (sumLeave < oEmployeeUnAuthorizeLeave.LeaveDays)
{
throw new Exception("Adjust-Days is greater to leave-days of that perticular month");
}
}
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
if (oEmployeeUnAuthorizeLeave.IsNew)
{
int id = tc.GenerateID("MONTHLYLEAVEENTRY", "EmpLeaveID");
base.SetObjectID(oEmployeeUnAuthorizeLeave, (id));
EmployeeUnAuthorizeLeaveDA.Insert(tc, oEmployeeUnAuthorizeLeave);
}
else
{
EmployeeUnAuthorizeLeaveDA.Update(tc, oEmployeeUnAuthorizeLeave);
}
tc.End();
return oEmployeeUnAuthorizeLeave.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(TransactionContext tc, EmployeeUnAuthorizeLeave oEmployeeUnAuthorizeLeave)
{
try
{
int id = tc.GenerateID("MONTHLYLEAVEENTRY", "EmpLeaveID");
base.SetObjectID(oEmployeeUnAuthorizeLeave, (id));
oEmployeeUnAuthorizeLeave.CreatedBy = oEmployeeUnAuthorizeLeave.CreatedBy;
oEmployeeUnAuthorizeLeave.CreatedDate = DateTime.Today;
EmployeeUnAuthorizeLeaveDA.Insert(tc, oEmployeeUnAuthorizeLeave);
}
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);
EmployeeUnAuthorizeLeaveDA.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
}
}
public void DeleteAll(List<EmployeeUnAuthorizeLeave> empLeaves)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
foreach (EmployeeUnAuthorizeLeave item in empLeaves)
{
EmployeeUnAuthorizeLeaveDA.Delete(tc, item.ID);
}
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 SaveAuthorizeLeave(int employeeId, DateTime month, List<EmployeeUnAuthorizeLeave> empLeaves)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
EmployeeUnAuthorizeLeaveDA.Delete(tc, month, employeeId);
foreach (EmployeeUnAuthorizeLeave leave in empLeaves)
{
leave.Type = EnumLeaveEntryType.PaidLeave;
leave.EmployeeID = employeeId;
leave.MonthDate = month;
this.Save(tc, leave);
}
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(TransactionContext tc, List<EmployeeUnAuthorizeLeave> empLeaves)
{
try
{
int id = tc.GenerateID("MONTHLYLEAVEENTRY", "EMPLEAVEID");
DataTable oitem = new DataTable("EMPOVERTIME");
oitem.Columns.Add(new DataColumn("EMPLEAVEID", typeof(int)));
oitem.Columns.Add(new DataColumn("EMPLOYEEID", typeof(int)));
oitem.Columns.Add(new DataColumn("LEAVEID", typeof(int)));
oitem.Columns.Add(new DataColumn("MONTHDATE", typeof(DateTime))); // NULL
oitem.Columns.Add(new DataColumn("LEAVEDAY", typeof(double))); // NULL
oitem.Columns.Add(new DataColumn("CREATEDBY", typeof(int)));
oitem.Columns.Add(new DataColumn("LEAVEMONTH", typeof(DateTime)));
oitem.Columns.Add(new DataColumn("FROMDATE", typeof(DateTime)));
oitem.Columns.Add(new DataColumn("TODATE", typeof(DateTime)));
oitem.Columns.Add(new DataColumn("CREATIONDATE", typeof(DateTime))); // NULL
oitem.Columns.Add(new DataColumn("MODIFIEDBY", typeof(int))); // NULL,
oitem.Columns.Add(new DataColumn("MODIFIEDDATE", typeof(DateTime))); // NULL,
oitem.Columns.Add(new DataColumn("TYPE", typeof(int))); // NULL,
oitem.Columns.Add(new DataColumn("REFERENCEID", typeof(int))); // NULL,
oitem.Columns.Add(new DataColumn("PARAMID", typeof(int))); // NULL,
oitem.Columns.Add(new DataColumn("ISLATEATTENDANCERELATED", typeof(int)));
oitem.Columns.Add(new DataColumn("PAYROLLTYPEID", typeof(int)));
// NULL,
foreach (EmployeeUnAuthorizeLeave item in empLeaves)
{
id = id + 1;
item.ID = id;
oitem.Rows.Add(
id,
item.EmployeeID,
item.UnAuthorizeleaveID,
item.MonthDate,
item.LeaveDays,
item.CreatedBy,
item.LeaveMonth,
item.FromDate,
item.ToDate,
item.CreatedDate,
item.ModifiedBy,
item.ModifiedDate,
item.Type,
item.ReferenceID,
item.ParamID,
item.IsLateAttendanceRelated,
item.PayrollTypeID
);
}
using (SqlBulkCopy bulkCopy = new SqlBulkCopy((SqlConnection)tc.Connection, SqlBulkCopyOptions.Default, (SqlTransaction)tc.Transaction))
{
bulkCopy.BulkCopyTimeout = 6000; // in seconds
bulkCopy.ColumnMappings.Add("EMPLEAVEID", "EMPLEAVEID");
bulkCopy.ColumnMappings.Add("EMPLOYEEID", "EMPLOYEEID");
bulkCopy.ColumnMappings.Add("LEAVEID", "LEAVEID");
bulkCopy.ColumnMappings.Add("MONTHDATE", "MONTHDATE");
bulkCopy.ColumnMappings.Add("LEAVEDAY", "LEAVEDAY");
bulkCopy.ColumnMappings.Add("CREATEDBY", "CREATEDBY");
bulkCopy.ColumnMappings.Add("LEAVEMONTH", "LEAVEMONTH");
bulkCopy.ColumnMappings.Add("FROMDATE", "FROMDATE");
bulkCopy.ColumnMappings.Add("TODATE", "TODATE");
bulkCopy.ColumnMappings.Add("CREATIONDATE", "CREATIONDATE");
bulkCopy.ColumnMappings.Add("MODIFIEDBY", "MODIFIEDBY");
bulkCopy.ColumnMappings.Add("MODIFIEDDATE", "MODIFIEDDATE");
bulkCopy.ColumnMappings.Add("TYPE", "TYPE");
bulkCopy.ColumnMappings.Add("REFERENCEID", "REFERENCEID");
bulkCopy.ColumnMappings.Add("PARAMID", "PARAMID");
bulkCopy.ColumnMappings.Add("ISLATEATTENDANCERELATED", "ISLATEATTENDANCERELATED");
bulkCopy.ColumnMappings.Add("PAYROLLTYPEID", "PAYROLLTYPEID");
bulkCopy.DestinationTableName = "MONTHLYLEAVEENTRY";
bulkCopy.WriteToServer(oitem);
}
}
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<EmployeeUnAuthorizeLeave> empLeaves, DateTime NextPayprocessDate)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
EmployeeUnAuthorizeLeaveDA.Delete(tc, NextPayprocessDate);
foreach (EmployeeUnAuthorizeLeave leave in empLeaves)
{
this.Save(tc, leave);
}
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public DataSet GetUnAuthorizeLeave(DateTime date)
{
DataSet unAuthoLeaves = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
unAuthoLeaves = EmployeeUnAuthorizeLeaveDA.GetUnAuthorizeLeave(tc, date);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return unAuthoLeaves;
}
public void Save(List<EmployeeUnAuthorizeLeave> empLeaves)
{
throw new NotImplementedException();
}
public List<EmployeeUnAuthorizeLeave> GetByEmployee(int nEmpID, EnumLeaveEntryType type)
{
throw new NotImplementedException();
}
public List<EmployeeUnAuthorizeLeave> GetByEmployee(int nEmpID, int nLeaveID, EnumLeaveEntryType type)
{
throw new NotImplementedException();
}
#endregion
}
#endregion
}