Task <NodeInListViewCommandResponseModel> IInteractionDispatcher <PersistRelatedEntityRequestModel, NodeInListViewCommandResponseModel> .InvokeAsync(PersistRelatedEntityRequestModel request, IPageState pageState)
{
return(InvokeAsync(request, new NodeInListViewCommandResponseModel(), pageState));
}
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 ! };
Task <ListEditorCommandResponseModel> IInteractionDispatcher <PersistEntitiesRequestModel, ListEditorCommandResponseModel> .InvokeAsync(PersistEntitiesRequestModel request, IPageState pageState)
{
return(InvokeAsync(request, new ListEditorCommandResponseModel(), pageState));
}
private async Task <T> InvokeAsync <T>(PersistEntitiesRequestModel request, T response, IPageState pageState)
where T : ViewCommandResponseModel
{
var collection = _collectionResolver.ResolveSetup(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.ResolveSetup(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);
}
public async Task <ApiCommandResponseModel> InvokeAsync(DeleteEntityRequestModel request, IPageState pageState)
{
if (string.IsNullOrWhiteSpace(request.Descriptor.RepositoryAlias) ||
string.IsNullOrWhiteSpace(request.Descriptor.Id))
{
throw new ArgumentNullException();
}
var parent = await _parentService.GetParentAsync(ParentPath.TryParse(request.Descriptor.ParentPath));
var subjectRepository = _repositoryResolver.GetRepository(request.Descriptor.RepositoryAlias);
var subjectEntity = await subjectRepository.GetByIdAsync(request.Descriptor.Id, parent)
?? throw new NotFoundException("Could not find entity to delete");
await _authService.EnsureAuthorizedUserAsync(Operations.Delete, subjectEntity);
await subjectRepository.DeleteAsync(request.Descriptor.Id, parent);
return(new ApiCommandResponseModel());
}
public async Task <ApiCommandResponseModel> InvokeAsync(PersistReorderRequestModel request, IPageState pageState)
{
if (string.IsNullOrWhiteSpace(request.Subject.RepositoryAlias) ||
string.IsNullOrWhiteSpace(request.Subject.Id))
{
throw new ArgumentNullException();
}
var subjectRepository = _repositoryResolver.GetRepository(request.Subject.RepositoryAlias);
var subjectParent = await _parentService.GetParentAsync(ParentPath.TryParse(request.Subject.ParentPath));
var subjectEntity = await subjectRepository.GetByIdAsync(request.Subject.Id, subjectParent)
?? throw new NotFoundException("Subject entity was not found");
await _authService.EnsureAuthorizedUserAsync(Operations.Update, subjectEntity);
await subjectRepository.ReorderAsync(request.BeforeId, request.Subject.Id, subjectParent);
return(new ApiCommandResponseModel());
}
public async Task <ApiCommandResponseModel> InvokeAsync(PersistEntityRequestModel request, IPageState pageState)
{
if (string.IsNullOrWhiteSpace(request.Descriptor.RepositoryAlias))
{
throw new ArgumentNullException();
}
var parent = await _parentService.GetParentAsync(ParentPath.TryParse(request.Descriptor.ParentPath));
var subjectRepository = _repositoryResolver.GetRepository(request.Descriptor.RepositoryAlias);
var referenceEntity = (request.EntityState == EntityState.IsExisting)
? await subjectRepository.GetByIdAsync(request.Descriptor.Id ?? throw new InvalidOperationException("Cannot modify entity without giving an Id."), parent)
: await subjectRepository.NewAsync(parent, request.Entity.GetType());
if (referenceEntity == null)
{
throw new NotFoundException("Reference entity is null");
}
var usageType = UsageType.Node | (request.EntityState == EntityState.IsNew ? UsageType.New : UsageType.Edit);
await _authService.EnsureAuthorizedUserAsync(usageType, request.Entity);
var editContext = _editContextFactory.GetEditContextWrapper(
usageType,
request.EntityState,
request.Entity,
referenceEntity,
parent,
request.Relations);
try
{
if (!editContext.IsValid())
{
throw new InvalidEntityException();
}
if (request.EntityState == EntityState.IsNew)
{
return(new ApiPersistEntityResponseModel
{
NewEntity = await subjectRepository.InsertAsync(editContext)
});
}
else if (request.EntityState == EntityState.IsExisting)
{
await subjectRepository.UpdateAsync(editContext);
return(new ApiCommandResponseModel());
}
else
{
throw new InvalidOperationException("Invalid usage type");
}
}
catch (InvalidEntityException)
{
return(new ApiPersistEntityResponseModel
{
ValidationErrors = editContext.ValidationErrors
});
}
}
public async Task <ApiCommandResponseModel> InvokeAsync(PersistRelatedEntityRequestModel request, IPageState pageState)
{
if (string.IsNullOrWhiteSpace(request.Subject.RepositoryAlias) ||
string.IsNullOrWhiteSpace(request.Subject.Id) ||
string.IsNullOrWhiteSpace(request.Related.RepositoryAlias) ||
string.IsNullOrWhiteSpace(request.Related.Id))
{
throw new ArgumentNullException();
}
var subjectRepository = _repositoryResolver.GetRepository(request.Subject.RepositoryAlias);
var relatedRepository = _repositoryResolver.GetRepository(request.Related.RepositoryAlias);
var subjectEntity = await subjectRepository.GetByIdAsync(request.Subject.Id, default)
?? throw new NotFoundException("Subject entity was not found");
var relatedEntity = await relatedRepository.GetByIdAsync(request.Related.Id, default)
?? throw new NotFoundException("Related entity was not found");
var parent = await _parentService.GetParentAsync(ParentPath.TryParse(request.Related.ParentPath));
var related = new RelatedEntity(parent, relatedEntity, request.Related.RepositoryAlias);
if (request.Action == PersistRelatedEntityRequestModel.Actions.Add)
{
await _authService.EnsureAuthorizedUserAsync(Operations.Add, subjectEntity);
await subjectRepository.AddAsync(related, request.Subject.Id);
}
else if (request.Action == PersistRelatedEntityRequestModel.Actions.Remove)
{
await _authService.EnsureAuthorizedUserAsync(Operations.Remove, subjectEntity);
await subjectRepository.AddAsync(related, request.Subject.Id);
}
return(new ApiCommandResponseModel());
}
public ViewState(IPageState pageState)
{
PageState = pageState ?? throw new ArgumentNullException(nameof(pageState));
}
