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();
}
