public List <EmployeeWeek> FillPlanningEmployeeWeeks(long storeid, long worldid, DateTime aBegin, DateTime aEnd)
{
if (_listweeks != null && _listweeks.Count > 0)
{
FillEmployeeWeeks(aBegin, aEnd, true);
// EmployeeTimeService timeService = EmployeeService.EmployeeTimeService as EmployeeTimeService;
// timeService.FillEmployeeWeeks(_listweeks, _employeeids, _dictionWeek, aBegin, aEnd, true);
if (LoadWeeks)
{
EmployeeTimeService timeService = EmployeeService.EmployeeTimeService as EmployeeTimeService;
EmployeeWeekTimePlanningService weekService = timeService.EmployeeWeekTimePlanningService as EmployeeWeekTimePlanningService;
List <EmployeeWeekTimePlanning> planningweeks = weekService.GetEmployeesWeekState(_employeeids, aBegin, aEnd);
if (planningweeks != null && planningweeks.Count > 0)
{
EmployeeWeek emplweek = null;
foreach (EmployeeWeekTimePlanning week in planningweeks)
{
if (_dictionWeek.TryGetValue(week.EmployeeID, out emplweek))
{
emplweek.NewWeek = false;
EmployeeWeekProcessor.Assign(week, emplweek);
}
}
}
}
}
return(_listweeks);
}
public void FillEmployeeWeeks(List <EmployeeWeek> weeks, DateTime beginDate, DateTime endDate)
{
if (weeks != null && weeks.Count > 0)
{
Dictionary <long, EmployeeWeek> _diction = EmployeeWeekProcessor.GetDictionary(weeks);
long[] ids = EmployeeWeekProcessor.GetEmployeeIds(weeks);
List <EmployeeDayStateRecording> daystates = servicedao.GetEmployeesStates(ids, beginDate, endDate);
if (daystates != null)
{
EmployeeWeek lastWeek = null;
EmployeeDay day = null;
foreach (EmployeeDayStateRecording edsp in daystates)
{
if ((lastWeek == null) || (edsp.EmployeeID != lastWeek.EmployeeId))
{
lastWeek = null;
_diction.TryGetValue(edsp.EmployeeID, out lastWeek);
}
if (lastWeek != null)
{
day = lastWeek.GetDay(edsp.Date);
if (day != null)
{
EmployeeDayProcessor.AssignDay(edsp, day);
}
}
}
}
}
}
public override void Save()
{
if (_employeeweeks != null && _employeeweeks.Count > 0)
{
//_weekservice.SaveEmployeeWeeks(_employeeweeks);
//_dayservice.SaveEmployeeWeeks(_employeeweeks);
long[] ids = EmployeeWeekProcessor.GetEmployeeIds(_employeeweeks);
SrvEmployeeWeekRecordingList srv_updater_weeks = new SrvEmployeeWeekRecordingList();
DateTime nextWeekMonday = DateTimeHelper.GetNextMonday(BeginDate);
srv_updater_weeks.InitList(ids, BeginDate);
SrvEmployeesRecordingDayList day_list = new SrvEmployeesRecordingDayList(ids, BeginDate);
foreach (EmployeeWeek e_w in _employeeweeks)
{
//srv_updater_weeks.UpdateSaldoAfterRecording(e_w.EmployeeId, nextWeekMonday, e_w.Saldo);
srv_updater_weeks.UpdateEntityAfterRecording(e_w);
foreach (EmployeeDay ed in e_w.DaysList)
{
day_list.CompareAndSave(ed);
}
}
EmployeeRecordingWorkingModelHelper wmhelper = new EmployeeRecordingWorkingModelHelper(_timeservice.EmployeeRecordingWorkingModelService);
wmhelper.SaveEmployeeWorkingModel(_employeeweeks);
}
}
public void SaveEmployeeWorkingModel(List<EmployeeWeek> lstWeeks)
{
if (lstWeeks == null || lstWeeks.Count == 0) return;
long[] ids = EmployeeWeekProcessor.GetEmployeeIds(lstWeeks);
List<EmployeeRecordingWorkingModel> lstEntities = new List<EmployeeRecordingWorkingModel>(lstWeeks.Count * 10);
DateTime begin, end;
begin = lstWeeks[0].BeginDate;
end = lstWeeks[0].EndDate;
EmployeeRecordingWorkingModel entity = null;
foreach (EmployeeWeek week in lstWeeks)
{
foreach (EmployeeDay day in week.DaysList)
{
if (day.WorkingModels != null && day.WorkingModels.Count > 0)
{
foreach (EmployeeWorkingModel model in day.WorkingModels)
{
entity = new EmployeeRecordingWorkingModel();
model.AssignTo(entity);
lstEntities.Add(entity);
}
}
}
}
SaveEmployeesWorkingModel(ids, lstEntities, begin, end);
}
public void FillEmployeeWeeks(List <EmployeeWeek> planningweeks)
{
if (planningweeks == null || planningweeks.Count == 0)
{
return;
}
long[] ids = EmployeeWeekProcessor.GetEmployeeIds(planningweeks);
List <EmployeeWeekTimeRecording> lst = GetEmployeesWeekState(ids, planningweeks[0].BeginDate, planningweeks[0].EndDate);
if (lst == null || lst.Count == 0)
{
return;
}
Dictionary <long, EmployeeWeekTimeRecording> dict = new Dictionary <long, EmployeeWeekTimeRecording>();
foreach (EmployeeWeekTimeRecording ewtp in lst)
{
dict[ewtp.EmployeeID] = ewtp;
}
EmployeeWeekTimeRecording entity = null;
foreach (EmployeeWeek ew in planningweeks)
{
if (dict.TryGetValue(ew.EmployeeId, out entity))
{
EmployeeWeekProcessor.Assign(entity, ew);
}
}
}
public void SaveContext()
{
if (Modified && WorldActualState != null)
{
UpdateHolidaysTime();
long[] ids_modified_employees = null;
List <EmployeeTimeRange> lst = EmployeeWeekProcessor.GetDelta(WorldActualState.List, out ids_modified_employees);
_EmployeeService.EmployeeTimeService.SaveActualEmployeeTimeRange(StoreId, BeginWeekDate, EndWeekDate, ids_modified_employees, lst);
Modified = false;
}
}
public void SaveEmployeeWorkingModel(EmployeeWeek week)
{
List<EmployeeWorkingModel> lst = EmployeeWeekProcessor.GetWorkingModels(week);
List<EmployeeRecordingWorkingModel> lstEntities = new List<EmployeeRecordingWorkingModel>(lst.Count);
EmployeeRecordingWorkingModel entity = null;
foreach (EmployeeWorkingModel model in lst)
{
entity = new EmployeeRecordingWorkingModel();
model.AssignTo(entity);
lstEntities.Add(entity);
}
SaveEmployeeWorkingModel(week.EmployeeId, lstEntities, week.BeginDate, week.EndDate);
}
public List <EmployeeWeek> GetEmployeesWeekStates(long[] emplids, DateTime beginDate, DateTime endDate)
{
List <EmployeeWeek> weeks = null;
EmployeeWeek week = null;
List <EmployeeWeekTimePlanning> entities = GetEmployeesWeekState(emplids, beginDate, endDate);
if (entities != null)
{
weeks = new List <EmployeeWeek>();
foreach (EmployeeWeekTimePlanning entity in entities)
{
week = new EmployeeWeek(entity);
weeks.Add(EmployeeWeekProcessor.Assign(entity, week));
}
}
return(weeks);
}
public void LoadEmployeePlanningAndRecording(StoreToWorld world)
{
_currentWorldID = 0;
if (world != null)
{
_currentWorldID = world.WorldID;
List <EmployeeWeek> planningWeeks = ClientEnvironment.EmployeeService.GetTimePlannignEmployeeByWorld2(StoreId, _currentWorldID, BeginWeekDate, EndWeekDate);
Absences.FillEmployeeWeek(planningWeeks);
_planningWorldState = new StoreWorldWeekState(world, BeginWeekDate, EndWeekDate);
EmployeeWeekProcessor.MarkAsPlannedWeek(planningWeeks);
if (planningWeeks != null)
{
_planningWorldState.List.AddRange(planningWeeks);
foreach (EmployeeWeek ew in planningWeeks)
{
ew.InitWeekState();
}
}
_planningWorldState.Context = this;
_planningWorldState.Calculate();
planningWeeks = ClientEnvironment.EmployeeService.GetTimeRecordingEmployeeByWorld(StoreId, _currentWorldID, BeginWeekDate, EndWeekDate);
Absences.FillEmployeeWeek(planningWeeks);
_actualWorldState = new StoreWorldWeekState(world, BeginWeekDate, EndWeekDate);
EmployeeWeekProcessor.MarkAsRecordingWeek(planningWeeks);
if (planningWeeks != null)
{
_actualWorldState.List.AddRange(planningWeeks);
foreach (EmployeeWeek ew in planningWeeks)
{
ew.InitWeekState();
}
}
_actualWorldState.Context = this;
_actualWorldState.Calculate();
}
}
public void SaveEmployeeWeek(EmployeeWeek planningweek)
{
if (planningweek == null)
{
throw new ArgumentNullException();
}
EmployeeWeekTimeRecording entity = GetEmployeeWeekState(planningweek.EmployeeId, planningweek.BeginDate, planningweek.EndDate);
if (entity == null)
{
entity = new EmployeeWeekTimeRecording();
}
EmployeeWeekProcessor.AssignTo(entity, planningweek);
SaveOrUpdate(entity);
//planningweek.ID = entity.ID;
}
public void UpdateSaldoAfterPlanning(EmployeeWeek week)
{
EmployeeWeekTimePlanning entity = GetByDate(week.EmployeeId, week.BeginDate);
if (entity == null)
{
entity = new EmployeeWeekTimePlanning();
EmployeeWeekProcessor.AssignTo(entity, week);
UpdateEntity(entity);
}
else
{
if (EmployeeWeekProcessor.IsModified(entity, week))
{
EmployeeWeekProcessor.AssignTo(entity, week);
UpdateEntity(entity);
}
}
UpdateSaldoFrom(week.EmployeeId, DateTimeHelper.GetNextMonday(week.BeginDate), week.Saldo);
}
public virtual void Save()
{
if (_employeeweeks != null && _employeeweeks.Count > 0)
{
long[] ids = EmployeeWeekProcessor.GetEmployeeIds(_employeeweeks);
// load from BeginDate to 2079 year
SrvEmployeeWeekPlanningList plan_list = new SrvEmployeeWeekPlanningList(ids, BeginDate);
SrvEmployeesPlanningDayList day_list = new SrvEmployeesPlanningDayList(ids, BeginDate);
foreach (EmployeeWeek w in _employeeweeks)
{
plan_list.UpdateSaldoAfterPlanning(w);
foreach (EmployeeDay ed in w.DaysList)
{
day_list.CompareAndSave(ed);
}
}
EmployeePlanningWorkingModelHelper wmhelper = new EmployeePlanningWorkingModelHelper(_timeservice.EmployeePlanningWorkingModelService);
wmhelper.SaveEmployeeWorkingModel(_employeeweeks);
}
}
public List <EmployeeWeek> FillActualEmployeeWeeks(long storeid, long worldid, DateTime aBegin, DateTime aEnd)
{
if (_listweeks != null && _listweeks.Count > 0)
{
//EmployeeTimeService timeService = EmployeeService.EmployeeTimeService as EmployeeTimeService;
//timeService.FillEmployeeWeeks(_listweeks, aBegin, aEnd, false);
FillEmployeeWeeks(aBegin, aEnd, false);
if (LoadWeeks)
{
EmployeeTimeService timeService = EmployeeService.EmployeeTimeService as EmployeeTimeService;
EmployeeWeekTimeRecordingService weekService = timeService.EmployeeWeekTimeRecordingService as EmployeeWeekTimeRecordingService;
List <EmployeeWeekTimeRecording> weeks = weekService.GetEmployeesWeekState(_employeeids, aBegin, aEnd);
if (weeks != null && weeks.Count > 0)
{
EmployeeWeek emplweek = null;
foreach (EmployeeWeekTimeRecording week in weeks)
{
if (_dictionWeek.TryGetValue(week.EmployeeID, out emplweek))
{
emplweek.NewWeek = false;
//emplweek.CustomEdit = week.CustomEdit;
//if (week.CustomEdit)
// emplweek.Saldo = week.Saldo;
EmployeeWeekProcessor.Assign(week, emplweek);
}
}
}
}
}
return(_listweeks);
}
public void FillEmployeeWeeks(List <EmployeeWeek> planningweeks, long[] emplIds, Dictionary <long, EmployeeWeek> dictWeek)
{
if (planningweeks == null || planningweeks.Count == 0)
{
return;
}
List <EmployeeWeekTimePlanning> lst = GetEmployeesWeekState(emplIds, planningweeks[0].BeginDate, planningweeks[0].EndDate);
if (lst == null || lst.Count == 0)
{
return;
}
EmployeeWeek ew = null;
foreach (EmployeeWeekTimePlanning ewtp in lst)
{
if (dictWeek.TryGetValue(ewtp.EmployeeID, out ew))
{
EmployeeWeekProcessor.Assign(ewtp, ew);
}
}
}
public void SaveEmployeeWeek(EmployeeWeek planningweek)
{
if (planningweek == null)
{
throw new ArgumentNullException();
}
EmployeeWeekTimePlanning entity = GetEmployeeWeekState(planningweek.EmployeeId, planningweek.BeginDate, planningweek.EndDate);
if (entity == null)
{
entity = new EmployeeWeekTimePlanning();
}
EmployeeWeekProcessor.AssignTo(entity, planningweek);
SaveOrUpdate(entity);
//planningweek.ID = entity.ID;
if (DateTimeHelper.Between(DateTime.Today, planningweek.BeginDate, planningweek.EndDate))
{
UpdatePlanningSaldo(entity);
}
}
public virtual void UpdateEntityAfterRecording(EmployeeWeek week)
{
EmployeeWeekTimeRecording entity = GetByDate(week.EmployeeId, week.BeginDate);
List <EmployeeWeekTimeRecording> list = GetEntitiesByEmployeeId(week.EmployeeId);
if (entity == null)
{
entity = new EmployeeWeekTimeRecording();
EmployeeWeekProcessor.AssignTo(entity, week);
UpdateEntity(entity);
if (list == null)
{
list = new List <EmployeeWeekTimeRecording>();
_index[week.EmployeeId] = list;
}
_entities.Add(entity);
list.Add(entity);
list.Sort();
}
else
{
if (EmployeeWeekProcessor.IsModified(entity, week))
{
EmployeeWeekProcessor.AssignTo(entity, week);
UpdateEntity(entity);
}
}
if (list != null)
{
int previous_saldo = entity.Saldo;
foreach (EmployeeWeekTimeRecording next_entity in list)
{
if (next_entity.WeekBegin <= week.BeginDate)
{
continue;
}
if (next_entity.CalculateSaldo(previous_saldo))
{
UpdateEntity(next_entity);
previous_saldo = next_entity.Saldo;
}
else
{
break;
}
}
}
SrvEmployeeWeekPlanningList planList = new SrvEmployeeWeekPlanningList(week.EmployeeId, week.EndDate.AddDays(1));
//planList.UpdateSaldoFrom2(week.EmployeeId, week.EndDate.AddDays(1), week.Saldo);
planList.UpdateSaldoAfterRecording(week.EmployeeId, list, week.EndDate.AddDays(1));
}
private void LoadEmployeePlanningAndRecording(bool bLoadStoreDays)
{
ClearContext();
if (bLoadStoreDays)
{
LoadStoreDayInfo();
}
ErrorCode = ErrorCodes.Empty;
if (m_storedays.IsUndefined())
{
ErrorCode |= ErrorCodes.NotExistsOpenTime;
}
if (m_storedays.AvgDayInWeek == 0)
{
ErrorCode |= ErrorCodes.NotExistsAvgDaysPerWeek;
}
if (ErrorCodes.Empty != ErrorCode)
{
ProcessError();
return;
}
if (CurrentStoreWorld != null)
{
List <EmployeeWeek> planningweeks = _EmployeeService.GetTimePlannignEmployeeByWorld2(StoreId, WorldId, BeginWeekDate, EndWeekDate);
EmployeeWeekProcessor.MarkAsPlannedWeek(planningweeks);
Absences.FillEmployeeWeek(planningweeks);
_PlanningWorldState = new StoreWorldWeekState(CurrentStoreWorld, BeginWeekDate, EndWeekDate);
if (planningweeks != null)
{
_PlanningWorldState.List.AddRange(planningweeks);
foreach (EmployeeWeek ew in planningweeks)
{
ew.InitWeekState();
}
}
_PlanningWorldState.Context = this;
_PlanningWorldState.Calculate();
planningweeks = _EmployeeService.GetTimeRecordingEmployeeByWorld(StoreId, WorldId, BeginWeekDate, EndWeekDate);
EmployeeWeekProcessor.MarkAsRecordingWeek(planningweeks);
Absences.FillEmployeeWeek(planningweeks);
_ActualWorldState = new StoreWorldWeekState(CurrentStoreWorld, BeginWeekDate, EndWeekDate);
if (planningweeks != null)
{
_ActualWorldState.List.AddRange(planningweeks);
foreach (EmployeeWeek ew in planningweeks)
{
ew.InitWeekState();
}
}
_ActualWorldState.PlannedWorld = false;
_ActualWorldState.Context = this;
_ActualWorldState.Calculate();
WorldPlanningInfo infoworld =
_StoreService.StoreToWorldService.GetStoreWorldPlanningInfo(false, StoreId, WorldId, BeginWeekDate);
_ActualWorldState.StoreWorldInfo = infoworld;
_PlanningWorldState.StoreWorldInfo = infoworld;
FillRecordingWorldInfoFromPlanningInfo();
Modified = false;
OnChangedContext();
}
}
public override void FillLastSaldo(Dictionary <long, EmployeeWeek> dict, long[] ids, DateTime aBeginWeek, bool bPlanning)
{
if (!bPlanning)
{
throw new ArgumentException("Austria don't support time recording");
}
DateTime todayMonday = DateTimeHelper.GetMonday(DateTime.Today);
Debug.Assert(aBeginWeek.DayOfWeek == DayOfWeek.Monday);
DateTime currentMonday = aBeginWeek;
bool bPastWeek = todayMonday > currentMonday;
bool bFutureWeek = todayMonday < currentMonday;
bool bCurrentWeek = todayMonday == currentMonday;
if (bCurrentWeek)
{
return;
}
if (bFutureWeek)
{
SrvEmployeeWeekPlanningList cache_weeks = new SrvEmployeeWeekPlanningList(ids, todayMonday);
foreach (EmployeeWeek week in dict.Values)
{
List <EmployeeWeekTimePlanning> list_weeks =
cache_weeks.GetEntitiesByEmployeeId(week.EmployeeId);
DateTime minDate = todayMonday;
EmployeeWeekTimePlanning prevWeekEntity = null;
if (list_weeks != null && list_weeks.Count > 0)
{
foreach (EmployeeWeekTimePlanning entity in list_weeks)
{
if (entity.WeekBegin < currentMonday && minDate <= entity.WeekBegin)
{
prevWeekEntity = entity;
minDate = prevWeekEntity.WeekBegin;
}
}
}
if (prevWeekEntity != null)
{
Debug.Assert(prevWeekEntity.WeekBegin < currentMonday);
Debug.Assert(prevWeekEntity.WeekBegin > todayMonday);
week.LastSaldo = prevWeekEntity.Saldo;
}
}
return;
}
if (bPastWeek)
{
foreach (EmployeeWeek week in dict.Values)
{
if (week.NewWeek)
{
week.LastSaldo = 0;
}
else
{
week.LastSaldo = EmployeeWeekProcessor.GetLastSaldoFromSaldo(week);
}
}
}
}
public List <EmployeeWeek> BuildEmployeeWeeks(long storeid, long worldid, DateTime aBegin, DateTime aEnd, bool bPlanning)
{
Store store = ServerEnvironment.StoreService.FindById(storeid);
if (store == null)
{
return(null);
}
long countryid = store.CountryID;
bool IsAustria = store.CountryID == ServerEnvironment.CountryService.AustriaCountryID;
// list of all employee for storeid and world
IList employees = EmployeeService.EmployeeDao.GetPlanningEmployeesByWorld(storeid, worldid, aBegin, aEnd);
if (employees == null && employees.Count == 0)
{
return(null);
}
long[] ids = new long[employees.Count];
for (int i = 0; i < employees.Count; i++)
{
ids[i] = (employees[i] as Employee).ID;
}
EmployeeRelationService relationService = EmployeeService.EmployeeRelationService as EmployeeRelationService;
List <EmployeeRelation> emplRelations = relationService.GetEmployeeRelationsByEmployeeIds(ids, aBegin, aEnd);
//CountryStoreWorldManager swmanager = new CountryStoreWorldManager(EmployeeService.StoreWorldService);
//swmanager.StoreId = storeid;
if (swCountryManager == null)
{
//long countryid = EmployeeService.StoreService.GetCountryByStoreId(storeid);
swCountryManager = new CountryStoreWorldManager(EmployeeService.StoreWorldService);
swCountryManager.CountryId = countryid;
}
List <EmployeeLongTimeAbsence> emplLongTimeAbsences =
EmployeeService.EmployeeLongTimeAbsenceService.GetEmployeesHasLongTimeAbsence(ids, aBegin, aEnd);
EmployeeLongTimeAbsenceIndexer absenceIndexer = new EmployeeLongTimeAbsenceIndexer(emplLongTimeAbsences);
DictionListEmployeeRelations relationIndexer = new DictionListEmployeeRelations(emplRelations);
List <EmployeeContract> contracts = EmployeeService.EmployeeContractService.GetEmployeeContracts(ids, aBegin, aEnd);
ContractIndexer = new DictionListEmployeesContract(contracts);
// applly relations
EmployeeRelation relationWorld = null;
bool bExistsRelation = false;
bool bExistsContract = false;
bool bNotExistsAbsence = true;
_listweeks = new List <EmployeeWeek>();
EmployeeWeek emplWeek = null;
foreach (Employee empl in employees)
{
emplWeek = new EmployeeWeek(empl.ID, empl.FullName, aBegin, aEnd, empl.OrderHwgrID.HasValue ? empl.OrderHwgrID.Value : 0);
emplWeek.LastSaldo = (int)Math.Round(empl.BalanceHours);
bExistsRelation = false;
foreach (EmployeeDay d in emplWeek.DaysList)
{
relationWorld = relationIndexer.GetRelationEntity(empl.ID, d.Date);
if (relationWorld != null)
{
d.StoreWorldId = swCountryManager.GetStoreWorldIdByStoreAndWorldId(relationWorld.StoreID, relationWorld.WorldID.Value);
d.StoreId = relationWorld.StoreID;
}
bExistsRelation |= d.HasRelation;
}
if (bExistsRelation)
{
bExistsContract = ContractIndexer.FillEmployeeWeek(emplWeek);
if (bExistsContract)
{
bNotExistsAbsence = absenceIndexer.FillEmployeeWeek(emplWeek);
if (bNotExistsAbsence)
{
_listweeks.Add(emplWeek);
}
}
}
}
FillEmployeeDayByStoreDay(storeid, aBegin, aEnd);
_dictionWeek = EmployeeWeekProcessor.GetDictionary(_listweeks);
_employeeids = EmployeeWeekProcessor.GetEmployeeIds(_listweeks);
if (bPlanning)
{
FillPlanningEmployeeWeeks(storeid, worldid, aBegin, aEnd);
}
else
{
FillActualEmployeeWeeks(storeid, worldid, aBegin, aEnd);
}
//LastSaldoBuilder saldoBuilder = new LastSaldoBuilder();
LastSaldoBuilder saldoBuilder = (IsAustria) ? new LastSaldoBuilderAustria() : new LastSaldoBuilder();
saldoBuilder.FillLastSaldo(_dictionWeek, _employeeids, aBegin, bPlanning);
EmployeeMonthWorkingTime monthData = new EmployeeMonthWorkingTime(EmployeeService.EmployeeTimeService as EmployeeTimeService);
monthData.IsPlanning = bPlanning;
monthData.CurrentMonday = aBegin;
CacheEmployeesAllIn managerAllIn = new CacheEmployeesAllIn();
managerAllIn.LoadByStoreRelation(storeid);
foreach (EmployeeWeek ew in _listweeks)
{
ew.WorkingTimeByMonth = monthData.GetMonthWorkingTime(ew.EmployeeId);
ew.CountSaturday = (byte)monthData.CountSaturday;
ew.CountSunday = (byte)monthData.CountSunday;
ew.WorkingDaysBefore = (byte)monthData.WorkingDaysBefore;
ew.WorkingDaysAfter = (byte)monthData.WorkingDaysAfter;
ew.AllIn = managerAllIn.GetAllIn(ew.EmployeeId, aBegin, aEnd);
}
return(_listweeks);
}
