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