EchoTex_Payroll/HRM.DA/Service/Attendance/MonthlyWorkPlanService.cs

1035 lines
43 KiB
C#
Raw Normal View History

2024-10-14 10:01:49 +06:00
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using HRM.BO;
using Ease.Core.Model;
using Ease.Core.DataAccess;
using Ease.Core.Utility;
using Microsoft.Data.SqlClient;
namespace HRM.DA
{
#region MonthlyWorkPlan Service
[Serializable]
public class MonthlyWorkPlanService : ServiceTemplate, IMonthlyWorkPlanService
{
public MonthlyWorkPlanService()
{
}
private void MapObject(MonthlyWorkPlan oMonthlyWorkPlan, DataReader oReader)
{
base.SetObjectID(oMonthlyWorkPlan, oReader.GetInt32("MonthlyWorkPlanID").Value);
oMonthlyWorkPlan.DaySerial = oReader.GetInt32("DaySerial", 0);
oMonthlyWorkPlan.WorkDate = oReader.GetDateTime("WorkDate").Value;
oMonthlyWorkPlan.ShiftID = oReader.GetInt32("ShiftID", 0);
oMonthlyWorkPlan.HolidayID = oReader.GetInt32("HolidayID", 0);
oMonthlyWorkPlan.WorkPlanGroupID = oReader.GetInt32("WorkPlanGroupID", 0);
oMonthlyWorkPlan.Type = (EnumWorkPlanDayType)oReader.GetInt32("Type").Value;
oMonthlyWorkPlan.CreatedBy = oReader.GetInt32("CreatedBy", 0);
oMonthlyWorkPlan.CreatedDate = oReader.GetDateTime("CreatedDate").Value;
oMonthlyWorkPlan.ModifiedBy = oReader.GetInt32("ModifiedBy");
oMonthlyWorkPlan.ModifiedDate = oReader.GetDateTime("ModifiedDate");
this.SetObjectState(oMonthlyWorkPlan, Ease.Core.ObjectState.Saved);
}
protected override T CreateObject<T>(DataReader oReader)
{
MonthlyWorkPlan oMonthlyWorkPlan = new MonthlyWorkPlan();
MapObject(oMonthlyWorkPlan, oReader);
return oMonthlyWorkPlan as T;
}
protected MonthlyWorkPlan CreateObject(DataReader oReader)
{
MonthlyWorkPlan oMonthlyWorkPlan = new MonthlyWorkPlan();
MapObject(oMonthlyWorkPlan, oReader);
return oMonthlyWorkPlan;
}
#region Service implementation
public List<MonthlyWorkPlan> Get(DateTime attnMonth, int payrollTypeID)
{
List<MonthlyWorkPlan> monthlyWorkPlans = new List<MonthlyWorkPlan>();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(MonthlyWorkPlanDA.Get(tc, attnMonth, payrollTypeID));
monthlyWorkPlans = this.CreateObjects<MonthlyWorkPlan>(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 monthlyWorkPlans;
}
public List<MonthlyWorkPlan> GetByDateAndGroupID(DateTime dAssDate, int groupID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(MonthlyWorkPlanDA.GetByDateAndGroupID(tc, dAssDate, groupID));
var monthlyWorkPlans = this.CreateObjects<MonthlyWorkPlan>(dr);
dr.Close();
tc.End();
return monthlyWorkPlans;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public List<MonthlyWorkPlan> Get(DateTime fromdate, DateTime todate, int payrollTypeID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(MonthlyWorkPlanDA.Get(tc, fromdate, todate, payrollTypeID));
var monthlyWorkPlans = this.CreateObjects<MonthlyWorkPlan>(dr);
dr.Close();
tc.End();
return monthlyWorkPlans;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
//public List<MonthlyWorkPlan> GetMonthlyDataByEmp(DateTime dAssDate, EnumWorkPlanGroup type, int nEmpID)
//{
// TransactionContext tc = null;
// try
// {
// tc = TransactionContext.Begin();
// DataReader dr = new DataReader(MonthlyWorkPlanDA.GetMonthlyDataByEmp(tc, dAssDate, type, nEmpID));
// var monthlyWorkPlans = this.CreateObjects<MonthlyWorkPlan>(dr);
// dr.Close();
// tc.End();
// return monthlyWorkPlans;
// }
// catch (Exception e)
// {
// #region Handle Exception
// if (tc != null)
// tc.HandleError();
// ExceptionLog.Write(e);
// throw new ServiceException(e.Message, e);
// #endregion
// }
//}
public List<MonthlyWorkPlan> Get(int payrollTypeID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(MonthlyWorkPlanDA.Get(tc, payrollTypeID));
var monthlyWorkPlans = this.CreateObjects<MonthlyWorkPlan>(dr);
dr.Close();
tc.End();
return monthlyWorkPlans;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public List<MonthlyWorkPlan> GetByPayrollTypeID(DateTime fromdate, DateTime todate, int payrolltypeID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr =
new DataReader(MonthlyWorkPlanDA.GetByPayrollTypeID(tc, fromdate, todate, payrolltypeID));
var monthlyWorkPlans = this.CreateObjects<MonthlyWorkPlan>(dr);
dr.Close();
tc.End();
return monthlyWorkPlans;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public List<MonthlyWorkPlan> GetByDateAndPayrollType(DateTime attnDate, int payrollTypeID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(MonthlyWorkPlanDA.GetByDateAndPayrollType(tc, attnDate, payrollTypeID));
var monthlyWorkPlans = this.CreateObjects<MonthlyWorkPlan>(dr);
dr.Close();
tc.End();
return monthlyWorkPlans;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public MonthlyWorkPlan GetByEmpID(int nEmpID, DateTime assDate, EnumWorkPlanGroup type)
{
MonthlyWorkPlan oMonthlyWorkPlan = new MonthlyWorkPlan();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(MonthlyWorkPlanDA.GetByEmpID(tc, nEmpID, assDate, type));
if (oreader.Read())
{
oMonthlyWorkPlan = this.CreateObject<MonthlyWorkPlan>(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 oMonthlyWorkPlan;
}
public MonthlyWorkPlan GetByEmpID(int nEmpID, DateTime workDate)
{
MonthlyWorkPlan oMonthlyWorkPlan = new MonthlyWorkPlan();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader oreader = new DataReader(MonthlyWorkPlanDA.GetByEmpID(tc, nEmpID, workDate));
if (oreader.Read())
{
oMonthlyWorkPlan = this.CreateObject<MonthlyWorkPlan>(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 oMonthlyWorkPlan;
}
public List<MonthlyWorkPlan> GetMonthlyDataByEmp(DateTime fromDate, DateTime toDate, EnumWorkPlanGroup type,
int nEmpID, int workPlanGroupID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr =
new DataReader(MonthlyWorkPlanDA.GetMonthlyDataByEmp(tc, fromDate, toDate, type, nEmpID,
workPlanGroupID));
var monthlyWorkPlans = this.CreateObjects<MonthlyWorkPlan>(dr);
dr.Close();
tc.End();
return monthlyWorkPlans;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public List<MonthlyWorkPlan> GetByDate(DateTime attnDate, int payrollTypeID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
DataReader dr = new DataReader(MonthlyWorkPlanDA.GetByDate(tc, attnDate, payrollTypeID));
var monthlyWorkPlans = this.CreateObjects<MonthlyWorkPlan>(dr);
dr.Close();
tc.End();
return monthlyWorkPlans;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public DateTime GetLastSavedWorkDate(int payrollTypeID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
var lastSavedWorkDate = MonthlyWorkPlanDA.GetLastSavedWorkDate(tc, payrollTypeID);
tc.End();
return lastSavedWorkDate;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public void Save(List<MonthlyWorkPlan> oMWPlans)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
var startDate = oMWPlans.Min(x => x.WorkDate);
var endDate = oMWPlans.Max(x => x.WorkDate);
int id = tc.GenerateID("MonthlyWorkPlan", "MonthlyWorkPlanID");
// Delete between these Date
MonthlyWorkPlanDA.Delete(tc, startDate, oMWPlans[0].payrollTypeID);
// Bulk insert
if (oMWPlans != null && oMWPlans.Count > 0)
{
DataTable _monthlyWorkPlan = null;
_monthlyWorkPlan = new DataTable("MonthlyWorkPlan");
_monthlyWorkPlan.Columns.Add("MONTHLYWORKPLANID", typeof(int));
_monthlyWorkPlan.Columns.Add("WORKDATE", typeof(DateTime));
_monthlyWorkPlan.Columns.Add("SHIFTID", typeof(int));
_monthlyWorkPlan.Columns.Add("HOLIDAYID", typeof(int));
_monthlyWorkPlan.Columns.Add("CREATEDBY", typeof(int));
_monthlyWorkPlan.Columns.Add("CREATEDDATE", typeof(DateTime));
_monthlyWorkPlan.Columns.Add("MODIFIEDBY", typeof(int));
_monthlyWorkPlan.Columns.Add("MODIFIEDDATE", typeof(DateTime));
_monthlyWorkPlan.Columns.Add("TYPE", typeof(int));
_monthlyWorkPlan.Columns.Add("WORKPLANGROUPID", typeof(int));
_monthlyWorkPlan.Columns.Add("DAYSERIAL", typeof(int));
_monthlyWorkPlan.Columns.Add("PAYROLLTYPEID", typeof(int));
foreach (MonthlyWorkPlan item in oMWPlans)
{
_monthlyWorkPlan.Rows.Add(
item.IsNew ? id++ : item.ID,
item.WorkDate,
DataReader.GetNullValue(item.ShiftID, 0),
DataReader.GetNullValue(item.HolidayID, 0),
DataReader.GetNullValue(item.CreatedBy, 0),
item.CreatedDate,
null,
null,
(int)item.Type,
item.WorkPlanGroupID,
item.DaySerial,
item.payrollTypeID);
}
using (SqlBulkCopy bulkCopy = new SqlBulkCopy((SqlConnection)tc.Connection,
SqlBulkCopyOptions.Default, (SqlTransaction)tc.Transaction))
{
bulkCopy.BulkCopyTimeout = 600; // in seconds
//bulkCopy.BatchSize = 5000;
bulkCopy.ColumnMappings.Add("MONTHLYWORKPLANID", "MONTHLYWORKPLANID");
bulkCopy.ColumnMappings.Add("WORKDATE", "WORKDATE");
bulkCopy.ColumnMappings.Add("SHIFTID", "SHIFTID");
bulkCopy.ColumnMappings.Add("HOLIDAYID", "HOLIDAYID");
bulkCopy.ColumnMappings.Add("CREATEDBY", "CREATEDBY");
bulkCopy.ColumnMappings.Add("CREATEDDATE", "CREATEDDATE");
bulkCopy.ColumnMappings.Add("MODIFIEDBY", "MODIFIEDBY");
bulkCopy.ColumnMappings.Add("MODIFIEDDATE", "MODIFIEDDATE");
bulkCopy.ColumnMappings.Add("TYPE", "TYPE");
bulkCopy.ColumnMappings.Add("WORKPLANGROUPID", "WORKPLANGROUPID");
bulkCopy.ColumnMappings.Add("DAYSERIAL", "DAYSERIAL");
bulkCopy.ColumnMappings.Add("PAYROLLTYPEID", "PAYROLLTYPEID");
bulkCopy.DestinationTableName = "MonthlyWorkPlan";
bulkCopy.WriteToServer(_monthlyWorkPlan);
}
}
//foreach (MonthlyWorkPlan oMWPlan in oMWPlans)
//{
// if (oMWPlan.IsNew)
// {
// int id = tc.GenerateID("MonthlyWorkPlan", "MonthlyWorkPlanID");
// base.SetObjectID(oMWPlan, ID.FromInteger(id));
// MonthlyWorkPlanDA.Insert(tc, oMWPlan);
// }
// else
// {
// MonthlyWorkPlanDA.Update(tc, oMWPlan);
// }
//}
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 UpdateShiftAndRoster(MonthlyWorkPlan oMWPlan)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
MonthlyWorkPlanDA.UpdateShiftAndRoster(tc, oMWPlan);
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 DeleteOnward(DateTime fromMonth, int payrolltypeid)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
MonthlyWorkPlanDA.Delete(tc, fromMonth, payrolltypeid);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
public void Delete(DateTime dFromDate, DateTime dToDate, int payrollTypeID)
{
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin(true);
MonthlyWorkPlanDA.Delete(tc, dFromDate, dToDate, payrollTypeID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
}
//public void Delete(DateTime assignDate, string empIDs)
//{
// TransactionContext tc = null;
// try
// {
// tc = TransactionContext.Begin(true);
// MonthlyWorkPlanDA.Delete(tc, assignDate, empIDs);
// tc.End();
// }
// catch (Exception e)
// {
// #region Handle Exception
// if (tc != null)
// tc.HandleError();
// ExceptionLog.Write(e);
// throw new ServiceException(e.Message, e);
// #endregion
// }
//}
public bool IsExist(DateTime dAssDate, int groupID)
{
bool isExist = false;
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
isExist = MonthlyWorkPlanDA.IsExist(tc, dAssDate, groupID);
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
return isExist;
}
public List<MonthlyWorkPlan> RefreshMonthlyWorkplan(DateTime monthFromDate, DateTime monthToDate, int payrollTypeID)
{
List<MonthlyWorkPlan> currentMonthlyWorkPlans = new List<MonthlyWorkPlan>();
var tempCurrentMonthlyWorkPlans = this.Get(monthFromDate, payrollTypeID);
var PreviousMonthPlans = this.Get(monthFromDate.AddMonths(-1) , payrollTypeID);
WorkPlanGroupService wfs = new WorkPlanGroupService();
List<WorkPlanGroup> wfGroups = wfs.Get(EnumStatus.Regardless, payrollTypeID, string.Empty, null);
AttnNationalHolidayService hcs = new AttnNationalHolidayService();
List<AttnNationalHoliday> AttNHolidays = hcs.Get(EnumStatus.Regardless, payrollTypeID);
MonthlyWorkPlan tempMonthlyWorkPlan;
ShiftRotationService srs = new ShiftRotationService();
List<ShiftRotation> shiftRotations = srs.Get(EnumStatus.Regardless, payrollTypeID);
if (monthFromDate.Day != 1) monthFromDate = GlobalFunctions.FirstDateOfMonth(monthFromDate);
foreach (var currentWPGroup in wfGroups)
{
if (tempCurrentMonthlyWorkPlans.Any(x => x.WorkPlanGroupID == currentWPGroup.ID))
{
currentMonthlyWorkPlans.AddRange(tempCurrentMonthlyWorkPlans.Where(x => x.WorkPlanGroupID== currentWPGroup.ID));
continue;
}
if (currentWPGroup.Type == EnumWorkPlanGroup.Fixed)
{
for (DateTime currentDate = monthFromDate; currentDate <= monthToDate; currentDate = currentDate.AddDays(1))
{
tempMonthlyWorkPlan = new MonthlyWorkPlan
{
WorkDate = currentDate,
WorkPlanGroupID = currentWPGroup.ID,
Type = EnumWorkPlanDayType.WorkingDay,
HolidayID = 0,
payrollTypeID = payrollTypeID
};
tempMonthlyWorkPlan.WorkPlanGroup = currentWPGroup;
if (currentDate.DayOfWeek.ToHolidayDayOfWeek() == currentWPGroup.HolidayOne || currentDate.DayOfWeek.ToHolidayDayOfWeek() == currentWPGroup.HolidayTwo)
{
tempMonthlyWorkPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
}
if (AttNHolidays.Any(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date))
{
tempMonthlyWorkPlan.Type = EnumWorkPlanDayType.NationalHoliday;
tempMonthlyWorkPlan.HolidayID = AttNHolidays.First(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date).ID;
}
switch (currentDate.DayOfWeek)
{
case DayOfWeek.Sunday:
tempMonthlyWorkPlan.ShiftID =(int) currentWPGroup.SundayShiftID;
break;
case DayOfWeek.Monday:
tempMonthlyWorkPlan.ShiftID = (int)currentWPGroup.MondayShiftID;
break;
case DayOfWeek.Tuesday:
tempMonthlyWorkPlan.ShiftID = (int)currentWPGroup.TuesdayShiftID;
break;
case DayOfWeek.Wednesday:
tempMonthlyWorkPlan.ShiftID = (int)currentWPGroup.WednesdayShiftID;
break;
case DayOfWeek.Thursday:
tempMonthlyWorkPlan.ShiftID = (int)currentWPGroup.ThursdayShiftID;
break;
case DayOfWeek.Friday:
tempMonthlyWorkPlan.ShiftID = (int)currentWPGroup.FridayShiftID;
break;
case DayOfWeek.Saturday:
tempMonthlyWorkPlan.ShiftID = (int)currentWPGroup.SaturdayShiftID;
break;
default:
break;
}
currentMonthlyWorkPlans.Add(tempMonthlyWorkPlan);
}
}
else
{
var lastDateofPreviousMonth = monthFromDate.AddMonths(-1).LastDateOfMonth();
var lastPreviousMWPlan = PreviousMonthPlans.FirstOrDefault(x => x.WorkDate.Date == lastDateofPreviousMonth && x.WorkPlanGroupID == currentWPGroup.ID);
var tempShiftRotations = shiftRotations.Where(x => x.WorkPlanType == currentWPGroup.Type).OrderBy(x => x.Sequence).ToList();
if(tempShiftRotations == null || tempShiftRotations.Count ==0)
{
throw new Exception("shift Rotation not found for the roster: " + currentWPGroup.Name);
}
if ((currentWPGroup.Type == EnumWorkPlanGroup.Double_Shift_1 || currentWPGroup.Type == EnumWorkPlanGroup.Double_Shift_2)
&& tempShiftRotations.Count != 2)
{
throw new Exception("There must be two roster for a double shift");
}
if ((currentWPGroup.Type == EnumWorkPlanGroup.Counter_Clock_1 || currentWPGroup.Type == EnumWorkPlanGroup.Counter_Clock_2
|| currentWPGroup.Type == EnumWorkPlanGroup.Counter_Clock_3) && tempShiftRotations.Count != 3)
{
throw new Exception("There must be three roster for a Counter-Clock-shift");
}
int DaySerial = 1;
int shiftID = currentWPGroup.InitialShiftID;
if (lastPreviousMWPlan != null)
{
lastPreviousMWPlan.WorkPlanGroup = currentWPGroup;
DaySerial = lastPreviousMWPlan.NextDaySerial;
shiftID = lastPreviousMWPlan.ShiftID;
if (DaySerial == 1)
{
var lastRotationShift = tempShiftRotations.FirstOrDefault(x => x.ShiftID == lastPreviousMWPlan.ShiftID);
shiftID = lastRotationShift.NextShiftID(tempShiftRotations);
}
}
tempMonthlyWorkPlan = new MonthlyWorkPlan();
for (DateTime currentDate = monthFromDate; currentDate <= monthToDate; currentDate = currentDate.AddDays(1))
{
tempMonthlyWorkPlan = new MonthlyWorkPlan
{
WorkDate = currentDate,
WorkPlanGroupID = currentWPGroup.ID,
ShiftID = shiftID,
Type = EnumWorkPlanDayType.WorkingDay,
HolidayID = 0,
DaySerial = DaySerial,
WorkPlanGroup= currentWPGroup
};
if (currentDate.DayOfWeek.ToHolidayDayOfWeek() == currentWPGroup.HolidayOne ||
currentDate.DayOfWeek.ToHolidayDayOfWeek() == currentWPGroup.HolidayTwo)
{
tempMonthlyWorkPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
}
else if (DaySerial == 6 && currentWPGroup.HasTwoHolidays && currentWPGroup.HolidayOne == HolidayDayOfWeek.Auto)
{
tempMonthlyWorkPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
}
else if (DaySerial == 7 && currentWPGroup.HasTwoHolidays && currentWPGroup.HolidayTwo == HolidayDayOfWeek.Auto)
{
tempMonthlyWorkPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
}
else if (DaySerial == 7 && !currentWPGroup.HasTwoHolidays && currentWPGroup.HolidayOne == HolidayDayOfWeek.Auto)
{
tempMonthlyWorkPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
}
if (AttNHolidays.Any(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date))
{
tempMonthlyWorkPlan.Type = EnumWorkPlanDayType.NationalHoliday;
tempMonthlyWorkPlan.HolidayID = AttNHolidays.First(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date).ID;
}
currentMonthlyWorkPlans.Add(tempMonthlyWorkPlan);
if (tempMonthlyWorkPlan.Type == EnumWorkPlanDayType.WeeklyHoliday && DaySerial != 7)
tempMonthlyWorkPlan.DaySerial = 7;
if (tempMonthlyWorkPlan.WorkPlanGroup.Type == EnumWorkPlanGroup.Two_Days_Shift_1 &&
tempMonthlyWorkPlan.Type == EnumWorkPlanDayType.WeeklyHoliday && DaySerial != 2)
continue;
if (tempMonthlyWorkPlan.WorkPlanGroup.Type == EnumWorkPlanGroup.Three_Days_Shift_1 &&
tempMonthlyWorkPlan.Type == EnumWorkPlanDayType.WeeklyHoliday && DaySerial != 3)
continue;
DaySerial = tempMonthlyWorkPlan.NextDaySerial;
if (DaySerial == 1)
{
var lastRotationShift = tempShiftRotations.FirstOrDefault(x => x.ShiftID == shiftID);
shiftID = lastRotationShift.NextShiftID(tempShiftRotations);
}
}
}
}
return currentMonthlyWorkPlans;
// lblStatus.Text = _currentMonthlyWorkPlans.All(o => o.ID.IsUnassigned) ? "UnSaved Data" : "Saved Data";
}
public void SetWorkDayType(MonthlyWorkPlan newPlan, List<AttnNationalHoliday> AttNHolidays , int DaySerial, DateTime currentDate, WorkPlanGroup currentWPGroup)
{
EnumWorkPlanDayType rtype = EnumWorkPlanDayType.WorkingDay;
if (currentDate.DayOfWeek.ToHolidayDayOfWeek() == currentWPGroup.HolidayOne || currentDate.DayOfWeek.ToHolidayDayOfWeek() == currentWPGroup.HolidayTwo)
{
newPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
}
else if (DaySerial == 6 && currentWPGroup.HasTwoHolidays && currentWPGroup.HolidayOne == HolidayDayOfWeek.Auto)
{
newPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
}
else if (DaySerial == 7 && currentWPGroup.HasTwoHolidays && currentWPGroup.HolidayTwo == HolidayDayOfWeek.Auto)
{
newPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
}
else if (DaySerial == 7 && !currentWPGroup.HasTwoHolidays && currentWPGroup.HolidayOne == HolidayDayOfWeek.Auto)
{
newPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
}
if (AttNHolidays.Any(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date))
{
newPlan.Type = EnumWorkPlanDayType.NationalHoliday;
newPlan.HolidayID = AttNHolidays.First(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date).ID;
}
}
public List<MonthlyWorkPlan> updateWorkPlan(MonthlyWorkPlan mplan)
{
List<AttnNationalHoliday> AttNHolidays = new AttnNationalHolidayService().Get(EnumStatus.Regardless, mplan.payrollTypeID);
var monthToDate = mplan.WorkDate.LastDateOfMonth();
DateTime dDate = mplan.WorkDate.AddDays(1);
int DaySerial = 1;
List<ShiftRotation> shiftRotation = new ShiftRotationService().Get(EnumStatus.Active, mplan.payrollTypeID);
mplan.WorkPlanGroup = new WorkPlanGroupService().Get((int)mplan.WorkPlanGroupID);
var tempShiftRotations = shiftRotation.Where(x => x.WorkPlanType == mplan.WorkPlanGroup.Type).OrderBy(x => x.Sequence).ToList();
int shiftID = mplan.ShiftID;
List<MonthlyWorkPlan> mplans = new List<MonthlyWorkPlan>();
mplans.Add(mplan);
List<Shift> oshifts = new ShiftService().Get(string.Empty, string.Empty, EnumStatus.Regardless, mplan.payrollTypeID);
this.SetWorkDayType(mplan, AttNHolidays, 1, mplan.WorkDate, mplan.WorkPlanGroup);
if (mplan.Type == EnumWorkPlanDayType.WorkingDay)
DaySerial = 2;
if (mplan.WorkPlanGroup.Type == EnumWorkPlanGroup.Fixed)
{
for (DateTime currentDate = dDate; currentDate <= monthToDate; currentDate = currentDate.AddDays(1))
{
MonthlyWorkPlan tempMonthlyWorkPlan = new MonthlyWorkPlan
{
WorkDate = currentDate,
WorkPlanGroupID = mplan.WorkPlanGroup.ID,
Type = EnumWorkPlanDayType.WorkingDay,
HolidayID = 0,
payrollTypeID = mplan.payrollTypeID
};
if (currentDate.DayOfWeek.ToHolidayDayOfWeek() == mplan.WorkPlanGroup.HolidayOne || currentDate.DayOfWeek.ToHolidayDayOfWeek() == mplan.WorkPlanGroup.HolidayTwo)
{
tempMonthlyWorkPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
}
if (AttNHolidays.Any(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date))
{
tempMonthlyWorkPlan.Type = EnumWorkPlanDayType.NationalHoliday;
tempMonthlyWorkPlan.HolidayID = AttNHolidays.First(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date).ID;
}
switch (currentDate.DayOfWeek)
{
case DayOfWeek.Sunday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.SundayShiftID;
break;
case DayOfWeek.Monday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.MondayShiftID;
break;
case DayOfWeek.Tuesday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.TuesdayShiftID;
break;
case DayOfWeek.Wednesday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.WednesdayShiftID;
break;
case DayOfWeek.Thursday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.ThursdayShiftID;
break;
case DayOfWeek.Friday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.FridayShiftID;
break;
case DayOfWeek.Saturday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.SaturdayShiftID;
break;
default:
break;
}
mplans.Add(tempMonthlyWorkPlan);
}
}
else
{
for (DateTime currentDate = dDate; currentDate <= monthToDate; currentDate = currentDate.AddDays(1))
{
MonthlyWorkPlan newPlan = new MonthlyWorkPlan();
newPlan.WorkDate = currentDate;
newPlan.WorkPlanGroupID = mplan.WorkPlanGroupID;
newPlan.payrollTypeID = mplan.payrollTypeID;
newPlan.WorkPlanGroup = mplan.WorkPlanGroup;
newPlan.DaySerial = DaySerial;
newPlan.Type = EnumWorkPlanDayType.WorkingDay;
//if (DaySerial == 7)
// newPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
//if (AttNHolidays.Any(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date))
//{
// newPlan.Type = EnumWorkPlanDayType.NationalHoliday;
// newPlan.HolidayID = AttNHolidays.First(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date).ID;
//}
this.SetWorkDayType(newPlan, AttNHolidays, DaySerial, newPlan.WorkDate, mplan.WorkPlanGroup);
if (DaySerial == 1)
{
var lastRotationShift = tempShiftRotations.FirstOrDefault(x => x.ShiftID == shiftID);
shiftID = lastRotationShift.NextShiftID(tempShiftRotations);
}
DaySerial = newPlan.NextDaySerial;
Shift oshif = oshifts.FirstOrDefault(x => x.ID == shiftID);
newPlan.ShiftID = oshif.ID;
mplans.Add(newPlan);
}
}
return mplans;
}
public List<MonthlyWorkPlan> updateWorkPlanSingleDay(MonthlyWorkPlan mplan)
{
List<AttnNationalHoliday> AttNHolidays = new AttnNationalHolidayService().Get(EnumStatus.Regardless, mplan.payrollTypeID);
var monthToDate = mplan.WorkDate.LastDateOfMonth();
DateTime dDate = mplan.WorkDate.AddDays(1);
int DaySerial = 1;
List<ShiftRotation> shiftRotation = new ShiftRotationService().Get(EnumStatus.Active, mplan.payrollTypeID);
mplan.WorkPlanGroup = new WorkPlanGroupService().Get((int)mplan.WorkPlanGroupID);
var tempShiftRotations = shiftRotation.Where(x => x.WorkPlanType == mplan.WorkPlanGroup.Type).OrderBy(x => x.Sequence).ToList();
int shiftID = mplan.ShiftID;
List<MonthlyWorkPlan> mplans = new List<MonthlyWorkPlan>();
mplans.Add(mplan);
List<Shift> oshifts = new ShiftService().Get(string.Empty, string.Empty, EnumStatus.Regardless, mplan.payrollTypeID);
this.SetWorkDayType(mplan, AttNHolidays, 1, mplan.WorkDate, mplan.WorkPlanGroup);
if (mplan.Type == EnumWorkPlanDayType.WorkingDay)
DaySerial = 2;
if (mplan.WorkPlanGroup.Type == EnumWorkPlanGroup.Fixed)
{
for (DateTime currentDate = dDate; currentDate <= monthToDate; currentDate = currentDate.AddDays(1))
{
MonthlyWorkPlan tempMonthlyWorkPlan = new MonthlyWorkPlan
{
WorkDate = currentDate,
WorkPlanGroupID = mplan.WorkPlanGroup.ID,
Type = EnumWorkPlanDayType.WorkingDay,
HolidayID = 0,
payrollTypeID = mplan.payrollTypeID
};
if (currentDate.DayOfWeek.ToHolidayDayOfWeek() == mplan.WorkPlanGroup.HolidayOne || currentDate.DayOfWeek.ToHolidayDayOfWeek() == mplan.WorkPlanGroup.HolidayTwo)
{
tempMonthlyWorkPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
}
if (AttNHolidays.Any(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date))
{
tempMonthlyWorkPlan.Type = EnumWorkPlanDayType.NationalHoliday;
tempMonthlyWorkPlan.HolidayID = AttNHolidays.First(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date).ID;
}
switch (currentDate.DayOfWeek)
{
case DayOfWeek.Sunday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.SundayShiftID;
break;
case DayOfWeek.Monday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.MondayShiftID;
break;
case DayOfWeek.Tuesday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.TuesdayShiftID;
break;
case DayOfWeek.Wednesday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.WednesdayShiftID;
break;
case DayOfWeek.Thursday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.ThursdayShiftID;
break;
case DayOfWeek.Friday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.FridayShiftID;
break;
case DayOfWeek.Saturday:
tempMonthlyWorkPlan.ShiftID = (int)mplan.WorkPlanGroup.SaturdayShiftID;
break;
default:
break;
}
mplans.Add(tempMonthlyWorkPlan);
}
}
else
{
for (DateTime currentDate = dDate; currentDate <= monthToDate; currentDate = currentDate.AddDays(1))
{
MonthlyWorkPlan newPlan = new MonthlyWorkPlan();
newPlan.WorkDate = currentDate;
newPlan.WorkPlanGroupID = mplan.WorkPlanGroupID;
newPlan.payrollTypeID = mplan.payrollTypeID;
newPlan.DaySerial = DaySerial;
newPlan.Type = EnumWorkPlanDayType.WorkingDay;
//if (DaySerial == 7)
// newPlan.Type = EnumWorkPlanDayType.WeeklyHoliday;
//if (AttNHolidays.Any(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date))
//{
// newPlan.Type = EnumWorkPlanDayType.NationalHoliday;
// newPlan.HolidayID = AttNHolidays.First(x => currentDate.Date >= x.FromDate.Date && currentDate.Date <= x.ToDate.Date).ID;
//}
this.SetWorkDayType(newPlan, AttNHolidays, DaySerial, newPlan.WorkDate, mplan.WorkPlanGroup);
if (DaySerial == 1)
{
var lastRotationShift = tempShiftRotations.FirstOrDefault(x => x.ShiftID == shiftID);
shiftID = lastRotationShift.NextShiftID(tempShiftRotations);
}
DaySerial = newPlan.NextDaySerial;
Shift oshif = oshifts.FirstOrDefault(x => x.ID == shiftID);
newPlan.ShiftID = oshif.ID;
mplans.Add(newPlan);
}
}
return mplans;
}
#endregion
}
#endregion
}