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 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 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 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 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> 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);
}
