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 OperEditorViewModel(ICachedService cachedService, IMapper mapper, IShell shell)
{
Shell = shell as CachedServiceShell;
this.cachedService = cachedService;
this.mapper = mapper;
IsValid = true;
validator = new OperEditorValidator();
var operTemplates = new SourceList <string>();
var canSave = this.WhenAnyValue(tvm => tvm.IsDirty,
isd => isd == true).Concat(Shell.CanEdit);
SaveChangesCommand = ReactiveCommand.CreateFromTask(async() => await Save(),
canSave);
CancelCommand = ReactiveCommand.CreateFromTask(async() =>
{
if (IsDirty)
{
if (!await Shell.ShowWarningAffirmativeDialogAsync
("All unsaved changes will be lost. Close window?"))
{
return;
}
}
Close();
});
this.ObservableForProperty(s => s.Mode)
.Subscribe(mode =>
{
var templates = mode.Value == OperMode.Exporter
? DataExporters.Select(pair => pair.Key)
: DataImporters.Select(pair => pair.Key);
operTemplates.ClearAndAddRange(templates);
OperTemplates = operTemplates.SpawnCollection();
ImplementationType = operTemplates.First();
});
this.ObservableForProperty(s => s.ImplementationType)
.Where(type => type.Value != null)
.Subscribe(type =>
{
var operType = Mode == OperMode.Exporter
? DataExporters[type.Value]
: DataImporters[type.Value];
if (operType == null)
{
return;
}
Configuration = Activator.CreateInstance(operType);
mapper.Map(cachedService, Configuration);
});
this.WhenAnyObservable(s => s.AllErrors.CountChanged)
.Subscribe(_ => IsValid = !AllErrors.Items.Any());
}
public TaskEditorViewModel(ICachedService service, IMapper mapper, IShell shell)
{
cachedService = service;
this.mapper = mapper;
validator = new TaskEditorValidator();
IsValid = true;
Shell = shell as CachedServiceShell;
taskParameters = new SourceList <TaskParameter>();
taskDependencies = new SourceList <DesktopTaskDependence>();
bindedOpers = new SourceList <DesktopOperation>();
incomingPackages = new SourceList <string>();
tasks = new SourceList <DesktopTaskNameId>();
DataImporters = cachedService.DataImporters;
DataExporters = cachedService.DataExporters;
implementationTypes = new SourceList <string>();
var canSave = this.WhenAnyValue(tvm => tvm.IsDirty, tvm => tvm.IsValid,
(isd, isv) => isd && isv).Concat(Shell.CanEdit);
SaveChangesCommand = ReactiveCommand.CreateFromTask(async() => await Save(),
canSave);
CancelCommand = ReactiveCommand.CreateFromTask(Cancel);
ClipBoardFillCommand = ReactiveCommand.Create <string>(Clipboard.SetText);
OpenCurrentTaskViewCommand = ReactiveCommand //todo: make without interface blocking
.CreateFromTask(async() =>
cachedService.OpenPageInBrowser(
await cachedService.GetCurrentTaskViewById(Id)));
RemoveOperationCommand = ReactiveCommand.Create <DesktopOperation>(to =>
{
if (SelectedOperation?.Id == to.Id)
{
ClearSelections();
}
bindedOpers.Remove(to);
}, Shell.CanEdit);
RemoveParameterCommand = ReactiveCommand
.Create <TaskParameter>(par => taskParameters.Remove(par), Shell.CanEdit);
RemoveDependenceCommand = ReactiveCommand
.Create <DesktopTaskDependence>(dep => taskDependencies.Remove(dep), Shell.CanEdit);
AddParameterCommand = ReactiveCommand.Create(() => taskParameters.Add(new TaskParameter
{
Name = "@RepPar"
}), Shell.CanEdit);
AddDependenceCommand = ReactiveCommand.CreateFromTask(async() =>
{
if (tasks.Count == 0)
{
await Shell.ShowMessageAsync("No any existing tasks in service");
return;
}
tasks
.Connect()
.Bind(out var cachedTasks)
.Subscribe();
var dependence = new DesktopTaskDependence {
Tasks = cachedTasks, TaskId = cachedTasks.First().Id
};
taskDependencies.Add(dependence);
}, Shell.CanEdit);
AddOperationCommand = ReactiveCommand.CreateFromTask(AddOperation, Shell.CanEdit);
CreateOperConfigCommand = ReactiveCommand.CreateFromTask(CreateOperConfig, Shell.CanEdit);
OpenTemplatesListCommand = ReactiveCommand.CreateFromTask(async() =>
{
if (SelectedOperationConfig != null && Shell.Role == ServiceUserRole.Editor)
{
if (!await Shell.ShowWarningAffirmativeDialogAsync
("All unsaved operation configuration changes will be lost. Close window?"))
{
return;
}
}
await SelectOperFromTemplates();
}, Shell.CanEdit);
SelectOperationCommand = ReactiveCommand.CreateFromTask <DesktopOperation>
(SelectOperation);
this.ObservableForProperty(s => s.Mode)
.Subscribe(mode =>
{
var templates = mode?.Value == OperMode.Exporter
? DataExporters.Select(pair => pair.Key)
: DataImporters.Select(pair => pair.Key);
implementationTypes.ClearAndAddRange(templates);
Type = implementationTypes.Items.FirstOrDefault();
});
this.ObservableForProperty(s => s.Type)
.Where(type => type.Value != null)
.Subscribe(type =>
{
var operType = Mode == OperMode.Exporter
? DataExporters[type.Value]
: DataImporters[type.Value];
if (operType == null)
{
return;
}
SelectedOperationConfig = Activator.CreateInstance(operType);
mapper.Map(cachedService, SelectedOperationConfig);
});
this.WhenAnyValue(tvm => tvm.SelectedOperationConfig)
.Where(selop => selop != null)
.Subscribe(conf =>
IncomingPackages = incomingPackages.SpawnCollection());
}
