public async Task SaveTemplate(ScheduleTemplate template)
{
var templateList = await GetTemplatesList();
if (!templateList.Items.Any(templateInfo => templateInfo.Name.Equals(template.Name)))
{
templateList.Items.Add(template.GetTemplateInfo());
}
var templateEncodedFile = Path.Combine(Path.GetTempPath(), String.Format("{0}.json", template.Name));
File.WriteAllText(templateEncodedFile, template.Serialize());
var templateArchiveFile = new StorageFile(
AppProfileManager.Instance.SharedFolder.RelativePathParts.Merge(
new[]
{
TemplatesFolderName,
String.Format("{0}.zip", template.Name)
}));
ZipHelper.CompressFiles(new[] { templateEncodedFile }, templateArchiveFile.LocalPath);
await templateArchiveFile.Upload();
await SaveTemplatesList(templateList);
}
internal override void resetParentsChildren()
{
// TODO: for parents null through
if (ScheduleTrades != null)
{
foreach (var child in ScheduleTrades)
{
child.resetParentsChildren();
}
}
if (TradeForScheduleScheduleTrades != null)
{
foreach (var child in TradeForScheduleScheduleTrades)
{
child.resetParentsChildren();
}
}
_Company = null;
_ScheduleTemplate = null;
_Shift = null;
_Task = null;
_User = null;
}
private void OpenTemplate()
{
var templateInfo = SelectedTemplateInfo;
if (templateInfo == null)
{
PopupMessageHelper.Instance.ShowWarning("Please select schedule in list");
return;
}
using (var form = new FormScheduleName())
{
form.Text = "Import Schedule Template";
if (form.ShowDialog(this) != DialogResult.OK)
{
return;
}
ScheduleTemplate template = null;
FormProgress.ShowProgress("Loading Schedule...", () =>
{
AsyncHelper.RunSync(async() =>
{
template = await BusinessObjects.Instance.ScheduleTemplatesManager.GetScheduleTemplate(templateInfo.Name);
template.Name = form.ScheduleName;
});
}, false);
BusinessObjects.Instance.ScheduleManager.AddScheduleFromTemplate(template);
}
DialogResult = DialogResult.OK;
Close();
}
private async System.Threading.Tasks.Task saveTemplate()
{
var result = await UserDialogs.Instance.PromptAsync("Save Template");
if (!result.Ok || string.IsNullOrEmpty(result.Text))
{
return;
}
var schedules = Schedules.Select(i => i.Tag as Schedule);
var scheduleTemplate = new ScheduleTemplate()
{
TemplateName = result.Text
};
scheduleTemplate.Schedules = new ObservableCollection <Schedule>();
foreach (var s in schedules)
{
var toSave = Common.Clone <Schedule>(s);
toSave.ScheduleId = null;
toSave.Shift = null;
toSave.Task = null;
toSave.DayOfWeek = (int)toSave.ScheduleDateValue.DayOfWeek;
toSave.ScheduleDate = null;
toSave.ScheduleTrades = null;
toSave.Published = false;
scheduleTemplate.Schedules.Add(toSave);
}
await runTask(async() => await DataService.PostItemAsync <ScheduleTemplate>("scheduleTemplates", scheduleTemplate));
}
public void AddScheduleFromTemplate(ScheduleTemplate sourceTemplate)
{
var schedule = CreateSchedule();
schedule.LoadFromTemplate(sourceTemplate);
schedule.Save();
OpenSchedule(schedule);
}
private static void ValidateScheduleTemplate(ScheduleTemplate t, List <ScheduleGenerateError> errors)
{
foreach (var(_, events) in CollectDays(t))
{
foreach (var eventTemplate in events)
{
ValidateEventTemplate(t, eventTemplate, errors);
}
}
}
public virtual ScheduleTemplate GetTemplate(string name)
{
var template = new ScheduleTemplate();
template.Name = name;
template.Date = DateTime.Now;
template.ScheduleSettingsContent = SettingsEncoded;
template.ScheduleResourcesContent = ResourcesEncoded;
template.PartitionTemplates.AddRange(GetPartitionTemplates());
return(template);
}
private static IEnumerable <Event> GenerateEvents(ulong chatId, ScheduleTemplate t)
{
var persons = GeneratePersons(t);
var categories = GenerateCategories(chatId, t);
var events = new List <Event>();
var days = CollectDays(t);
foreach (var(dayOfWeek, eventTemplates) in days)
{
var startDay = t.FirstWeekMonday + TimeSpan.FromDays((int)dayOfWeek - 1);
foreach (var eventTemplate in eventTemplates)
{
var eventTimePeriod = t.RegularScheduleTime[eventTemplate.Order];
var weeks = WeekPeriodTemplate.GetWeekRange(eventTemplate.WeekPeriods);
foreach (var week in weeks)
{
var weekDay = startDay + TimeSpan.FromDays(7 * (week - 1));
var eventStart = weekDay.Date + eventTimePeriod.StartTime;
var ev = new Event
{
StartUtcDateTime = eventStart,
Duration = eventTimePeriod.Duration,
Category = categories[eventTemplate.CategoryIndex],
Description = eventTemplate.Description,
Location = eventTemplate.Location,
TagId = (ulong)eventTemplate.Tag
};
ev.Participants = eventTemplate.ParticipantsIndexes.Select(pi => new EventParticipant
{
Event = ev,
Person = persons[pi]
}).ToList();
ev.Organizers = eventTemplate.OrganizerIndexes.Select(oi => new EventOrganizer
{
Event = ev,
Person = persons[oi]
}).ToList();
events.Add(ev);
}
}
}
return(events);
}
private static Person[] GeneratePersons(ScheduleTemplate t)
{
return(t.Persons.Select(p => new Person
{
Email = p.Email,
FirstName = p.FirstName,
LastName = p.LastName,
Patronymic = p.Patronymic,
VkUser = p.VkUserId != null ? new VkUser()
{
Id = p.VkUserId.Value
} : null
}).ToArray());
}
private static void ValidateLimitErrors(ScheduleTemplate t, ICollection <ScheduleGenerateError> errors)
{
if (t.CategoryNames.Count > MaxCategories)
{
errors.Add(ScheduleGenerateError.ExceedsLimitCategories);
}
if (t.Persons.Count > MaxPersons)
{
errors.Add(ScheduleGenerateError.ExceedsLimitPersons);
}
if (t.RegularScheduleTime.Count > MaxRegularScheduleCount)
{
errors.Add(ScheduleGenerateError.ExceedsLimitRegularSchedule);
}
foreach (var(_, events) in CollectDays(t))
{
if (events.Count > MaxEventTemplatesPerDay)
{
errors.Add(ScheduleGenerateError.ExceedsLimitEventTemplatesPerDay);
}
else
{
foreach (var eventTemplate in events)
{
if (eventTemplate.OrganizerIndexes.Count > MaxOrganizersPerEvent)
{
errors.Add(ScheduleGenerateError.ExceedsLimitOrganizersPerEvent);
}
if (eventTemplate.ParticipantsIndexes.Count > MaxParticipantsPerEvent)
{
errors.Add(ScheduleGenerateError.ExceedsLimitParticipantsPerEvent);
}
var weeksCount = WeekPeriodTemplate.GetWeekRange(eventTemplate.WeekPeriods).Count();
if (weeksCount > MaxEventRepeatWeekPeriod)
{
errors.Add(ScheduleGenerateError.ExceedsLimitWeeksPerEvent);
}
}
}
}
}
/// <inheritdoc />
public ScheduleGenerateResult Generate(ulong chatId, ScheduleTemplate template)
{
var events = Enumerable.Empty <Event>();
var regularSchedules = Enumerable.Empty <EveryDayRegularSchedule>();
var errors = new List <ScheduleGenerateError>();
ValidateLimitErrors(template, errors);
ValidateScheduleTemplate(template, errors);
if (errors.Count == 0)
{
events = GenerateEvents(chatId, template);
regularSchedules = GenerateRegularSchedule(chatId, template);
}
return(new ScheduleGenerateResult(errors.ToArray(), events, regularSchedules));
}
public void DailyAt14_30()
{
var dateTemplate = new DailyScheduleTemplate();
var timeTemplate = new ExactTimeScheduleTemplate(14, 30);
var template = new ScheduleTemplate(dateTemplate, timeTemplate);
var startDate = new DateTime(2019, 10, 23, 04, 34, 56);
var schedule = new ScheduleInstance(template, startDate);
schedule.Take(5).Should().Equal(new DateTime[] {
new DateTime(2019, 10, 23, 14, 30, 00),
new DateTime(2019, 10, 24, 14, 30, 00),
new DateTime(2019, 10, 25, 14, 30, 00),
new DateTime(2019, 10, 26, 14, 30, 00),
new DateTime(2019, 10, 27, 14, 30, 00)
});
}
public async Task <ScheduleTemplate> GetScheduleTemplate(string name)
{
var templateArchiveFile = new StorageFile(
AppProfileManager.Instance.SharedFolder.RelativePathParts.Merge(
new[]
{
TemplatesFolderName,
String.Format("{0}.zip", name)
}));
if (await templateArchiveFile.Exists(true, true))
{
await templateArchiveFile.Download(true);
var templateEncodedFile = ZipHelper.ExtractFiles(templateArchiveFile.LocalPath).FirstOrDefault();
return(ScheduleTemplate.FromFile(templateEncodedFile));
}
throw new FileNotFoundException("Schedule Template not found in cloud");
}
private static void ValidateEventTemplate(ScheduleTemplate s, EventTemplate e, List <ScheduleGenerateError> errors)
{
if (e.Order > s.RegularScheduleTime.Count)
{
errors.Add(ScheduleGenerateError.NoScheduleForEvent);
}
if (e.CategoryIndex < 0 || e.CategoryIndex >= s.CategoryNames.Count)
{
errors.Add(ScheduleGenerateError.NoCategoryForEvent);
}
errors.AddRange(from organizerIndex in e.OrganizerIndexes
where organizerIndex < 0 || organizerIndex >= s.Persons.Count
select ScheduleGenerateError.NoPersonForEventOrganizer);
errors.AddRange(from participantIndex in e.ParticipantsIndexes
where participantIndex < 0 || participantIndex >= s.Persons.Count
select ScheduleGenerateError.NoPersonForEventParticipant);
}
public async Task SaveTemplate(ScheduleTemplate template)
{
var templateList = await GetTemplatesList();
if (!templateList.Items.Any(templateInfo => templateInfo.Name.Equals(template.Name)))
templateList.Items.Add(template.GetTemplateInfo());
var templateEncodedFile = Path.Combine(Path.GetTempPath(), String.Format("{0}.json", template.Name));
File.WriteAllText(templateEncodedFile, template.Serialize());
var templateArchiveFile = new StorageFile(
AppProfileManager.Instance.SharedFolder.RelativePathParts.Merge(
new[]
{
TemplatesFolderName,
String.Format("{0}.zip", template.Name)
}));
ZipHelper.CompressFiles(new[] { templateEncodedFile }, templateArchiveFile.LocalPath);
await templateArchiveFile.Upload();
await SaveTemplatesList(templateList);
}
public void WeeklyEveryMondayAt17_30()
{
var dateTemplate = new WeeklyScheduleTemplate(1);
dateTemplate[DayOfWeek.Monday] = true;
var timeTemplate = new ExactTimeScheduleTemplate(17, 30);
var template = new ScheduleTemplate(dateTemplate, timeTemplate);
var startDate = new DateTime(2019, 10, 23, 04, 34, 56);
var schedule = new ScheduleInstance(template, startDate);
schedule.Take(5).Should().Equal(new DateTime[] {
new DateTime(2019, 10, 28, 17, 30, 00),
new DateTime(2019, 11, 04, 17, 30, 00),
new DateTime(2019, 11, 11, 17, 30, 00),
new DateTime(2019, 11, 18, 17, 30, 00),
new DateTime(2019, 11, 25, 17, 30, 00)
});
}
public void DailyEvery3HoursFrom9To19()
{
var dateTemplate = new DailyScheduleTemplate();
var timeTemplate = new HourlyScheduleTemplate(3);
timeTemplate.From(9, 00);
timeTemplate.To(19, 00);
var template = new ScheduleTemplate(dateTemplate, timeTemplate);
var startDate = new DateTime(2019, 10, 23, 04, 34, 56);
var schedule = new ScheduleInstance(template, startDate);
schedule.Take(8).Should().Equal(new DateTime[] {
new DateTime(2019, 10, 23, 09, 00, 00),
new DateTime(2019, 10, 23, 12, 00, 00),
new DateTime(2019, 10, 23, 15, 00, 00),
new DateTime(2019, 10, 23, 18, 00, 00),
new DateTime(2019, 10, 24, 09, 00, 00),
new DateTime(2019, 10, 24, 12, 00, 00),
new DateTime(2019, 10, 24, 15, 00, 00),
new DateTime(2019, 10, 24, 18, 00, 00)
});
}
private void CreateTimeSlotTemplates(EntitiesDataContext _EDC, ShippingPoint _sp)
{
Dictionary <TimeSlotsTemplateStartHour, TimeSlotsTemplateEndHour> _hours = new Dictionary <TimeSlotsTemplateStartHour, TimeSlotsTemplateEndHour>()
{
{ TimeSlotsTemplateStartHour._0, TimeSlotsTemplateEndHour._1 }, { TimeSlotsTemplateStartHour._1, TimeSlotsTemplateEndHour._2 }, { TimeSlotsTemplateStartHour._2, TimeSlotsTemplateEndHour._3 }, { TimeSlotsTemplateStartHour._3, TimeSlotsTemplateEndHour._4 }, { TimeSlotsTemplateStartHour._4, TimeSlotsTemplateEndHour._5 },
{ TimeSlotsTemplateStartHour._5, TimeSlotsTemplateEndHour._6 }, { TimeSlotsTemplateStartHour._6, TimeSlotsTemplateEndHour._7 }, { TimeSlotsTemplateStartHour._7, TimeSlotsTemplateEndHour._8 }, { TimeSlotsTemplateStartHour._8, TimeSlotsTemplateEndHour._9 }, { TimeSlotsTemplateStartHour._9, TimeSlotsTemplateEndHour._10 },
{ TimeSlotsTemplateStartHour._10, TimeSlotsTemplateEndHour._11 }, { TimeSlotsTemplateStartHour._11, TimeSlotsTemplateEndHour._12 }, { TimeSlotsTemplateStartHour._12, TimeSlotsTemplateEndHour._13 }, { TimeSlotsTemplateStartHour._13, TimeSlotsTemplateEndHour._14 }, { TimeSlotsTemplateStartHour._14, TimeSlotsTemplateEndHour._15 },
{ TimeSlotsTemplateStartHour._15, TimeSlotsTemplateEndHour._16 }, { TimeSlotsTemplateStartHour._16, TimeSlotsTemplateEndHour._17 }, { TimeSlotsTemplateStartHour._17, TimeSlotsTemplateEndHour._18 }, { TimeSlotsTemplateStartHour._18, TimeSlotsTemplateEndHour._19 }, { TimeSlotsTemplateStartHour._19, TimeSlotsTemplateEndHour._20 },
{ TimeSlotsTemplateStartHour._20, TimeSlotsTemplateEndHour._21 }, { TimeSlotsTemplateStartHour._21, TimeSlotsTemplateEndHour._22 }, { TimeSlotsTemplateStartHour._22, TimeSlotsTemplateEndHour._23 }, { TimeSlotsTemplateStartHour._23, TimeSlotsTemplateEndHour._0 }
};
ScheduleTemplate _schedule = new ScheduleTemplate()
{
ShippingPointLookupTitle = _sp, Title = _sp.Title() + " All day schedule."
};
_EDC.ScheduleTemplate.InsertOnSubmit(_schedule);
_EDC.SubmitChanges();
List <TimeSlotsTemplateDay> _days = new List <TimeSlotsTemplateDay>()
{
{ TimeSlotsTemplateDay.Friday }, { TimeSlotsTemplateDay.Monday }, { TimeSlotsTemplateDay.Saturday }, { TimeSlotsTemplateDay.Sunday }, { TimeSlotsTemplateDay.Thursday }, { TimeSlotsTemplateDay.Tuesday }, { TimeSlotsTemplateDay.Wednesday }
};
foreach (TimeSlotsTemplateDay _day in _days)
{
List <TimeSlotsTemplate> _ts = new List <TimeSlotsTemplate>();
foreach (TimeSlotsTemplateStartHour _sh in _hours.Keys)
{
_ts.Add(new TimeSlotsTemplate()
{
TimeSlotsTemplateDay = _day, TimeSlotsTemplateEndHour = _hours[_sh], TimeSlotsTemplateEndMinute = TimeSlotsTemplateEndMinute._0, TimeSlotsTemplateStartHour = _sh, TimeSlotsTemplateStartMinute = TimeSlotsTemplateStartMinute._0, ScheduleTemplateTitle = _schedule
});
}
_EDC.TimeSlotsTemplate.InsertAllOnSubmit(_ts);
_EDC.SubmitChanges();
}
}
private static IEnumerable <EveryDayRegularSchedule> GenerateRegularSchedule(ulong chatId, ScheduleTemplate template)
{
return(template.RegularScheduleTime.Select(t => new EveryDayRegularSchedule
{
ChatId = chatId, StartUtcTime = t.StartTime, Duration = t.Duration
}));
}
public IntermediateWeeklyScheduleBuilder(ScheduleTemplate template)
: base(template)
{
_DateTemplate = (WeeklyScheduleTemplate)template.DateTemplate;
}
public WeekScheduleBuilder(ScheduleTemplate template)
{
_Template = template;
_DateTemplate = (WeeklyScheduleTemplate)template.DateTemplate;
}
public DayScheduleBuilder(ScheduleTemplate template)
{
_Template = template;
}
public IntermediateDayScheduleBuilder2(ScheduleTemplate template)
{
_Template = template;
_TimeTemplate = (RecurringTimeScheduleTemplate)template.TimeTemplate;
}
private void AddTimeslotsActivity_ExecuteCode(object sender, EventArgs e)
{
try
{
using (EntitiesDataContext _EDC = new EntitiesDataContext(workflowProperties.SiteUrl))
{
TimeSlotTimeSlot.DeleteExpired(_EDC);
TimeSlotsInitiationData _data = TimeSlotsInitiationData.Deserialize(workflowProperties.InitiationData);
ScheduleTemplate _tmpl = Element.GetAtIndex <ScheduleTemplate>(_EDC.ScheduleTemplate, workflowProperties.ItemId.ToString());
if (_tmpl.ShippingPointLookupTitle == null)
{
throw new ApplicationException("Template does not have Shipingpoint assigned");
}
var _src = from _tst in _tmpl.TimeSlotsTemplate
group _tst by _tst.TimeSlotsTemplateDay.Value;
Dictionary <TimeSlotsTemplateDay, IGrouping <TimeSlotsTemplateDay, TimeSlotsTemplate> > _dys = _src.ToDictionary(x => x.Key);
Dictionary <DayOfWeek, TimeSlotsTemplateDay> _tt = new Dictionary <DayOfWeek, TimeSlotsTemplateDay>()
{
{ DayOfWeek.Friday, TimeSlotsTemplateDay.Friday },
{ DayOfWeek.Monday, TimeSlotsTemplateDay.Monday },
{ DayOfWeek.Saturday, TimeSlotsTemplateDay.Saturday },
{ DayOfWeek.Sunday, TimeSlotsTemplateDay.Sunday },
{ DayOfWeek.Thursday, TimeSlotsTemplateDay.Thursday },
{ DayOfWeek.Tuesday, TimeSlotsTemplateDay.Tuesday },
{ DayOfWeek.Wednesday, TimeSlotsTemplateDay.Wednesday },
};
for (int _week = 0; _week < _data.Duration; _week++)
{
for (int _dayIdx = 0; _dayIdx < 7; _dayIdx++)
{
TimeSlotsTemplateDay _dayOfWeek = _tt[_data.StartDate.DayOfWeek];
if (_dys.ContainsKey(_dayOfWeek))
{
foreach (var _item in _dys[_dayOfWeek])
{
DateTime _strt = CreateDateTime(_data, _item.TimeSlotsTemplateStartHour.Value.Hour2Int(), _item.TimeSlotsTemplateStartMinute.Value.Minute2Int());
DateTime _end = CreateDateTime(_data, _item.TimeSlotsTemplateEndHour.Value.Hour2Int(), _item.TimeSlotsTemplateStartMinute.Value.Minute2Int());
TimeSlotTimeSlot _nts = new TimeSlotTimeSlot()
{
StartTime = _strt,
EndTime = _end,
TimeSlot2ShippingPointLookup = _tmpl.ShippingPointLookupTitle,
EntryTime = _strt,
ExitTime = _end,
Occupied = Occupied.Free,
IsDouble = false,
TimeSpan = (_end - _strt).TotalMinutes
};
_EDC.TimeSlot.InsertOnSubmit(_nts);
m_TimeSlotsCounter++;
}
} //!_tt.ContainsKey(_
_data.StartDate += TimeSpan.FromDays(1);
}
_EDC.SubmitChanges();
}
}
}
catch (Exception ex)
{
string _frmt = "Workflow aborted in AddTimeslotsActivity because of the error: {0}";
throw new ApplicationException(String.Format(_frmt, ex.Message));
}
}
public static DayScheduleBuilder EveryDay()
{
var template = new ScheduleTemplate(new DailyScheduleTemplate());
return(new DayScheduleBuilder(template));
}
public static MonthScheduleBuilder EveryMonths(int every)
{
var template = new ScheduleTemplate(new MonthlyScheduleTemplate(every));
return(new MonthScheduleBuilder(template));
}
public static WeekScheduleBuilder EveryWeeks(int every)
{
var template = new ScheduleTemplate(new WeeklyScheduleTemplate(every));
return(new WeekScheduleBuilder(template));
}
public virtual void LoadFromTemplate(ScheduleTemplate sourceTemplate)
{
Name = sourceTemplate.Name;
SettingsEncoded = sourceTemplate.ScheduleSettingsContent;
ResourcesEncoded = sourceTemplate.ScheduleResourcesContent;
}
private static IEnumerable <(DayOfWeek dayOfWeek, List <EventTemplate> events)> CollectDays(ScheduleTemplate t)
{
return(new[]
private static Category[] GenerateCategories(ulong chatId, ScheduleTemplate t)
{
return(t.CategoryNames.Select(c => new Category {
Name = c, ChatId = chatId
}).ToArray());
}
public MonthScheduleBuilder(ScheduleTemplate template)
{
_Template = template;
_DateTemplate = (MonthlyScheduleTemplate)template.DateTemplate;
}
