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