public async Task <ViewCommand> ProcessRelationActionAsync(UsageType usageType, string collectionAlias, IEntity relatedEntity, IEnumerable <EditContext> editContexts, string actionId, object?customData) { var collection = _collectionProvider.GetCollection(collectionAlias); var button = collection.FindButton(actionId); if (button == null) { throw new Exception($"Cannot determine which button triggered action for collection {collectionAlias}"); } var rootEditContext = await GetRootEditContextAsync(usageType, collectionAlias, null); var newEntity = await EnsureCorrectConcurrencyAsync(() => collection.Repository.NewAsync(null, collection.EntityVariant.Type)); await EnsureAuthorizedUserAsync(rootEditContext, button); ViewCommand viewCommand; var context = new ButtonContext(null, customData); switch (await button.ButtonClickBeforeRepositoryActionAsync(rootEditContext, context)) { case CrudType.Create: if (button.EntityVariant == null) { throw new InvalidOperationException(); } if (usageType.HasFlag(UsageType.List)) { viewCommand = new NavigateCommand { Uri = UriHelper.Node(Constants.New, collectionAlias, button.EntityVariant, default, null) }; }
public Task <CrudType> HandlePaneAsync(Type pane, EditContext editContext, ButtonContext buttonContext, CrudType?defaultCrudType) { var args = new PaneEventArgs(pane, _tcs.Task, editContext, buttonContext, defaultCrudType); OnPaneRequested?.Invoke(null, args); return(_tcs.Task); }
public async Task CompleteButtonInteractionAsync(IListButtonInteractionRequestModel request) { var(handler, button) = FindButtonHandler(request.ListContext.CollectionAlias, request.ActionId); var context = new ButtonContext(request.ListContext.Parent, request.CustomData); await handler.ButtonClickAfterRepositoryActionAsync(button, request.ListContext.ProtoEditContext, context); }
public async Task <(CrudType crudType, IEntityVariantSetup?entityVariant)> ValidateButtonInteractionAsync(IListButtonInteractionRequestModel request) { var(handler, button) = FindButtonHandler(request.ListContext.CollectionAlias, request.ActionId); // NOTE: this might check too much or reject because of the wrong reasons. await _authService.EnsureAuthorizedUserAsync(request.ListContext.ProtoEditContext, button); var context = new ButtonContext(request.ListContext.Parent, request.CustomData); return(await handler.ButtonClickBeforeRepositoryActionAsync(button, request.ListContext.ProtoEditContext, context), button.EntityVariant); }
public async Task <(CrudType crudType, IEntityVariantSetup?entityVariant)> ValidateButtonInteractionAsync(IListButtonInteractionRequestModel request) { var(handler, button) = FindButtonHandler(request.ListContext.CollectionAlias, request.ActionId); // TODO: this can cause an Update action be validated on the root, while it applies to the children (which is also checked) // this could lead to invalid rejection of action await _authService.EnsureAuthorizedUserAsync(request.ListContext.ProtoEditContext, button); var context = new ButtonContext(request.ListContext.Parent, request.CustomData); return(await handler.ButtonClickBeforeRepositoryActionAsync(button, request.ListContext.ProtoEditContext, context), button.EntityVariant); }
public async Task <CrudType> ValidateButtonInteractionAsync(IEditorInListInteractionRequestModel request) { var(handler, button) = FindButtonHandler(request.ListContext.CollectionAlias, request.ActionId); await _authService.EnsureAuthorizedUserAsync(request.EditContext, button); if (handler.RequiresValidForm(button, request.EditContext) && !request.EditContext.IsValid()) { throw new InvalidEntityException(); } var context = new ButtonContext(request.EditContext.Parent, request.CustomData); return(await handler.ButtonClickBeforeRepositoryActionAsync(button, request.EditContext, context)); }
public MainViewModel() { buttonContext = new ButtonContext(); ClickButtonCommand = new Command(arg => ClickButtonMethod()); ClickSearchCommand = new Command(arg => ClickSearchMethod()); ClickTitleCommand = new Command(arg => ClickTitleMethod()); ClickContentCommand = new Command(arg => ClickContentMethod()); ClickPriorityCommand = new Command(arg => ClickPriorityMethod()); ClickDateCommand = new Command(arg => ClickDateMethod()); ClickAddCommand = new Command(arg => ClickAddMethod()); ClickEditCommand = new Command(arg => ClickEditMethod()); ClickDeleteCommand = new Command(arg => ClickDeleteMethod()); s = Shedules_Singleton.getInstance("DbTasks"); Tasks = s.Tasks; ClickEditMethod(); ClickTitleMethod(); }
private Button MakeButton(XivSubRace race, XivGender gender) { var btn = new Button(); var context = new ButtonContext() { Race = race, Gender = gender }; btn.DataContext = context; var text = race.GetDisplayName(); btn.Content = text; btn.Margin = new Thickness(5); btn.Click += Btn_Click; return(btn); }
public PaneRequestEventArgs(Type paneType, FormEditContext editContext, ButtonContext buttonContext) { PaneType = paneType; EditContext = editContext ?? throw new ArgumentNullException(nameof(editContext)); ButtonContext = buttonContext ?? throw new ArgumentNullException(nameof(buttonContext)); }
public override Task <CrudType> ButtonClickBeforeRepositoryActionAsync(ButtonSetup button, FormEditContext editContext, ButtonContext context) => _mediator.NotifyEventAsync(this, new PaneRequestEventArgs(typeof(TSidePane), editContext, context));
public override Task <CrudType> ButtonClickBeforeRepositoryActionAsync(IButton button, EditContext editContext, ButtonContext context) { return(_sidePaneService.HandlePaneAsync(typeof(TSidePane), editContext, context, button.DefaultCrudType)); }
// this method is called just before the IRepository action is performed, based upon the CrudType this button returns public Task <CrudType> ButtonClickBeforeRepositoryActionAsync(IButton button, EditContext editContext, ButtonContext context) { if (editContext.Entity is Tag tag) { tag.Name = Guid.NewGuid().ToString()[0..6];
public async Task <CrudType> ButtonClickBeforeRepositoryActionAsync(ButtonSetup button, FormEditContext editContext, ButtonContext context) { await Task.Delay(1000); // this dictates how the repository must interpret the button action as after the button has been clicked return(CrudType.Refresh); }
public Task ButtonClickAfterRepositoryActionAsync(ButtonSetup button, FormEditContext editContext, ButtonContext context) { // this method is invoked after the repository has performed their action return(Task.CompletedTask); }
public ButtonsController(ButtonContext context) { _context = context; }
private void RegisterEvents() { ButtonContext.RegisterButtonReaction(); ButtonContext.RegisterOnClick(ButtonContext_OnClick); EditableValueChanged += OnEditableValueChanged; }
public override async Task <CrudType> ButtonClickBeforeRepositoryActionAsync(IButton button, FormEditContext editContext, ButtonContext context) { var request = await _navigationHandler.CreateNavigationRequestAsync(button, editContext); if (request != null) { var collection = request.IsPage ? null : _collectionResolver.ResolveSetup(request.CollectionAlias); var pageType = request.IsPage ? PageType.Page : request.IsList ? PageType.Collection : PageType.Node; var usageType = request.IsNew ? UsageType.New : request.IsEdit ? UsageType.Edit : UsageType.View; _mediator.NotifyEvent(this, new NavigationEventArgs(new PageStateModel { CollectionAlias = request.CollectionAlias, Id = request.Id, PageType = pageType, ParentPath = request.ParentPath, UsageType = usageType, VariantAlias = request.VariantAlias ?? collection?.EntityVariant.Alias ?? string.Empty }, true)); } return(CrudType.None); }
public void buttonJoinRoom(ButtonContext button) { joinRoom(button.roomName); }
public virtual Task <CrudType> ButtonClickBeforeRepositoryActionAsync(IButton button, EditContext editContext, ButtonContext context) { return(button.DefaultButtonType switch { DefaultButtonType.New => Task.FromResult(CrudType.Create), DefaultButtonType.SaveNew => Task.FromResult(CrudType.Insert), DefaultButtonType.SaveExisting => Task.FromResult(CrudType.Update), DefaultButtonType.Delete => Task.FromResult(CrudType.Delete), DefaultButtonType.Edit => Task.FromResult(CrudType.Edit), DefaultButtonType.Remove => Task.FromResult(CrudType.Remove), DefaultButtonType.Add => Task.FromResult(CrudType.Add), DefaultButtonType.Pick => Task.FromResult(CrudType.Pick), DefaultButtonType.Return => Task.FromResult(CrudType.Return), DefaultButtonType.Up => Task.FromResult(CrudType.Up), _ => Task.FromResult(CrudType.View), });
public PaneEventArgs(Type paneType, Task returnTask, FormEditContext editContext, ButtonContext buttonContext, CrudType?defaultCrudType) { PaneType = paneType ?? throw new ArgumentNullException(nameof(paneType)); ReturnTask = returnTask ?? throw new ArgumentNullException(nameof(returnTask)); EditContext = editContext ?? throw new ArgumentNullException(nameof(editContext)); ButtonContext = buttonContext ?? throw new ArgumentNullException(nameof(buttonContext)); DefaultCrudType = defaultCrudType; }
public async Task <ViewCommand> ProcessListActionAsync(UsageType usageType, string collectionAlias, ParentPath?parentPath, IEnumerable <EditContext> editContexts, string actionId, object?customData) { var collection = _collectionProvider.GetCollection(collectionAlias); var button = collection.FindButton(actionId); if (button == null) { throw new Exception($"Cannot determine which button triggered action for collection {collectionAlias}"); } var parent = await _parentService.GetParentAsync(parentPath); var rootEditContext = await GetRootEditContextAsync(usageType, collectionAlias, parent); var entity = await EnsureCorrectConcurrencyAsync(() => collection.Repository.NewAsync(parent, collection.EntityVariant.Type)); await EnsureAuthorizedUserAsync(rootEditContext, button); ViewCommand viewCommand; var context = new ButtonContext(parent, customData); switch (await button.ButtonClickBeforeRepositoryActionAsync(rootEditContext, context)) { case CrudType.Create: if (button.EntityVariant == null) { throw new InvalidOperationException($"Button of type {CrudType.Create} must an {nameof(button.EntityVariant)}."); } if (usageType.HasFlag(UsageType.List)) { viewCommand = new NavigateCommand { Uri = UriHelper.Node(Constants.New, collectionAlias, button.EntityVariant, parentPath, null) }; } else { viewCommand = new UpdateParameterCommand { Action = Constants.New, CollectionAlias = collectionAlias, VariantAlias = button.EntityVariant.Alias, ParentPath = parentPath?.ToPathString(), Id = null }; } break; case CrudType.Update: var contextsToProcess = editContexts.Where(x => x.IsModified()).Where(x => button.RequiresValidForm(x) ? x.IsValid() : true); var affectedEntities = new List <IEntity>(); foreach (var editContext in contextsToProcess) { try { await EnsureAuthorizedUserAsync(editContext, button); EnsureValidEditContext(editContext, button); await EnsureCorrectConcurrencyAsync(() => collection.Repository.UpdateAsync(editContext)); affectedEntities.Add(editContext.Entity); } catch (Exception) { // do not care about any exception in this case } } viewCommand = new ReloadCommand(affectedEntities.SelectNotNull(x => x.Id)); break; case CrudType.None: viewCommand = new NoOperationCommand(); break; case CrudType.Refresh: viewCommand = new ReloadCommand(); break; case CrudType.Return: viewCommand = new NavigateCommand { Uri = UriHelper.Collection(Constants.Edit, collectionAlias, parentPath) }; break; case CrudType.Up: var(newParentPath, parentCollectionAlias, parentId) = ParentPath.RemoveLevel(parentPath); if (parentCollectionAlias == null) { return(new NoOperationCommand()); } var parentCollection = _collectionProvider.GetCollection(parentCollectionAlias); viewCommand = new NavigateCommand { Uri = UriHelper.Node( usageType.HasFlag(UsageType.Edit) ? Constants.Edit : Constants.List, parentCollectionAlias, parentCollection.EntityVariant, newParentPath, parentId) }; break; default: throw new InvalidOperationException(); } await button.ButtonClickAfterRepositoryActionAsync(rootEditContext, context); return(viewCommand); }
public async Task <ViewCommand> ProcessRelationActionAsync(UsageType usageType, string collectionAlias, IEntity relatedEntity, IEnumerable <EditContext> editContexts, string actionId, object?customData) { var collection = _collectionProvider.GetCollection(collectionAlias); var button = collection.FindButton(actionId); if (button == null) { throw new Exception($"Cannot determine which button triggered action for collection {collectionAlias}"); } var rootEditContext = await GetRootEditContextAsync(usageType, collectionAlias, null); var newEntity = await EnsureCorrectConcurrencyAsync(() => collection.Repository.InternalNewAsync(null, collection.EntityVariant.Type)); await EnsureAuthorizedUserAsync(rootEditContext, button); ViewCommand viewCommand; var context = new ButtonContext(null, customData); switch (await button.ButtonClickBeforeRepositoryActionAsync(rootEditContext, context)) { case CrudType.Create: if (button.EntityVariant == null) { throw new InvalidOperationException(); } if (usageType.HasFlag(UsageType.List)) { viewCommand = new NavigateCommand { Uri = UriHelper.Node(Constants.New, collectionAlias, button.EntityVariant, null, null) }; } else { viewCommand = new UpdateParameterCommand { Action = Constants.New, CollectionAlias = collectionAlias, VariantAlias = button.EntityVariant.Alias, ParentId = null, Id = null }; } break; case CrudType.Update: var contextsToProcess = editContexts.Where(x => x.IsModified()).Where(x => button.RequiresValidForm(x) ? x.IsValid() : true); var affectedEntities = new List <IEntity>(); foreach (var editContext in contextsToProcess) { try { var updatedEntity = editContext.Entity; await EnsureAuthorizedUserAsync(editContext, button); EnsureValidEditContext(editContext, button); var relationContainer = editContext.GenerateRelationContainer(); await EnsureCorrectConcurrencyAsync(() => collection.Repository.InternalUpdateAsync(updatedEntity.Id, null, updatedEntity, relationContainer)); affectedEntities.Add(updatedEntity); } catch (Exception) { // do not care about exceptions here } } viewCommand = new ReloadCommand(affectedEntities.Select(x => x.Id)); break; case CrudType.Add: viewCommand = new UpdateParameterCommand { Action = Constants.Add, CollectionAlias = collectionAlias, VariantAlias = null, ParentId = null, Id = null }; break; case CrudType.None: viewCommand = new NoOperationCommand(); break; case CrudType.Refresh: viewCommand = new ReloadCommand(); break; case CrudType.Return: viewCommand = new ReturnCommand(); break; default: throw new InvalidOperationException(); } await button.ButtonClickAfterRepositoryActionAsync(rootEditContext, context); return(viewCommand); }
public async Task <CrudType> ButtonClickBeforeRepositoryActionAsync(Button button, EditContext editContext, ButtonContext context) { var i = 0; var max = Convert.ToInt64(context.CustomData); do { await _repository.InsertAsync(context.ParentId, new AzureTableStorageEntity() { Description = $"New New New {i}", Title = $"Item {i}" }, default); }while (++i < max); return(CrudType.Refresh); }
public Task ButtonClickAfterRepositoryActionAsync(Button button, EditContext editContext, ButtonContext context) { return(Task.CompletedTask); }
public async Task <ViewCommand> ProcessEntityActionAsync(UsageType usageType, string collectionAlias, string?parentId, string?id, EditContext editContext, string actionId, object?customData) { var collection = _collectionProvider.GetCollection(collectionAlias); var entityVariant = collection.GetEntityVariant(editContext.Entity); var button = collection.FindButton(actionId); if (button == null) { throw new Exception($"Cannot determine which button triggered action for collection {collectionAlias}"); } await EnsureAuthorizedUserAsync(editContext, button); EnsureValidEditContext(editContext, button); var relationContainer = editContext.GenerateRelationContainer(); ViewCommand viewCommand; var context = new ButtonContext(parentId, customData); switch (await button.ButtonClickBeforeRepositoryActionAsync(editContext, context)) { case CrudType.View: viewCommand = new NavigateCommand { Uri = UriHelper.Node(Constants.View, collectionAlias, entityVariant, parentId, id) }; break; case CrudType.Edit: viewCommand = new NavigateCommand { Uri = UriHelper.Node(Constants.Edit, collectionAlias, entityVariant, parentId, id) }; break; case CrudType.Update: await EnsureCorrectConcurrencyAsync(() => collection.Repository.InternalUpdateAsync(id ?? throw new InvalidOperationException(), parentId, editContext.Entity, relationContainer)); viewCommand = new ReloadCommand(id); break; case CrudType.Insert: var entity = await EnsureCorrectConcurrencyAsync(() => collection.Repository.InternalInsertAsync(parentId, editContext.Entity, relationContainer)); if (entity == null) { throw new Exception("Inserting the new entity failed."); } editContext.SwapEntity(entity); viewCommand = new NavigateCommand { Uri = UriHelper.Node(Constants.Edit, collectionAlias, entityVariant, parentId, editContext.Entity.Id) }; break; case CrudType.Delete: await EnsureCorrectConcurrencyAsync(() => collection.Repository.InternalDeleteAsync(id ?? throw new InvalidOperationException(), parentId)); viewCommand = new NavigateCommand { Uri = UriHelper.Collection(Constants.List, collectionAlias, parentId) }; break; case CrudType.None: viewCommand = new NoOperationCommand(); break; case CrudType.Refresh: viewCommand = new ReloadCommand(); break; case CrudType.Return: viewCommand = new ReturnCommand(); break; default: throw new InvalidOperationException(); } await button.ButtonClickAfterRepositoryActionAsync(editContext, context); return(viewCommand); }
public CanvasController(ButtonContext context) { _context = context; }
public async Task <ViewCommand> ProcessRelationActionAsync(UsageType usageType, string collectionAlias, IEntity relatedEntity, string id, EditContext editContext, string actionId, object?customData) { var collection = _collectionProvider.GetCollection(collectionAlias); var button = collection.FindButton(actionId); if (button == null) { throw new Exception($"Cannot determine which button triggered action for collection {collectionAlias}"); } await EnsureAuthorizedUserAsync(editContext, button); EnsureValidEditContext(editContext, button); var relationContainer = editContext.GenerateRelationContainer(); // since the id is known, get the entity variant from the entity var entityVariant = collection.GetEntityVariant(editContext.Entity); ViewCommand viewCommand; var context = new ButtonContext(null, customData); switch (await button.ButtonClickBeforeRepositoryActionAsync(editContext, context)) { case CrudType.View: viewCommand = new NavigateCommand { Uri = UriHelper.Node(Constants.View, collectionAlias, entityVariant, null, id) }; break; case CrudType.Edit: viewCommand = new NavigateCommand { Uri = UriHelper.Node(Constants.Edit, collectionAlias, entityVariant, null, id) }; break; case CrudType.Update: await EnsureCorrectConcurrencyAsync(() => collection.Repository.InternalUpdateAsync(id, null, editContext.Entity, relationContainer)); viewCommand = new ReloadCommand(id); break; case CrudType.Insert: var insertedEntity = await EnsureCorrectConcurrencyAsync(() => collection.Repository.InternalInsertAsync(null, editContext.Entity, relationContainer)); if (insertedEntity == null) { throw new Exception("Inserting the new entity failed."); } editContext.SwapEntity(insertedEntity); await EnsureCorrectConcurrencyAsync(() => collection.Repository.InternalAddAsync(relatedEntity, editContext.Entity.Id)); viewCommand = new UpdateParameterCommand { Action = Constants.New, CollectionAlias = collectionAlias, VariantAlias = entityVariant.Alias, ParentId = null, Id = editContext.Entity.Id }; break; case CrudType.Delete: await EnsureCorrectConcurrencyAsync(() => collection.Repository.InternalDeleteAsync(id, null)); viewCommand = new ReloadCommand(); break; case CrudType.Pick: await EnsureCorrectConcurrencyAsync(() => collection.Repository.InternalAddAsync(relatedEntity, id)); viewCommand = new ReloadCommand(); break; case CrudType.Remove: await EnsureCorrectConcurrencyAsync(() => collection.Repository.InternalRemoveAsync(relatedEntity, id)); viewCommand = new ReloadCommand(); break; case CrudType.None: viewCommand = new NoOperationCommand(); break; case CrudType.Refresh: viewCommand = new ReloadCommand(); break; default: throw new InvalidOperationException(); } await button.ButtonClickAfterRepositoryActionAsync(editContext, context); return(viewCommand); }
private void RegisterEvents() { ButtonContext.RegisterButtonReaction(0.05f); }
public virtual Task <CrudType> ButtonClickBeforeRepositoryActionAsync(Button button, EditContext editContext, ButtonContext context) { switch (button.DefaultButtonType) { case DefaultButtonType.New: return(Task.FromResult(CrudType.Create)); case DefaultButtonType.SaveNew: return(Task.FromResult(CrudType.Insert)); case DefaultButtonType.SaveExisting: return(Task.FromResult(CrudType.Update)); case DefaultButtonType.Delete: return(Task.FromResult(CrudType.Delete)); case DefaultButtonType.Edit: return(Task.FromResult(CrudType.Edit)); default: case DefaultButtonType.View: return(Task.FromResult(CrudType.View)); case DefaultButtonType.Remove: return(Task.FromResult(CrudType.Remove)); case DefaultButtonType.Add: return(Task.FromResult(CrudType.Add)); case DefaultButtonType.Pick: return(Task.FromResult(CrudType.Pick)); case DefaultButtonType.Return: return(Task.FromResult(CrudType.Return)); } }
public override async Task <CrudType> ButtonClickBeforeRepositoryActionAsync(ButtonSetup button, FormEditContext editContext, ButtonContext context) { var request = await _navigationHandler.CreateNavigationRequestAsync(button, editContext); if (request != null) { var collection = request.IsPage ? null : await _collectionResolver.ResolveSetupAsync(request.CollectionAlias); var usageType = request.IsNew ? UsageType.New : request.IsEdit ? UsageType.Edit : UsageType.View; NavigationState navigationState; if (request.IsPage) { navigationState = new NavigationState(request.CollectionAlias, usageType); } else if (request.IsList) { navigationState = new NavigationState(request.CollectionAlias, request.ParentPath, usageType); } else { navigationState = new NavigationState(request.CollectionAlias, request.ParentPath, request.VariantAlias ?? collection !.EntityVariant.Alias, request.Id, usageType); } _navigationStateProvider.AppendNavigationState(navigationState); } return(CrudType.None); }