public IEditContext GetEditContextWrapper(FormEditContext editContext)
{
var contextType = typeof(FormEditContextWrapper <>).MakeGenericType(editContext.Entity.GetType());
var instance = Activator.CreateInstance(contextType, editContext);
return((IEditContext)instance);
}
public override Task SetParametersAsync(ParameterView parameters)
{
parameters.SetParameterProperties(this);
if (EditContext == null)
{
if (CascadedEditContext == null)
{
throw new InvalidOperationException($"{GetType()} requires a CascadingParameter {nameof(EditContext)}.");
}
EditContext = CascadedEditContext;
AttachValidationStateChangedListener();
}
else if (EditContext != CascadedEditContext)
{
DetachValidationStateChangedListener();
EditContext = CascadedEditContext;
AttachValidationStateChangedListener();
}
return(base.SetParametersAsync(ParameterView.Empty));
}
public OperationAuthorizationRequirement GetOperation(ButtonSetup button, FormEditContext editContext)
{
// use the RapidCMS.Core.Authorization.Operations to define what action this button represents
// and how the authorization handler must challenge the current logged in user with to see whether they
// can actually perform this action
return(Operations.Delete);
}
private static void AddAttributes(this RenderTreeBuilder builder, FormEditContext editContext, ExpressionFieldUI expressionField)
{
builder.AddAttribute(1, nameof(BaseDisplay.Entity), editContext.Entity);
builder.AddAttribute(2, nameof(BaseDisplay.EntityState), editContext.EntityState);
builder.AddAttribute(3, nameof(BaseDisplay.Parent), editContext.Parent);
builder.AddAttribute(4, nameof(BaseDisplay.Expression), expressionField.Expression);
}
public IEditContext GetEditContextWrapper(FormEditContext editContext)
{
var contextType = typeof(FormEditContextWrapper <>).MakeGenericType(editContext.Entity.GetType());
var instance = Activator.CreateInstance(contextType, editContext);
return(instance as IEditContext ?? throw new InvalidOperationException("Cannot create FormEditContextWrapper"));
}
public async Task EnsureAuthorizedUserAsync(FormEditContext editContext, ButtonSetup button)
{
if (!await IsUserAuthorizedAsync(editContext, button))
{
throw new UnauthorizedAccessException();
}
}
public Task SetEntityAsync(FormEditContext editContext, IParent?parent)
{
_editContext = editContext;
_parent = parent;
var data = _relatedElementsGetter?.Getter(_property.Getter(_editContext.Entity)) ?? _property.Getter(_editContext.Entity);
if (data is IEnumerable <IEntity> entityCollection)
{
_relatedIds = entityCollection.Select(x => (object)x.Id !).ToList();
}
else if (data is IEnumerable <object> objectCollection)
{
_relatedIds = objectCollection.ToList();
}
else if (data is IEnumerable enumerable && data is not string)
{
var list = new List <object>();
foreach (var element in enumerable)
{
if (element != null)
{
list.Add(element);
}
}
_relatedIds = list;
}
return(Task.CompletedTask);
}
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 Task <CrudType> HandlePaneAsync(Type pane, FormEditContext 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 <IEnumerable <SectionUI> > GetSectionsForEditContextAsync(FormEditContext editContext, NavigationState navigationState)
{
var type = editContext.Entity.GetType();
return(await _list.Panes
.Where(pane => pane.VariantType.IsSameTypeOrDerivedFrom(type))
.ToListAsync(pane => GetSectionUIAsync(pane, editContext, navigationState)));
}
private static void AddAttributes(this RenderTreeBuilder builder, FormEditContext editContext, PropertyFieldUI propertyField)
{
builder.AddAttribute(1, nameof(BaseEditor.Entity), editContext.Entity);
builder.AddAttribute(2, nameof(BaseEditor.EntityState), editContext.EntityState);
builder.AddAttribute(3, nameof(BaseEditor.Parent), editContext.Parent);
builder.AddAttribute(4, nameof(BaseEditor.Property), propertyField.Property);
builder.AddAttribute(5, nameof(BaseEditor.IsDisabledFunc), propertyField.IsDisabled);
builder.AddAttribute(6, nameof(BaseEditor.Placeholder), propertyField.Placeholder);
}
public void NotifyClick(FormEditContext editContext, object?customData)
{
OnClick?.Invoke(this, new ButtonClickEventArgs
{
ViewModel = this,
EditContext = editContext,
Data = customData
});
}
public IEditContext GetEditContextWrapper(FormEditContext editContext)
{
var collection = _collectionResolver.ResolveSetup(editContext.CollectionAlias);
var contextType = typeof(FormEditContextWrapper <>).MakeGenericType(collection.EntityVariant.Type);
var instance = Activator.CreateInstance(contextType, editContext);
return((IEditContext)instance);
}
public async Task <IEnumerable <ButtonUI> > GetButtonsForEditContextAsync(FormEditContext editContext)
{
if (_node.Buttons == null)
{
return(Enumerable.Empty <ButtonUI>());
}
return(await GetButtonsAsync(_node.Buttons, editContext));
}
public IEditContext GetEditContextWrapper(FormEditContext editContext)
{
var collection = _collectionResolver.ResolveSetup(editContext.CollectionAlias);
var contextType = typeof(FormEditContextWrapper <>).MakeGenericType(collection.EntityVariant.Type);
var instance = Activator.CreateInstance(contextType, editContext);
return(instance as IEditContext ?? throw new InvalidOperationException("Cannot create FormEditContextWrapper"));
}
public void Setup()
{
_subject = new FormEditContext(
"alias",
"repoAlias",
"variantAlias",
new Entity {
Id = "1"
},
public async Task <IEnumerable <TabUI>?> GetTabsAsync(FormEditContext editContext)
{
var data = await _dataViewResolver.GetDataViewsAsync(editContext.CollectionAlias);
return(data.ToList(x => new TabUI(x.Id)
{
Label = x.Label
}));
}
public async Task WhenInvalidEntityIsValidated_ThenIsValidShouldReturnFalseAsync()
{
_serviceCollection.AddSingleton <EntityValidator>();
_subject = new FormEditContext(
"alias",
"repoAlias",
"variantAlias",
new Entity(),
public void Setup()
{
_serviceCollection.AddSingleton <DataAnnotationEntityValidator>();
_subject = new FormEditContext(
"alias",
"repoAlias",
"variantAlias",
new Entity {
Id = "1"
},
public async Task <ListContext> GetAsync(GetEntitiesRequestModel request)
{
var collection = await _collectionResolver.ResolveSetupAsync(request.CollectionAlias);
var variant = collection.GetEntityVariant(request.VariantAlias);
var repository = _repositoryResolver.GetRepository(collection);
var requestedEntityVariantIsDefaultVariant = variant.Alias == collection.EntityVariant.Alias;
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(new ViewContext(collection.Alias, parent), collection.EntityVariant.Type));
var newEntity = requestedEntityVariantIsDefaultVariant
? protoEntity
: await _concurrencyService.EnsureCorrectConcurrencyAsync(() => repository.NewAsync(new ViewContext(collection.Alias, parent), variant.Type));
await _authService.EnsureAuthorizedUserAsync(request.UsageType, protoEntity);
await _dataViewResolver.ApplyDataViewToViewAsync(request.View);
var action = (request.UsageType & ~(UsageType.List)) switch
{
UsageType.Add when relatedEntity != null => () => repository.GetAllNonRelatedAsync(new RelatedViewContext(relatedEntity !, collection.Alias, parent), request.View),
_ when relatedEntity != null => () => repository.GetAllRelatedAsync(new RelatedViewContext(relatedEntity !, collection.Alias, parent), request.View),
_ when relatedEntity == null => () => repository.GetAllAsync(new ViewContext(collection.Alias, parent), request.View),
_ => default(Func <Task <IEnumerable <IEntity> > >)
};
if (action == default)
{
throw new InvalidOperationException($"UsageType {request.UsageType} is invalid for this method");
}
var isRoot = parent == null || request.IsEmbedded;
var protoEditContextUsage = request.UsageType | (isRoot ? UsageType.Root : UsageType.NotRoot);
var protoEditContext = new FormEditContext(request.CollectionAlias, collection.RepositoryAlias, collection.EntityVariant.Alias, protoEntity, parent, protoEditContextUsage | UsageType.List, collection.Validators, _serviceProvider);
var newEditContext = new FormEditContext(request.CollectionAlias, collection.RepositoryAlias, variant.Alias, newEntity, parent, request.UsageType | UsageType.Node, collection.Validators, _serviceProvider);
var existingEntities = await _concurrencyService.EnsureCorrectConcurrencyAsync(action);
return(new ListContext(
request.CollectionAlias,
protoEditContext,
parent,
request.UsageType,
ConvertEditContexts(request, protoEditContext, newEditContext, existingEntities),
_serviceProvider));
}
internal ButtonUI(IButtonActionHandler handler, IButtonSetup button, FormEditContext editContext)
{
ButtonId = button.ButtonId ?? throw new ArgumentNullException(nameof(button.ButtonId));
Icon = button.Icon;
Label = button.Label;
ShouldConfirm = handler.ShouldAskForConfirmation(button, editContext);
IsPrimary = button.IsPrimary;
RequiresValidForm = handler.RequiresValidForm(button, editContext);
CustomType = button.CustomType;
}
public async Task <IEnumerable <SectionUI> > GetSectionsForEditContextAsync(FormEditContext editContext)
{
if (_node.Panes == null)
{
return(Enumerable.Empty <SectionUI>());
}
var type = editContext.Entity.GetType();
return(await _node.Panes
.Where(pane => pane.VariantType.IsSameTypeOrBaseTypeOf(type))
.ToListAsync(pane => GetSectionUIAsync(pane, editContext)));
}
public async Task NotifyClickAsync(FormEditContext editContext, object?customData)
{
var task = OnClick?.InvokeAsync(new ButtonClickEventArgs
{
ViewModel = this,
EditContext = editContext,
Data = customData
});
if (task != null)
{
await task;
}
}
public Task SetEntityAsync(FormEditContext editContext, IParent?parent)
{
if (_editContext != null)
{
_editContext.OnFieldChanged -= EditContext_OnFieldChanged;
}
_editContext = editContext;
if (_editContext.Entity is PropertyModel property)
{
_editContext.OnFieldChanged += EditContext_OnFieldChanged;
_property = property;
}
return(Task.CompletedTask);
}
public async Task SetEntityAsync(FormEditContext editContext, IParent?parent)
{
_editContext = editContext;
_parent = parent;
await SetElementsAsync();
var data = _setup.RelatedElementsGetter?.Getter(_property.Getter(_editContext.Entity)) ?? _property.Getter(_editContext.Entity);
if (data is ICollection <IEntity> entityCollection)
{
_relatedIds = entityCollection.Select(x => (object)x.Id !).ToList();
}
else if (data is ICollection <object> objectCollection)
{
_relatedIds = objectCollection;
}
else if (data is IEnumerable enumerable)
{
var list = new List <object>();
foreach (var element in enumerable)
{
if (element != null)
{
list.Add(element);
}
}
_relatedIds = list;
}
else
{
return;
}
UpdateRelatedElements();
}
protected internal async Task <SectionUI> GetSectionUIAsync(PaneSetup pane, FormEditContext editContext)
{
var fields = pane.Fields.Select(field =>
{
var dataProvider = _dataProviderResolver.GetDataProvider(field);
if (dataProvider != null)
{
editContext.DataProviders.Add(dataProvider);
}
return(index: field.Index, element: (ElementUI)GetField(field, dataProvider));
});
var subCollections = pane.SubCollectionLists.Select(subCollection =>
{
return(index: subCollection.Index, element: (ElementUI) new SubCollectionUI(subCollection));
});
var relatedCollections = pane.RelatedCollectionLists.Select(relatedCollection =>
{
return(index: relatedCollection.Index, element: (ElementUI) new RelatedCollectionUI(relatedCollection));
});
return(new SectionUI(pane.IsVisible)
{
Buttons = await GetButtonsAsync(pane.Buttons, editContext),
CustomType = pane.CustomType,
Label = pane.Label,
Elements = fields
.Union(subCollections)
.Union(relatedCollections)
.OrderBy(x => x.index)
.ToList(x => x.element)
});
}
private List <FormEditContext> ConvertEditContexts(
GetEntitiesRequestModel request,
FormEditContext protoEditContext,
FormEditContext newEditContext,
IEnumerable <IEntity> existingEntities)
{
if (request.UsageType.HasFlag(UsageType.Add))
{
return(existingEntities
.Select(ent => new FormEditContext(protoEditContext, ent, UsageType.Node | UsageType.Pick, _serviceProvider))
.ToList());
}
else if (request.UsageType.HasFlag(UsageType.Edit) || request.UsageType.HasFlag(UsageType.New))
{
var entities = existingEntities
.Select(ent => new FormEditContext(protoEditContext, ent, UsageType.Node | UsageType.Edit, _serviceProvider))
.ToList();
if (request.UsageType.HasFlag(UsageType.New))
{
entities.Insert(0, newEditContext);
}
return(entities);
}
else if (request.UsageType.HasFlag(UsageType.View))
{
return(existingEntities
.Select(ent => new FormEditContext(protoEditContext, ent, UsageType.Node | UsageType.View, _serviceProvider))
.ToList());
}
else
{
throw new InvalidOperationException($"Failed to process {request.UsageType} for collection {request.CollectionAlias}");
}
}
public Task SetEntityAsync(FormEditContext editContext, IParent?parent)
{
return(Task.CompletedTask);
}
public Task <bool> IsUserAuthorizedAsync(FormEditContext editContext, ButtonSetup button)
{
throw new NotImplementedException("This method is not implemented in ApiAuthService as it makes no sense here.");
}
protected async Task <List <ButtonUI> > GetButtonsAsync(IEnumerable <IButtonSetup> buttons, FormEditContext editContext)
{
return(await buttons
.GetAllButtons()
.SelectNotNullAsync(async button =>
{
var handler = _buttonActionHandlerResolver.GetButtonActionHandler(button);
if (handler.IsCompatible(button, editContext) &&
await _authService.IsUserAuthorizedAsync(editContext, button))
{
return new ButtonUI(handler, button, editContext);
}
else
{
return default;
}
})
.ToListAsync());
}
