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