public CommandFactory(IPersister persister, ISecurityManager security, IVersionManager versionMaker, IEditUrlManager editUrlManager, IContentAdapterProvider adapters, StateChanger changer) { //this.persister = persister; //makeVersionOfMaster = On.Master(new MakeVersionCommand(versionMaker)); //showEdit = new RedirectToEditCommand(editUrlManager); //clone = new CloneCommand(); //unpublishedDate = new EnsureNotPublishedCommand(); // moved to StateChanger //ensurePublishedDate = new EnsurePublishedCommand(); // moved to StateChanger this.security = security; save = new SaveCommand(persister); delete = new DeleteCommand(persister.Repository); replaceMaster = new ReplaceMasterCommand(versionMaker); makeVersion = new MakeVersionCommand(versionMaker); useDraftCmd = new UseDraftCommand(versionMaker); saveOnPageVersion = new SaveOnPageVersionCommand(versionMaker); draftState = new UpdateContentStateCommand(changer, ContentState.Draft); publishedState = new UpdateContentStateCommand(changer, ContentState.Published); updateObject = new UpdateObjectCommand(); useMaster = new UseMasterCommand(); validate = new ValidateCommand(); saveActiveContent = new ActiveContentSaveCommand(); moveToPosition = new MoveToPositionCommand(); updateReferences = new UpdateReferencesCommand(); }
public CommandFactory(IPersister persister, ISecurityManager security, IVersionManager versionMaker, IEditUrlManager editUrlManager, IContentAdapterProvider adapters, StateChanger changer) { this.persister = persister; makeVersionOfMaster = On.Master(new MakeVersionCommand(versionMaker)); replaceMaster = new ReplaceMasterCommand(versionMaker); makeVersion = new MakeVersionCommand(versionMaker); useNewVersion = new UseNewVersionCommand(versionMaker); updateObject = new UpdateObjectCommand(); delete = new DeleteCommand(persister.Repository); showPreview = new RedirectToPreviewCommand(adapters); showEdit = new RedirectToEditCommand(editUrlManager); useMaster = new UseMasterCommand(); clone = new CloneCommand(); validate = new ValidateCommand(); this.security = security; save = new SaveCommand(persister); incrementVersionIndex = new IncrementVersionIndexCommand(versionMaker); draftState = new UpdateContentStateCommand(changer, ContentState.Draft); publishedState = new UpdateContentStateCommand(changer, ContentState.Published); saveActiveContent = new ActiveContentSaveCommand(); moveToPosition = new MoveToPositionCommand(); unpublishedDate = new EnsureNotPublishedCommand(); publishedDate = new EnsurePublishedCommand(); updateReferences = new UpdateReferencesCommand(); }
public async Task <ActionResult> Save(Domain.Models.ContentType contentType, int id) { var cmd = new SaveCommand(contentType, id).SetUserContext(User); var response = await cmd.Execute(); return(JsonResult(response)); //if (response.Success) //{ // return Json(new { success = true }); //} //else //{ // return JsonError(response.Message); //} }
public void SaveToFile() { using (var fs = new FileStream(FileName, FileMode.Create, FileAccess.ReadWrite, FileShare.Read)) { using (var sw = new StreamWriter(fs, Encoding.UTF8)) { sw.Write(FileContent); } } MD5Code = FileHelper.ComputeMD5(FileName); Status &= ~(TabStatus.NoSave); SaveCommand.RaiseCanExecuteChanged(); }
private void Save() { var dialog = new SaveFileDialog { DefaultExt = "json", RestoreDirectory = true, Filter = @"JSON files (*.json)|*.json|All files (*.*)|*.*" }; if (dialog.ShowDialog() == DialogResult.OK) { SaveCommand command = new SaveCommand(dialog.FileName); command.TargetDrawing = TargetDrawing; _invoker.EnqueueCommandForExecution(command); } }
private void InvalidateCommands() { EditFeeScheuleCommand.RaiseCanExecuteChanged(); SaveCommand.RaiseCanExecuteChanged(); PrintCommand.RaiseCanExecuteChanged(); CancelCommand.RaiseCanExecuteChanged(); DeleteCommand.RaiseCanExecuteChanged(); EditAttributeCommand.RaiseCanExecuteChanged(); DeleteAttributeCommand.RaiseCanExecuteChanged(); DeleteFeeScheuleCommand.RaiseCanExecuteChanged(); NewOrderCommand.RaiseCanExecuteChanged(); EditContactCommand.RaiseCanExecuteChanged(); DeleteContactCommand.RaiseCanExecuteChanged(); EditEmployeeCommand.RaiseCanExecuteChanged(); DeleteEmployeeCommand.RaiseCanExecuteChanged(); }
public TestViewModel() { Collection = new CollectionViewSource(); LoadData(); #region CommandExecution NextEvent = new NextCommand(this); PreviousEvent = new PreviousCommand(this); AddEvent = new AddCommand(this); SaveEvent = new SaveCommand(this); #endregion }
public async Task <ActionResult> SaveComment(int commentId) { var cmd = new SaveCommand(Domain.Models.ContentType.Comment, commentId); var response = await cmd.Execute(); //Saving.SaveSubmission(messageId, loggedInUser); if (response.Success) { return(Json("Saving ok", JsonRequestBehavior.AllowGet)); } else { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, response.Message)); } }
private void OnIsActiveChanged() { SaveCommand.RaiseCanExecuteChanged(); CompileCommand.IsActive = IsActive; CompileCommand.RaiseCanExecuteChanged(); RedoCommand.IsActive = IsActive; RedoCommand.RaiseCanExecuteChanged(); UndoCommand.IsActive = IsActive; UndoCommand.RaiseCanExecuteChanged(); if (IsActiveChanged != null) IsActiveChanged.Invoke(this, new EventArgs()); }
private void ClearCommandExecute() { if (isEditMode) { NavigationService.GoBack(); } else { SelectedCategory = null; SelectedType = null; Sum = string.Empty; Note = string.Empty; SaveCommand.RaiseCanExecuteChanged(); } }
public ValidationViewModel() { Validator.RegisterNotifier(this); Validator.ValidationChanged += (s, e) => SaveCommand.RaiseCanExecuteChanged(); PropertyChanged += (s, e) => { e.Case(() => Name, a => { foreach (var dis in nameDisposables) { dis.Dispose(); } nameDisposables = new List <IDisposable>(); }); }; }
public void MigratesTheFileSystem( [Frozen] Mock <IFileSystem> fileSystem, [Frozen] Mock <IFileSystemMigrator> migrator) { // Arrange var sut = new SaveCommand( new Mock <IPackageAssemblyResolver>().Object, fileSystem.Object, new Mock <ILog>().Object, migrator.Object); // Act sut.Execute(); // Assert migrator.Verify(m => m.Migrate(), Times.Once); }
public virtual void Load(TModel model, bool isNew, object parameter = null) { //детали DetailsViewModel.Load(model, UnitOfWork); DetailsViewModel.Item.PropertyChanged += ItemOnPropertyChanged; //группы юнитов var units = GetUnits(model, parameter); GroupsViewModel.Load(units, DetailsViewModel.Item, UnitOfWork, isNew); GroupsViewModel.GroupChanged += OnGroupChanged; AfterUnitsLoading(); SaveCommand.RaiseCanExecuteChanged(); }
/// <inheritdoc /> public override void Initialize() { SaveCommand = new SaveCommand(); CancelCommand = new CancelCommand(); AddCommand = new AddCommand(); RemoveCommand = new RemoveCommand(); Connector = Repository.GetContextObject(); SourceEnd = Connector.SupplierEnd; TargetEnd = Connector.ClientEnd; switch (SourceEnd.Stereotype) { case "ObjectProperty": ShowSourceEnd = SourceEnd.Stereotype == "ObjectProperty" ? Visibility.Visible : Visibility.Collapsed; break; case "RdfsProperty": ShowSourceEnd = SourceEnd.Stereotype == "RdfsProperty" ? Visibility.Visible : Visibility.Collapsed; break; } switch (TargetEnd.Stereotype) { case "ObjectProperty": ShowTargetEnd = TargetEnd.Stereotype == "ObjectProperty" ? Visibility.Visible : Visibility.Collapsed; break; case "RdfsProperty": ShowTargetEnd = TargetEnd.Stereotype == "RdfsProperty" ? Visibility.Visible : Visibility.Collapsed; break; } SourceViewModel = new ConnectorUserControlViewModel { ConnectorEnd = SourceEnd, ElementNameValue = Repository.GetElementByID(Connector.SupplierID).Name }; TargetViewModel = new ConnectorUserControlViewModel { ConnectorEnd = TargetEnd, ElementNameValue = Repository.GetElementByID(Connector.ClientID).Name }; SourceViewModel.ResourceDictionary = ResourceDictionary; TargetViewModel.ResourceDictionary = ResourceDictionary; SourceViewModel.Initialize(); TargetViewModel.Initialize(); }
public MyIssuesFilterViewModel(IActionMenuFactory actionMenu) { Title = "Filter"; State = IssueState.Open; SortType = IssueSort.None; FilterType = IssueFilterState.All; SaveCommand = ReactiveCommand.CreateAsyncTask(_ => Task.FromResult(new MyIssuesFilterModel(FilterType, State, SortType, Labels, Ascending))); SaveCommand.Subscribe(_ => DismissCommand.ExecuteIfCan()); DismissCommand = ReactiveCommand.Create().WithSubscription(_ => Dismiss()); SelectStateCommand = ReactiveCommand.CreateAsyncTask(async sender => { var options = Enum.GetValues(typeof(IssueState)).Cast <IssueState>().ToList(); var picker = actionMenu.CreatePicker(); foreach (var option in options) { picker.Options.Add(option.Humanize()); } picker.SelectedOption = options.IndexOf(State); var ret = await picker.Show(sender); State = options[ret]; }); SelectSortCommand = ReactiveCommand.CreateAsyncTask(async sender => { var options = Enum.GetValues(typeof(IssueSort)).Cast <IssueSort>().ToList(); var picker = actionMenu.CreatePicker(); foreach (var option in options) { picker.Options.Add(option.Humanize()); } picker.SelectedOption = options.IndexOf(SortType); var ret = await picker.Show(sender); SortType = options[ret]; }); SelectFilterTypeCommand = ReactiveCommand.CreateAsyncTask(async sender => { var options = Enum.GetValues(typeof(IssueFilterState)).Cast <IssueFilterState>().ToList(); var picker = actionMenu.CreatePicker(); foreach (var option in options) { picker.Options.Add(option.Humanize()); } picker.SelectedOption = options.IndexOf(FilterType); var ret = await picker.Show(sender); FilterType = options[ret]; }); }
public void SelectedIndexChanged() { if (Index >= 0) { CurrentReservationDto = new ReservationDto(ReservationDtos[Index]); selectedKundeDto = CurrentReservationDto.Kunde; selectedAutoDto = CurrentReservationDto.Auto; DetailsVisibility = true; OnPropertyChanged(nameof(CurrentReservationDto)); OnPropertyChanged(nameof(DetailsVisibility)); OnPropertyChanged(nameof(selectedKundeDto)); OnPropertyChanged(nameof(selectedAutoDto)); } DeleteCommand.RaiseCanExecuteChanged(); SaveCommand.RaiseCanExecuteChanged(); }
public ManualTestViewModel() { Checks.Add(CheckSize); Checks.Add(CheckLayout); Checks.Add(CheckCorner); Checks.Add(CheckToastCommon); Checks.Add(CheckDialogCommon); Checks.Add(CheckDialog); Checks.Add(CheckLoadingCommon); Checks.Add(CheckLoading); RunCommand.Subscribe(async _ => { await ToastTest(); await DialogTest(); await LoadingTest(); }); void CheckChange(bool turned) { foreach (var check in Checks) { check.Value = turned; } } AllCheckCommand.Subscribe(_ => CheckChange(true)); NoneCheckCommand.Subscribe(_ => CheckChange(false)); SaveCommand.Subscribe(_ => { for (var i = 0; i < Checks.Count; i++) { Application.Current.Properties[$"check{i}"] = Checks[i].Value; } Application.Current.SavePropertiesAsync(); }); for (var i = 0; i < Checks.Count; i++) { if (Application.Current.Properties.TryGetValue($"check{i}", out var check)) { Checks[i].Value = (bool)check; } } }
public FileCommand(NewCommand newCommand, OpenCommand openCommand, SaveCommand saveCommand, SaveAsCommand saveAsCommand, PrintCommand printCommand, PrintPreviewCommand printPreviewCommand, ExitCommand exitCommand) : base(MenuStrings.fileToolStripMenuItem_Text) { ChildrenCommands = new List <IToolbarCommand> { newCommand, openCommand, null, saveCommand, saveAsCommand, null, printCommand, printPreviewCommand, null, exitCommand }; }
public SettingsViewModel( ISettingsModel settingsModel, LoadCommand loadCommand, SaveCommand saveCommand, SendCommand sendCommand) { this.settingsModel = settingsModel; this.Fields = new ObservableCollection <FieldViewModel>(); this.LoadCommand = loadCommand; this.SaveCommand = saveCommand; this.SendCommand = sendCommand; this.settingsModel.EepromFields.ForEach(f => { this.Fields.Add(new FieldViewModel(f, settingsModel)); }); }
private void OnSaveExecute() { if (EmployeesOnAddedState.Count != 0) { foreach (var employee in EmployeesOnAddedState) { var employeeToAdd = _employeeRepository.GetById(employee.Id); _companyRepository.AttachEmployee(employeeToAdd); Company.Employees.Add(employeeToAdd); } } _companyRepository.Save(); IsDirty = _companyRepository.HasChanges(); SaveCommand.RaiseCanExecuteChanged(); _eventAggregator.GetEvent <CompanySavedEvent>().Publish(Company.Id); }
private async void SelectExecute(GraphModel obj) { if (obj != null && obj.Id != 0) { var blResult = await _graphService.GetByIdAsync(obj.Id); if (blResult.Succeed) { SelectedGraphModel = blResult.Value; SaveCommand.NotifyCanExecuteChanged(); } else { await ShowMessage(blResult.ErrorMessage); } } }
public async Task SaveOrder(T request) { var collection = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, CaseBaseModel> >(CollectionName); using (ITransaction tx = this.stateManager.CreateTransaction()) { await collection.AddAsync(tx, request.Id, request); SaveCommand <T> saveCommand = new SaveCommand <T>(); saveCommand.Data = request; var saveQueue = await stateManager.GetOrAddReactiveReliableQueue <Commands.Command>("case"); await saveQueue.EnqueueAsync(tx, saveCommand); await tx.CommitAsync(); } }
private void raise() { OnPropertyChanged(() => ReportName); OnPropertyChanged(() => ReportDefinition); OnPropertyChanged(() => Description); OnPropertyChanged(() => ScriptingLanguage); OnPropertyChanged(() => Parameters); OnPropertyChanged(() => Dependencies); OnPropertyChanged(() => Author); OnPropertyChanged(() => TemplateFileName); OnPropertyChanged(() => TemplateState); OnPropertyChanged(() => Script); OnPropertyChanged(() => SectionsCV); OnPropertyChanged(() => TemplateText); SaveCommand.RaiseCanExecuteChanged(); }
private void OnTextChanged(EditorInfo info) { if (info.Guid != _guid) { return; } if (info.IsModified || !File.Exists(FileName)) { Status |= TabStatus.NoSave; } else { Status &= ~(TabStatus.NoSave); } SaveCommand.RaiseCanExecuteChanged(); }
protected override async void LoadControl(object param = null) { _attribuetDescriptionService = _attribuetDescriptionService ?? App.Container.Resolve <IAttribuetDescriptionService>(); var blResult = await _attribuetDescriptionService.GetAllAsync(); if (blResult.Succeed) { ConfigureSideBar(blResult.Value.ToObservable()); SideBar.SelectedItem = SideBar.Items.FirstOrDefault(); } else { await ShowMessage(blResult.ErrorMessage); } SaveCommand.NotifyCanExecuteChanged(); }
/// <summary> /// Properties initializer /// </summary> private void Init() { notes = new ObservableCollection <NoteModel>(); notesForLV = new ObservableCollection <NoteModel>(); SaveCommand = new SaveCommand(this); AddCommand = new AddCommand(this); EditCommand = new EditCommand(this); CancelCommand = new CancelCommand(this); DeleteCommand = new DeleteCommand(this); ExitCommand = new ExitCommand(this); FontIncrease = new FontIncrease(this); FontDecrease = new FontDecrease(this); BoldCommand = new BoldCommand(this); ItalicCommand = new ItalicCommand(this); UnderlineCommand = new UnderlineCommand(this); EditMode = false; ReadOnly = true; }
void OnSelectedItemChanged(ProjectItem oldValue, ProjectItem newValue) { if (oldValue != null) { oldValue.TextChanged -= OnTextChanged; } if (newValue != null) { newValue.TextChanged += OnTextChanged; } SaveCommand.RaiseCanExecuteChanged(); SaveAsCommand.RaiseCanExecuteChanged(); CloseAllTabsCommand.RaiseCanExecuteChanged(); CloseCurrentTabCommand.RaiseCanExecuteChanged(); AddNewFolderCommand.RaiseCanExecuteChanged(); ContextMenuAddFolderCommand.RaiseCanExecuteChanged(); RenameCommand.RaiseCanExecuteChanged(); }
protected override void GoBackCommand_Execute() { //если придет запрос при несохраненных изменениях if (SaveCommand.CanExecute()) { var dr = Container.Resolve <IMessageService>().ShowYesNoMessageDialog("Сохранение", "Сохранить сделанные изменения?", defaultNo: true); if (dr == MessageDialogResult.Yes) { SaveCommand.Execute(); } if (dr == MessageDialogResult.No) { IsConfirmGoBackWithoutSaving = true; } } base.GoBackCommand_Execute(); }
private void EditStatement() { _statementvalueList = new List <StatementValues>(); var _avalibleSignalsByName = new List <string>(); foreach (Signal signal in _avalibleSignals) { _avalibleSignalsByName.Add(signal.Name); } var statementVm2 = new StatementVm3(_statementvalueList, _avalibleSignalsByName); var statementView2 = new Views.StatementWindow3(); statementView2.DataContext = statementVm2; statementView2.ShowDialog(); if (statementVm2.VALID_DATA_FLAG) { if (_statementvalueList.Count == 1) { //_trigger.AddStatement(CreateStatement(_statementvalueList.ElementAt(0))); StatementString = _trigger.ToString(); } else { foreach (StatementValues SV in _statementvalueList) { var compoundstatement = new Statement.StatementCollection(); } } _canSave = true; SaveCommand.RaiseCanExecuteChanged(); } else { StatementString = ""; _canSave = false; SaveCommand.RaiseCanExecuteChanged(); } }
/// <summary> /// Ends the edit. /// </summary> /// <param name="commit">if set to <c>true</c> [commit].</param> private void EndEdit(bool commit) { if (this.textBox == null) { return; } var textBoxBindingExpression = this.textBox.GetBindingExpression(TextBox.TextProperty); var textBlockBindingExpression = this.GetBindingExpression(TextProperty); if (commit) { var isDirty = textBoxBindingExpression.IsDirty; if (textBoxBindingExpression != null) { textBoxBindingExpression.UpdateSource(); } if (textBlockBindingExpression != null) { textBlockBindingExpression.UpdateTarget(); } if (isDirty && SaveCommand != null && SaveCommand.CanExecute(null)) { SaveCommand.Execute(null); } } this.internalIsEditingChange = true; this.IsEditing = false; this.internalIsEditingChange = false; var p = (Panel)this.Parent; p.Children.Remove(this.textBox); this.textBox = null; this.Visibility = Visibility.Visible; if (this.oldfocus != null && this.oldfocus.IsVisible) { this.oldfocus.Focus(); } }
public ComposerViewModel(string title, Func <string, Task> saveFunc, IAlertDialogFactory alertDialogFactory) { Title = title; SaveCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.Text).Select(x => !string.IsNullOrEmpty(x)), t => saveFunc(Text)); SaveCommand.AlertExecuting(alertDialogFactory, "Saving..."); SaveCommand.Subscribe(x => Dismiss()); DismissCommand = ReactiveCommand.CreateAsyncTask(async t => { if (string.IsNullOrEmpty(Text)) { return(true); } return(await alertDialogFactory.PromptYesNo("Discard Comment?", "Are you sure you want to discard this comment?")); }); DismissCommand.Where(x => x).Subscribe(_ => Dismiss()); }
public void Test_Document() { DocumentReceiver receiver = new DocumentReceiver(); ICommandDocument openCommand = new OpenCommand(receiver); ICommandDocument closeCommand = new CloseCommand(receiver); ICommandDocument saveCommand = new SaveCommand(receiver); MenuOption menu = new MenuOption ( openCommand: openCommand, saveCommand: saveCommand, closeCommand: closeCommand ); menu.OpenClick(); menu.SaveClick(); menu.CloseClick(); }
public ProductEditModel() { Save = new SaveCommand(); }