HRM-10/HRM.DA/Service/Employee/EmployeeService.cs
2026-11-09 14:41:04 +06:00

6244 lines
200 KiB
C#

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 System.Linq.Expressions;
using HRM.BO;
using System.ComponentModel.DataAnnotations;
using static iTextSharp.text.pdf.AcroFields;
namespace HRM.DA
{
public class EmployeeService : ServiceTemplate, IEmployeeService
{
public EmployeeService()
{
}
private void MapObject(Employee oEmployee, DataReader oReader)
{
try
{
base.SetObjectID(oEmployee, oReader.GetInt32("EmployeeID").Value);
oEmployee.GlobalID = oReader.GetString("globalID");
oEmployee.EmployeeNo = oReader.GetString("employeeNo");
oEmployee.Name = oReader.GetString("name");
oEmployee.Gender = (EnumGender)oReader.GetInt32("gender").Value;
//oEmployee.IsManager = oReader.GetBoolean("IsManager").Value;
oEmployee.BirthDate = oReader.GetDateTime("birthDate").Value;
oEmployee.JoiningDate = oReader.GetDateTime("joiningDate").Value;
//DateTime? RetirementDateValue = oReader.GetDateTime("RetirementDate");
//oEmployee.RetirementDate = RetirementDateValue.HasValue ? RetirementDateValue.Value : null;
oEmployee.EndOfContractDate = oReader.GetDateTime("endOfContractDate"); // ? oReader.GetDateTime("endOfContractDate").Value : DateTime.MinValue;
oEmployee.CardDate = oReader.GetDateTime("CardDate");
oEmployee.EmailAddress = oReader.GetString("emailAddress");
oEmployee.MobileNo = oReader.GetString("mobileNo");
oEmployee.TinNo = oReader.GetString("tinNo");
oEmployee.CategoryID = oReader.GetInt32("categoryID", true, 0);
oEmployee.ForeignExPat = oReader.GetBoolean("foreignExPat").Value;
oEmployee.TaxCircle = (EnumTaxCircle)oReader.GetInt32("TAXCIRCLE", true, 0);
oEmployee.IsConfirmed = oReader.GetBoolean("isConfirmed").Value;
oEmployee.Status = (EnumEmployeeStatus)oReader.GetInt32("status").Value;
/*oEmployee.ProfileStatus = oReader.GetInt32("ProfileStatus") != null
? (EnumProfileStatus)oReader.GetInt32("ProfileStatus").Value
: EnumProfileStatus.Inserted_By_Employee;*/
//oEmployee.IsShownInTaxSheet = oReader.GetBoolean("isShownInTaxSheet").Value;
oEmployee.PFMemberType = (EnumPFMembershipType)oReader.GetInt32("pFMemberType").Value;
oEmployee.PFMemberShiptDate = oReader.GetDateTime("pfMemberShipDt").HasValue
? oReader.GetDateTime("pfMemberShipDt").Value
: DateTime.Now;
oEmployee.BranchID = oReader.GetInt32("branchID");
oEmployee.AccountNo = oReader.GetString("accountNo");
oEmployee.OutPayBranchID = oReader.GetInt32("OUTPAYBRANCHID");
oEmployee.OutPayAccountNo = oReader.GetString("outPayAccountNo");
oEmployee.DepartmentID = oReader.GetInt32("departmentID");
oEmployee.LocationID = oReader.GetInt32("locationID");
oEmployee.ReligionID = oReader.GetInt32("religionID").Value;
oEmployee.MaritalStatus = (EnumMaritalStatus)oReader.GetInt32("maritalStatusID").Value;
oEmployee.DesignationID = oReader.GetInt32("designationID");
oEmployee.GradeID = oReader.GetInt32("gradeID", 0);
oEmployee.BasicSalary = oReader.GetDouble("basicSalary").Value;
oEmployee.PrevBasic = oReader.GetDouble("prevBasic").Value;
oEmployee.PaymentMode = (EnumPaymentMode)oReader.GetInt32("paymentMode").Value;
oEmployee.OutPayPaymentMode = (EnumPaymentMode)oReader.GetInt32("OutPayPaymentMode").Value;
oEmployee.FatherName = oReader.GetString("fatherName");
oEmployee.MotherName = oReader.GetString("MOTHERNAME");
oEmployee.FatherOccupationId = oReader.GetInt32("FATHEROCCUPATIONID", 0);
oEmployee.MotherOccupationId = oReader.GetInt32("MOTHEROCCUPATIONID", 0);
oEmployee.IsEligibleOT = oReader.GetBoolean("isEligibleOT").Value;
oEmployee.DescriptionText = oReader.GetString("desigDescription");
oEmployee.DesktopUserPass = oReader.GetString("desktopUserPass");
oEmployee.PayrollTypeID = oReader.GetInt32("payrollTypeID").Value;
//oEmployee.IsAutoProcess = oReader.GetBoolean("IsAutoProcess").Value;
oEmployee.CardID = oReader.GetInt32("cardID");
oEmployee.GrossSalary = oReader.GetDouble("grossSalary").Value;
//oEmployee.PhotoPath = oReader.GetString("PhotoPath");
oEmployee.PayScaleId = oReader.GetInt32("payScaleId");
oEmployee.TaxAmount = oReader.GetDouble("taxAmount").Value;
oEmployee.CurrentHistoryID = oReader.GetInt32("EmpHistoryID");
oEmployee.MonthStatusUpdate = oReader.GetInt32("MonthStatusUpdate").HasValue
? (EnumEmployeeStatus)oReader.GetInt32("MonthStatusUpdate")
: EnumEmployeeStatus.Live;
//Diu to few clients already gets 0 default values;
if (oEmployee.MonthStatusUpdate == 0) oEmployee.MonthStatusUpdate = EnumEmployeeStatus.Live;
oEmployee.ConfirDate = oReader.GetDateTime("dateOfConfirmation");
oEmployee.DiscontinueDate = oReader.GetDateTime("dateOfExpiry");
//!= null
// ? oReader.GetDateTime("dateOfExpiry").Value
// : DateTime.MinValue;
oEmployee.VendorCode = oReader.GetString("VendorCode");
//oEmployee.Role = (EnumRole)oReader.GetInt32("Role").Value;
//oEmployee.Role = oReader.GetBoolean("Role").Value;
oEmployee.CreatedBy = oReader.GetInt32("CreatedBy").Value;
oEmployee.CreatedDate = oReader.GetDateTime("CreationDate").Value;
oEmployee.ModifiedBy = oReader.GetInt32("ModifiedBy");
oEmployee.ModifiedDate = oReader.GetDateTime("ModifiedDate");
oEmployee.PersonType = (EnumPersonType)oReader.GetInt32("PersonType", true, 0);
oEmployee.LineManagerID = oReader.GetInt32("LineManagerID").HasValue ? oReader.GetInt32("LineManagerID").Value : null;
oEmployee.SecondLineManagerID = oReader.GetInt32("SecondLineManagerID").HasValue ? oReader.GetInt32("SecondLineManagerID").Value : null;
oEmployee.MobileNo = oReader.GetString("MobileNo");
oEmployee.GeId = oReader.GetString("GeId", true, string.Empty);
oEmployee.ExtraField1 = oReader.GetString("ExtraField1", true, string.Empty);
oEmployee.ExtraField2 = (EnumBaseStation)oReader.GetInt32("ExtraField2", true, 0);
oEmployee.ExtraField3 = oReader.GetString("ExtraField3", true, string.Empty);
oEmployee.ExtraField4 = oReader.GetString("ExtraField4", true, string.Empty);
oEmployee.ExtraField5 = oReader.GetString("ExtraField5", true, string.Empty);
oEmployee.FirstName = oReader.GetString("FirstName", true, string.Empty);
oEmployee.LastName = oReader.GetString("LastName", true, string.Empty);
oEmployee.CrgId = oReader.GetInt32("CrgId");
oEmployee.NationalityID = oReader.GetInt32("NATIONALITYID", true, 0);
oEmployee.ProfileCompletionPercent = oReader.GetInt32("ProfileComplitionPercent", true, 0);
oEmployee.InsuranceId = oReader.GetString("InsuranceId", true, string.Empty);
oEmployee.InclusionDate = oReader.GetDateTime("InclusionDate", true, DateTime.MinValue);
oEmployee.IsFixedLocation = oReader.GetBoolean("IsFixedLocation", true, false);
oEmployee.HasDisableChildren = oReader.GetBoolean("HasDisableChildren", true, false);
oEmployee.IsSalaryWithHeld = oReader.GetBoolean("IsSalaryWithHeld", true, false);
oEmployee.NationalId = oReader.GetString("NATIONALID", true, string.Empty);
oEmployee.PassportNo = oReader.GetString("PASSPORTNO", true, string.Empty);
oEmployee.Address = oReader.GetString("Address", true, string.Empty);
//oEmployee.SBU = oReader.GetString("SBU", true, string.Empty);
this.SetObjectState(oEmployee, Ease.Core.ObjectState.Saved);
}
catch (Exception e)
{
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
}
}
protected override T CreateObject<T>(DataReader oReader)
{
Employee oEmployee = new Employee();
MapObject(oEmployee, oReader);
return oEmployee as T;
}
protected Employee CreateObject(DataReader oReader)
{
Employee oEmployee = new Employee();
MapObject(oEmployee, oReader);
return oEmployee;
}
//protected List<Employee> CreateObjects(DataReader oDatareader)
//{
//}
#region Service implementation
public Employee Get(TransactionContext tc, int id)
{
Employee oEmployee = null;
try
{
DataReader oreader = new DataReader(EmployeeDA.Get(tc, id));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(oreader);
}
oreader.Close();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return oEmployee;
}
public List<Employee> GetAbsentEmployees(DateTime fromDate, DateTime toDate)
{
TransactionContext tc = null;
List<Employee> employees = new List<Employee>();
try
{
DataReader dr = new DataReader(EmployeeDA.GetAbsentEmployees(tc, fromDate, toDate));
employees = this.CreateObjects<Employee>(dr);
dr.Close();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return employees;
}
public List<Employee> GetAllLive()
{
TransactionContext tc = null;
List<Employee> employees = new List<Employee>();
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetAllLive(tc));
employees = this.CreateObjects<Employee>(dr);
dr.Close();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return employees;
}
public Employee Get(int id)
{
Employee oEmployee = null;
//Employee oLMEmployee = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.Get(tc, id));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(oreader);
}
oreader.Close();
tc.End();
//if (oEmployee != null &&
// oEmployee.LineManagerID != null &&
// oEmployee.LineManagerID != 0)
//{
// DataReader oreaderLM = new DataReader(EmployeeDA.Get(tc, (int)oEmployee.LineManagerID));
// if (oreaderLM.Read())
// {
// oLMEmployee = this.CreateObject<Employee>(oreaderLM);
// }
// oreaderLM.Close();
//}
//tc.End();
//if (oEmployee != null)
//{
// Grade grade = oEmployee.GradeID != null ? new GradeService().Get(oEmployee.GradeID.GetValueOrDefault()) : null;
// Department department = oEmployee.DepartmentID != null ? new DepartmentService().Get((int)oEmployee.DepartmentID) : null;
// Designation designation = oEmployee.DesignationID != null ? new DesignationService().Get((int)oEmployee.DesignationID) : null;
// oEmployee.GradeName = grade != null ? grade.Name : string.Empty;
// oEmployee.DepartmentName = department != null ? department.Name : string.Empty;
// oEmployee.DesignationName = designation != null ? designation.Name : string.Empty;
// oEmployee.LineManager = oLMEmployee != null ? oLMEmployee.Name + " (" + oLMEmployee.EmployeeNo + ")" : string.Empty;
// Category category = oEmployee.CategoryID != 0
// ? new CategoryService().Get(oEmployee.CategoryID)
// : null;
// oEmployee.CategoryName = category != null ? category.Name : string.Empty;
//}
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return oEmployee;
}
public Employee GetByEmpCode(string empCode)
{
Employee oEmployee = null;
//Employee oLMEmployee = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetByEmpCode(tc, empCode));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
public Employee GetEmployeeForHnm(int id)
{
Employee oEmployee = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetEmpForHNM(tc, id));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
public List<Employee> Get(string id)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetEmployeeByIDs(tc, id));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetMaternityLeaveEmployee(DateTime formDate, DateTime toDate)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetMaternityLeaveEmployee(tc, formDate, toDate));
employees = this.CreateObjects<Employee>(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 employees;
}
public bool GetIsFixedPositionForMobile(int employeeid)
{
#region WF Movements
TransactionContext tc = null;
bool IsFixedPosition = false;
try
{
tc = TransactionContext.Begin();
IsFixedPosition = EmployeeDA.GetIsFixedPositionForMobile(tc, employeeid);
tc.End();
}
catch (ServiceException ex)
{
#region Handle Error
if (tc != null)
tc.HandleError();
ExceptionLog.Write(ex);
throw new ServiceException(ex.Message);
#endregion
}
#endregion
return IsFixedPosition;
}
public DataTable GetEmployeeForDashboard(int ID)
{
TransactionContext tc = null;
DataTable dt = null;
try
{
tc = TransactionContext.Begin();
dt = EmployeeDA.GetEmployeeForDashboard(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
}
return dt;
}
public DataTable GetNewJoiners(int payrolltypeID)
{
TransactionContext tc = null;
DataTable dt = null;
try
{
tc = TransactionContext.Begin();
dt = EmployeeDA.GetNewJoiners(tc, payrolltypeID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataTable GetNewJoinersWithSearchText(string searchText, int payrolltypeID)
{
TransactionContext tc = null;
DataTable dt = null;
try
{
tc = TransactionContext.Begin();
dt = EmployeeDA.GetNewJoinersWithSearchText(tc, searchText, payrolltypeID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataTable GetEmployeeByLinemanagerId(int linemanagerId, int teamType, int payrolltypeId)
{
TransactionContext tc = null;
DataTable dt = null;
try
{
tc = TransactionContext.Begin();
dt = EmployeeDA.GetEmployeeByLinemanagerId(tc, linemanagerId, teamType, payrolltypeId);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataTable GetEmployeeActivitiesForDashboard(int employeeID)
{
TransactionContext tc = null;
DataTable dt = null;
try
{
tc = TransactionContext.Begin();
dt = EmployeeDA.GetEmployeeActivitiesForDashboard(tc, employeeID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataTable getNameAndEmail(int empid)
{
TransactionContext tc = null;
DataTable dt = null;
try
{
tc = TransactionContext.Begin();
dt = EmployeeDA.GetNameAndMail(tc, empid);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataTable GetNameAndMailWithNoLock(int empid)
{
TransactionContext tc = null;
DataTable dt = null;
try
{
tc = TransactionContext.Begin();
dt = EmployeeDA.GetNameAndMailWithNoLock(tc, empid);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataTable GetUserForLandingPage(int userId)
{
TransactionContext tc = null;
DataTable dt = null;
try
{
tc = TransactionContext.Begin();
dt = EmployeeDA.GetUserForLandingPage(tc, userId);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataSet GetAbsentEmployeesForLM(DateTime fromDate, DateTime toDate, EnumAttendanceType attnType)
{
TransactionContext tc = null;
DataSet employees = null;
try
{
tc = TransactionContext.Begin();
employees = EmployeeDA.GetAbsentEmployeesForLM(tc, fromDate, toDate, attnType);
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return employees;
}
public DataSet GetLinemanagerPendingList()
{
TransactionContext tc = null;
DataSet employees = null;
try
{
employees = EmployeeDA.GetLinemanagerPendingList(tc);
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return employees;
}
public List<Employee> GetAllHREmpsWorkAniversary(string payrollTypeId)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetAllHREmpsWorkAniversary(tc, payrollTypeId));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetAllHREmpsBirthday(string payrollTypeId)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetAllHREmpsBirthday(tc, payrollTypeId));
employees = this.CreateObjects<Employee>(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 employees;
}
public DataTable GetMaternityLeaveEmployeeBasicInfo(int empID)
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetMaternityLeaveEmployeeBasicInfo(tc, empID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds.Tables[0];
}
public List<Employee> GetAllAbsentOnYesterdayEmps(string payrollTypeId)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetAllAbsentOnYesterdayEmps(tc, payrollTypeId));
employees = this.CreateObjects<Employee>(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 employees;
}
internal List<Employee> GetByEmpNos(TransactionContext tc, string sEmpIDs)
{
List<Employee> employees = new List<Employee>();
try
{
DataReader dr = new DataReader(EmployeeDA.GetByEmpNos(tc, sEmpIDs));
employees = this.CreateObjects<Employee>(dr);
dr.Close();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return employees;
}
public List<Employee> GetByEmpNos(string sEmpIDs)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetByEmpNos(tc, sEmpIDs));
employees = this.CreateObjects<Employee>(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 employees;
}
public Employee GetByCardID(int id)
{
Employee oEmployee = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetByCardID(tc, id));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
public Employee GetParentEmployee(int id)
{
Employee oEmployee = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetParentEmployee(tc, id));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
public Employee GetLineManager(int empId)
{
Employee item = new Employee();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetLineManager(tc, empId));
if (oreader.Read())
{
item = this.CreateObject<Employee>(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 item;
}
public Employee GetwitoutchekPayrolltype(string employeeNo)
{
Employee oEmployee = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetWithOutcheckPayrollType(tc, employeeNo));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
public Employee Get(string employeeNo, int payrollTypeID)
{
Employee oEmployee = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.Get(tc, employeeNo, payrollTypeID));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
public Employee GetByEmail(string email)
{
Employee oEmployee = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetbyEmail(tc, email));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
public Employee GetFromAll(string employeeNo, int payrollTypeID)
{
Employee oEmployee = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetFromAll(tc, employeeNo, payrollTypeID));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
//public List<Employee> Get(List<SearchEmployee> searchEmployees, int payrollTypeID)
//{
// List<Employee> employees = new List<Employee>();
// string InEmps = "";
// foreach (SearchEmployee item in searchEmployees)
// {
// InEmps = InEmps + item.EmployeeID.ToString() + ", ";
// }
// if (InEmps.Length > 2) InEmps = InEmps.Substring(0, InEmps.Length - 2);
// TransactionContext tc = null;
// try
// {
// tc = TransactionContext.Begin();
// DataReader dr = new DataReader(EmployeeDA.GetbyInSQL(tc, InEmps, payrollTypeID));
// employees = this.CreateObjects<Employee>(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 employees;
//}
public List<Employee> GetByDeptIDs(string sIDs, int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetByDeptIDs(tc, sIDs, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
public DataSet GetAllEmpBasicInfo(string empIDs)
{
DataSet designationWiseCountDS = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
designationWiseCountDS = EmployeeDA.GetAllEmpBasicInfo(tc, empIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return designationWiseCountDS;
}
public List<Employee> GetByDeptShiftGFType(string deptIDs, int shiftID, string GFType, int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr =
new DataReader(EmployeeDA.GetByDeptShiftGFType(tc, deptIDs, shiftID, GFType, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
//Previously Get
public List<Employee> GetWithPayrollType(int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetWithPayrollType(tc, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetForSuperUser()
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetForSuperUser(tc));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetAllEmps()
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetAllEmps(tc));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetAllEmps(int payrollTypeid)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetAllEmps(tc, payrollTypeid));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetAllEmps(TransactionContext tc)
{
List<Employee> employees = new List<Employee>();
try
{
DataReader dr = new DataReader(EmployeeDA.GetAllEmps(tc));
employees = this.CreateObjects<Employee>(dr);
dr.Close();
}
catch (Exception e)
{
#region Handle Exception
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return employees;
}
public DataSet GetEmployeeIncrement(string empIDs)
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeIncrement(tc, empIDs);
}
catch (Exception e)
{
throw new ServiceException(e.Message, e);
}
return ds;
}
public void UpdateLM2(List<Employee> emps)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
foreach (Employee item in emps)
{
EmployeeDA.UpdateLM(tc, item.ID, (int)item.LineManagerID, item.SecondLineManagerID);
}
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 GetCashAdvice(string sEmpIDs, string dSalDate)
{
DataSet oDataSet = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oDataSet = EmployeeDA.GetCashAdvice(tc, sEmpIDs, dSalDate);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return oDataSet;
}
public List<Employee> GetJoiningData(DateTime formDate)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetJoiningData(tc, formDate));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetWithDiscontinue(int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetWithDiscontinue(tc, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
//for Attendance Process
public List<Employee> GetAbsentEmp(DateTime attnDate, EnumWorkPlanGroup wpGroup, int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetAbsentEmp(tc, attnDate, wpGroup, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetAttendaceEmp(EnumWorkPlanGroup wpGroup, int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetAttendaceEmp(tc, wpGroup, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetEmpExceptAutoWP(DateTime attnDate, int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetEmpExceptAutoWP(tc, attnDate, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetDiscontinueEmp(DateTime attnDate, DateTime currentDate, int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetDiscontinueEmp(tc, attnDate, currentDate, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
//
public List<Employee> Get(int status, DateTime lastDateOfYear)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.Get(tc, status, lastDateOfYear));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> Get(EnumEmployeeStatus status, int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.Get(tc, status, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
public DataTable GetEmpIDsOfManager(int status, DateTime lastDateOfYear)
{
DataTable dataTableOfEmployee = new DataTable("Employee");
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataSet dataSet = EmployeeDA.GetEmpIDsOfManager(tc, status, lastDateOfYear);
dataTableOfEmployee = dataSet.Tables[0];
dataSet.Dispose();
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dataTableOfEmployee;
}
public DataSet GetEncashmentReport(string sEmpIDs, string leaveYear)
{
DataSet oDataSet = null;
TransactionContext tc = null;
try
{
#region Retrieving data
tc = TransactionContext.Begin();
oDataSet = EmployeeDA.GetEncashmentReport(tc, sEmpIDs, leaveYear);
tc.End();
#endregion
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
throw new ServiceException(e.Message, e);
#endregion
}
return oDataSet;
}
public List<Employee> GetEmpsWithDiscontinue(string empIDs, int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetEmpsWithDiscontinue(tc, empIDs, payrollTypeID));
employees = this.CreateObjects<Employee>(dr);
dr.Close();
tc.End();
List<Designation> designations = new DesignationService().GetAll();
List<Department> departments = new DepartmentService().GetAll();
List<Location> locations = new LocationService().GetLocations();
employees.ForEach(emp =>
{
if (emp.DesignationID != null)
{
//emp.Designation = new DesignationService().Get(emp.DesignationID.Value);
emp.Designation = designations.Where(x => x.ID == emp.DesignationID.Value).FirstOrDefault();
}
else
{
emp.Designation = new Designation();
}
if (emp.DepartmentID != null)
{
emp.Department = departments.Where(x => x.ID == emp.DepartmentID.Value).FirstOrDefault();
//emp.Department = new DepartmentService().Get(emp.DepartmentID.Value);
}
else
{
emp.Department = new Department();
}
if (emp.LocationID != null)
{
emp.Location = locations.Where(x => x.ID == emp.LocationID.Value).FirstOrDefault();
//emp.Location = new LocationService().Get(emp.LocationID.Value);
}
else
{
emp.Location = new Location();
}
});
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return employees;
}
public List<Employee> GetByEmpIDs(string empIDs, int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetByEmpIDs(tc, empIDs, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetByEmpIDs(string empIDs)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetByEmpIDs(tc, empIDs));
employees = this.CreateObjects<Employee>(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 employees;
}
public void UpdateBanglaInformation(List<object> employeBanglaInfo)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
EmployeeDA.UpdateBanglaInformation(tc, employeBanglaInfo);
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 UpdateBanglaContactInformation(List<object> employeBanglaInfo)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
EmployeeDA.UpdateBanglaContactInformation(tc, employeBanglaInfo);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public List<Employee> GetNew(DateTime dt, int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetNew(tc, dt, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetFssEmp(string empIDs, int payrollTypeID)
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetFssEmp(tc, empIDs, payrollTypeID));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetTopMostEmployees()
{
List<Employee> employees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetTopMostEmployees(tc));
employees = this.CreateObjects<Employee>(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 employees;
}
//Insert For Excel Data
//public void SaveBasicInfo(Employee oEmployee)
//{
// TransactionContext tc = null;
// try
// {
// tc = TransactionContext.Begin(true);
// if (oEmployee.IsNew)
// {
// int id = tc.GenerateID("Employee", "EmployeeID");
// base.SetObjectID(oEmployee, id);
// EmployeeDA.Insert(tc, oEmployee);
// tc.End();
// if (oEmployee.EmployeeGradeSalary != null)
// {
// oEmployee.EmployeeGradeSalary.EmployeeID = oEmployee.ID;
// oEmployee.EmployeeGradeSalary.GradeSalaryTypeID = 1;
// oEmployee.EmployeeGradeSalary.EffectDate = SystemInformation.CurrentSysInfo.LastPayProcessDate;
// }
// if (oEmployee.EmployeeBankAccount != null)
// {
// oEmployee.EmployeeBankAccount.EmployeeID = oEmployee.ID;
// oEmployee.EmployeeBankAccount.EffectDate = SystemInformation.CurrentSysInfo.LastPayProcessDate;
// }
// if (oEmployee.EmployeePosting != null)
// {
// oEmployee.EmployeePosting.EmployeeID = oEmployee.ID;
// oEmployee.EmployeePosting.EffectDate = SystemInformation.CurrentSysInfo.LastPayProcessDate;
// }
// oEmployee.EmployeeGradeSalary.Insert();
// //oEmployee.EmployeeBankAccount.Insert();
// (new EmployeeBankAccountService()).Insert(oEmployee.EmployeeGradeSalary);
// oEmployee.EmployeePosting.Insert();
// }
// else
// {
// EmployeeDA.Update(tc, oEmployee);
// tc.End();
// }
// }
// catch (Exception e)
// {
// #region Handle Exception
// if (tc != null)
// tc.HandleError();
// ExceptionLog.Write(e);
// throw new ServiceException(e.Message, e);
// #endregion
// }
//}
public int Save(Employee oEmployee)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
if (oEmployee.IsNew)
{
int id = tc.GenerateID("Employee", "EmployeeID");
base.SetObjectID(oEmployee, id);
EmployeeDA.Insert(tc, oEmployee);
}
else
{
EmployeeDA.Update(tc, oEmployee);
}
tc.End();
return oEmployee.ID;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public int SaveHnmEmployee(List<object> employeeData)
{
TransactionContext tc = null;
Employee oEmployee = null;
EmpContact empContact = null;
int id = 0;
try
{
foreach (var item in employeeData)
{
if (item is Employee)
{
oEmployee = (Employee)item;
}
if (item is EmpContact)
{
empContact = (EmpContact)item;
}
}
tc = TransactionContext.Begin(true);
if (oEmployee != null && oEmployee.IsNew)
{
id = tc.GenerateID("Employee", "EmployeeID");
base.SetObjectID(oEmployee, id);
EmployeeDA.Insert(tc, oEmployee);
}
else
{
EmployeeDA.Update(tc, oEmployee);
}
EmployeeDA.DeleteEmpContact(tc, oEmployee.ID);
if (empContact != null)
{
empContact.EmployeeID = oEmployee.ID;
var iD = tc.GenerateID("EMPCONTACT", "ContactID");
base.SetObjectID(empContact, iD);
EmployeeDA.InsertEmpContact(tc, empContact);
}
tc.End();
return oEmployee.ID;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
//public void SaveIntegration(List<HREmployee> oEmps)
//{
// TransactionContext tc = null;
// try
// {
// tc = TransactionContext.Begin(true);
// EmpLifeCycleService lcService = null;
// EmployeeBankAccountService ebaService = null;
// foreach (HREmployee oEmployee in oEmps)
// {
// if (string.IsNullOrEmpty(oEmployee.EmployeeNo)) continue;
// if (oEmployee.IsNew)
// {
// int id = tc.GenerateID("Employee", "EmployeeID");
// base.SetObjectID(oEmployee, ID.FromInteger(id));
// oEmployee.CreatedBy = User.CurrentUser.ID;
// oEmployee.CreatedDate = DateTime.Today;
// HREmployeeDA.InsertForIntegration(tc, oEmployee);
// }
// else
// {
// oEmployee.ModifiedBy = User.CurrentUser.ID;
// oEmployee.ModifiedDate = DateTime.Today;
// HREmployeeDA.UpdateForIntegration(tc, oEmployee);
// }
// //Insert Life cycle
// if (oEmployee.EmpLifeCycle != null && oEmployee.EmpLifeCycle.StatusDetailID != null && !oEmployee.EmpLifeCycle.StatusDetailID.IsUnassigned)
// {
// lcService = new EmpLifeCycleService();
// oEmployee.EmpLifeCycle.EmployeeID = oEmployee.ID;
// oEmployee.EmpLifeCycle.CreatedBy = User.CurrentUser.ID;
// oEmployee.EmpLifeCycle.CreatedDate = DateTime.Now;
// lcService.SaveIntegration(oEmployee.EmpLifeCycle, tc, oEmployee);
// }
// //Insert Employee Account History
// if (oEmployee.EmployeeBankAccount != null)
// {
// ebaService = new EmployeeBankAccountService();
// oEmployee.EmployeeBankAccount.EmployeeID = oEmployee.ID;
// oEmployee.EmployeeBankAccount.CreatedBy = User.CurrentUser.ID;
// oEmployee.EmployeeBankAccount.CreatedDate = DateTime.Now; ;
// if (oEmployee.EmployeeBankAccount.EffectDate != DateTime.MinValue)
// ebaService.SaveIntegration(oEmployee.EmployeeBankAccount, tc);
// }
// //Insert Employee Contacts
// if (oEmployee.Contacts != null && oEmployee.Contacts.Count > 0)
// {
// if (!oEmployee.IsNew)
// HREmployeeDA.Delete(tc, "EmpContact", "EmployeeID", oEmployee.ID);
// foreach (EmpContact item in oEmployee.Contacts)
// {
// item.EmployeeID = oEmployee.ID;
// this.SetObjectID(item, ID.FromInteger(HREmployeeDA.GetNewID(tc, "EmpContact", "ContactID")));
// HREmployeeDA.Insert(tc, item);
// }
// }
// //Insert Employee Spoused
// if (oEmployee.Spouses != null && oEmployee.Spouses.Count > 0)
// {
// //if (!oEmployee.IsNew)
// // HREmployeeDA.Delete(tc, "EmpSpouse", "EmployeeID", oEmployee.ID);
// foreach (EmpSpouse item in oEmployee.Spouses)
// {
// item.EmployeeID = oEmployee.ID;
// this.SetObjectID(item, ID.FromInteger(HREmployeeDA.GetNewID(tc, "EmpSpouse", "SpouseID")));
// HREmployeeDA.Insert(tc, item);
// }
// }
// //Insert Employee Child
// if (oEmployee.ChildrenList != null && oEmployee.ChildrenList.Count > 0)
// {
// //if (!oEmployee.IsNew)
// // HREmployeeDA.Delete(tc, "EmpChildren", "EmployeeID", oEmployee.ID);
// foreach (EmpChildren item in oEmployee.ChildrenList)
// {
// item.EmployeeID = oEmployee.ID;
// this.SetObjectID(item, ID.FromInteger(HREmployeeDA.GetNewID(tc, "EmpChildren", "ChildID")));
// HREmployeeDA.Insert(tc, item);
// }
// }
// //Insert Employee Costcenter
// if (oEmployee.EmployeeCostCenters != null && oEmployee.EmployeeCostCenters.Count > 0)
// {
// //if (!oEmployee.IsNew)
// // HREmployeeDA.Delete(tc, "EMPCOSTCENTER", "EmployeeID", oEmployee.ID);
// oEmployee.EmployeeCostCenters.ForEach(x => x.EmployeeID = oEmployee.ID);
// EmployeeCostCenterService ocda = new EmployeeCostCenterService();
// ocda.Insert(tc, oEmployee.EmployeeCostCenters);
// //foreach (EmployeeCostCenter item in oEmployee.EmployeeCostCenters)
// //{
// // item.EmployeeID = oEmployee.ID;
// // this.SetObjectID(item, ID.FromInteger(HREmployeeDA.GetNewID(tc, "EMPCOSTCENTER", "CostCenterID")));
// // HREmployeeDA.Insert(tc, item);
// //}
// }
// //Update AuroraEmployee
// AuroraEmployeeCompositeTypeDA.UpdateForProcess(tc, DateTime.Today, User.CurrentUser.ID.ToString(), oEmployee.EmployeeNo, oEmployee.GlobalID);
// }
// tc.End();
// }
// catch (Exception e)
// {
// #region Handle Exception
// if (tc != null)
// tc.HandleError();
// ExceptionLog.Write(e);
// throw new ServiceException(e.Message, e);
// #endregion
// }
//}
public int GetCurrentHeadCount(int departmentId, int designationId, int gradeId)
{
TransactionContext tc = null;
int? empCount = 0;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetCurrentHeadCount(tc, departmentId, designationId, gradeId));
if (dr.Read())
{
empCount = 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 empCount ?? 0;
}
public void UpdateLineManager(List<Employee> employees)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
foreach (Employee item in employees)
{
EmployeeDA.UpdateLineManager(tc, item);
}
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, int UserID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
EmployeeDA.Delete(tc, id, UserID);
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(int UserID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
EmployeeDA.DeleteAll(tc, UserID);
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 UpdateStatus(int employeeID, int historyID, DateTime effectDate, EnumEmployeeStatus status)
{
TransactionContext tc = null;
tc = TransactionContext.Begin(true);
EmployeeDA.UpdateStatus(tc, employeeID, historyID, effectDate, status);
tc.End();
}
public void UpdateCardInformation(int employeeID, int CardID, bool IsAutoProcess)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
EmployeeDA.UpdateCardInformation(tc, employeeID, CardID, IsAutoProcess);
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 UpdateEmpCardHistory(int employeeID, int CardID, DateTime cardDate, string cardNumber)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
EmployeeDA.UpdateEmpCardHistory(tc, employeeID, CardID, cardDate, cardNumber);
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 UpdateEmpCardHistory(TransactionContext tc, int employeeID, int CardID, DateTime cardDate,
string cardNumber)
{
try
{
EmployeeDA.UpdateEmpCardHistory(tc, employeeID, CardID, cardDate, cardNumber);
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public void UpdateCardInformation(TransactionContext tc, int employeeID, int CardID, bool IsAutoProcess)
{
try
{
EmployeeDA.UpdateCardInformation(tc, employeeID, CardID, IsAutoProcess);
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public void UpdatePFMemship(int empID, EnumPFMembershipType PFType, DateTime dPFEffectDate)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
EmployeeDA.UpdatePFMemship(tc, empID, PFType, dPFEffectDate);
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 UpdateTaxAmount(int employeeID, double TaxAmount)
{
TransactionContext tc = null;
tc = TransactionContext.Begin(true);
EmployeeDA.UpdateTaxAmount(tc, employeeID, TaxAmount);
tc.End();
}
public void UpdateEmpRole(Employee oEmp)
{
TransactionContext tc = null;
tc = TransactionContext.Begin(true);
EmployeeDA.UpdateEmpRole(tc, oEmp);
tc.End();
}
public void DoConfirm(int employeeID, DateTime confirmDate, DateTime pfMShipDate, bool IsConfirm,
bool IsPFMember)
{
TransactionContext tc = null;
tc = TransactionContext.Begin(true);
EmployeeDA.DoConfirm(tc, employeeID, confirmDate, pfMShipDate, IsConfirm, IsPFMember);
tc.End();
}
public void UndoConfirm(int employeeID, bool IsConfirm)
{
TransactionContext tc = null;
tc = TransactionContext.Begin(true);
EmployeeDA.UndoConfirm(tc, employeeID, IsConfirm);
tc.End();
}
public void UpdatePayrollType(int employeeID, int payrollTypeID, DateTime dEffectDate)
{
TransactionContext tc = null;
tc = TransactionContext.Begin(true);
EmployeeDA.UpdatePayrollType(tc, employeeID, payrollTypeID, dEffectDate);
tc.End();
}
public void UpdatePayrollType(TransactionContext tc, int employeeID, int payrollTypeID)
{
EmployeeDA.UpdatePayrollType(tc, employeeID, payrollTypeID);
}
public void UpdateBankAcc(TransactionContext tc, int employeeID, int branchid, string accountNo,
EnumPaymentMode paymentMode)
{
EmployeeDA.UpdateBankAcc(tc, employeeID, branchid, accountNo, paymentMode);
}
public void UpdateOPIBankAcc(TransactionContext tc, int employeeID, int branchid, string accountNo,
EnumPaymentMode paymentMode)
{
EmployeeDA.UpdateOPIBankAcc(tc, employeeID, branchid, accountNo, paymentMode);
}
public DataSet GetEmpBasicInfo(string sEmpID)
{
DataSet oEmpBasicInfos = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpBasicInfos = EmployeeDA.GetEmpBasicInfo(tc, 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 oEmpBasicInfos;
}
public DataSet GetEmpBasicInfoForReport(string sEmpID)
{
DataSet oEmpBasicInfos = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpBasicInfos = EmployeeDA.GetEmpBasicInfoForReport(tc, 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 oEmpBasicInfos;
}
public DataSet GetDivision(int nEmpID)
{
DataSet oEmpBasicInfos = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpBasicInfos = EmployeeDA.GetDivision(tc, nEmpID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return oEmpBasicInfos;
}
/*public DataSet GetLineManager(int sEmpID)
{
DataSet oLineManager = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oLineManager = EmployeeDA.GetLineManager(tc, 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 oLineManager;
}*/
public DataSet GetEmpDetails(string sEmpID)
{
DataSet oEmpDetails = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpDetails = EmployeeDA.GetEmpDetails(tc, 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 oEmpDetails;
}
public DataSet GetEmpDetailsView(string sEmpID)
{
DataSet oEmpDetails = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpDetails = EmployeeDA.GetEmpDetailsView(tc, 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 oEmpDetails;
}
#region Discontinue Employee Details
/// <summary>
/// Employees discontinued between fromDate and toDate (by discontinue date) in one payroll type, with
/// the same fields, null handling and department tiers as the Employee Details report.
/// One query for all rows; departments are loaded once and looked up by ID.
/// </summary>
public List<HRM.BO.Report.DiscontinueEmployeeDetailInfo> GetDiscontinuedEmployeeDetails(DateTime fromDate,
DateTime toDate, int payrollTypeID)
{
var items = new List<HRM.BO.Report.DiscontinueEmployeeDetailInfo>();
Dictionary<int, Department> departments = new DepartmentService().GetAll()
.GroupBy(d => d.ID)
.ToDictionary(g => g.Key, g => g.First());
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetDiscontinuedEmployeeDetails(tc, fromDate, toDate, payrollTypeID));
while (dr.Read())
items.Add(MapDiscontinuedEmployee(dr, departments));
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 items;
}
private static HRM.BO.Report.DiscontinueEmployeeDetailInfo MapDiscontinuedEmployee(DataReader dr,
Dictionary<int, Department> departments)
{
var item = new HRM.BO.Report.DiscontinueEmployeeDetailInfo();
item.EmployeeId = dr.GetInt32("EmployeeId") ?? 0;
item.EmployeeNo = dr.GetString("EMPLOYEENO");
item.Name = dr.GetString("NAME");
item.BasicSalary = dr.GetDecimal("BASICSALARY") ?? 0;
item.GrossSalary = dr.GetDecimal("GrossSalary") ?? 0;
item.TaxAmount = dr.GetDecimal("TAXAMOUNT") ?? 0;
item.FatherName = dr.GetString("Fathername");
item.FatherOccupation = dr.GetString("FatherOccupation");
item.MotherOccupation = dr.GetString("MotherOccupation");
item.MotherName = dr.GetString("MotherName");
item.Gender = dr.GetString("Gender");
item.BirthDate = dr.GetDateTime("BIRTHDATE");
item.BirthPlace = dr.GetString("BIRTHPlace");
item.TinNo = dr.GetString("TINNO");
item.JoiningDate = dr.GetDateTime("JOININGDATE");
item.EmailAddress = dr.GetString("EMAILADDRESS");
item.Category = dr.GetString("Category");
item.Status = dr.GetString("Status");
item.Location = dr.GetString("Location");
item.Division = dr.GetString("Division");
item.Company = dr.GetString("Company");
item.Department = dr.GetString("Department");
item.Section = dr.GetString("Section");
item.Designation = dr.GetString("DESIGNATION");
item.Grade = dr.GetString("GRADE");
item.Religion = dr.GetString("RELIGION");
item.MaritalStatus = dr.GetString("MaritalStatus");
item.MobileNo = dr.GetString("MOBILENO");
item.DateOfConfirmation = dr.GetDateTime("DATEOFCONFIRMATION");
item.NationalId = dr.GetString("NATIONALID");
item.PassportNo = dr.GetString("PassPortNo");
item.PhotoPath = dr.GetString("PhotoPath");
int? bloodGroup = dr.GetInt32("bloodgroup");
item.BloodGroup = ((EnumBloodGroup)(bloodGroup ?? (int)EnumBloodGroup.None)).BloodGroupToFriendlyName();
item.LineManagerNo = dr.GetString("LineManagerNo");
item.LineManagerName = dr.GetString("LineManagerName");
item.LineManagerEmail = dr.GetString("LineManagerEmail");
item.LineManagerDes = dr.GetString("LineManagerDes");
item.LmDivision = dr.GetString("lmDivision");
item.LmDepartment = dr.GetString("lmDepartment");
item.EmpStatus = dr.GetString("EmpStatus");
item.Nationality = dr.GetString("NATIONALITY");
item.OutPayBank = dr.GetString("OUTPayBank");
item.OutPayBranch = dr.GetString("OUTPayBranch");
item.OutPayAccountNo = dr.GetString("OutPayAccountNo");
// Bank / Branch / Account No fall back to the out-pay values when empty, as Employee Details shows them.
string accountNo = dr.GetString("ACCOUNTNO");
string bank = dr.GetString("Bank");
string branch = dr.GetString("Branch");
item.AccountNo = string.IsNullOrEmpty(accountNo) ? item.OutPayAccountNo : accountNo;
item.Bank = string.IsNullOrEmpty(bank) ? item.OutPayBank : bank;
item.Branch = string.IsNullOrEmpty(branch) ? item.OutPayBranch : branch;
item.DiscontinueDate = dr.GetDateTime("DiscontinueDate");
int? departmentID = dr.GetInt32("EmpDepartmentID");
Department department = null;
if (departmentID.HasValue)
departments.TryGetValue(departmentID.Value, out department);
string[] tiers = GetDepartmentTierNames(department, departments);
if (tiers != null)
{
item.deptireOne = tiers[0];
item.deptireTwo = tiers[1];
item.deptireThree = tiers[2];
item.deptireFour = tiers[3];
item.deptireFive = tiers[4];
}
return item;
}
/// <summary>
/// The five department tier names (tier 1 = top), worked out exactly as the Employee Details report
/// (EmployeeController.GetEmpDetailInfo) does. Null when there is no department.
/// </summary>
private static string[] GetDepartmentTierNames(Department dept, Dictionary<int, Department> departments)
{
if (dept == null)
return null;
Func<int?, Department> find = id =>
{
Department d = null;
if (id.HasValue)
departments.TryGetValue(id.Value, out d);
return d;
};
Department tire5 = null, tire4 = null, tire3 = null, tire2 = null, tire1 = null;
if (dept.ParentID != null)
{
for (int i = dept.Tier; i > 0; i--)
{
if (i == 5) tire5 = find(dept.ID);
if (i == 4) tire4 = tire5 != null ? find(tire5.ParentID) : find(dept.ID);
if (i == 3) tire3 = tire4 != null ? find(tire4.ParentID) : find(dept.ID);
if (i == 2) tire2 = tire3 != null ? find(tire3.ParentID) : find(dept.ID);
if (i == 1) tire1 = tire2 != null ? find(tire2.ParentID) : find(dept.ID);
}
}
return new[]
{
tire1 == null ? "" : tire1.Name,
tire2 == null ? "" : tire2.Name,
tire3 == null ? "" : tire3.Name,
tire4 == null ? "" : tire4.Name,
tire5 == null ? "" : tire5.Name,
};
}
#endregion
public DataSet GetEmpDetailsView()
{
DataSet oEmpDetails = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpDetails = EmployeeDA.GetEmpDetailsView(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return oEmpDetails;
}
//public DataSet GetEmployeeCV(string sEmpID)
//{
// DataSet oEmpCV = new DataSet();
// TransactionContext tc = null;
// try
// {
// tc = TransactionContext.Begin();
// oEmpCV = EmployeeDA.GetEmployeeCV(tc, 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 oEmpCV;
//}
public DataSet GetEmpForLetterOfIntroDuction(string sEmpID, DateTime month)
{
DataSet oEmpDetails = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpDetails = EmployeeDA.GetEmpForLetterOfIntroduction(tc, sEmpID, 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 oEmpDetails;
}
public DataSet GetEmpPosting(string sEmpID)
{
DataSet oEmpPostings = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpPostings = EmployeeDA.GetEmpPosting(tc, 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 oEmpPostings;
}
public DataSet GetLineManagerFromOrg(int sEmpID)
{
DataSet oLineManager = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oLineManager = EmployeeDA.GetLineManagerFromOrg(tc, 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 oLineManager;
}
public DataSet GetEmpConfirmHis(DateTime dEffectDate, DateTime dEffectDate2, int payrollTypeID)
{
DataSet oEmpConfirms = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpConfirms = EmployeeDA.GetEmpConfirmHis(tc, dEffectDate, dEffectDate2, payrollTypeID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return oEmpConfirms;
}
public DataSet GetEmpPFHis(DateTime dEffectDate)
{
DataSet oEmpConfirms = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpConfirms = EmployeeDA.GetEmpPFHis(tc, dEffectDate);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return oEmpConfirms;
}
public DataSet GetEmpJoining(DateTime dEffectDate, DateTime dEffectDate2)
{
DataSet oEmpConfirms = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpConfirms = EmployeeDA.GetEmpJoining(tc, dEffectDate, dEffectDate2);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return oEmpConfirms;
}
public DataSet GetEmpJoining4Novartis(DateTime dEffectDate, int payrollTypeID)
{
DataSet oEmpJoining = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oEmpJoining = EmployeeDA.GetEmpJoining4Novartis(tc, dEffectDate, payrollTypeID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return oEmpJoining;
}
public int GetDays(int nPayrollTypeID)
{
int nDays = 0;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
nDays = EmployeeDA.GetDays(tc, nPayrollTypeID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return nDays;
}
#endregion
public List<Employee> Get()
{
TransactionContext tc = null;
List<Employee> users = new List<Employee>();
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.Get(tc));
users = this.CreateObjects<Employee>(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 users;
}
public double GetEmpBasicSalary(int ID)
{
TransactionContext tc = null;
double empBasicSalary = 0.0;
try
{
tc = TransactionContext.Begin();
empBasicSalary = EmployeeDA.GetEmpBasicSalary(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
}
return empBasicSalary;
}
public DataTable GetOtEligibleEmployees(int payrolltypeid)
{
DataTable dt = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
dt = EmployeeDA.GetOtEligibleEmployees(tc, payrolltypeid);
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public List<Employee> GetEmployeesForPicker(string employeeCode, string employeeName)
{
TransactionContext tc = null;
List<Employee> users = new List<Employee>();
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetEmployeesForPicker(tc, employeeCode, employeeName));
users = this.CreateObjects<Employee>(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 users;
}
public DataSet GetByMonthStartMonthEndForContinueFromDiscontinue(DateTime startmonth, DateTime endmonth,
int payrollTypeID)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetByMonthStartMonthEndForContinueFromDiscontinue(tc, startmonth, endmonth,
payrollTypeID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataTable GetShortInformation(string empID)
{
DataTable dataTableOfEmployee = new DataTable("GetShortInformation");
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataSet dataSet = EmployeeDA.GetShortInformation(tc, empID);
dataTableOfEmployee = dataSet.Tables[0];
dataSet.Dispose();
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dataTableOfEmployee;
}
public DataSet GetITAndBasic(DateTime startmonth, DateTime endmonth)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetITAndBasic(tc, startmonth, endmonth);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
//For Excel Upload
public static void SaveDepartment(TransactionContext tc, List<Employee> employees)
{
try
{
foreach (Employee oEmployee in employees)
{
EmployeeDA.UpdateDepartment(tc, oEmployee);
}
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
//Data Integration
public void SaveIntegration(List<Employee> oEmps, int currentUserId, DateTime NextPayProcessDate, DateTime LastPayProcessDate)
{
TransactionContext tc = null;
int nn = 1;
string empNo = "";
string Errmsg = "";
try
{
tc = TransactionContext.Begin(true);
foreach (Employee oEmployee in oEmps)
{
empNo = oEmployee.EmployeeNo;
Errmsg = "Error during updateting/Inserting employee";
if (oEmployee.IsNew)
{
int id = tc.GenerateID("Employee", "EmployeeID");
base.SetObjectID(oEmployee, id);
EmployeeDA.Insert(tc, oEmployee);
}
else
{
EmployeeDA.Update(tc, oEmployee);
}
Errmsg = "Error during life-cycle update ";
EmpLifeCycleService lcService = new EmpLifeCycleService();
oEmployee.EmpLifeCycle.EmployeeID = oEmployee.ID;
oEmployee.EmpLifeCycle.CreatedBy = currentUserId;
oEmployee.EmpLifeCycle.CreatedDate = DateTime.Now;
lcService.SaveIntegration(oEmployee.EmpLifeCycle, tc, oEmployee, NextPayProcessDate, currentUserId, LastPayProcessDate);
//Save Employee Account History
Errmsg = "Error during Bank Account";
if (oEmployee.EmployeeBankAccount.AccountNo != "")
{
EmployeeBankAccountService ebaService = new EmployeeBankAccountService();
oEmployee.EmployeeBankAccount.EmployeeID = oEmployee.ID;
oEmployee.EmployeeBankAccount.CreatedBy = currentUserId;
oEmployee.EmployeeBankAccount.CreatedDate = DateTime.Now; ;
oEmployee.EmployeeBankAccount.BranchID = (int)oEmployee.BranchID;
if (oEmployee.EmployeeBankAccount.EffectDate != DateTime.MinValue)
ebaService.SaveIntegration(oEmployee.EmployeeBankAccount, tc);
}
nn++;
}
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(Errmsg + " from employee:" + empNo + " " + e.Message, e);
#endregion
}
}
public static void SaveForUpload(TransactionContext tc, List<Employee> employees, EnumRegularDataUpload uploadtype, bool IsFinantialAprovalRequired)
{
List<EmployeeStatus> empstatuss = new EmployeeStatusService().Get(tc, EnumStatus.Regardless);
PayrollType opayrolltype = new PayrollTypeService().Get(tc, employees[0].PayrollTypeID);
EmployeeStatus joiningEmpstatu = empstatuss.FirstOrDefault(x => x.IsJoining == true);
if (joiningEmpstatu == null) throw new Exception("Joing Life-cycle status not found in the system");
string empNo = "";
try
{
foreach (Employee oEmployee in employees)
{
oEmployee.EmployeeNo = oEmployee.EmployeeNo.Trim('`');
empNo = oEmployee.EmployeeNo;
oEmployee.CreatedDate = DateTime.Today;
oEmployee.Name = oEmployee.Name == "" ? "Employee-" + oEmployee.EmployeeNo : oEmployee.Name;
EmployeeDA.Insert(tc, oEmployee);
int id = 0;
if (uploadtype == EnumRegularDataUpload.EmployeeWithBasic || !IsFinantialAprovalRequired)
{
id = tc.GenerateID("GRADESALARYASSIGNMENT", "EmpGradeSalaryID");
(new EmployeeService()).SetObjectID(oEmployee.EmployeeGradeSalary, id);
oEmployee.EmployeeGradeSalary.EmployeeID = oEmployee.ID;
oEmployee.EmployeeGradeSalary.GradeSalaryTypeID = joiningEmpstatu.ID;
oEmployee.EmployeeGradeSalary.GradeID = (int)oEmployee.GradeID;
oEmployee.EmployeeGradeSalary.CreatedBy = oEmployee.CreatedBy;
oEmployee.EmployeeGradeSalary.CreatedDate = DateTime.Today;
oEmployee.EmployeeGradeSalary.EffectDate = oEmployee.JoiningDate;
//
// Create Arrear, it is for regular upload only
if (uploadtype == EnumRegularDataUpload.EmployeeRegularUpload)
{
if (oEmployee.JoiningDate < GlobalFunctions.FirstDateOfMonth(opayrolltype.NextPayProcessDate))
{
(new EmployeeService()).SetObjectID(oEmployee.EmployeeGradeSalary, id);
oEmployee.EmployeeGradeSalary.TillDate = opayrolltype.LastPayProcessDate;
oEmployee.EmployeeGradeSalary.ArrearType = EnumArrearType.ToCalculate;
EmployeeGradeSalaryDA.Insert(tc, oEmployee.EmployeeGradeSalary);
oEmployee.EmployeeGradeSalary.EffectDate = GlobalFunctions.FirstDateOfMonth(opayrolltype.NextPayProcessDate);
oEmployee.EmployeeGradeSalary.ArrearType = EnumArrearType.NotPresent;
oEmployee.EmployeeGradeSalary.TillDate = null;
id = id + 1;
EmployeeGradeSalaryDA.Insert(tc, oEmployee.EmployeeGradeSalary);
}
else EmployeeGradeSalaryDA.Insert(tc, oEmployee.EmployeeGradeSalary);
}
else EmployeeGradeSalaryDA.Insert(tc, oEmployee.EmployeeGradeSalary);
}
if (oEmployee.BranchID != null)
{
(new EmployeeService()).SetObjectID(oEmployee.EmployeeBankAccount, tc.GenerateID("BANKACCOUNTHISTORY", "EmpBankAccountID"));
oEmployee.EmployeeBankAccount.EmployeeID = oEmployee.ID;
oEmployee.EmployeeBankAccount.CreatedBy = oEmployee.CreatedBy;
oEmployee.EmployeeBankAccount.CreatedDate = DateTime.Today;
oEmployee.EmployeeBankAccount.BranchID = (int)oEmployee.BranchID;
oEmployee.EmployeeBankAccount.AccountNo = oEmployee.EmployeeBankAccount.AccountNo; // == "" ? "1234" : oEmployee.EmployeeBankAccount.AccountNo;
EmployeeBankAccountDA.Insert(tc, oEmployee.EmployeeBankAccount);
}
if (oEmployee.OutPayBranchID != null)
{
(new EmployeeService()).SetObjectID(oEmployee.EmployeeOPIBankAccount, tc.GenerateID("BANKACCOUNTHISTORY", "EmpBankAccountID"));
oEmployee.EmployeeOPIBankAccount.EmployeeID = oEmployee.ID;
oEmployee.EmployeeOPIBankAccount.CreatedBy = oEmployee.CreatedBy;
oEmployee.EmployeeOPIBankAccount.CreatedDate = DateTime.Today;
oEmployee.EmployeeOPIBankAccount.AccountNo = oEmployee.EmployeeOPIBankAccount.AccountNo;// == "" ? "1234" : oEmployee.EmployeeOPIBankAccount.AccountNo;
EmployeeBankAccountDA.Insert(tc, oEmployee.EmployeeOPIBankAccount);
}
#region Emplifecycle
id = tc.GenerateID("EmpLifecycle", "EmpLifecycleID");
oEmployee.EmpLifeCycle = new EmpLifeCycle();
(new EmployeeService()).SetObjectID(oEmployee.EmpLifeCycle, (tc.GenerateID("EmpLifecycle", "EmpLifecycleID")));
oEmployee.EmpLifeCycle.EmployeeGradeSalary = oEmployee.EmployeeGradeSalary;
oEmployee.EmpLifeCycle.Description = joiningEmpstatu.Description;
oEmployee.EmpLifeCycle.EmployeeID = oEmployee.ID;
oEmployee.EmpLifeCycle.BasicSalary = oEmployee.BasicSalary;
oEmployee.EmpLifeCycle.GrossSalary = oEmployee.GrossSalary;
oEmployee.EmpLifeCycle.EffectDate = oEmployee.JoiningDate;
oEmployee.EmpLifeCycle.GradeID = oEmployee.GradeID;
oEmployee.EmpLifeCycle.DepartmentID = oEmployee.DepartmentID;
oEmployee.EmpLifeCycle.DesignationID = oEmployee.DesignationID;
oEmployee.EmpLifeCycle.StatusDetailID = joiningEmpstatu.ID;
oEmployee.EmpLifeCycle.Status = EnumStatus.Active;
oEmployee.EmpLifeCycle.EmployeeStatus = EnumEmployeeStatus.Live;
oEmployee.EmpLifeCycle.LocationID = oEmployee.LocationID;
oEmployee.EmpLifeCycle.CategoryID = oEmployee.CategoryID;
oEmployee.EmpLifeCycle.IsConfirm = (oEmployee.IsConfirmed == true) ? true : false;
oEmployee.EmpLifeCycle.CreatedBy = oEmployee.CreatedBy;
oEmployee.EmpLifeCycle.CreatedDate = oEmployee.CreatedDate;
oEmployee.EmpLifeCycle.GradeSalaryAssesmentID = oEmployee.EmployeeGradeSalary.ID;
oEmployee.EmpLifeCycle.SalaryMonth = opayrolltype.NextPayProcessDate;
if (uploadtype == EnumRegularDataUpload.EmployeeWithBasic || !IsFinantialAprovalRequired)
{
oEmployee.EmpLifeCycle.ApprovalStatus = EnumAuthStatus.Approved;
oEmployee.EmpLifeCycle.Approvedby = oEmployee.EmpLifeCycle.CreatedBy;
oEmployee.EmpLifeCycle.ApprovedDate = DateTime.Now;
}
new EmpLifeCycleService().Insert(tc, oEmployee.EmpLifeCycle);
#endregion
}
foreach (Employee oEmployee in employees)
{
#region Line Manager
if (oEmployee.LineManagerNo != null && oEmployee.LineManagerNo != string.Empty)
EmployeeDA.UpdateLineManager(tc, oEmployee.ID, oEmployee.LineManagerNo);
#endregion
}
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message + " Employee ID:" + empNo, e);
#endregion
}
}
//public static void SaveForUpload(TransactionContext tc, List<Employee> employees, EnumRegularDataUpload uploadtype)
//{
// List<EmployeeStatus> empstatuss = new EmployeeStatusService().Get(tc, EnumStatus.Regardless);
// PayrollType opayrolltype = new PayrollTypeService().Get(tc, employees[0].PayrollTypeID);
// EmployeeStatus joiningEmpstatu = empstatuss.FirstOrDefault(x => x.IsJoining == true);
// if (joiningEmpstatu == null) throw new Exception("Joing Life-cycle status not found in the system");
// string empNo = "";
// try
// {
// foreach (Employee oEmployee in employees)
// {
// oEmployee.EmployeeNo = oEmployee.EmployeeNo.Trim('`');
// empNo = oEmployee.EmployeeNo;
// oEmployee.CreatedDate = DateTime.Today;
// oEmployee.Name = oEmployee.Name == "" ? "Employee-" + oEmployee.EmployeeNo : oEmployee.Name;
// EmployeeDA.Insert(tc, oEmployee);
// int id = tc.GenerateID("GRADESALARYASSIGNMENT", "EmpGradeSalaryID");
// (new EmployeeService()).SetObjectID(oEmployee.EmployeeGradeSalary, id);
// oEmployee.EmployeeGradeSalary.EmployeeID = oEmployee.ID;
// oEmployee.EmployeeGradeSalary.GradeSalaryTypeID = joiningEmpstatu.ID;
// oEmployee.EmployeeGradeSalary.GradeID = (int)oEmployee.GradeID;
// oEmployee.EmployeeGradeSalary.CreatedBy = oEmployee.CreatedBy;
// oEmployee.EmployeeGradeSalary.CreatedDate = DateTime.Today;
// oEmployee.EmployeeGradeSalary.EffectDate = oEmployee.JoiningDate;
// //
// // Create Arrear, it is for regular upload only
// if (uploadtype == EnumRegularDataUpload.EmployeeRegularUpload)
// {
// if (oEmployee.JoiningDate < GlobalFunctions.FirstDateOfMonth(opayrolltype.NextPayProcessDate))
// {
// (new EmployeeService()).SetObjectID(oEmployee.EmployeeGradeSalary, id);
// oEmployee.EmployeeGradeSalary.TillDate = opayrolltype.LastPayProcessDate;
// oEmployee.EmployeeGradeSalary.ArrearType = EnumArrearType.ToCalculate;
// EmployeeGradeSalaryDA.Insert(tc, oEmployee.EmployeeGradeSalary);
// oEmployee.EmployeeGradeSalary.EffectDate = GlobalFunctions.FirstDateOfMonth(opayrolltype.NextPayProcessDate);
// oEmployee.EmployeeGradeSalary.ArrearType = EnumArrearType.NotPresent;
// oEmployee.EmployeeGradeSalary.TillDate = null;
// id = id + 1;
// EmployeeGradeSalaryDA.Insert(tc, oEmployee.EmployeeGradeSalary);
// }
// else EmployeeGradeSalaryDA.Insert(tc, oEmployee.EmployeeGradeSalary);
// }
// else EmployeeGradeSalaryDA.Insert(tc, oEmployee.EmployeeGradeSalary);
// if (oEmployee.BranchID != null)
// {
// (new EmployeeService()).SetObjectID(oEmployee.EmployeeBankAccount, tc.GenerateID("BANKACCOUNTHISTORY", "EmpBankAccountID"));
// oEmployee.EmployeeBankAccount.EmployeeID = oEmployee.ID;
// oEmployee.EmployeeBankAccount.CreatedBy = oEmployee.CreatedBy;
// oEmployee.EmployeeBankAccount.CreatedDate = DateTime.Today;
// oEmployee.EmployeeBankAccount.BranchID = (int)oEmployee.BranchID;
// oEmployee.EmployeeBankAccount.AccountNo = oEmployee.EmployeeBankAccount.AccountNo; // == "" ? "1234" : oEmployee.EmployeeBankAccount.AccountNo;
// EmployeeBankAccountDA.Insert(tc, oEmployee.EmployeeBankAccount);
// }
// if (oEmployee.OutPayBranchID != null)
// {
// (new EmployeeService()).SetObjectID(oEmployee.EmployeeOPIBankAccount, tc.GenerateID("BANKACCOUNTHISTORY", "EmpBankAccountID"));
// oEmployee.EmployeeOPIBankAccount.EmployeeID = oEmployee.ID;
// oEmployee.EmployeeOPIBankAccount.CreatedBy = oEmployee.CreatedBy;
// oEmployee.EmployeeOPIBankAccount.CreatedDate = DateTime.Today;
// oEmployee.EmployeeOPIBankAccount.AccountNo = oEmployee.EmployeeOPIBankAccount.AccountNo;// == "" ? "1234" : oEmployee.EmployeeOPIBankAccount.AccountNo;
// EmployeeBankAccountDA.Insert(tc, oEmployee.EmployeeOPIBankAccount);
// }
// #region Emplifecycle
// id = tc.GenerateID("EmpLifecycle", "EmpLifecycleID");
// oEmployee.EmpLifeCycle = new EmpLifeCycle();
// (new EmployeeService()).SetObjectID(oEmployee.EmpLifeCycle, (tc.GenerateID("EmpLifecycle", "EmpLifecycleID")));
// oEmployee.EmpLifeCycle.EmployeeGradeSalary = oEmployee.EmployeeGradeSalary;
// oEmployee.EmpLifeCycle.Description = joiningEmpstatu.Description;
// oEmployee.EmpLifeCycle.EmployeeID = oEmployee.ID;
// oEmployee.EmpLifeCycle.BasicSalary = oEmployee.BasicSalary;
// oEmployee.EmpLifeCycle.EffectDate = oEmployee.JoiningDate;
// oEmployee.EmpLifeCycle.GradeID = oEmployee.GradeID;
// oEmployee.EmpLifeCycle.DepartmentID = oEmployee.DepartmentID;
// oEmployee.EmpLifeCycle.DesignationID = oEmployee.DesignationID;
// oEmployee.EmpLifeCycle.StatusDetailID = joiningEmpstatu.ID;
// oEmployee.EmpLifeCycle.Status = EnumStatus.Active;
// oEmployee.EmpLifeCycle.EmployeeStatus = EnumEmployeeStatus.Live;
// oEmployee.EmpLifeCycle.LocationID = oEmployee.LocationID;
// oEmployee.EmpLifeCycle.CategoryID = oEmployee.CategoryID;
// oEmployee.EmpLifeCycle.IsConfirm = (oEmployee.IsConfirmed == true) ? true : false;
// oEmployee.EmpLifeCycle.CreatedBy = oEmployee.CreatedBy;
// oEmployee.EmpLifeCycle.CreatedDate = oEmployee.CreatedDate;
// oEmployee.EmpLifeCycle.GradeSalaryAssesmentID = oEmployee.EmployeeGradeSalary.ID;
// new EmpLifeCycleService().Insert(tc, oEmployee.EmpLifeCycle);
// #endregion
// }
// foreach (Employee oEmployee in employees)
// {
// #region Line Manager
// if (oEmployee.LineManagerNo != null && oEmployee.LineManagerNo != string.Empty)
// EmployeeDA.UpdateLineManager(tc, oEmployee.ID, oEmployee.LineManagerNo);
// #endregion
// }
// }
// catch (Exception e)
// {
// #region Handle Exception
// if (tc != null)
// tc.HandleError();
// ExceptionLog.Write(e);
// throw new ServiceException(e.Message + " Employee ID:" + empNo, e);
// #endregion
// }
//}
public static void SaveForIntegration(TransactionContext tc, List<Employee> employees,
EnumRegularDataUpload uploadtype)
{
List<EmployeeStatus> empstatuss = new EmployeeStatusService().Get(tc, EnumStatus.Regardless);
PayrollType opayrolltype = new PayrollTypeService().Get(tc, employees[0].PayrollTypeID);
//EmployeeStatus joiningEmpstatu = empstatuss.FirstOrDefault(x => x.IsJoining == true);
//if (joiningEmpstatu == null) throw new Exception("Joing Life-cycle status not found in the system");
int maxEmpID = tc.GenerateID("Employee", "EmployeeID");
string empNo = "";
try
{
foreach (Employee oEmployee in employees)
{
oEmployee.EmployeeNo = oEmployee.EmployeeNo.Trim('`');
empNo = oEmployee.EmployeeNo;
oEmployee.CreatedDate = DateTime.Today;
oEmployee.Name = oEmployee.Name == "" ? "Employee-" + oEmployee.EmployeeNo : oEmployee.Name;
if (maxEmpID <= oEmployee.ID)
EmployeeDA.Insert(tc, oEmployee);
else EmployeeDA.IntegrationUpdate(tc, oEmployee);
//EmployeeStatus joiningEmpstatu = empstatuss.FirstOrDefault(x => x.Description == oEmployee.EmpLifeCycle.Description);
//if (joiningEmpstatu == null) throw new Exception("Joing Life-cycle status not found in the system");
//int id = tc.GenerateID("GRADESALARYASSIGNMENT", "EmpGradeSalaryID");
//(new EmployeeService()).SetObjectID(oEmployee.EmployeeGradeSalary, id);
//oEmployee.EmployeeGradeSalary.EmployeeID = oEmployee.ID;
//oEmployee.EmployeeGradeSalary.GradeSalaryTypeID = joiningEmpstatu.ID;
//oEmployee.EmployeeGradeSalary.GradeID = (int)oEmployee.GradeID;
//oEmployee.EmployeeGradeSalary.CreatedBy = oEmployee.CreatedBy;
//oEmployee.EmployeeGradeSalary.CreatedDate = DateTime.Today;
//oEmployee.EmployeeGradeSalary.EffectDate = oEmployee.JoiningDate;
////
// Create Arrear, it is for regular upload only
//if (oEmployee.EmployeeGradeSalary != null)
//{
// if (oEmployee.EmployeeGradeSalary.EffectDate < GlobalFunctions.FirstDateOfMonth(opayrolltype.NextPayProcessDate))
// {
// (new EmployeeService()).SetObjectID(oEmployee.EmployeeGradeSalary, id);
// oEmployee.EmployeeGradeSalary.TillDate = opayrolltype.LastPayProcessDate;
// oEmployee.EmployeeGradeSalary.ArrearType = EnumArrearType.ToCalculate;
// EmployeeGradeSalaryDA.Insert(tc, oEmployee.EmployeeGradeSalary);
// oEmployee.EmployeeGradeSalary.EffectDate = GlobalFunctions.FirstDateOfMonth(opayrolltype.NextPayProcessDate);
// oEmployee.EmployeeGradeSalary.ArrearType = EnumArrearType.NotPresent;
// oEmployee.EmployeeGradeSalary.TillDate = null;
// id = id + 1;
// EmployeeGradeSalaryDA.Insert(tc, oEmployee.EmployeeGradeSalary);
// }
// else EmployeeGradeSalaryDA.Insert(tc, oEmployee.EmployeeGradeSalary);
//}
if (oEmployee.EmployeeBankAccount != null)
{
(new EmployeeService()).SetObjectID(oEmployee.EmployeeBankAccount, tc.GenerateID("BANKACCOUNTHISTORY", "EmpBankAccountID"));
EmployeeBankAccountDA.Insert(tc, oEmployee.EmployeeBankAccount);
EmployeeDA.UpdateBankAcc(tc, oEmployee.ID, oEmployee.EmployeeBankAccount.BranchID
, oEmployee.EmployeeBankAccount.AccountNo, EnumPaymentMode.BankTransfer);
}
if (oEmployee.OutPayBranchID != null)
{
(new EmployeeService()).SetObjectID(oEmployee.EmployeeOPIBankAccount, tc.GenerateID("BANKACCOUNTHISTORY", "EmpBankAccountID"));
oEmployee.EmployeeOPIBankAccount.EmployeeID = oEmployee.ID;
oEmployee.EmployeeOPIBankAccount.CreatedBy = oEmployee.CreatedBy;
oEmployee.EmployeeOPIBankAccount.CreatedDate = DateTime.Today;
oEmployee.EmployeeOPIBankAccount.AccountNo = oEmployee.EmployeeOPIBankAccount.AccountNo;// == "" ? "1234" : oEmployee.EmployeeOPIBankAccount.AccountNo;
EmployeeBankAccountDA.Insert(tc, oEmployee.EmployeeOPIBankAccount);
}
#region Emplifecycle
// int id = tc.GenerateID("EmpLifecycle", "EmpLifecycleID");
oEmployee.EmpLifeCycle.SalaryMonth = opayrolltype.NextPayProcessDate;
new EmpLifeCycleService().Save(tc, oEmployee.EmpLifeCycle,
opayrolltype.NextPayProcessDate, opayrolltype.ID);
#endregion
}
foreach (Employee oEmployee in employees)
{
#region Line Manager
if (oEmployee.LineManagerNo != null && oEmployee.LineManagerNo != string.Empty)
EmployeeDA.UpdateLineManager(tc, oEmployee.ID, oEmployee.LineManagerNo);
#endregion
}
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message + " Employee ID:" + empNo, e);
#endregion
}
}
public void UpdateCardInformation(TransactionContext tc, int employeeID, int CardID, DateTime cardDate,
EnumCardStatus cardStatus, bool IsAutoProcess)
{
try
{
EmployeeDA.UpdateCardInformation(tc, employeeID, CardID, cardDate, cardStatus, IsAutoProcess);
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public List<Employee> GetEmployeesYetNotAssigned()
{
List<Employee> notAssignedEmployees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetEmployeesYetNotAssigned(tc));
//if (oreader.Read())
//{
notAssignedEmployees = this.CreateObjects<Employee>(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 notAssignedEmployees;
}
public List<Employee> GetSubordinates(int employeeID)
{
List<Employee> oEmployees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetSubordinates(tc, employeeID));
oEmployees = this.CreateObjects<Employee>(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 oEmployees;
}
public List<Employee> GetMonthlyAttnEmployee(DateTime fromDate, DateTime toDate, int payrollTypeID)
{
List<Employee> oEmployees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader =
new DataReader(EmployeeDA.GetMonthlyAttnEmployee(tc, fromDate, toDate, payrollTypeID));
oEmployees = this.CreateObjects<Employee>(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 oEmployees;
}
public DataTable GetDepartmentName(int empID, bool banglaDescriptionExits)
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetDepartmentName(tc, empID, banglaDescriptionExits);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds.Tables[0];
}
public List<Employee> NotYetAssigned(int payrollTypeID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeWorkPlanSetupDA.NotYetAssigned(tc, payrollTypeID));
var totalEmployee = this.CreateObjects<Employee>(dr);
dr.Close();
tc.End();
return totalEmployee;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
private string recure(string subQuery, int level)
{
if (level == 0)
{
return subQuery;
}
return "Select OrganogramID From Organogram Where ParentID IN ("
+ recure(subQuery + "", level - 1) + ")";
}
//public List<Employee> GetAllSubordinates(int nodeID)
//{
// TransactionContext tc = null;
// List<Employee> employees = new List<Employee>();
// string sql = string.Empty;
// try
// {
// tc = TransactionContext.Begin(true);
// OrganogramBasic ogBasic = OrganogramBasic.Get(nodeID);
// OrganogramService osv = new OrganogramService();
// int maxLevel = osv.GetMaxTier(tc);
// if (ogBasic != null)
// {
// string subQuery = "Select OrganogramID From Organogram Where ParentID=" + nodeID.ToString();
// for (int i = 0; i <= maxLevel - ogBasic.Tier; i++)
// {
// if (sql.Length > 0) sql += " UNION ";
// sql = sql + recure(subQuery, i);
// }
// sql = "Select Employee.* From OrganEmployee , Employee Where OrganEmployee.NodeID In " +
// "(" + sql + ")" +
// "AND OrganEmployee.EmployeeID IS NOT NULL AND OrganEmployee.EmployeeID = Employee.EmployeeID AND Employee.Status =1";
// DataReader oreader = new DataReader(EmployeeDA.GetSubordinates(tc, sql));
// employees = this.CreateObjects<Employee>(oreader);
// oreader.Close();
// }
// tc.End();
// return employees;
// }
// catch (Exception e)
// {
// #region Handle Exception
// if (tc != null)
// tc.HandleError();
// ExceptionLog.Write(e);
// throw new ServiceException("Failed to Get Subordinates", e);
// #endregion
// }
//}
public List<Employee> GetGrandChilds(int employeeID)
{
List<Employee> oEmployees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetGrandChilds(tc, employeeID));
oEmployees = this.CreateObjects<Employee>(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 oEmployees;
}
public List<Employee> GetbyDepartment(int deptId)
{
List<Employee> oEmployees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetbyDepartment(tc, deptId));
oEmployees = this.CreateObjects<Employee>(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 oEmployees;
}
public DataSet GetEmpDashBoardInfo(int empID)
{
DataSet dsetDashBoard = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
dsetDashBoard = EmployeeDA.GetEmpDashBoardInfo(tc, empID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dsetDashBoard;
}
public List<Employee> GetAllSubordinatesNew(int employeeID)
{
List<Employee> oEmployees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetAllSubordinatesNew(tc, employeeID));
oEmployees = this.CreateObjects<Employee>(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 oEmployees;
}
public List<Employee> GetGrandChilds(string sEmpNos)
{
List<Employee> oEmployees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetGrandChilds(tc, sEmpNos));
oEmployees = this.CreateObjects<Employee>(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 oEmployees;
}
public List<Employee> GetAssignedEmployees(int nPMPYearID, int nEmpID)
{
List<Employee> oEmployees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetAssignedEmployees(tc, nPMPYearID, nEmpID));
oEmployees = this.CreateObjects<Employee>(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 oEmployees;
}
public List<Employee> GetEmployeesByJoiningMonth(DateTime fromDate, DateTime toDate)
{
List<Employee> oEmployeesByJoiningMonth = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetEmployeesByJoiningMonth(tc, fromDate, toDate));
oEmployeesByJoiningMonth = this.CreateObjects<Employee>(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 oEmployeesByJoiningMonth;
}
public DataTable GetDesignationWiseEmployeeCountsByDepartmentID(int departmentID)
{
DataSet designationWiseCountDS = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
designationWiseCountDS = EmployeeDA.GetDesignationWiseEmployeeCountsByDepartmentID(tc, departmentID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return designationWiseCountDS.Tables[0];
}
public DataSet GetEmpBasicInfoForPSlip(string sEmpID, DateTime dMonth)
{
DataSet empBasicInfoForPSlipDSet = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
empBasicInfoForPSlipDSet = EmployeeDA.GetEmpBasicInfoForPSlip(tc, sEmpID, dMonth);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return empBasicInfoForPSlipDSet;
}
public DataTable GetGradeWiseEmployeeCountsByDepartmentID(int departmentID)
{
DataSet gradeWiseCountDS = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
gradeWiseCountDS = EmployeeDA.GetGradeWiseEmployeeCountsByDepartmentID(tc, departmentID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return gradeWiseCountDS.Tables[0];
}
public DataTable GetGradeWiseEmployeeCounts()
{
DataSet gradeWiseCountDS = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
gradeWiseCountDS = EmployeeDA.GetGradeWiseEmployeeCounts(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return gradeWiseCountDS.Tables[0];
}
public Employee Get4Web(string employeeNo)
{
Employee oEmployee = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.Get4Web(tc, employeeNo));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
public Employee GetDepartmentHead(EnumOGPositionType type, int departmentID)
{
Employee oEmployee = new Employee();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetDepartmentHead(tc, type, departmentID));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
public DataSet GetAllGeneralInfo(string sEmpIDs)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetAllGeneralInfo(tc, sEmpIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataSet GetAllContactInfo(string sEmpIDs)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetAllContactInfo(tc, sEmpIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataSet GetSpouseInfo(string sEmpIDs)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetSpouseInfo(tc, sEmpIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataSet GetChildInfo(string sEmpIDs)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetChildInfo(tc, sEmpIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataSet GetEmpExperienceInfo(string sEmpIDs)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetEmpExperienceInfo(tc, sEmpIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataSet GetEmpTrainingInfo(string sEmpIDs)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetEmpTrainingInfo(tc, sEmpIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataSet GetEmpAcademicInfo(string sEmpIDs)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetEmpAcademicInfo(tc, sEmpIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataSet GetEmpReferenceInfo(string sEmpIDs)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetEmpReferenceInfo(tc, sEmpIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataSet GetEmpPublicationInfo(string sEmpIDs)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetEmpPublicationInfo(tc, sEmpIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataTable GetBasicSalary()
{
DataTable allData = new DataTable();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetBasicSalary(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataTable GetBasicSalaryWithDiscontinue(DateTime salaryMonth)
{
DataTable allData = new DataTable();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetBasicSalaryWithDiscontinue(tc, salaryMonth);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public string GetBasicSalary(int id)
{
string currentBasic = "";
DataTable allData = new DataTable();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetBasicSalary(tc, id);
//currentBasic = allData[BASICSALARY];
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return currentBasic;
}
public DataSet GetEmpNomineeInfo(string sEmpIDs)
{
DataSet allData = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
allData = EmployeeDA.GetEmpNomineeInfo(tc, sEmpIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return allData;
}
public DataSet GetEmployeeGeneralData()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeGeneralData(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetEmployeeContactData()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeContactData(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetEmployeeSpouseData()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeSpouseData(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetEmployeeChildrenData()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeChildrenData(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetEmployeeAcademicData()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeAcademicData(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetEmployeeTrainingData()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeTrainingData(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetEmployeeExperienceData()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeExperienceData(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetEmployeeNomineeData()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeNomineeData(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetListOfPromotion()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetListOfPromotion(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetListOfTransfer()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetListOfTransfer(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetJobSeparationList()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetJobSeparationList(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetConfirmedEmployeeList()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetConfirmedEmployeeList(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataTable GetEmpFromView(string empNo)
{
DataTable dtEmpInfo = new DataTable();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
DataSet ds = EmployeeDA.GetEmpFromView(tc, empNo);
if (ds != null || (ds.Tables.Count > 0))
dtEmpInfo = ds.Tables[0];
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dtEmpInfo;
}
public void Get(TransactionContext tc, out Employee emp, string employeeNo)
{
emp = new Employee();
DataReader reader = new DataReader(EmployeeDA.Get(tc, employeeNo));
if (reader.Read())
emp = this.CreateObject(reader);
reader.Close();
}
//public void GetLoggedUserCredentials(out Employee emp, out SystemInformation sysInfo, out DataSet dsNotiAndPendi, string logInID)
//{
// TransactionContext tc = null;
// try
// {
// tc = TransactionContext.Begin();
// this.Get(tc, out emp, logInID);
// if (emp != null || emp.ID == 0)
// {
// WFMovementTranService wfService = new WFMovementTranService();
// dsNotiAndPendi = wfService.GetNotificationAndPendingJobCount(tc, emp.ID);
// SystemInformationService sys = new SystemInformationService();
// sys.Get(tc, out sysInfo);
// }
// else
// {
// if (tc != null)
// tc.HandleError();
// throw new ServiceException("Employee not found");
// }
// tc.End();
// }
// catch (Exception e)
// {
// #region Handle Exception
// if (tc != null)
// tc.HandleError();
// ExceptionLog.Write(e);
// throw new ServiceException(e.Message, e);
// #endregion
// }
//}
public DataTable GetDFSL()
{
DataSet designationWiseCountDS = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
designationWiseCountDS = EmployeeDA.GetDFSL(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return designationWiseCountDS.Tables[0];
}
public DataSet GetEmployeeGenderRatio()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeGenderRatio(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetEmployeeSummaryData()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeSummaryData(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetEmployeeAttritionData()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeAttritionData(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetDashBoardGraphData()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetDashBoardGraphData(tc);
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetEmployeeSummaryDataByDepartment(Employee emp)
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeSummaryDataByDepartment(tc, emp);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public Employee GetByName(string EmpName)
{
Employee oEmployee = new Employee();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetByName(tc, EmpName));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
public Employee GetByEmployeeNo(string EmpName)
{
Employee oEmployee = new Employee();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.getByEmployeeNo(tc, EmpName));
if (oreader.Read())
{
oEmployee = this.CreateObject<Employee>(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 oEmployee;
}
public List<Employee> GetByPrimaryLMID(int employeeID)
{
List<Employee> employees = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetByPrimaryLMID(tc, employeeID));
employees = this.CreateObjects<Employee>(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 employees;
}
public List<Employee> GetFirstLMTeamMembers(int employeeID)
{
List<Employee> oEmployees = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetFirstLMTeamMembers(tc, employeeID));
oEmployees = this.CreateObjects<Employee>(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 oEmployees;
}
public List<Employee> GetSubordinatesByLineManager(int employeeID)
{
List<Employee> oEmployees = null;
TransactionContext sc = null;
try
{
sc = TransactionContext.Begin();
DataReader oreader = new DataReader(EmployeeDA.GetSubordinatesByLineManager(sc, employeeID));
oEmployees = this.CreateObjects<Employee>(oreader);
oreader.Close();
sc.End();
}
catch (Exception e)
{
#region Handle Exception
if (sc != null)
sc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return oEmployees;
}
public DataTable GetSubordinatesByLineManagerForMobile(int employeeID)
{
TransactionContext sc = null;
try
{
sc = TransactionContext.Begin();
return EmployeeDA.GetsubordinateforMobile(sc, employeeID);
sc.End();
}
catch (Exception e)
{
#region Handle Exception
if (sc != null)
sc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public DataTable GetSubordinatesByLineManagerForMobileWithNoLock(int employeeID)
{
TransactionContext sc = null;
try
{
sc = TransactionContext.Begin();
return EmployeeDA.GetSubordinatesByLineManagerForMobileWithNoLock(sc, employeeID);
sc.End();
}
catch (Exception e)
{
#region Handle Exception
if (sc != null)
sc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public DataSet GetEstimatedConfirmationReport()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEstimatedConfirmationReport(tc);
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetEstimatedRetirementReport()
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEstimatedRetirementReport(tc);
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetSelfServiceBasicData(int employeeId)
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetSelfServiceBasicData(tc, employeeId);
ds.Tables[0].Columns.Add("ServiceTenure");
ds.Tables[0].Columns.Add("Age");
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
ds.Tables[0].Rows[0]["ServiceTenure"] = GlobalFunctions.AgeCalculateInYear(Convert.ToDateTime(ds.Tables[0].Rows[0]["JoiningDate"]), DateTime.Today);
ds.Tables[0].Rows[0]["Age"] = GlobalFunctions.AgeCalculate(Convert.ToDateTime(ds.Tables[0].Rows[0]["BirthDate"]), DateTime.Today);
}
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetSelfServiceContactData(int employeeId)
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetSelfServiceContactData(tc, employeeId);
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataTable GetBasic(string sEmpIDs)
{
DataSet gradeWiseCountDS = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
gradeWiseCountDS = EmployeeDA.GetBasic(tc, sEmpIDs);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return gradeWiseCountDS.Tables[0];
}
public List<Employee> GetEmployeesRequisitionID(int requisitionID)
{
List<Employee> oEmployees = new List<Employee>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(InternalRecruitmentDA.GetEmployeesRequisitionID(tc, requisitionID));
oEmployees = this.CreateObjects<Employee>(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 oEmployees;
}
public DataSet GetLandingPageData(int isEmployee, int isLeave, int isAttendance, int payrollTypeId)
{
TransactionContext tc = null;
DataSet ds = new DataSet();
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetLandingPageData(tc, isEmployee, isLeave, isAttendance, payrollTypeId);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetHolidayInfoForDashboard()
{
TransactionContext tc = null;
DataSet ds = new DataSet();
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetHolidayInfoForDashboard(tc);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetBankAdviceReport(string sEmpIDs, string leaveYear)
{
DataSet oDataSet = null;
TransactionContext tc = null;
try
{
#region Retrieving data
tc = TransactionContext.Begin();
oDataSet = EmployeeDA.GetBankAdviceReport(tc, sEmpIDs, leaveYear);
tc.End();
#endregion
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
throw new ServiceException(e.Message, e);
#endregion
}
return oDataSet;
}
public DataSet GetEncashPayslip(string sEmpIDs, string leaveYear)
{
DataSet oDataSet = null;
TransactionContext tc = null;
try
{
#region Retrieving data
tc = TransactionContext.Begin();
oDataSet = EmployeeDA.GetEncashPayslip(tc, sEmpIDs, leaveYear);
tc.End();
#endregion
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
throw new ServiceException(e.Message, e);
#endregion
}
return oDataSet;
}
public DataSet GetLeaveCashAdvice(string sEmpIDs, string leaveYear)
{
DataSet oDataSet = null;
TransactionContext tc = null;
try
{
#region Retrieving data
tc = TransactionContext.Begin();
oDataSet = EmployeeDA.GetLeaveCashAdvice(tc, sEmpIDs, leaveYear);
tc.End();
#endregion
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
throw new ServiceException(e.Message, e);
#endregion
}
return oDataSet;
}
public DataSet GetEmpDigitalServiceBook(int empID)
{
DataSet dsetDSB = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
dsetDSB = EmployeeDA.GetEmpDigitalServiceBook(tc, empID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dsetDSB;
}
public bool IsCCApplicable(int empid, string companyCode, string salesEmail)
{
TransactionContext tc = null;
bool isApplicable = false;
try
{
tc = TransactionContext.Begin();
isApplicable = EmployeeDA.IsCCApplicable(tc, empid, companyCode, salesEmail);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return isApplicable;
}
public DataTable GetRegularizableEmail(string regularizableEmployeeIds)
{
TransactionContext tc = null;
DataTable oDataTable = null;
try
{
#region Retrieving data
tc = TransactionContext.Begin();
oDataTable = EmployeeDA.GetRegularizableEmail(tc, regularizableEmployeeIds);
tc.End();
#endregion
}
catch (Exception e)
{
#region Handle Exception
tc?.HandleError();
throw new ServiceException(e.Message, e);
#endregion
}
return oDataTable;
}
public DataSet GetMobileProfile(int EmpID)
{
TransactionContext tc = null;
DataSet ds = new DataSet();
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetMobileProfile(tc, EmpID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataSet GetMobileProfileNew(int EmpID)
{
TransactionContext tc = null;
DataSet ds = new DataSet();
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetMobileProfileNew(tc, EmpID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataTable GetMyTeam(int empid)
{
DataTable dt = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
dt = EmployeeDA.GetMyTeam(tc, empid);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataTable GetCordinatorTeam(Employee oEmp)
{
DataTable dt = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
dt = EmployeeDA.GetCordinatorTeam(tc, oEmp);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataTable GetEmployeeCount(Employee oEmp)
{
DataTable dt = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
dt = EmployeeDA.GetEmployeeCount(tc, oEmp);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataTable getEmpInfoForGateman(int empid)
{
DataTable dt = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
dt = EmployeeDA.getEmpInfoForGateman(tc, empid);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataTable GetEmpOrganogramInfo(Employee oEmp, int? PayrollTypeId = null)
{
DataTable dt = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
dt = EmployeeDA.GetEmpOrganogramInfo(tc, oEmp, PayrollTypeId);
if (dt != null && dt.Rows.Count > 0)
{
foreach (DataRow row in dt.Rows)
{
if (row["birthdate"] != DBNull.Value)
{
// Use the global AgeCalculator function to calculate age
string age = GlobalFunctions.AgeCalculateInYear(Convert.ToDateTime(row["birthdate"]), DateTime.Today);
// Add the calculated age back to the DataTable, assuming an 'Age' column exists.
// If 'Age' column does not exist, you can add it programmatically.
if (!dt.Columns.Contains("Age"))
{
dt.Columns.Add("Age", typeof(string)); // Add 'Age' column if it doesn't exist
}
if (!dt.Columns.Contains("id"))
{
dt.Columns.Add("id", typeof(int));
}
row["id"] = row["employeeid"];
row["Age"] = age; // Assign the calculated age to the 'Age' column
}
}
}
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return dt;
}
public DataTable GetCostCenterInfo(string empID)
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetCostCenterInfo(tc, empID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds.Tables[0];
}
public List<Employee> GetEmployeeByCoordinator(int corID)
{
TransactionContext tc = null;
List<Employee> employees = new List<Employee>();
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(EmployeeDA.GetEmployeeByCoordinator(tc, corID));
employees = this.CreateObjects<Employee>(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 employees;
}
public string GetNextCode(int payrollTypeId)
{
TransactionContext tc = null;
string _code = "";
try
{
tc = TransactionContext.Begin();
_code = GlobalFunctionDA.GetMaxCode(tc, "employee", "employeeno");
tc.End();
int newCode = 0;
int.TryParse(_code, out newCode);
newCode = newCode + 1;
_code = newCode.ToString();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return _code;
}
public DataSet GetPFLedger(string sEmpID, DateTime FromDate, DateTime toDate)
{
DataSet oGrossPay = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
oGrossPay = EmployeeDA.GetPFLedger(tc, sEmpID, FromDate, toDate);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return oGrossPay;
}
public DataSet GetEmployeeSummaryDataByIds(string empIds)
{
DataSet ds = new DataSet();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
ds = EmployeeDA.GetEmployeeSummaryDataByIds(tc, empIds);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return ds;
}
public DataTable GetEmployeeForFundContribution(int payrollTypeID, DateTime month)
{
DataTable dt = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
dt = EmployeeDA.GetEmployeeForFundContribution(tc, payrollTypeID, 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 dt;
}
public DataTable GetEmployeeForFundLoanDeduction(int payrollTypeID, DateTime month)
{
DataTable dt = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
dt = EmployeeDA.GetEmployeeForFundLoanDeduction(tc, payrollTypeID, 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 dt;
}
public bool CheckLineManager(TransactionContext tc, int employeeID)
{
bool isLineManager = false;
try
{
isLineManager = EmployeeDA.CheckLineManager(tc, employeeID);
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return isLineManager;
}
public List<AttritionReport> GetEmployeeAttritionReportData(DateTime fromMonth, DateTime toMonth, int payrolltypeID, int selectedGroup, int? selectedGroupTwo)
{
DataTable dt = null;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
dt = EmployeeDA.GetEmpAttritionReportData(tc, payrolltypeID);
tc.End();
// Convert to strongly typed list
var allEmployees = dt.AsEnumerable().Select(r => new EmployeeAttritionData
{
EmployeeID = r.Field<int>("EMPLOYEEID"),
EmployeeNo = r.Field<string>("EMPLOYEENO"),
Name = r.Field<string>("NAME"),
PayrollTypeID = r.Field<int>("PAYROLLTYPEID"),
JoiningDate = r.Field<DateTime>("JOININGDATE"),
EndOfContractDate = r.Field<DateTime?>("ENDOFCONTRACTDATE"),
Category = r.Field<string>("Category"),
Grade = r.Field<string>("Grade"),
Department = r.Field<string>("Department"),
Designation = r.Field<string>("Designation")
}).ToList();
// Month range
var months = Enumerable.Range(0, ((toMonth.Year - fromMonth.Year) * 12) + toMonth.Month - fromMonth.Month + 1)
.Select(i => fromMonth.AddMonths(i))
.ToList();
var result = new List<AttritionReport>();
// First group: Category or Grade
var firstGrouping = allEmployees.GroupBy(x => selectedGroup == 1 ? x.Category : x.Grade);
foreach (var grp in firstGrouping)
{
IEnumerable<IGrouping<string, EmployeeAttritionData>> secondGrouping;
// Second level grouping (if selected)
if (selectedGroupTwo == 1)
secondGrouping = grp.GroupBy(x => x.Department);
else if (selectedGroupTwo == 2)
secondGrouping = grp.GroupBy(x => x.Designation);
else
secondGrouping = new List<IGrouping<string, EmployeeAttritionData>>
{
new FakeGrouping<string, EmployeeAttritionData>(grp.Key, grp)
};
foreach (var subGrp in secondGrouping)
{
var item = new AttritionReport
{
GroupName = grp.Key,
SubGroupName = (selectedGroupTwo == null) ? "" : subGrp.Key,
MonthData = new List<MonthWiseData>()
};
foreach (var month in months)
{
var firstDay = GlobalFunctions.FirstDateOfMonth(month).Date;
var lastDay = GlobalFunctions.LastDateOfMonth(month).Date.AddDays(1).AddTicks(-1);
var beginningHC = subGrp.Count(e => e.JoiningDate < firstDay && (e.EndOfContractDate == null || e.EndOfContractDate >= firstDay));
var joiner = subGrp.Count(e => e.JoiningDate >= firstDay && e.JoiningDate <= lastDay);
var leaver = subGrp.Count(e => e.EndOfContractDate != null && e.EndOfContractDate >= firstDay && e.EndOfContractDate <= lastDay);
var endHC = beginningHC + joiner - leaver;
item.MonthData.Add(new MonthWiseData
{
Month = month.ToString("MMMM yyyy"),
BeginningHC = beginningHC,
Joiner = joiner,
TotalLeaver = leaver,
EndHC = endHC
});
}
result.Add(item);
}
}
return result;
}
catch (Exception e)
{
tc?.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
}
}
public class FakeGrouping<TKey, TElement> : IGrouping<TKey, TElement>
{
public TKey Key { get; }
private IEnumerable<TElement> _values;
public FakeGrouping(TKey key, IEnumerable<TElement> values)
{
Key = key;
_values = values;
}
public IEnumerator<TElement> GetEnumerator() => _values.GetEnumerator();
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => _values.GetEnumerator();
}
}
}