5546 lines
170 KiB
C#
5546 lines
170 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").Value;
|
|
oEmployee.ForeignExPat = oReader.GetBoolean("foreignExPat").Value;
|
|
oEmployee.TaxCircle = (EnumTaxCircle)oReader.GetInt32("taxCircle", true, 0);
|
|
//oEmployee.TaxCircle = oReader.GetString("taxCircle");
|
|
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");
|
|
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 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 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;
|
|
}
|
|
|
|
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 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)
|
|
{
|
|
|
|
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 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.AgeCalculate(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(Employee oEmp)
|
|
{
|
|
DataTable dt = null;
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin(true);
|
|
dt = EmployeeDA.GetMyTeam(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 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)
|
|
{
|
|
DataTable dt = null;
|
|
TransactionContext tc = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin(true);
|
|
dt = EmployeeDA.GetEmpOrganogramInfo(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 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;
|
|
}
|
|
}
|
|
} |