private async Task ValidateIsUniqueAsync(
UpdateCustomEntityUrlCommand command,
CustomEntityDefinitionSummary definition,
IExecutionContext executionContext
)
{
if (!definition.ForceUrlSlugUniqueness)
{
return;
}
var query = new IsCustomEntityPathUniqueQuery();
query.CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode;
query.CustomEntityId = command.CustomEntityId;
query.LocaleId = command.LocaleId;
query.UrlSlug = command.UrlSlug;
var isUnique = await _queryExecutor.ExecuteAsync(query, executionContext);
if (!isUnique)
{
var message = string.Format("A {0} already exists with the {2} '{1}'",
definition.Name,
command.UrlSlug,
definition.Terms.GetOrDefault(CustomizableCustomEntityTermKeys.UrlSlug, "url slug").ToLower());
throw new UniqueConstraintViolationException(message, "UrlSlug", command.UrlSlug);
}
}
private CustomEntity MapEntity(AddCustomEntityCommand command, CustomEntityDefinitionSummary definition, IExecutionContext executionContext)
{
var entity = new CustomEntity();
_entityAuditHelper.SetCreated(entity, executionContext);
entity.Locale = GetLocale(command.LocaleId);
entity.UrlSlug = command.UrlSlug;
entity.CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode;
var version = new CustomEntityVersion();
version.Title = command.Title.Trim();
version.SerializedData = _dbUnstructuredDataSerializer.Serialize(command.Model);
version.DisplayVersion = 1;
if (command.Publish)
{
entity.PublishStatusCode = PublishStatusCode.Published;
entity.PublishDate = command.PublishDate ?? executionContext.ExecutionDate;
version.WorkFlowStatusId = (int)WorkFlowStatus.Published;
}
else
{
entity.PublishStatusCode = PublishStatusCode.Unpublished;
entity.PublishDate = command.PublishDate;
version.WorkFlowStatusId = (int)WorkFlowStatus.Draft;
}
_entityAuditHelper.SetCreated(version, executionContext);
entity.CustomEntityVersions.Add(version);
return(entity);
}
/// <summary>
/// Maps a code base custom entity definition into a CustomEntityDefinitionSummary object.
/// </summary>
/// <param name="codeDefinition">Code based definition to map.</param>
public CustomEntityDefinitionSummary Map(ICustomEntityDefinition codeDefinition)
{
if (codeDefinition == null)
{
throw new ArgumentNullException(nameof(codeDefinition));
}
var result = new CustomEntityDefinitionSummary()
{
CustomEntityDefinitionCode = codeDefinition.CustomEntityDefinitionCode,
Description = codeDefinition.Description,
ForceUrlSlugUniqueness = codeDefinition.ForceUrlSlugUniqueness,
Name = codeDefinition.Name,
NamePlural = codeDefinition.NamePlural,
AutoGenerateUrlSlug = codeDefinition.AutoGenerateUrlSlug,
AutoPublish = codeDefinition.AutoPublish,
HasLocale = codeDefinition.HasLocale,
Ordering = CustomEntityOrdering.None
};
result.DataModelType = codeDefinition.GetDataModelType();
result.Terms = codeDefinition.GetTerms();
if (codeDefinition is IOrderableCustomEntityDefinition orderableDefinition)
{
result.Ordering = orderableDefinition.Ordering;
}
return(result);
}
private async Task ValidateIsUniqueAsync(AddCustomEntityCommand command, CustomEntityDefinitionSummary definition)
{
if (!definition.ForceUrlSlugUniqueness)
{
return;
}
var query = GetUniquenessQuery(command, definition);
var isUnique = await _queryExecutor.ExecuteAsync(query);
EnforceUniquenessResult(isUnique, command, definition);
}
private void ValidateCommand(AddCustomEntityCommand command, CustomEntityDefinitionSummary definition)
{
if (definition.AutoGenerateUrlSlug)
{
command.UrlSlug = SlugFormatter.ToSlug(command.Title);
}
else
{
command.UrlSlug = SlugFormatter.ToSlug(command.UrlSlug);
}
if (command.LocaleId.HasValue && !definition.HasLocale)
{
throw new PropertyValidationException(definition.NamePlural + " cannot be assigned locales", "LocaleId");
}
}
/// <summary>
/// Maps a CustomEntityDefinitionSummary into a CustomEntityDefinitionMicroSummary object.
/// </summary>
/// <param name="codeDefinition">Instance to map.</param>
public CustomEntityDefinitionMicroSummary Map(CustomEntityDefinitionSummary summary)
{
if (summary == null)
{
throw new ArgumentNullException(nameof(summary));
}
var result = new CustomEntityDefinitionMicroSummary()
{
CustomEntityDefinitionCode = summary.CustomEntityDefinitionCode,
Description = summary.Description,
ForceUrlSlugUniqueness = summary.ForceUrlSlugUniqueness,
Name = summary.Name,
NamePlural = summary.NamePlural
};
return(result);
}
private async Task SetOrdering(CustomEntity customEntity, CustomEntityDefinitionSummary definition)
{
if (definition.Ordering == CustomEntityOrdering.Full)
{
var maxOrdering = await _dbContext
.CustomEntities
.MaxAsync(e => e.Ordering);
if (maxOrdering.HasValue)
{
// don't worry too much about race conditons here
// if two entities are added at the same time it's no
// big deal if the ordering is tied
customEntity.Ordering = maxOrdering.Value + 1;
}
else
{
customEntity.Ordering = 0;
}
}
}
private async Task <ICustomEntityRoutingRule> GetAndValidateRoutingRuleAsync(
AddPageCommand command,
CustomEntityDefinitionSummary definition,
IExecutionContext executionContext
)
{
var rules = await _queryExecutor.ExecuteAsync(new GetAllCustomEntityRoutingRulesQuery(), executionContext);
var rule = rules.SingleOrDefault(r => r.RouteFormat == command.CustomEntityRoutingRule);
if (rule == null)
{
throw new PropertyValidationException("Routing rule not found", "CustomEntityRoutingRule", command.CustomEntityRoutingRule);
}
if (rule.RequiresUniqueUrlSlug && !definition.ForceUrlSlugUniqueness)
{
throw new PropertyValidationException("Ths routing rule requires a unique url slug, but the selected custom entity does not enforce url slug uniqueness", "CustomEntityRoutingRule");
}
return(rule);
}
private CustomEntity MapEntity(AddCustomEntityCommand command, CustomEntityDefinitionSummary definition, IExecutionContext executionContext)
{
// Create Page
var entity = new CustomEntity();
_entityAuditHelper.SetCreated(entity, executionContext);
entity.Locale = GetLocale(command.LocaleId);
entity.UrlSlug = command.UrlSlug;
entity.CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode;
var version = new CustomEntityVersion();
version.Title = command.Title.Trim();
version.SerializedData = _dbUnstructuredDataSerializer.Serialize(command.Model);
version.WorkFlowStatusId = command.Publish ? (int)WorkFlowStatus.Published : (int)WorkFlowStatus.Draft;
_entityAuditHelper.SetCreated(version, executionContext);
entity.CustomEntityVersions.Add(version);
return(entity);
}
private void Map(UpdateCustomEntityUrlCommand command, CustomEntity entity, CustomEntityDefinitionSummary definition)
{
entity.UrlSlug = command.UrlSlug;
entity.LocaleId = command.LocaleId;
}
private void EnforceUniquenessResult(bool isUnique, AddCustomEntityCommand command, CustomEntityDefinitionSummary definition)
{
if (!isUnique)
{
string message;
string prop;
if (definition.AutoGenerateUrlSlug)
{
// If the slug is autogenerated then we should show the error with the title
message = string.Format("The {1} '{0}' must be unique (symbols and spaces are ignored in the uniqueness check)",
command.Title,
definition.Terms.GetOrDefault(CustomizableCustomEntityTermKeys.Title, "title").ToLower());
prop = "Title";
}
else
{
message = string.Format("The {1} '{0}' must be unique",
command.UrlSlug,
definition.Terms.GetOrDefault(CustomizableCustomEntityTermKeys.UrlSlug, "url slug").ToLower());
prop = "UrlSlug";
}
throw new UniqueConstraintViolationException(message, prop, command.UrlSlug);
}
}
private IsCustomEntityUrlSlugUniqueQuery GetUniquenessQuery(AddCustomEntityCommand command, CustomEntityDefinitionSummary definition)
{
var query = new IsCustomEntityUrlSlugUniqueQuery();
query.CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode;
query.LocaleId = command.LocaleId;
query.UrlSlug = command.UrlSlug;
return(query);
}
private async Task <CustomEntityDefinition> GetAndValidateDbDefinitionAsync(AddCustomEntityCommand command, CustomEntityDefinitionSummary definition)
{
var dbDefinition = await QueryDbDefinition(command).SingleOrDefaultAsync();
// Registrastion is done via code, so if it doesnt exist in the db yet, lets add it
if (dbDefinition == null)
{
await _commandExecutor.ExecuteAsync(new EnsureEntityDefinitionExistsCommand(command.CustomEntityDefinitionCode));
dbDefinition = new CustomEntityDefinition()
{
CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode,
ForceUrlSlugUniqueness = definition.ForceUrlSlugUniqueness,
HasLocale = definition.HasLocale,
IsOrderable = definition.Ordering != CustomEntityOrdering.None
};
_dbContext.CustomEntityDefinitions.Add(dbDefinition);
}
else
{
// update record
dbDefinition.ForceUrlSlugUniqueness = definition.ForceUrlSlugUniqueness;
dbDefinition.HasLocale = definition.HasLocale;
dbDefinition.IsOrderable = definition.Ordering != CustomEntityOrdering.None;
}
return(dbDefinition);
}
private Task <PagedQueryResult <CustomEntityPublishStatusQuery> > RunQueryAsync(SearchCustomEntitySummariesQuery query, CustomEntityDefinitionSummary definition, IExecutionContext executionContext)
{
var dbQuery = _dbContext
.CustomEntityPublishStatusQueries
.AsNoTracking()
.Include(v => v.CustomEntityVersion)
.ThenInclude(v => v.Creator)
.Include(v => v.CustomEntity)
.ThenInclude(c => c.Creator)
.Include(v => v.CustomEntity)
.ThenInclude(c => c.Locale)
.FilterByActive()
.FilterByStatus(PublishStatusQuery.Latest, executionContext.ExecutionDate)
.FilterByCustomEntityDefinitionCode(query.CustomEntityDefinitionCode);
// Filter by locale
if (query.LocaleId > 0)
{
dbQuery = dbQuery.Where(p => p.CustomEntity.LocaleId == query.LocaleId);
}
else if (query.InterpretNullLocaleAsNone)
{
dbQuery = dbQuery.Where(p => !p.CustomEntity.LocaleId.HasValue);
}
if (!string.IsNullOrWhiteSpace(query.Text))
{
dbQuery = dbQuery
.Where(e => e.CustomEntityVersion.Title.Contains(query.Text) || e.CustomEntityVersion.SerializedData.Contains(query.Text))
.OrderByDescending(e => e.CustomEntityVersion.Title == query.Text)
.ThenByDescending(e => e.CustomEntityVersion.Title.Contains(query.Text));
}
else if (definition.Ordering != CustomEntityOrdering.None)
{
dbQuery = dbQuery
.OrderBy(e => e.CustomEntity.Locale.IETFLanguageTag)
.ThenBy(e => !e.CustomEntity.Ordering.HasValue)
.ThenBy(e => e.CustomEntity.Ordering)
.ThenBy(e => e.CustomEntityVersion.Title);
}
else
{
dbQuery = dbQuery
.OrderBy(e => e.CustomEntity.Locale.IETFLanguageTag)
.ThenBy(e => e.CustomEntityVersion.Title);
}
var dbPagedResult = dbQuery.ToPagedResultAsync(query);
return(dbPagedResult);
}
private IQueryable <CustomEntitySummaryQueryModel> GetQuery(SearchCustomEntitySummariesQuery query, CustomEntityDefinitionSummary definition)
{
var dbQuery = _dbContext
.CustomEntityVersions
.AsNoTracking()
.Where(e => e.CustomEntity.CustomEntityDefinitionCode == query.CustomEntityDefinitionCode)
.Where(v => v.WorkFlowStatusId == (int)WorkFlowStatus.Draft || v.WorkFlowStatusId == (int)WorkFlowStatus.Published)
.GroupBy(e => e.CustomEntityId, (key, g) => g.OrderByDescending(v => v.WorkFlowStatusId == (int)WorkFlowStatus.Draft).FirstOrDefault());
// Filter by locale
if (query.LocaleId > 0)
{
dbQuery = dbQuery.Where(p => p.CustomEntity.LocaleId == query.LocaleId);
}
else if (query.InterpretNullLocaleAsNone)
{
dbQuery = dbQuery.Where(p => !p.CustomEntity.LocaleId.HasValue);
}
if (!string.IsNullOrWhiteSpace(query.Text))
{
dbQuery = dbQuery
.Where(e => e.Title.Contains(query.Text) || e.SerializedData.Contains(query.Text))
.OrderByDescending(e => e.Title == query.Text)
.ThenByDescending(e => e.Title.Contains(query.Text));
}
else if (definition.Ordering != CustomEntityOrdering.None)
{
dbQuery = dbQuery
.OrderBy(e => e.CustomEntity.Locale.IETFLanguageTag)
.ThenBy(e => !e.CustomEntity.Ordering.HasValue)
.ThenBy(e => e.CustomEntity.Ordering)
.ThenBy(e => e.Title);
}
else
{
dbQuery = dbQuery
.OrderBy(e => e.CustomEntity.Locale.IETFLanguageTag)
.ThenBy(e => e.Title);
}
return(dbQuery.ProjectTo <CustomEntitySummaryQueryModel>());
}
