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