public Task <INodeUIResolver> GetNodeUIResolverAsync(UsageType usageType, string collectionAlias) { var collection = _collectionResolver.GetCollection(collectionAlias); var node = usageType.HasFlag(UsageType.View) ? collection.NodeView ?? collection.NodeEditor : collection.NodeEditor ?? collection.NodeView; if (node == null) { throw new InvalidOperationException($"Failed to get UI configuration from collection {collectionAlias} for action {usageType}"); } INodeUIResolver nodeUI = new NodeUIResolver(node, _dataProviderResolver, _buttonActionHandlerResolver, _authService, _httpContextAccessor); return(Task.FromResult(nodeUI)); }
public async Task <TreeCollectionUI?> GetCollectionAsync(string alias, ParentPath?parentPath) { var collection = _collectionResolver.GetCollection(alias); if (collection == null) { throw new InvalidOperationException($"Failed to get collection for given alias ({alias})."); } var parent = await _parentService.GetParentAsync(parentPath); var testEntity = await _repositoryResolver.GetRepository(collection).NewAsync(parent, collection.EntityVariant.Type); var tree = new TreeCollectionUI(collection.Alias, collection.Name) { EntitiesVisible = collection.TreeView?.EntityVisibility == EntityVisibilty.Visible, RootVisible = collection.TreeView?.RootVisibility == CollectionRootVisibility.Visible, Icon = collection.Icon ?? "list", DefaultOpenEntities = collection.TreeView?.DefaultOpenEntities ?? false }; if (collection.ListEditor != null && await _authService.IsUserAuthorizedAsync(Operations.Update, testEntity)) { tree.State = new PageStateModel { CollectionAlias = collection.Alias, PageType = PageType.Collection, ParentPath = parentPath, UsageType = UsageType.Edit }; } else if (collection.ListView != null && await _authService.IsUserAuthorizedAsync(Operations.Read, testEntity)) { tree.State = new PageStateModel { CollectionAlias = collection.Alias, PageType = PageType.Collection, ParentPath = parentPath, UsageType = UsageType.View }; } return(tree); }
private (IButtonActionHandler handler, IButtonSetup button) FindButtonHandler(string collectionAlias, string buttonId) { var collection = _collectionResolver.GetCollection(collectionAlias); var button = collection.FindButton(buttonId); if (button == null) { throw new Exception($"Cannot determine which button triggered action for collection {collectionAlias}"); } return(_buttonActionHandlerResolver.GetButtonActionHandler(button), button); }
private async Task <T> InvokeAsync <T>(PersistEntityRequestModel request, T response, IPageState pageState) where T : ViewCommandResponseModel { var collection = _collectionResolver.GetCollection(request.EditContext.CollectionAlias); var repository = _repositoryResolver.GetRepository(collection); var entityVariant = collection.GetEntityVariant(request.EditContext.Entity); var crudType = await _buttonInteraction.ValidateButtonInteractionAsync(request); switch (crudType) { case CrudType.View: pageState.PushState(new PageStateModel { PageType = PageType.Node, UsageType = UsageType.View, CollectionAlias = request.EditContext.CollectionAlias, VariantAlias = entityVariant.Alias, ParentPath = request.EditContext.Parent?.GetParentPath(), Id = request.EditContext.Entity.Id }); break; case CrudType.Edit: pageState.PushState(new PageStateModel { PageType = PageType.Node, UsageType = UsageType.Edit, CollectionAlias = request.EditContext.CollectionAlias, VariantAlias = entityVariant.Alias, ParentPath = request.EditContext.Parent?.GetParentPath(), Id = request.EditContext.Entity.Id }); break; case CrudType.Update: await _concurrencyService.EnsureCorrectConcurrencyAsync(() => repository.UpdateAsync(request.EditContext)); if (request.EditContext.IsReordered()) { await _concurrencyService.EnsureCorrectConcurrencyAsync( () => repository.ReorderAsync(request.EditContext.ReorderedBeforeId, request.EditContext.Entity.Id !, request.EditContext.Parent)); } response.RefreshIds = new[] { request.EditContext.Entity.Id ! };
public async Task <EditContext> GetAsync(GetEntityRequestModel request) { if (string.IsNullOrWhiteSpace(request.Id) && (request.UsageType.HasFlag(UsageType.View) || request.UsageType.HasFlag(UsageType.Edit))) { throw new InvalidOperationException($"Cannot View/Edit Node when id is null"); } if (!string.IsNullOrWhiteSpace(request.Id) && request.UsageType.HasFlag(UsageType.New)) { throw new InvalidOperationException($"Cannot New Node when id is not null"); } var collection = _collectionResolver.GetCollection(request.CollectionAlias); var repository = _repositoryResolver.GetRepository(collection); var parent = await _parentService.GetParentAsync(request.ParentPath); var action = (request.UsageType & ~(UsageType.Node | UsageType.Root | UsageType.NotRoot)) switch { UsageType.View => () => repository.GetByIdAsync(request.Id !, parent), UsageType.Edit => () => repository.GetByIdAsync(request.Id !, parent), UsageType.New => () => repository.NewAsync(parent, collection.GetEntityVariant(request.VariantAlias).Type) !, _ => default(Func <Task <IEntity?> >) }; if (action == default) { throw new InvalidOperationException($"UsageType {request.UsageType} is invalid for this method"); } var entity = await _concurrencyService.EnsureCorrectConcurrencyAsync(action); if (entity == null) { throw new Exception("Failed to get entity for given id(s)"); } await _authService.EnsureAuthorizedUserAsync(request.UsageType, entity); return(new EditContext(request.CollectionAlias, entity, parent, request.UsageType | UsageType.Node, _serviceProvider)); } }
public async Task <ListContext> GetAsync(GetEntitiesRequestModel request) { var collection = _collectionResolver.GetCollection(request.CollectionAlias); var repository = _repositoryResolver.GetRepository(collection); var parent = request is GetEntitiesOfParentRequestModel parentRequest ? await _parentService.GetParentAsync(parentRequest.ParentPath) : default; var relatedEntity = (request as GetEntitiesOfRelationRequestModel)?.Related; var protoEntity = await _concurrencyService.EnsureCorrectConcurrencyAsync(() => repository.NewAsync(parent, collection.EntityVariant.Type)); await _authService.EnsureAuthorizedUserAsync(request.UsageType, protoEntity); await _dataViewResolver.ApplyDataViewToQueryAsync(request.Query, collection); var action = (request.UsageType & ~(UsageType.List | UsageType.Root | UsageType.NotRoot)) switch { UsageType.Add when relatedEntity != null => () => repository.GetAllNonRelatedAsync(relatedEntity !, request.Query), _ when relatedEntity != null => () => repository.GetAllRelatedAsync(relatedEntity !, request.Query), _ when relatedEntity == null => () => repository.GetAllAsync(parent, request.Query), _ => default(Func <Task <IEnumerable <IEntity> > >) }; if (action == default) { throw new InvalidOperationException($"UsageType {request.UsageType} is invalid for this method"); } var existingEntities = await _concurrencyService.EnsureCorrectConcurrencyAsync(action); var protoEditContext = new EditContext(request.CollectionAlias, protoEntity, parent, request.UsageType | UsageType.List, _serviceProvider); return(new ListContext( request.CollectionAlias, protoEditContext, parent, request.UsageType, ConvertEditContexts(request, protoEditContext, existingEntities), _serviceProvider)); }
public IGodzillaCollection <TItem> GetCollection <TItem>() { var collection = _resolver.GetCollection <TItem>(_provider); return(_initializer.CreateCollection(collection)); }
IRepository IRepositoryResolver.GetRepository(string collectionAlias) { return((this as IRepositoryResolver).GetRepository(_collectionResolver.GetCollection(collectionAlias))); }
public virtual IGodzillaCollection <TItem> GetCollection <TItem>(string collectionId) { var collection = _resolver.GetCollection <TItem>(_transactionManager, collectionId, typeof(TItem)); return(_initializer.CreateCollection(collection)); }
private async Task <T> InvokeAsync <T>(PersistEntitiesRequestModel request, T response, IPageState pageState) where T : ViewCommandResponseModel { var collection = _collectionResolver.GetCollection(request.ListContext.CollectionAlias); var repository = _repositoryResolver.GetRepository(collection); var(crudType, entityVariant) = await _buttonInteraction.ValidateButtonInteractionAsync(request); switch (crudType) { case CrudType.Create: if (entityVariant == null) { throw new InvalidOperationException($"Button of type {CrudType.Create} must have an EntityVariant."); } if (response is ListViewCommandResponseModel) { pageState.PushState(new PageStateModel { PageType = PageType.Node, UsageType = UsageType.New, CollectionAlias = request.ListContext.CollectionAlias, VariantAlias = entityVariant.Alias, ParentPath = request.ListContext.Parent?.GetParentPath() }); } else { var currentState = pageState.GetCurrentState(); pageState.PushState(new PageStateModel { PageType = PageType.Collection, UsageType = UsageType.New, CollectionAlias = request.ListContext.CollectionAlias, VariantAlias = entityVariant.Alias, ParentPath = request.ListContext.Parent?.GetParentPath(), // is this the best place here? ActiveTab = currentState?.ActiveTab, CurrentPage = currentState?.CurrentPage ?? 1, MaxPage = currentState?.MaxPage, SearchTerm = currentState?.SearchTerm, }); } break; case CrudType.Update: var affectedEntities = new List <IEntity>(); foreach (var editContext in request.ListContext.EditContexts.Where(f => f.IsModified() || f.IsReordered())) { var innerRequest = new PersistEntityCollectionRequestModel { ActionId = request.ActionId, CustomData = request.CustomData, EditContext = editContext, ListContext = request.ListContext }; await _buttonInteraction.ValidateButtonInteractionAsync(innerRequest); if (editContext.IsModified()) { await _concurrencyService.EnsureCorrectConcurrencyAsync(() => repository.UpdateAsync(editContext)); } if (editContext.IsReordered()) { await _concurrencyService.EnsureCorrectConcurrencyAsync( () => repository.ReorderAsync(editContext.ReorderedBeforeId, editContext.Entity.Id !, editContext.Parent)); } affectedEntities.Add(editContext.Entity); } response.RefreshIds = affectedEntities.SelectNotNull(x => x.Id); break; case CrudType.None: response.NoOp = true; break; case CrudType.Refresh: break; case CrudType.Return: if (pageState.PopState() == null) { pageState.ReplaceState(new PageStateModel { PageType = PageType.Collection, UsageType = collection.ListEditor == null ? UsageType.View : UsageType.Edit, CollectionAlias = request.ListContext.CollectionAlias, ParentPath = request.ListContext.Parent?.GetParentPath() }); } break; case CrudType.Up: if (pageState.PopState() == null) { var(newParentPath, parentCollectionAlias, parentId) = ParentPath.RemoveLevel(request.ListContext.Parent?.GetParentPath()); if (parentCollectionAlias == null) { break; } var parentCollection = _collectionResolver.GetCollection(parentCollectionAlias); pageState.ReplaceState(new PageStateModel { PageType = PageType.Node, UsageType = parentCollection.NodeEditor == null ? UsageType.View : UsageType.Edit, CollectionAlias = parentCollectionAlias, ParentPath = newParentPath, VariantAlias = collection.EntityVariant.Alias, Id = parentId }); } break; case CrudType.Add when request.Related != null: pageState.PushState(new PageStateModel { PageType = PageType.Collection, UsageType = UsageType.Add, CollectionAlias = request.ListContext.CollectionAlias, Related = request.Related }); break; default: throw new InvalidOperationException(); } await _buttonInteraction.CompleteButtonInteractionAsync(request); return(response); }