private void OnSchedulesLoaded(object obj)
{
switch (ScheduleType)
{
case ScheduleTypes.AC:
Schedules = _schedulesRepository.ACSchedules;
break;
case ScheduleTypes.Heat:
Schedules = _schedulesRepository.HeatSchedules;
break;
case ScheduleTypes.Light:
Schedules = _schedulesRepository.LightSchedules;
break;
case ScheduleTypes.SKUD:
Schedules = _schedulesRepository.SKUDSchedules;
break;
case ScheduleTypes.Ventilation:
Schedules = _schedulesRepository.VentilationSchedules;
break;
}
_changedByServer = true;
if (AddressList.Any())
{
var currentSchedule = Schedules.FirstOrDefault(s => s.ControlledObjects.Contains(new Property()));
CurrentSchedule = currentSchedule ?? Schedules[0];
}
}
public TimeTrigger GetActiveTimeTrigger()
{
if (Schedules.Any(s => s.Active))
{
return(Schedules.FirstOrDefault(s => s.Active).GetActiveTimeTrigger());
}
else //It is possible that a user deletes the active schedule, then there is no active program
{
return(null);
}
}
public TimeTrigger GetActiveTimeTriggerForDevice(string deviceName)
{
if (Schedules?.Any(s => s.Active && s.AppliesToDeviceNames.Contains(deviceName)) == true)
{
return(Schedules?.FirstOrDefault(s => s.Active && s.AppliesToDeviceNames.Contains(deviceName)).GetActiveTimeTrigger());
}
else //It is possible that a user deletes the active schedule, then there is no active program
{
return(null);
}
}
private IEnumerable <int> PopulateWeeks(Schedule schedule)
{
List <int> weeks = new List <int>();
foreach (KeyValuePair <int, double> item in Schedules.FirstOrDefault().Nutrients.FirstOrDefault().WeekAndDoseDict)
{
weeks.Add(item.Key);
}
return(weeks);
}
private void Cancel()
{
if (CurrentSchedule != null)
{
if (CurrentSchedule.Id == 0)
{
CurrentSchedule = Schedule.FromScheduleClass(Schedules.FirstOrDefault());
}
else
{
CurrentSchedule = null;
CurrentSchedule = Schedule.FromScheduleClass(SelectedSchedule);
}
}
}
private async void SaveSchedule()
{
if (CurrentSchedule == null)
{
throw new Exception("Расписание не выбрано");
}
if (string.IsNullOrWhiteSpace(CurrentSchedule.Name))
{
throw new Exception("Не задано название расписания");
}
try
{
IsBusy = true;
var sc = Schedules.FirstOrDefault(s => s.Id == CurrentSchedule.Id) ?? new ScheduleClass();
if (sc.Id == 0)
{
sc.SetType(CurrentSchedule.Type);
}
sc.Days = CurrentSchedule.DaySchedules.Select(s => new List <ValueTimeRange>(s.Spans)).ToArray();
sc.Name = CurrentSchedule.Name;
var savedSchedule = await _scheduleRepository.SaveSchedule(sc, CurrentSchedule.Id == 0);
if (savedSchedule == null)
{
throw new Exception("Не удалось сохранить расписание, попробуйте позже.");
}
else
{
if (CurrentSchedule.Id != 0)
{
Schedules.Remove(SelectedSchedule);
}
Schedules.Add(savedSchedule);
SelectedSchedule = savedSchedule;
}
}
finally
{
IsBusy = false;
}
}
private async void DeleteSchedule()
{
int index = Schedules.IndexOf(SelectedItem);
if (SelectedItem.Exceptions.Count > 0)
{
if (await(new ViewModelLocator()).Main.DialogBox("In Use Exception",
"The Schedule Is Being Used In The Default Weekly Schedule Or Exceptions. If you choose to continue exceptions contaning this schedule will be deleted too",
MessageDialogStyle.AffirmativeAndNegative) ==
MessageDialogResult.Affirmative)
{
_dataService.DeleteSchedule(SelectedItem);
}
if (index > 0)
{
SelectedItem = Schedules.ElementAt(index - 1);
}
else
{
if (Schedules.Count > 0)
{
SelectedItem = Schedules.FirstOrDefault();
}
}
}
else
{
_dataService.DeleteSchedule(SelectedItem);
if (index > 0)
{
SelectedItem = Schedules.ElementAt(index - 1);
}
else
{
if (Schedules.Count > 0)
{
SelectedItem = Schedules.FirstOrDefault();
}
}
}
(new ViewModelLocator()).Main.StartScheduler();
}
public ReorderExistingPdfViewModel(Document document, IErrorLogger logger)
{
this.Document = document;
this.Logger = logger;
if (ReorderExistingPdfCommand.ReorderOptions?.Schedule == null)
{
this.SelectedSchedule = Schedules.FirstOrDefault();
}
else
{
this.SelectedSchedule = Schedules.Where(schedule => schedule.ViewName == ReorderExistingPdfCommand.ReorderOptions.Schedule.ViewName).FirstOrDefault();
this.InclusionExclusionColumn = ReorderExistingPdfCommand.ReorderOptions.InclusionColumn;
this.SortColumn = ReorderExistingPdfCommand.ReorderOptions.SortColumn;
this.SelectedPdfFile = ReorderExistingPdfCommand.ReorderOptions.PdfFileName;
}
this.PropertyChanged += ReorderExistingPdfViewModel_PropertyChanged;
}
private async void DropSchedule()
{
if (CurrentSchedule != null && CurrentSchedule.Id != null)
{
IsBusy = true;
try
{
const string dropScheduleUrl = @"/Schedules/";
await _dataTransport.DeleteRequestAsync(dropScheduleUrl + CurrentSchedule.Id, true);
Schedules.Remove(SelectedSchedule);
SelectedSchedule = Schedules.FirstOrDefault();
}
catch
{
throw new Exception("Не удалось удалить расписание, попробуйте позже.");
}
finally
{
IsBusy = false;
}
}
}
public void Initialize(ViewRequest viewRequest)
{
if (Shell.Role == ServiceUserRole.Editor)
{
Shell.AddVMCommand("File", "Save",
"SaveChangesCommand", this)
.SetHotKey(ModifierKeys.Control, Key.S);
Shell.AddVMCommand("Edit", "Add operation from existing templates",
"OpenTemplatesListCommand", this);
Shell.AddVMCommand("Edit", "Add new operation",
"CreateOperConfigCommand", this);
}
tasks.ClearAndAddRange(cachedService.Tasks.Items
.Select(task => mapper.Map <DesktopTaskNameId>(task)));
Schedules = cachedService.Schedules.SpawnCollection();
if (viewRequest is TaskEditorRequest request)
{
mapper.Map(request.Task, this);
HasSchedule = ScheduleId > 0;
if (request.TaskOpers != null)
{
bindedOpers.ClearAndAddRange(request.TaskOpers.OrderBy(to => to.Number)
.Select(to => mapper.Map <DesktopOperation>(to)));
}
if (request.Task.DependsOn != null)
{
taskDependencies.ClearAndAddRange(request.Task.DependsOn
.Select(dep =>
{
tasks
.Connect()
.Bind(out var cachedTasks)
.Subscribe();
var desktopDep = mapper.Map <DesktopTaskDependence>(dep);
desktopDep.Tasks = cachedTasks;
return(desktopDep);
}));
}
if (request.DependsOn != null)
{
taskDependencies.ClearAndAddRange(request
.DependsOn.OrderBy(dep => dep.TaskId));
}
if (!string.IsNullOrEmpty(request.Task.Parameters))
{
taskParameters.ClearAndAddRange(JsonConvert
.DeserializeObject <Dictionary <string, object> >(request.Task.Parameters)
.Select(pair => new TaskParameter
{
Name = pair.Key,
Value = pair.Value
}));
}
TaskDependencies = new ObservableCollectionExtended <DesktopTaskDependence>();
taskDependencies.Connect()
.Bind(TaskDependencies)
.Subscribe(_ => this.RaisePropertyChanged(nameof(TaskDependencies)));
taskDependencies.Connect()
.WhenAnyPropertyChanged("TaskId", "MaxSecondsPassed")
.Subscribe(_ => this.RaisePropertyChanged(nameof(TaskDependencies)));
if (request.ViewId == "Creating new Task")
{
HasSchedule = true;
ScheduleId = Schedules.First()?.Id;
Name = "New task";
}
if (request.ViewId.Contains("copy"))
{
Name = request.ViewId;
}
}
void Changed(object sender, PropertyChangedEventArgs e)
{
if (Shell.Role == ServiceUserRole.Viewer || IsDirty || e.PropertyName == "SelectedOperation")
{
return;
}
IsDirty = true;
Title += '*';
}
AllErrors.Connect()
.Subscribe(_ => IsValid = !AllErrors.Items.Any());
this.ObservableForProperty(s => s.HasSchedule)
.Subscribe(hassch =>
ScheduleId = hassch.Value ? Schedules.FirstOrDefault()?.Id : null);
taskParameters.Connect() //todo: real-time updating of duplicates indicators
.WhenAnyPropertyChanged("Name")
.Subscribe(_ =>
{
foreach (var dim in TaskParameters)
{
dim.IsDuplicate = false;
}
var duplicatgroups = TaskParameters
.GroupBy(dim => dim.Name)
.Where(g => g.Count() > 1)
.ToList();
foreach (var group in duplicatgroups)
{
foreach (var dim in group)
{
dim.IsDuplicate = true;
dim.HasErrors = true;
}
}
this.RaisePropertyChanged(nameof(TaskParameters));
});
taskParameters.Connect()
.WhenAnyPropertyChanged("Value")
.Subscribe(_ => this.RaisePropertyChanged(nameof(TaskParameters)));
taskParameters.Connect()
.WhenAnyPropertyChanged("HasErrors")
.Subscribe(_ =>
{
IsValid = !AllErrors.Items.Any() &&
!TaskParameters.Any(param => param.HasErrors);
});
TaskParameters = new ObservableCollectionExtended <TaskParameter>();
taskParameters.Connect()
.Bind(TaskParameters)
.Skip(1)
.Subscribe(_ =>
{
UpdateParametersList();
this.RaisePropertyChanged(nameof(TaskParameters));
});
ImplementationTypes = implementationTypes.SpawnCollection();
BindedOpers = new ObservableCollectionExtended <DesktopOperation>();
bindedOpers.Connect()
.Bind(BindedOpers)
.Subscribe(_ => this.RaisePropertyChanged(nameof(bindedOpers)));
bindedOpers.Connect()
.Subscribe(_ =>
{
var packages = bindedOpers.Items.Where(oper => DataImporters.ContainsKey(oper.ImplementationType))
.Select(oper =>
(DeserializeOperationConfigByType(oper.ImplementationType, oper.Config) as
IPackagedImporterConfig)
?.PackageName).Where(name => !string.IsNullOrEmpty(name)).Distinct().ToList();
incomingPackages.ClearAndAddRange(packages);
this.RaisePropertyChanged(nameof(bindedOpers));
});
PropertyChanged += Changed;
} //init vm
public void Refresh(Area Area)
{
var CurrentSchedules = new List <TimeTableItemViewModel>();
var SchedulesResult = m_CalculationBll.GetSchedulesByTime(CurrentStation.Schedules, CurrentStation.ESTW.Time);
if (!SchedulesResult.Succeeded)
{
Dispatcher.Invoke(() => MessageBox.Show(SchedulesResult.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Error));
return;
}
foreach (var Schedule in SchedulesResult.Result)
{
if (Schedule.Train == null)
{
continue;
}
bool Visible = true;
bool IsNew = false;
if (Schedule.Time < CurrentStation.ESTW.Time)
{
Visible = false;
}
var Current = Schedules.FirstOrDefault(s => s.TrainNumber == Schedule.Train.Number);
if (Current == null)
{
Current = new TimeTableItemViewModel(Schedule);
IsNew = true;
}
if (Area.LiveTrains.ContainsKey(Current.TrainNumber))
{
var LiveTrain = Area.LiveTrains[Current.TrainNumber];
Current.Delay = LiveTrain.Delay;
var LiveSchedule = LiveTrain.Schedules.FirstOrDefault(s => s.Schedule == Schedule);
if (LiveSchedule != null)
{
Visible = true;
Current.LiveTrack = LiveSchedule.LiveTrack;
var Index = LiveTrain.Schedules.IndexOf(LiveSchedule);
if (LiveSchedule.LiveDeparture != null || LiveTrain.Schedules.Where((s, i) => i > Index && s.LiveArrival != null).Count() > 0)
{
Visible = false;
}
}
LeibitTime ActualTime;
if (LiveTrain.Block != null && LiveTrain.Block.Track != null)
{
ActualTime = LiveTrain.Block.Track.Station.ESTW.Time;
}
else
{
ActualTime = Area.ESTWs.Where(e => e.IsLoaded).DefaultIfEmpty().Max(e => e.Time);
}
if (ActualTime != null && LiveTrain.LastModified != null && ActualTime > LiveTrain.LastModified.AddMinutes(1))
{
Visible = false;
}
if (Visible)
{
var DelayInfos = LiveTrain.Schedules.SelectMany(s => s.Delays).Where(d => d.Reason.IsNotNullOrWhiteSpace()).Select(d => d.Reason);
if (DelayInfos.Count() > 0)
{
Current.DelayReason = String.Join(", ", DelayInfos);
}
var StartSchedule = LiveTrain.Schedules.SingleOrDefault(s => s.Schedule.Handling == eHandling.Start && s.Schedule.Station == CurrentStation);
Current.IsReady = StartSchedule != null && StartSchedule.Schedule.Station.ESTW.Time >= StartSchedule.Schedule.Departure.AddMinutes(-2);
}
}
if (Visible)
{
if (IsNew)
{
Dispatcher.Invoke(() => Schedules.Add(Current));
}
CurrentSchedules.Add(Current);
}
}
var RemovedItems = Schedules.Except(CurrentSchedules).ToList();
Dispatcher.Invoke(() => RemovedItems.ForEach(s => Schedules.Remove(s)));
}
public override void CalcSchedules()
{
Schedules.Clear();
Schedules.Add(Device.StartTime);
var nextTime = Device.StartTime.AddMinutes(GetFirstSpan());
//如下一次开始时间 < endtime,且够一个周期的时间
if (nextTime.AddMinutes(Device.Period * (int)Device.TimeType) <= Device.EndTime)
{
Schedules.Add(nextTime);
while (true)
{
nextTime = nextTime.AddMinutes(Device.Period * (int)Device.TimeType);
if (nextTime.AddMinutes(Device.Period * (int)Device.TimeType) > Device.EndTime)
{
break;
}
Schedules.Add(nextTime);
}
}
LogFactory.Create().Info($"DEVICE{Device.DeviceId} CalcSchedules ==>{Schedules.Count}, first{Schedules.FirstOrDefault():yyyy-MM-dd HH:mm:ss}, last{Schedules.LastOrDefault():yyyy-MM-dd HH:mm:ss}");
}
public virtual Schedule GetSchedule(string scheduleType)
{
return(Schedules.FirstOrDefault(s => s.ScheduleType == scheduleType));
}
