// Rule 8) public holiday
public void Rule8(ProjectModel project, WeekModel week, List <ActivityModel> activities, List <EmployeeInfo> EmployeesInProjectInfoInYear, List <Tuple <SlotModel, ActivityModel> > slotsActivities)
{
if (!_rules.Single(e => e.RuleID == 8).RuleStatus)
{
return;
}
var publicHolidays = Nager.Date.DateSystem.GetPublicHoliday(project.CountryCode, week.FirstDayOfTheWeek, week.FirstDayOfTheWeek.AddDays(6)).ToList();
foreach (var publicHoliday in publicHolidays)
{
var dow = (int)publicHoliday.Date.DayOfWeek;
var PublicHolidayActivity = activities.Where(e => e.TimeOfDay == TimeSlot.ALL_DAY && e.Name.Contains("public holiday") && e.DayOfWeek == (DaySlot)dow).Single();
foreach (var employeeInfo in EmployeesInProjectInfoInYear)
{
var s = slotsActivities.Where(e => e.Item1.ProjectID == project.ProjectID && e.Item1.ActivityID == PublicHolidayActivity.ActivityID && e.Item1.EmployeeID == '#' + employeeInfo.Employee.EmployeeID).SingleOrDefault();
if (s == null) // only add public holidays once - do not add again when regenerating
{
slotsActivities.Add(new Tuple <SlotModel, ActivityModel>(new SlotModel {
ProjectID = project.ProjectID, WeekID = week.WeekID, ActivityID = PublicHolidayActivity.ActivityID, EmployeeID = employeeInfo.Employee.EmployeeID
}, PublicHolidayActivity));
}
else if (s.Item1.EmployeeID.Substring(0, 1).Equals("#"))
{
s.Item1.EmployeeID = s.Item1.EmployeeID.Substring(1); // remove # symbol
}
employeeInfo.WorkHourStats.WeekSum += PublicHolidayActivity.Hours;
}
}
}
public ActionResult Weeks()
{
ViewBag.AllowDuplicates = ConfigurationManager.AppSettings["AllowDuplicate"] == "1";
WeeksModel model = new WeeksModel();
//Get the previous 5 weeks worth
for (int i = 0; i < 5; i++)
{
Tuple <DateTime, DateTime> dates = Utilities.GetWeekStartEndDates(_EndDay, DateTime.Today.AddDays(i * -7));
using (TimeLineDB db = new TimeLineDB())
{
List <TimeLineModel> lines = db.TimeLines.Where(x => x.UserID == User.Identity.Name)
.Where(x => x.LineDate >= dates.Item1)
.Where(x => x.LineDate <= dates.Item2)
.ToList();
WeekModel week = new WeekModel
{
WeekStart = dates.Item1,
WeekEnd = dates.Item2,
TotalHours = lines.Sum(x => (x.Hours)),
TotalClients = lines.Select(x => x.ClientID).Distinct().Count()
};
model.Weeks.Add(week);
}
}
return(View("Weeks", model));
}
public void Calculo(ref List <PersonaModel> listaEmpleados)
{
WeekModel week = new WeekModel();
WeekendModel weekend = new WeekendModel();
foreach (var lsE in listaEmpleados)
{
int TotalValor = 0;
foreach (var lsHora in lsE.lstDatos)
{
var num_horas = (lsHora.hasta - lsHora.desde).Hours;
if (week.isWeek(lsHora.dia))
{
TotalValor += week.CalculoValor(lsHora.desde, lsHora.hasta) * num_horas;
}
if (weekend.isWeekend(lsHora.dia))
{
TotalValor += weekend.CalculoValor(lsHora.desde, lsHora.hasta) * num_horas;
}
}
lsE.intValorTotal = TotalValor;
}
}
public async Task ChangeTaskDate(string jobId, Guid dayAssignId, DateTime date)
{
JobAssign jobAssign = jobAssignProvider.GetByJobId(jobId);
IDayAssign dayAssign = dayAssignService.GetDayAssignById(dayAssignId);
WeekModel weekModel = jobAssign.WeekList.First();
int weekDay = date.GetWeekDayNumber();
int weekNumber = date.GetWeekNumber();
var dayPerWeekList = new List <DayPerWeekModel> {
new DayPerWeekModel {
Id = Guid.NewGuid(), WeekDay = weekDay
}
};
var weekList = new List <WeekModel> {
new WeekModel {
Number = weekNumber, IsDisabled = false, ChangedBy = weekModel.ChangedBy
}
};
await messageBus.Publish(new ChangeJobAssignWeeksCommand(jobAssign.Id, weekList, (ChangedByRole)weekModel.ChangedBy, false));
await messageBus.Publish(new SaveDaysPerWeekCommand(jobAssign.Id, dayPerWeekList));
await messageBus.Publish(new ChangeOperationalTaskDateCommand(dayAssignId, date, weekDay));
if (dayAssign.StatusId == JobStatus.Expired)
{
await jobStatusService.Pending(dayAssign.Id, dayAssign.StatusId);
}
}
private async Task UpdateDestinationAsync(string operation, WeekModel weekModel, DeltaModel delta, IEnumerable <ShiftModel> shifts, Func <string, ShiftModel, Task> destinationMethod, ILogger log)
{
var tasks = shifts
.Select(shift => UpdateDestinationAsync(operation, weekModel, delta, shift, destinationMethod, log))
.ToArray();
await Task.WhenAll(tasks);
}
public async Task <ResultModel> Run([ActivityTrigger] WeekModel weekModel, ILogger log)
{
log.LogWeek(weekModel);
// initialise source service
var credentials = await _secretsService.GetCredentialsAsync(weekModel.TeamId);
_scheduleSourceService.SetCredentials(weekModel.TeamId, credentials);
// get the current set of shifts from JDA
var shifts = await _scheduleSourceService.ListWeekShiftsAsync(weekModel.TeamId, weekModel.StoreId, weekModel.StartDate, weekModel.TimeZoneInfoId);
log.LogShifts(weekModel, shifts);
// get the last saved set of shifts
var savedShifts = await _scheduleCacheService.LoadScheduleAsync(weekModel.TeamId, weekModel.StartDate);
// compute the delta
var delta = _scheduleDeltaService.ComputeDelta(savedShifts.Tracked, shifts);
log.LogFullDelta(weekModel, delta);
if (delta.HasChanges)
{
delta.RemoveSkipped(savedShifts.Skipped);
delta.ApplyMaximum(_options.MaximumDelta);
log.LogPartialDelta(weekModel, delta);
var allShifts = delta.All;
// set teams employee
var employeeLookup = BuildEmployeeLookup(savedShifts.Tracked);
await SetTeamsEmployeeIds(allShifts.Where(s => string.IsNullOrEmpty(s.TeamsEmployeeId)), employeeLookup, weekModel, log);
// set job & department name
var jobLookup = BuildJobLookup(savedShifts.Tracked);
await SetJobAndDepartmentName(allShifts, jobLookup, weekModel, log);
// set teams schedule group (N.B this must be set after teams employee id and jobs)
var groupLookup = BuildScheduleGroupLookup(savedShifts.Tracked);
await SetTeamsSchedulingGroupId(allShifts.Where(s => string.IsNullOrEmpty(s.TeamsSchedulingGroupId)), groupLookup, weekModel, log);
await AddEmployeesToSchedulingGroups(delta, groupLookup, weekModel, log);
// update teams
await ApplyDeltaAsync(weekModel, delta, log);
log.LogAppliedDelta(weekModel, delta);
// apply the final delta to the savedShifts
delta.ApplyChanges(savedShifts.Tracked);
delta.ApplySkipped(savedShifts.Skipped);
await _scheduleCacheService.SaveScheduleAsync(weekModel.TeamId, weekModel.StartDate, savedShifts);
}
return(delta.AsResult());
}
public IActionResult ListProjectWeeks(int?ProjectID, string FromWeekID = "", string ToWeekID = "")
{
if (ProjectID == null)
{
return(NotFound());
}
// TODO add regex check on from and to week id
var weeks = _context.Week.Where(e => e.ProjectID == ProjectID);
var weekComparer = new CompareWeekModel();
var WeekIDRegex = new Regex(@"^\d\d-\d\d\d\d$");
if (FromWeekID != null && FromWeekID != "" && WeekIDRegex.IsMatch(FromWeekID)) // FromWeekID is valid
{
if (ToWeekID != null && ToWeekID != "" && WeekIDRegex.IsMatch(ToWeekID)) // FromWeekID and ToWeekID is valid
{
}
else // FromWeekID is valid and ToWeekID is invalid
{
var fromDate = WeekModel.GetMondayFromWeekID(FromWeekID);
ToWeekID = WeekModel.GetIso8601WeekOfYear(fromDate.AddDays(21)) + "-" + DateTime.Now.Year;
}
}
else // FromWeekID is invalid
{
if (ToWeekID != null && ToWeekID != "" && WeekIDRegex.IsMatch(ToWeekID)) // FromWeekID is invalid and ToWeekID is valid
{
var toDate = WeekModel.GetMondayFromWeekID(ToWeekID);
FromWeekID = WeekModel.GetIso8601WeekOfYear(toDate.AddDays(-21)) + "-" + DateTime.Now.Year;
}
else // FromWeekID is invalid and ToWeekID is invalid
{
FromWeekID = WeekModel.GetIso8601WeekOfYear(DateTime.Now) + "-" + DateTime.Now.Year;
ToWeekID = WeekModel.GetIso8601WeekOfYear(DateTime.Now.AddDays(21)) + "-" + DateTime.Now.Year;
}
}
weeks = weeks.Where(e => weekComparer.CompareWeekIDs(e.WeekID, ToWeekID) <= 0 && weekComparer.CompareWeekIDs(e.WeekID, FromWeekID) >= 0);
var weekList = weeks.ToList();
weekList.Sort(new CompareWeekModel());
var weeksView = new List <DetailsWeekViewModel>();
foreach (var week in weekList)
{
weeksView.Add(_WeeksRepository.PrepareWeekViewModel(_context, week));
}
var ListProjectWeekViewModel = new ListProjectWeekViewModel
{
ProjectID = ProjectID.Value,
FromWeekID = FromWeekID,
ToWeekID = ToWeekID,
WeekViewModels = weeksView
};
return(View(ListProjectWeekViewModel));
}
public void WeekGenerateDaysTest()
{
WeekModel model = new WeekModel();
model.GenerateDays(new Day(new DateTime(2017, 11, 11)));
Assert.IsTrue(model.Days[0].DateEquals(new Day(new DateTime(2017, 11, 6))));
Assert.IsTrue(model.Days.Length == 7);
Assert.IsTrue(model.Days[6].DateEquals(new Day(new DateTime(2017, 11, 12))));
}
public JsonResult Save(WeekModel weekModel)
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(weekModel.ToString());
xmlDocument.Save(Server.MapPath("~/WeeklyScheduleExample.xml"));
return(Json("Ok"));
}
public ActionResult Index()
{
//Create a weekly schedule from an example xml-file
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(Server.MapPath("~/WeeklyScheduleExample.xml"));
WeekModel week = WeekModel.GetRecord(xmlDocument.OuterXml);
return(View(week));
}
public void WeekGetPreviousDays()
{
WeekModel model = new WeekModel();
Day day = new Day(new DateTime(2017, 11, 11));
model.GenerateDays(day);
Day previousDay = model.GetPreviousDay();
Assert.AreEqual(day.WeekOfYear - 1, previousDay.WeekOfYear);
}
public void WeekGetNextDays()
{
WeekModel model = new WeekModel();
Day day = new Day(new DateTime(2017, 11, 11));
model.GenerateDays(day);
Day nextDay = model.GetNextDay();
Assert.AreEqual(day.WeekOfYear + 1, nextDay.WeekOfYear);
}
public async Task <ResultModel> Run([ActivityTrigger] WeekModel weekModel, ILogger log)
{
var activityModel = new TeamActivityModel
{
TeamId = weekModel.TeamId,
DateValue = weekModel.StartDate.AsDateString(),
ActivityType = "Shifts",
WfmBuId = weekModel.WfmBuId,
StartDate = weekModel.StartDate,
TimeZoneInfoId = weekModel.TimeZoneInfoId
};
return(await RunDeltaActivity(activityModel, log).ConfigureAwait(false));
}
public void Days_of_week_2019_03_01_and_en_us()
{
var week = new WeekModel(new CultureInfo("en-US"), new LocalDate(2019, 3, 1));
var days = week.Days.ToArray();
days.Length.Should().Be(7);
days[0].Day.Should().Be(24);
days[1].Day.Should().Be(25);
days[2].Day.Should().Be(26);
days[3].Day.Should().Be(27);
days[4].Day.Should().Be(28);
days[5].Day.Should().Be(1);
days[6].Day.Should().Be(2);
}
public WeekView(TableLayoutPanel _panel, Label _title, TableLayoutPanel _headerPanel, DayManager _dayManager)
{
panel = _panel;
headerPanel = _headerPanel;
title = _title;
dayManager = _dayManager;
model = new WeekModel();
hoursPictureBox = new PictureBox();
hoursPictureBox.Dock = DockStyle.Fill;
panel.Controls.Add(hoursPictureBox, 0, 0);
cellHeight = hoursPictureBox.Height / 24;
hoursPictureBox.Paint += new PaintEventHandler(hoursPictureBox_OnPaint);
}
private YearTaskStatus GetWeekStatus(WeekModel week, Job job, int year, Guid housingDepartmentId)
{
int currentWeek = DateTime.UtcNow.GetWeekNumber();
int currentYear = DateTime.UtcNow.Year;
IEnumerable <JobAssign> jobAssignsForWeek = job.Assigns
.Where(x => (x.TillYear == default(int) || x.TillYear >= currentYear) &&
x.WeekList.Any(y => y.Number == week.Number) &&
x.HousingDepartmentIdList.Contains(housingDepartmentId));
List <IDayAssign> dayAssignsForWeek = job.DayAssigns
.Where(x => x.Year == year && x.WeekNumber == week.Number)
.ToList();
bool isJobExisted = year > job.CreationDate.Year || (year == job.CreationDate.Year && week.Number >= job.CreationDate.GetWeekNumber()) &&
(year > currentYear || week.Number >= currentWeek || dayAssignsForWeek.HasValue());
List <IDayAssign> filteredDayAssignForWeek = dayAssignsForWeek.Where(x => x.ExpiredWeekNumber == week.Number || x.ExpiredWeekNumber == null).ToList();
if (filteredDayAssignForWeek.Any(x => x.StatusId == JobStatus.Expired))
{
CheckExpiredDayAssignStatus(job, housingDepartmentId, filteredDayAssignForWeek, currentWeek, currentYear);
}
// TODO: If you think that you can refactor this, notify Igor about you courage.
bool isAllDayAssignCompleted = filteredDayAssignForWeek.Any() && filteredDayAssignForWeek.All(x => x.StatusId == JobStatus.Completed);
bool isAllTicketHasDayAssign = IsTaskHasOnlyRealTicket(job.Assigns, filteredDayAssignForWeek);
if (week.ChangedBy == (int)ChangedByRole.None || !isJobExisted || !jobAssignsForWeek.HasValue())
{
return(YearTaskStatus.NotDefined);
}
else if (isAllDayAssignCompleted && isAllTicketHasDayAssign)
{
return(YearTaskStatus.Finished);
}
else if (year > currentYear || (year == currentYear && week.Number >= currentWeek))
{
return(YearTaskStatus.NotStarted);
}
else
{
return(YearTaskStatus.Failed);
}
}
public void Days_of_week_2019_04_11()
{
var week = new WeekModel(new CultureInfo("de-DE"), new LocalDate(2019, 4, 11));
var days = week.Days.ToArray();
days.Length.Should().Be(7);
days[0].Day.Should().Be(8);
days[0].DayOfWeek.Should().Be(IsoDayOfWeek.Monday);
days[0].DisplayName.Should().Be("Mo");
days[1].Day.Should().Be(9);
days[1].DayOfWeek.Should().Be(IsoDayOfWeek.Tuesday);
days[1].DisplayName.Should().Be("Di");
days[2].Day.Should().Be(10);
days[3].Day.Should().Be(11);
days[4].Day.Should().Be(12);
days[5].Day.Should().Be(13);
days[6].Day.Should().Be(14);
}
public List <WeekModel> Week(DateTime month)
{
var list = dal.Week(month);
var total = list.Sum(p => p.UseAmount);
var result = list.Select(p => new WeekModel()
{
UseAmount = p.UseAmount,
Week = $"{month.Year}年第{p.Week}周",
Percent = Math.Round(p.UseAmount * 100 / total, 2),
WeekIndex = p.Week,
IsSum = false,
ShowDetail = false
}).ToList();
var sum = new WeekModel()
{
UseAmount = total, Week = "总计", IsSum = true
};
result.Add(sum);
return(result);
}
private async Task UpdateDestinationAsync(string operation, WeekModel weekModel, DeltaModel delta, ShiftModel shift, Func <string, ShiftModel, Task> destinationMethod, ILogger log)
{
try
{
await destinationMethod(weekModel.TeamId, shift);
}
catch (ArgumentException)
{
delta.SkippedChange(shift);
log.LogShiftSkipped(weekModel, operation, shift);
}
catch (MicrosoftGraphException ex)
{
delta.FailedChange(shift);
log.LogShiftError(ex, weekModel, operation, shift);
}
catch (Exception ex)
{
delta.FailedChange(shift);
log.LogShiftError(ex, weekModel, operation, shift);
}
}
public static void LogSchedulingGroupError(this ILogger log, Exception ex, WeekModel week, ShiftModel shift)
{
log.LogError(new EventId(11, "Scheduling Group"), ex, "Scheduling Group: Status={status}, DepartmentName={departmentName}, SourceId={sourceId}, EmployeeId={employeeId}, StoreId={storeId}, TeamId={teamId}, WeekDate={weekDate}", Status.Failed, shift.DepartmentName, shift.JdaShiftId, shift.JdaEmployeeId, week.StoreId, week.TeamId, week.StartDate.AsDateString());
}
private async Task SetTeamsSchedulingGroupId(IEnumerable <ShiftModel> shifts, IDictionary <string, string> groupLookup, WeekModel weekModel, ILogger log)
{
foreach (var shift in shifts)
{
if (string.IsNullOrEmpty(shift.DepartmentName))
{
log.LogDepartmentNotFound(weekModel, shift);
continue;
}
if (!groupLookup.ContainsKey(shift.DepartmentName))
{
try
{
// first attempt to get an existing group with the department name
var groupId = await _scheduleDestinationService.GetSchedulingGroupIdByNameAsync(weekModel.TeamId, shift.DepartmentName);
if (string.IsNullOrEmpty(groupId))
{
// the group with the specified name does not exist, so create it, populated with all users from the shifts
// collection having this department
var userIds = GetAllUsersInDepartment(shifts, shift.DepartmentName);
groupId = await _scheduleDestinationService.CreateSchedulingGroupAsync(weekModel.TeamId, shift.DepartmentName, userIds);
}
groupLookup.Add(shift.DepartmentName, groupId);
}
catch (MicrosoftGraphException e)
{
log.LogSchedulingGroupError(e, weekModel, shift);
continue;
}
catch (Exception e)
{
log.LogSchedulingGroupError(e, weekModel, shift);
continue;
}
}
shift.TeamsSchedulingGroupId = groupLookup[shift.DepartmentName];
}
}
private async Task SetJobAndDepartmentName(IEnumerable <ShiftModel> shifts, IDictionary <string, JobModel> jobLookup, WeekModel weekModel, ILogger log)
{
var activities = shifts
.SelectMany(s => s.Jobs)
.Where(a => !string.IsNullOrEmpty(a.JdaJobId));
foreach (var activity in activities)
{
if (!jobLookup.TryGetValue(activity.JdaJobId, out var job))
{
try
{
job = await _scheduleSourceService.GetJobAsync(weekModel.TeamId, weekModel.StoreId, activity.JdaJobId)
?? throw new KeyNotFoundException();
jobLookup[activity.JdaJobId] = job;
}
catch (Exception)
{
log.LogJobNotFound(weekModel, activity);
continue;
}
}
activity.Code = job.Name;
activity.DepartmentName = job.DepartmentName;
activity.ThemeCode = job.ThemeCode;
}
foreach (var shift in shifts)
{
var firstJob = shift.Jobs
.OrderBy(j => j.StartDate)
.FirstOrDefault();
shift.DepartmentName = firstJob?.DepartmentName;
shift.ThemeCode = firstJob?.ThemeCode;
}
}
private async Task SetTeamsEmployeeIds(IEnumerable <ShiftModel> shifts, IDictionary <int, string> employeeLookup, WeekModel weekModel, ILogger log)
{
await _scheduleSourceService.LoadEmployeesAsync(weekModel.TeamId, shifts.Select(s => s.JdaEmployeeId.ToString()).Distinct().ToList());
foreach (var shift in shifts)
{
if (!employeeLookup.ContainsKey(shift.JdaEmployeeId))
{
EmployeeModel jdaEmployee;
try
{
jdaEmployee = await _scheduleSourceService.GetEmployeeAsync(weekModel.TeamId, shift.JdaEmployeeId.ToString())
?? throw new KeyNotFoundException();
}
catch (Exception)
{
log.LogEmployeeNotFound(weekModel, shift);
continue;
}
try
{
var graphEmployee = await _scheduleDestinationService.GetEmployeeAsync(weekModel.TeamId, jdaEmployee.LoginName)
?? throw new KeyNotFoundException();
employeeLookup.Add(shift.JdaEmployeeId, graphEmployee.DestinationId);
}
catch (KeyNotFoundException)
{
employeeLookup.Add(shift.JdaEmployeeId, null);
}
catch (Exception e)
{
log.LogMemberError(e, weekModel, jdaEmployee);
employeeLookup.Add(shift.JdaEmployeeId, null);
}
}
shift.TeamsEmployeeId = employeeLookup[shift.JdaEmployeeId];
}
}
public static void LogShiftError(this ILogger log, Exception ex, WeekModel week, string operationName, ShiftModel shift)
{
log.LogError(new EventId(9, "Shift"), ex, "Shift: Status={status}, OperationName={operationName}, SourceId={sourceId}, EmployeeId={employeeId}, StoreId={storeId}, TeamId={teamId}, WeekDate={weekDate}", Status.Failed, operationName, shift.JdaShiftId, shift.JdaEmployeeId, week.StoreId, week.TeamId, week.StartDate.AsDateString());
}
public static void LogSchedulingGroupError(this ILogger log, Exception ex, WeekModel week, string departmentName, string schedulingGroupId)
{
log.LogError(new EventId(11, "Scheduling Group"), ex, "Scheduling Group: Status={status}, DepartmentName={departmentName}, SchedulingGroupId={schedulingGroupId}, StoreId={storeId}, TeamId={teamId}, WeekDate={weekDate}", Status.Failed, departmentName, schedulingGroupId, week.StoreId, week.TeamId, week.StartDate.AsDateString());
}
public static void LogSchedulingGroupError(this ILogger log, MicrosoftGraphException ex, WeekModel week, ShiftModel shift)
{
log.LogError(new EventId(11, "Scheduling Group"), ex, "Scheduling Group: Status={status}, ErrorCode={errorCode}, ErrorDescription={errorDescription}, ErrorRequestId={errorRequestId}, ErrorDate={errorDate}, DepartmentName={departmentName}, SourceId={sourceId}, EmployeeId={employeeId}, StoreId={storeId}, TeamId={teamId}, WeekDate={weekDate}", Status.Failed, ex.Error.Code, ex.Error.Message, ex.Error.InnerError?.RequestId, ex.Error.InnerError?.Date, shift.DepartmentName, shift.JdaShiftId, shift.JdaEmployeeId, week.StoreId, week.TeamId, week.StartDate.AsDateString());
}
private async Task AddEmployeesToSchedulingGroups(DeltaModel delta, IDictionary <string, string> groupLookup, WeekModel weekModel, ILogger log)
{
var allShifts = delta.All;
foreach (var department in groupLookup.Keys)
{
// get all the user id's in this department
var userIds = GetAllUsersInDepartment(allShifts, department);
if (userIds.Count > 0)
{
try
{
// and add them to the matching schedule group if necessary
await _scheduleDestinationService.AddUsersToSchedulingGroupAsync(weekModel.TeamId, groupLookup[department], userIds);
}
catch (Exception e)
{
delta.Created.Concat(delta.Updated).Where(i => i.DepartmentName == department).ForEach(i => delta.FailedChange(i));
log.LogSchedulingGroupError(e, weekModel, department, groupLookup[department]);
continue;
}
}
}
}
private async Task ApplyDeltaAsync(WeekModel weekModel, DeltaModel delta, ILogger log)
{
await UpdateDestinationAsync(nameof(delta.Created), weekModel, delta, delta.Created, _scheduleDestinationService.CreateShiftAsync, log);
await UpdateDestinationAsync(nameof(delta.Updated), weekModel, delta, delta.Updated, _scheduleDestinationService.UpdateShiftAsync, log);
await UpdateDestinationAsync(nameof(delta.Deleted), weekModel, delta, delta.Deleted, _scheduleDestinationService.DeleteShiftAsync, log);
}
private static void AddDefaultWeekData(ProjectTrackerIpDataContext context)
{
string yearCounts = ConfigurationManager.AppSettings["YearCountsForPastYear"];
if (yearCounts == "0" || yearCounts == null)
{
yearCounts = "2";
}
int weekCount = 0;
///Get weeks of year
int year = DateTime.Now.Year;
//past data
for (int iYearCount = 0; iYearCount < Convert.ToInt16(yearCounts); iYearCount++)
{
int yearCalculate = year - iYearCount - 1;
var firstDayOfYear = new System.DateTime(yearCalculate, 1, 1);
var beginningDayOfWeek = firstDayOfYear.AddDays(-1 * Convert.ToInt32(firstDayOfYear.DayOfWeek));
var endingDayOfWeek = beginningDayOfWeek.AddDays(6);
var weekOfYear = 1;
List <WeekModel> weeksOfTheYear = new List <WeekModel>();
while (beginningDayOfWeek.Year < yearCalculate + 1)
{
var week = new WeekModel {
Number = weekOfYear, BeginningOfWeek = beginningDayOfWeek
};
weeksOfTheYear.Add(week);
beginningDayOfWeek = beginningDayOfWeek.AddDays(7);
endingDayOfWeek = beginningDayOfWeek.AddDays(6);
weekOfYear++;
context.Add(new Week
{
WeekId = weekCount++,
WeekNumber = week.Number,
Year = yearCalculate,
Text = String.Format(
"Week {0}: ({1} to {2})",
week.Number,
beginningDayOfWeek.ToShortDateString(),
endingDayOfWeek.ToShortDateString())
});
}
}
yearCounts = ConfigurationManager.AppSettings["YearCountsForFutureYear"];
//future data
for (int iYearCount = 0; iYearCount < Convert.ToInt16(yearCounts); iYearCount++)
{
int yearCalculate = year + iYearCount;
var firstDayOfYear = new System.DateTime(yearCalculate, 1, 1);
var beginningDayOfWeek = firstDayOfYear.AddDays(-1 * Convert.ToInt32(firstDayOfYear.DayOfWeek));
var endingDayOfWeek = beginningDayOfWeek.AddDays(6);
var weekOfYear = 1;
List <WeekModel> weeksOfTheYear = new List <WeekModel>();
while (beginningDayOfWeek.Year < yearCalculate + 1)
{
var week = new WeekModel {
Number = weekOfYear, BeginningOfWeek = beginningDayOfWeek
};
weeksOfTheYear.Add(week);
beginningDayOfWeek = beginningDayOfWeek.AddDays(7);
endingDayOfWeek = beginningDayOfWeek.AddDays(6);
weekOfYear++;
context.Add(new Week
{
WeekId = weekCount++,
WeekNumber = week.Number,
Year = yearCalculate,
Text = String.Format(
"Week {0}: ({1} to {2})",
week.Number,
beginningDayOfWeek.ToShortDateString(),
endingDayOfWeek.ToShortDateString())
});
}
}
}
public static void LogShiftSkipped(this ILogger log, WeekModel week, string operationName, ShiftModel shift)
{
log.LogTrace(new EventId(10, "Shift"), "Shift: Status={status}, OperationName={operationName}, SourceId={sourceId}, EmployeeId={employeeId}, StoreId={storeId}, TeamId={teamId}, WeekDate={weekDate}", Status.Skipped, operationName, shift.JdaShiftId, shift.JdaEmployeeId, week.StoreId, week.TeamId, week.StartDate.AsDateString());
}
