private static void ValidateFieldNames(IUpsertCommand command, FieldNames?fields, string path, AddValidation e, Func <string, bool> isAllowed)
{
if (fields != null)
{
fields.Foreach((fieldName, fieldIndex) =>
{
var fieldPrefix = $"{path}[{fieldIndex}]";
var field = command?.Fields?.FirstOrDefault(x => x.Name == fieldName);
if (string.IsNullOrWhiteSpace(fieldName))
{
e(Not.Defined("Field"), fieldPrefix);
}
else if (field == null && !isAllowed(fieldName))
{
e(T.Get("schemas.fieldNotInSchema"), fieldPrefix);
}
else if (field?.Properties?.IsUIProperty() == true)
{
e(T.Get("schemas.fieldCannotBeUIField"), fieldPrefix);
}
});
foreach (var duplicate in fields.Duplicates())
{
if (!string.IsNullOrWhiteSpace(duplicate))
{
e(T.Get("schemas.duplicateFieldName", new { field = duplicate }), path);
}
}
}
}
public static void CanReorder(ReorderFields command, Schema schema)
{
Guard.NotNull(command, nameof(command));
IArrayField?arrayField = null;
if (command.ParentFieldId != null)
{
arrayField = GuardHelper.GetArrayFieldOrThrow(schema, command.ParentFieldId.Value, false);
}
Validate.It(e =>
{
if (command.FieldIds == null)
{
e(Not.Defined(nameof(command.FieldIds)), nameof(command.FieldIds));
}
if (arrayField == null)
{
ValidateFieldIds(command, schema.FieldsById, e);
}
else
{
ValidateFieldIds(command, arrayField.FieldsById, e);
}
});
}
private static void ValidateFieldNames(Schema schema, FieldNames?fields, string path, AddValidation e, Func <string, bool> isAllowed)
{
if (fields != null)
{
fields.Foreach((fieldName, fieldIndex) =>
{
var fieldPrefix = $"{path}[{fieldIndex}]";
var field = schema.FieldsByName.GetOrDefault(fieldName ?? string.Empty);
if (string.IsNullOrWhiteSpace(fieldName))
{
e(Not.Defined("Field"), fieldPrefix);
}
else if (field == null && !isAllowed(fieldName))
{
e(T.Get("schemas.fieldNotInSchema"), fieldPrefix);
}
else if (field?.IsUI() == true)
{
e(T.Get("schemas.fieldCannotBeUIField"), fieldPrefix);
}
});
foreach (var duplicate in fields.Duplicates())
{
if (!string.IsNullOrWhiteSpace(duplicate))
{
e(T.Get("schemas.duplicateFieldName", new { field = duplicate }), path);
}
}
}
}
private static void ValidateField(UpsertSchemaFieldBase field, string prefix, AddValidation e)
{
if (!field.Name.IsPropertyName())
{
e(Not.ValidJavascriptName(nameof(field.Name)), $"{prefix}.{nameof(field.Name)}");
}
if (field.Properties == null)
{
e(Not.Defined(nameof(field.Properties)), $"{prefix}.{nameof(field.Properties)}");
}
else
{
if (field.Properties.IsUIProperty())
{
if (field.IsHidden)
{
e(T.Get("schemas.uiFieldCannotBeHidden"), $"{prefix}.{nameof(field.IsHidden)}");
}
if (field.IsDisabled)
{
e(T.Get("schemas.uiFieldCannotBeDisabled"), $"{prefix}.{nameof(field.IsDisabled)}");
}
}
var errors = FieldPropertiesValidator.Validate(field.Properties);
errors.Foreach((x, _) => x.WithPrefix($"{prefix}.{nameof(field.Properties)}").AddTo(e));
}
}
public static void CanChangePlan(ChangePlan command, AppPlan plan, IAppPlansProvider appPlans)
{
Guard.NotNull(command, nameof(command));
Validate.It(() => "Cannot change plan.", e =>
{
if (string.IsNullOrWhiteSpace(command.PlanId))
{
e(Not.Defined("Plan id"), nameof(command.PlanId));
return;
}
if (appPlans.GetPlan(command.PlanId) == null)
{
e("A plan with this id does not exist.", nameof(command.PlanId));
}
if (!string.IsNullOrWhiteSpace(command.PlanId) && plan != null && !plan.Owner.Equals(command.Actor))
{
e("Plan can only changed from the user who configured the plan initially.");
}
if (string.Equals(command.PlanId, plan?.PlanId, StringComparison.OrdinalIgnoreCase))
{
e("App has already this plan.");
}
});
}
public static void CanChangePlan(ChangePlan command, IAppEntity app, IAppPlansProvider appPlans)
{
Guard.NotNull(command);
Validate.It(e =>
{
if (string.IsNullOrWhiteSpace(command.PlanId))
{
e(Not.Defined(nameof(command.PlanId)), nameof(command.PlanId));
return;
}
if (appPlans.GetPlan(command.PlanId) == null)
{
e(T.Get("apps.plans.notFound"), nameof(command.PlanId));
}
var plan = app.Plan;
if (!string.IsNullOrWhiteSpace(command.PlanId) && plan != null && !plan.Owner.Equals(command.Actor))
{
e(T.Get("apps.plans.notPlanOwner"));
}
});
}
public static void CanUpdate(Schema schema, UpdateField command)
{
Guard.NotNull(command, nameof(command));
var field = GuardHelper.GetFieldOrThrow(schema, command.FieldId, command.ParentFieldId);
if (field.IsLocked)
{
throw new DomainException("Schema field is already locked.");
}
Validate.It(() => "Cannot update field.", e =>
{
if (command.Properties == null)
{
e(Not.Defined("Properties"), nameof(command.Properties));
}
else
{
var errors = FieldPropertiesValidator.Validate(command.Properties);
errors.Foreach(x => x.WithPrefix(nameof(command.Properties)).AddTo(e));
}
});
}
public static Task CanCreate(CreateRule command, IAppProvider appProvider)
{
Guard.NotNull(command);
return(Validate.It(() => "Cannot create rule.", async e =>
{
if (command.Trigger == null)
{
e(Not.Defined("Trigger"), nameof(command.Trigger));
}
else
{
var errors = await RuleTriggerValidator.ValidateAsync(command.AppId.Id, command.Trigger, appProvider);
errors.Foreach(x => x.AddTo(e));
}
if (command.Action == null)
{
e(Not.Defined("Action"), nameof(command.Action));
}
else
{
var errors = command.Action.Validate();
errors.Foreach(x => x.AddTo(e));
}
}));
}
public static Task CanUpdate(UpdateRule command, Guid appId, IAppProvider appProvider)
{
Guard.NotNull(command);
return(Validate.It(() => "Cannot update rule.", async e =>
{
if (command.Trigger == null && command.Action == null && command.Name == null)
{
e(Not.Defined("Either trigger, action or name"), nameof(command.Trigger), nameof(command.Action));
}
if (command.Trigger != null)
{
var errors = await RuleTriggerValidator.ValidateAsync(appId, command.Trigger, appProvider);
errors.Foreach(x => x.AddTo(e));
}
if (command.Action != null)
{
var errors = command.Action.Validate();
errors.Foreach(x => x.AddTo(e));
}
}));
}
public static void CanUpdate(LanguagesConfig languages, UpdateLanguage command)
{
Guard.NotNull(command, nameof(command));
var config = GetConfigOrThrow(languages, command.Language);
Validate.It(() => "Cannot update language.", e =>
{
if (command.Language == null)
{
e(Not.Defined("Language code"), nameof(command.Language));
}
if ((languages.Master == config || command.IsMaster) && command.IsOptional)
{
e("Master language cannot be made optional.", nameof(command.IsMaster));
}
if (command.Fallback == null)
{
return;
}
foreach (var fallback in command.Fallback)
{
if (!languages.Contains(fallback))
{
e($"App does not have fallback language '{fallback}'.", nameof(command.Fallback));
}
}
});
}
public static void CanRemove(RemoveContributor command, IAppEntity app)
{
Guard.NotNull(command, nameof(command));
var contributors = app.Contributors;
Validate.It(e =>
{
if (string.IsNullOrWhiteSpace(command.ContributorId))
{
e(Not.Defined(nameof(command.ContributorId)), nameof(command.ContributorId));
}
var ownerIds = contributors.Where(x => x.Value == Role.Owner).Select(x => x.Key).ToList();
if (ownerIds.Count == 1 && ownerIds.Contains(command.ContributorId))
{
e(T.Get("apps.contributors.onlyOneOwner"));
}
});
if (!contributors.ContainsKey(command.ContributorId))
{
throw new DomainObjectNotFoundException(command.ContributorId);
}
}
public static void CanUpdate(UpdateRole command, IAppEntity app)
{
Guard.NotNull(command);
var roles = app.Roles;
CheckRoleExists(roles, command.Name);
Validate.It(e =>
{
if (string.IsNullOrWhiteSpace(command.Name))
{
e(Not.Defined(nameof(command.Name)), nameof(command.Name));
}
else if (Roles.IsDefault(command.Name))
{
e(T.Get("apps.roles.defaultRoleNotUpdateable"));
}
if (command.Permissions == null)
{
e(Not.Defined(nameof(command.Permissions)), nameof(command.Permissions));
}
});
}
public static void CanDelete(DeleteRole command, IAppEntity app)
{
Guard.NotNull(command);
var roles = app.Roles;
CheckRoleExists(roles, command.Name);
Validate.It(e =>
{
if (string.IsNullOrWhiteSpace(command.Name))
{
e(Not.Defined(nameof(command.Name)), nameof(command.Name));
}
else if (Roles.IsDefault(command.Name))
{
e(T.Get("apps.roles.defaultRoleNotRemovable"));
}
if (app.Clients.Values.Any(x => string.Equals(x.Role, command.Name, StringComparison.OrdinalIgnoreCase)))
{
e(T.Get("apps.roles.usedRoleByClientsNotRemovable"));
}
if (app.Contributors.Values.Any(x => string.Equals(x, command.Name, StringComparison.OrdinalIgnoreCase)))
{
e(T.Get("apps.roles.usedRoleByContributorsNotRemovable"));
}
});
}
public async Task <IEnumerable <ValidationError> > Visit(ContentChangedTriggerV2 trigger)
{
var errors = new List <ValidationError>();
if (trigger.Schemas != null)
{
var tasks = new List <Task <ValidationError?> >();
foreach (var schema in trigger.Schemas)
{
if (schema.SchemaId == DomainId.Empty)
{
errors.Add(new ValidationError(Not.Defined("SchemaId"), nameof(trigger.Schemas)));
}
else
{
tasks.Add(CheckSchemaAsync(schema));
}
}
var checkErrors = await Task.WhenAll(tasks);
errors.AddRange(checkErrors.NotNull());
}
return(errors);
}
private static void ValidateField(UpsertSchemaFieldBase field, string prefix, AddValidation e)
{
if (!field.Name.IsPropertyName())
{
e("Field name must be a valid javascript property name.", $"{prefix}.{nameof(field.Name)}");
}
if (field.Properties == null)
{
e(Not.Defined("Field properties"), $"{prefix}.{nameof(field.Properties)}");
}
else
{
if (!field.Properties.IsForApi())
{
if (field.IsHidden)
{
e("UI field cannot be hidden.", $"{prefix}.{nameof(field.IsHidden)}");
}
if (field.IsDisabled)
{
e("UI field cannot be disabled.", $"{prefix}.{nameof(field.IsDisabled)}");
}
}
var errors = FieldPropertiesValidator.Validate(field.Properties);
errors.Foreach(x => x.WithPrefix($"{prefix}.{nameof(field.Properties)}").AddTo(e));
}
}
private static void ValidateData(ContentDataCommand command, AddValidation e)
{
if (command.Data == null)
{
e(Not.Defined("Data"), nameof(command.Data));
}
}
public static void CanUpdate(Workflows workflows, UpdateWorkflow command)
{
Guard.NotNull(command, nameof(command));
CheckWorkflowExists(workflows, command.WorkflowId);
Validate.It(() => "Cannot update workflow.", e =>
{
if (command.Workflow == null)
{
e(Not.Defined("Workflow"), nameof(command.Workflow));
return;
}
var workflow = command.Workflow;
if (!workflow.Steps.ContainsKey(workflow.Initial))
{
e(Not.Defined("Initial step"), $"{nameof(command.Workflow)}.{nameof(workflow.Initial)}");
}
if (workflow.Initial == Status.Published)
{
e("Initial step cannot be published step.", $"{nameof(command.Workflow)}.{nameof(workflow.Initial)}");
}
var stepsPrefix = $"{nameof(command.Workflow)}.{nameof(workflow.Steps)}";
if (!workflow.Steps.ContainsKey(Status.Published))
{
e("Workflow must have a published step.", stepsPrefix);
}
foreach (var step in workflow.Steps)
{
var stepPrefix = $"{stepsPrefix}.{step.Key}";
if (step.Value == null)
{
e(Not.Defined("Step"), stepPrefix);
}
else
{
foreach (var(status, transition) in step.Value.Transitions)
{
var transitionPrefix = $"{stepPrefix}.{nameof(step.Value.Transitions)}.{status}";
if (!workflow.Steps.ContainsKey(status))
{
e("Transition has an invalid target.", transitionPrefix);
}
if (transition == null)
{
e(Not.Defined("Transition"), transitionPrefix);
}
}
}
public static void MustHaveName(this AssetFolderOperation operation, string folderName)
{
if (string.IsNullOrWhiteSpace(folderName))
{
operation.AddError(Not.Defined(nameof(folderName)), "FolderName");
}
operation.ThrowOnErrors();
}
public static void MustHaveData(this ContentOperation operation, ContentData?data)
{
if (data == null)
{
operation.AddError(Not.Defined(nameof(data)), nameof(data));
}
operation.ThrowOnErrors();
}
public static void CanAdd(AddWorkflow command)
{
Guard.NotNull(command, nameof(command));
Validate.It(() => "Cannot add workflow.", e =>
{
if (string.IsNullOrWhiteSpace(command.Name))
{
e(Not.Defined("Name"), nameof(command.Name));
}
});
}
public static void CanConfigurePreviewUrls(ConfigurePreviewUrls command)
{
Guard.NotNull(command, nameof(command));
Validate.It(() => "Cannot configure preview urls.", e =>
{
if (command.PreviewUrls == null)
{
e(Not.Defined("Preview Urls"), nameof(command.PreviewUrls));
}
});
}
public static void CanCreate(CreateComment command)
{
Guard.NotNull(command, nameof(command));
Validate.It(() => "Cannot create comment.", e =>
{
if (string.IsNullOrWhiteSpace(command.Text))
{
e(Not.Defined("Text"), nameof(command.Text));
}
});
}
public static void CanUploadImage(UploadAppImage command)
{
Guard.NotNull(command, nameof(command));
Validate.It(e =>
{
if (command.File == null)
{
e(Not.Defined(nameof(command.File)), nameof(command.File));
}
});
}
public static void CanRename(RenameAssetFolder command)
{
Guard.NotNull(command, nameof(command));
Validate.It(e =>
{
if (string.IsNullOrWhiteSpace(command.FolderName))
{
e(Not.Defined(nameof(command.FolderName)), nameof(command.FolderName));
}
});
}
public static void CanUploadImage(UploadAppImage command)
{
Guard.NotNull(command);
Validate.It(() => "Cannot upload image.", e =>
{
if (command.File == null)
{
e(Not.Defined("File"), nameof(command.File));
}
});
}
public static void CanCreate(CreateComment command)
{
Guard.NotNull(command);
Validate.It(e =>
{
if (string.IsNullOrWhiteSpace(command.Text))
{
e(Not.Defined(nameof(command.Text)), nameof(command.Text));
}
});
}
public static void CanConfigurePreviewUrls(ConfigurePreviewUrls command)
{
Guard.NotNull(command, nameof(command));
Validate.It(e =>
{
if (command.PreviewUrls == null)
{
e(Not.Defined(nameof(command.PreviewUrls)), nameof(command.PreviewUrls));
}
});
}
public static void CanRename(RenameAssetFolder command)
{
Guard.NotNull(command);
Validate.It(() => "Cannot rename asset.", e =>
{
if (string.IsNullOrWhiteSpace(command.FolderName))
{
e(Not.Defined("Folder name"), nameof(command.FolderName));
}
});
}
public static void CanAdd(AddWorkflow command)
{
Guard.NotNull(command);
Validate.It(e =>
{
if (string.IsNullOrWhiteSpace(command.Name))
{
e(Not.Defined(nameof(command.Name)), nameof(command.Name));
}
});
}
public static Task CanAssign(AppContributors contributors, Roles roles, AssignContributor command, IUserResolver users, IAppLimitsPlan plan)
{
Guard.NotNull(command, nameof(command));
return(Validate.It(() => "Cannot assign contributor.", async e =>
{
if (!roles.ContainsKey(command.Role))
{
e(Not.Valid("role"), nameof(command.Role));
}
if (string.IsNullOrWhiteSpace(command.ContributorId))
{
e(Not.Defined("Contributor id"), nameof(command.ContributorId));
}
else
{
var user = await users.FindByIdOrEmailAsync(command.ContributorId);
if (user == null)
{
throw new DomainObjectNotFoundException(command.ContributorId, "Contributors", typeof(IAppEntity));
}
command.ContributorId = user.Id;
if (!command.IsRestore)
{
if (string.Equals(command.ContributorId, command.Actor?.Identifier, StringComparison.OrdinalIgnoreCase))
{
throw new DomainForbiddenException("You cannot change your own role.");
}
if (contributors.TryGetValue(command.ContributorId, out var role))
{
if (role == command.Role)
{
e(Not.New("Contributor", "role"), nameof(command.Role));
}
}
else
{
if (plan.MaxContributors > 0 && contributors.Count >= plan.MaxContributors)
{
e("You have reached the maximum number of contributors for your plan.");
}
}
}
}
}));
}