public void FillExpressionParts(string expression)
{
var parts = expression.Split(',').Select(part => new CronCategoryPart(part));
foreach (var existingpart in expressionParts.Items)
{
existingpart.Dispose();
}
expressionParts.ClearAndAddRange(parts);
}
public ExportViewModel(IShell sh, IAppModel am, IDialogCoordinator dc,
IAppConfig cfg, IMapper mapper)
{
shell = sh;
appModel = am;
dialCoord = dc;
this.mapper = mapper;
_appConfig = cfg;
AvailableBoxes = appModel.Boxes;
boards = new SourceList <BoardToExport>();
AvailableBoards = boards.SpawnCollection();
ExportJson = true;
DatePostfix = true;
SplitBoardsToFiles = false;
PdfOptionsAvailable = new PdfOptionsAvailable
{
PageSizes = Enum.GetValues(typeof(PageSize)).Cast <PageSize>().ToArray(),
PageOrientations = Enum.GetValues(typeof(PageOrientation)).Cast <PageOrientation>().ToArray(),
ScaleFittings = Enum.GetValues(typeof(ScaleFitting)).Cast <ScaleFitting>().ToArray()
};
PdfOptions = new PdfOptions
{
PageSize = PageSize.A4,
PageOrientation = PageOrientation.Portrait,
ScaleOptions = new ScaleOptions
{
Padding = new Thickness(),
ScaleToFit = true,
ScaleFitting = ScaleFitting.BothDirections,
MaxScale = 1.0,
MinScale = 0.0
}
};
var canExport = boards
.Connect()
.AutoRefresh()
.Filter(x => x.IsChecked)
.Select(x => AvailableBoards.Count(y => y.IsChecked) > 0 &&
!string.IsNullOrEmpty(SelectedBox.Uri) && File.Exists(SelectedBox.Uri));
ExportCommand = ReactiveCommand.CreateFromTask(ExportCommandExecute, canExport);
SelectTargetFolderCommand = ReactiveCommand.Create(SelectTargetFolderCommandExecute);
CancelCommand = ReactiveCommand.Create(Close);
this.ObservableForProperty(x => x.SelectedBox)
.Where(x => x.Value != null)
.Select(x => x.Value)
.Subscribe(box =>
{
boards.ClearAndAddRange(box.Boards.Items
.Select(x => new BoardToExport {
Board = x, IsChecked = true
}));
TargetFile = Path.GetFileNameWithoutExtension(box.Uri) + "_export";
});
this.ObservableForProperty(x => x.TargetFolder)
.Subscribe(x => cfg.ArchiveFolder = x.Value);
SelectedBox = AvailableBoxes.First();
var fi = new FileInfo(SelectedBox.Uri);
TargetFolder = cfg.ArchiveFolder ?? fi.DirectoryName;
_appConfig.ColorThemeObservable
.Subscribe(x => ColorTheme = x);
}
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 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 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());
}
public TaskManagerViewModel(ICachedService cachedService, IMapper mapper, IShell shell)
{
CanClose = false;
this.cachedService = cachedService;
this.mapper = mapper;
Shell = shell as CachedServiceShell;
var packageBuilder = new ProtoPackageBuilder();
selectedTaskInstances = new SourceList <DesktopTaskInstance>();
operInstances = new SourceList <DesktopOperInstance>();
IObservable <bool> canOpenInstancePage = this //todo:some check for is viewdataset?"
.WhenAnyValue(t => t.SelectedInstanceData,
si => !string.IsNullOrEmpty(si?.DataSet));
OpenPage = ReactiveCommand.Create <string>
(cachedService.OpenPageInBrowser, canOpenInstancePage);
EditTaskCommand = ReactiveCommand.CreateFromTask(async() =>
{
if (SelectedTask == null)
{
return;
}
var id = SelectedTask.Id;
cachedService.RefreshData();
if (cachedService
.Tasks.Items.FirstOrDefault(task => task.Id == id) == null)
{
await Shell.ShowMessageAsync("Task not longer exists");
return;
}
var name = $"Task {id} editor";
Shell.ShowView <TaskEditorView>(new TaskEditorRequest
{
ViewId = name,
Task = cachedService
.Tasks.Items.FirstOrDefault(task => task.Id == id),
TaskOpers = cachedService.Operations.Items.Where(to => to.TaskId == id).ToList()
},
new UiShowOptions {
Title = name
});
});
DeleteCommand = ReactiveCommand.CreateFromTask(async() =>
await Delete(), Shell.CanEdit);
StopTaskCommand = ReactiveCommand.CreateFromTask <int, string>(async par =>
{
if (!await Shell.ShowWarningAffirmativeDialogAsync("Сancel task execution?"))
{
return("False");
}
var t = await this.cachedService.StopTaskByInstanceId(par);
LoadInstanceCompactsByTaskId(SelectedTask.Id);
return(t);
}, Shell.CanStopRun);
RunTaskCommand = ReactiveCommand.CreateFromTask <DesktopTask>(async par =>
{
var workingInstances = await cachedService.GetWorkingTaskInstancesById(par.Id);
if (workingInstances.Count > 0)
{
await Shell.ShowMessageAsync(
$"This task already has working instances ({string.Join(", ", workingInstances)}). " +
"You can try to execute it later");
}
else
{
if (!await Shell.ShowWarningAffirmativeDialogAsync($"Do you want to execute task {par.Name}?"))
{
return;
}
var res = await cachedService.StartTaskById(par.Id);
LoadInstanceCompactsByTaskId(SelectedTask.Id);
await Shell.ShowMessageAsync(res, "Task execution");
}
}, Shell.CanStopRun);
this.WhenAnyValue(s => s.SelectedTask)
.Where(x => x != null)
.Subscribe(x => LoadInstanceCompactsByTaskId(x.Id));
this.WhenAnyValue(s => s.SelectedTaskInstance)
.Subscribe(x =>
{
if (x == null)
{
operInstances.Clear();
}
else
{
operInstances.ClearAndAddRange(
cachedService.GetOperInstancesByTaskInstanceId(x.Id)
.Select(mapper.Map <DesktopOperInstance>));
}
});
this.WhenAnyValue(s => s.SelectedOperInstance)
.Subscribe(async x =>
{
var data = new DesktopOperInstance();
if (x != null)
{
var fullInstance = cachedService
.GetFullOperInstanceById(SelectedOperInstance.Id);
data = mapper.Map <DesktopOperInstance>(fullInstance);
if (fullInstance.DataSet != null)
{
try
{
data.DataSet = JsonConvert.SerializeObject(packageBuilder.GetPackageValues(
OperationPackage.Parser.ParseFrom(fullInstance.DataSet)));
}
catch
{
await Shell.ShowMessageAsync("Exception occured during dataset decoding");
}
}
}
SelectedInstanceData = x == null
? null
: data;
});
}
private void LoadInstanceCompactsByTaskId(int taskId)
{
selectedTaskInstances
.ClearAndAddRange(cachedService.GetInstancesByTaskId(taskId)
.Select(ti => mapper.Map <DesktopTaskInstance>(ti)).OrderByDescending(inst => inst.StartTime));
}
