/// <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 static void ValidateDefinitionExists(ICustomEntityDefinition definition, string identifier) { if (definition == null) { throw new EntityNotFoundException <ICustomEntityDefinition>($"ICustomEntityDefinition '{identifier}' is not registered. but has been requested.", identifier); } }
public CustomEntityDynamicEntityDefinition(ICustomEntityDefinition customEntityDefinition) { Condition.Requires(customEntityDefinition).IsNotNull(); EntityDefinitionCode = customEntityDefinition.CustomEntityDefinitionCode; Name = customEntityDefinition.Name; }
/// <summary> /// Consructs a new instance of InvalidCustomEntityDefinitionException. /// </summary> /// <param name="message">The exception message.</param> /// <param name="invalidDefinition">The custom entity definition that caused the exception.</param> /// <param name="allCustomEntityDefinitions">Optional collection of all the custom entity definitions when available.</param> public InvalidCustomEntityDefinitionException( string message, ICustomEntityDefinition invalidDefinition, IEnumerable <ICustomEntityDefinition> allCustomEntityDefinitions = null ) : base(message) { InvalidDefinition = invalidDefinition; AllDefinitions = allCustomEntityDefinitions?.ToArray(); }
public CustomEntityDynamicEntityDefinition(ICustomEntityDefinition customEntityDefinition) { if (customEntityDefinition == null) { throw new ArgumentNullException(nameof(customEntityDefinition)); } EntityDefinitionCode = customEntityDefinition.CustomEntityDefinitionCode; Name = customEntityDefinition.Name; }
public CustomEntityPermissionBuilder( ICustomEntityDefinition customEntityDefinition, IPermissionSetBuilder permissionSetBuilder, bool isIncludeOperation ) : base(permissionSetBuilder, isIncludeOperation) { if (customEntityDefinition == null) { throw new ArgumentNullException(nameof(customEntityDefinition)); } _customEntityDefinition = customEntityDefinition; }
private static IOrderedQueryable <CustomEntityPublishStatusQuery> SortByOrdering( IQueryable <CustomEntityPublishStatusQuery> dbQuery, SortDirection sortDirection, ICustomEntityDefinition definition ) { var primarySorted = dbQuery .OrderByWithSortDirection(e => e.CustomEntity.Locale.IETFLanguageTag, sortDirection) .ThenByWithSortDirection(e => !e.CustomEntity.Ordering.HasValue, sortDirection) .ThenByWithSortDirection(e => e.CustomEntity.Ordering, sortDirection); // Partially ordered entities will need a secondary sort level defined if (definition is ISortedCustomEntityDefinition sortedDefinition) { // secondary sort direction can be different if (sortDirection == SortDirection.Default) { sortDirection = sortedDefinition.DefaultSortDirection; } else { // Flip the secondary sort direction if the requested sort direction is reversed sortDirection = sortedDefinition.DefaultSortDirection == SortDirection.Default ? SortDirection.Reversed : SortDirection.Default; } switch (sortedDefinition.DefaultSortType) { case CustomEntityQuerySortType.Default: case CustomEntityQuerySortType.Natural: case CustomEntityQuerySortType.Title: return(primarySorted.ThenByWithSortDirection(e => e.CustomEntityVersion.Title, sortDirection)); case CustomEntityQuerySortType.Locale: return(primarySorted .ThenByWithSortDirection(e => e.CustomEntity.Locale.IETFLanguageTag, sortDirection) .ThenByWithSortDirection(e => e.CustomEntityVersion.Title, sortDirection)); case CustomEntityQuerySortType.CreateDate: return(primarySorted.ThenByDescendingWithSortDirection(e => e.CustomEntity.CreateDate, sortDirection)); case CustomEntityQuerySortType.PublishDate: return(primarySorted.ThenByDescendingWithSortDirection(e => e.CustomEntity.PublishDate ?? e.CustomEntityVersion.CreateDate, sortDirection)); default: throw new Exception($"{nameof(CustomEntityQuerySortType)} not recognised: {sortedDefinition.DefaultSortType}"); } } // default secondary sorting return(primarySorted.ThenByWithSortDirection(e => e.CustomEntityVersion.Title, sortDirection)); }
public ContentRepositoryCustomEntityByUrlSlugQueryBuilder( IExtendableContentRepository contentRepository, ICustomEntityDefinition customEntityDefinition, string urlSlug ) { if (customEntityDefinition == null) { throw new ArgumentNullException(nameof(customEntityDefinition)); } ExtendableContentRepository = contentRepository; _customEntityDefinition = customEntityDefinition; _urlSlug = urlSlug; }
/// <summary> /// If the url slug is autogenerated, we need to update it only when the custom entity is published. /// </summary> private async Task UpdateUrlSlugIfRequired(CustomEntityVersion dbVersion, ICustomEntityDefinition definition) { if (!definition.AutoGenerateUrlSlug) { return; } var urlCommand = new UpdateCustomEntityUrlCommand() { CustomEntityId = dbVersion.CustomEntityId, LocaleId = dbVersion.CustomEntity.LocaleId, UrlSlug = SlugFormatter.ToSlug(dbVersion.Title) }; await _commandExecutor.ExecuteAsync(urlCommand); }
private Task <PagedQueryResult <CustomEntityPublishStatusQuery> > RunQueryAsync( SearchCustomEntitySummariesQuery query, ICustomEntityDefinition definition, IExecutionContext executionContext ) { var dbQuery = _dbContext .CustomEntityPublishStatusQueries .AsNoTracking() .Include(v => v.CustomEntityVersion) .ThenInclude(v => v.Creator) .Include(v => v.CustomEntity) .ThenInclude(c => c.Creator) .FilterActive() .FilterByDate(c => c.CustomEntity.CreateDate, query.CreatedAfter, query.CreatedBefore) .FilterByStatus(PublishStatusQuery.Latest, executionContext.ExecutionDate) .FilterByCustomEntityDefinitionCode(query.CustomEntityDefinitionCode); // Filter by locale if (query.LocaleId > 0 && definition.HasLocale) { 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 { dbQuery = dbQuery .SortBy(definition, CustomEntityQuerySortType.Default); } var dbPagedResult = dbQuery.ToPagedResultAsync(query); return(dbPagedResult); }
/// <summary> /// Maps a code base custom entity definition into a CustomEntityDefinitionMicroSummary object. /// </summary> /// <param name="codeDefinition">Code based definition to map.</param> public CustomEntityDefinitionMicroSummary Map(ICustomEntityDefinition codeDefinition) { if (codeDefinition == null) { throw new ArgumentNullException(nameof(codeDefinition)); } var result = new CustomEntityDefinitionMicroSummary() { CustomEntityDefinitionCode = codeDefinition.CustomEntityDefinitionCode, Description = codeDefinition.Description, ForceUrlSlugUniqueness = codeDefinition.ForceUrlSlugUniqueness, Name = codeDefinition.Name, NamePlural = codeDefinition.NamePlural }; return(result); }
private async Task ValidateTitleAsync(CustomEntityVersion dbVersion, ICustomEntityDefinition definition, IExecutionContext executionContext) { if (!definition.ForceUrlSlugUniqueness || SlugFormatter.ToSlug(dbVersion.Title) == dbVersion.CustomEntity.UrlSlug) { return; } var query = GetUniquenessQuery(dbVersion, definition); var isUnique = await _queryExecutor.ExecuteAsync(query, executionContext); if (!isUnique) { var message = string.Format("Cannot publish because the {1} '{0}' is not unique (symbols and spaces are ignored in the uniqueness check)", dbVersion.Title, definition.GetTerms().GetOrDefault(CustomizableCustomEntityTermKeys.Title, "title").ToLower()); throw new UniqueConstraintViolationException(message, "Title", dbVersion.Title); } }
public ActionResult Index(ICustomEntityDefinition definition) { var options = new CustomEntityModuleOptions() { CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode, ForceUrlSlugUniqueness = definition.ForceUrlSlugUniqueness, HasLocale = definition.HasLocale, AutoGenerateUrlSlug = definition.AutoGenerateUrlSlug, AutoPublish = definition.AutoPublish, Name = definition.NamePlural, NameSingular = definition.Name, Terms = definition.GetTerms() }; if (definition is IOrderableCustomEntityDefinition) { options.Ordering = ((IOrderableCustomEntityDefinition)definition).Ordering; } return(View("~/Admin/Modules/CustomEntities/Mvc/Views/Index.cshtml", options)); }
public ActionResult Index(ICustomEntityDefinition definition) { var options = new CustomEntityModuleOptions() { CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode, ForceUrlSlugUniqueness = definition.ForceUrlSlugUniqueness, HasLocale = definition.HasLocale, AutoGenerateUrlSlug = definition.AutoGenerateUrlSlug, AutoPublish = definition.AutoPublish, Name = definition.NamePlural, NameSingular = definition.Name, Terms = definition.GetTerms() }; if (definition is IOrderableCustomEntityDefinition) { options.Ordering = ((IOrderableCustomEntityDefinition)definition).Ordering; } var viewPath = ViewPathFormatter.View("CustomEntities", nameof(Index)); return(View(viewPath, options)); }
public CustomEntityPublishPermission(ICustomEntityDefinition customEntityDefinition) { EntityDefinition = new CustomEntityDynamicEntityDefinition(customEntityDefinition); PermissionType = new PermissionType("CMEPUB", "Publish", "Publish or unpublish a " + customEntityDefinition.Name.ToLower()); }
private IsCustomEntityPathUniqueQuery GetUniquenessQuery(CustomEntityVersion dbVersion, ICustomEntityDefinition definition) { var query = new IsCustomEntityPathUniqueQuery(); query.CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode; query.LocaleId = dbVersion.CustomEntity.LocaleId; query.UrlSlug = SlugFormatter.ToSlug(dbVersion.Title); query.CustomEntityId = dbVersion.CustomEntityId; return(query); }
private static bool UseOrderableSort(ICustomEntityDefinition customEntityDefinition) { return(customEntityDefinition is IOrderableCustomEntityDefinition orderableCustomEntityDefinition && orderableCustomEntityDefinition.Ordering != CustomEntityOrdering.None); }
/// <summary> /// Applies the specified sorting to the query, taking into account /// the any default sorting settings on the custom entity definition. /// </summary> /// <param name="dbQuery">Query to sort.</param> /// <param name="customEntityDefinition"> /// The definition for the entity being sorted. This may contain default /// sorting settings that will be applied if CustomEntityQuerySortType.Default /// is specified. /// </param> /// <param name="sortType">The sort type to apply.</param> /// <param name="optionalSortDirection"> /// An optional sort direction, falling back to the default /// if not specified. /// </param> public static IOrderedQueryable <CustomEntityPublishStatusQuery> SortBy( this IQueryable <CustomEntityPublishStatusQuery> dbQuery, ICustomEntityDefinition customEntityDefinition, CustomEntityQuerySortType sortType, SortDirection?optionalSortDirection = null ) { IOrderedQueryable <CustomEntityPublishStatusQuery> result; var sortDirection = optionalSortDirection ?? SortDirection.Default; if (sortType == CustomEntityQuerySortType.Default && customEntityDefinition is ISortedCustomEntityDefinition sortedDefinition && !(customEntityDefinition is IOrderableCustomEntityDefinition)) { sortType = sortedDefinition.DefaultSortType; if (!optionalSortDirection.HasValue) { sortDirection = sortedDefinition.DefaultSortDirection; } } switch (sortType) { case CustomEntityQuerySortType.Default: case CustomEntityQuerySortType.Natural: if (UseOrderableSort(customEntityDefinition)) { result = SortByOrdering(dbQuery, sortDirection, customEntityDefinition); } else { result = dbQuery .OrderByWithSortDirection(e => e.CustomEntityVersion.Title, sortDirection); } break; case CustomEntityQuerySortType.Locale: if (UseOrderableSort(customEntityDefinition)) { result = SortByOrdering(dbQuery, sortDirection, customEntityDefinition); } else { result = dbQuery .OrderByWithSortDirection(e => e.CustomEntity.Locale.IETFLanguageTag, sortDirection) .ThenByWithSortDirection(e => e.CustomEntityVersion.Title, sortDirection); } break; case CustomEntityQuerySortType.Title: result = dbQuery .OrderByWithSortDirection(e => e.CustomEntityVersion.Title, sortDirection); break; case CustomEntityQuerySortType.CreateDate: result = dbQuery .OrderByDescendingWithSortDirection(e => e.CustomEntity.CreateDate, sortDirection); break; case CustomEntityQuerySortType.PublishDate: result = dbQuery .OrderByDescendingWithSortDirection(e => e.CustomEntity.PublishDate ?? e.CustomEntityVersion.CreateDate, sortDirection) ; break; default: throw new Exception($"{nameof(CustomEntityQuerySortType)} not recognised: {sortType}"); } return(result); }
public CustomEntityAdminModulePermission(ICustomEntityDefinition customEntityDefinition) { EntityDefinition = new CustomEntityDynamicEntityDefinition(customEntityDefinition); PermissionType = CommonPermissionTypes.AdminModule(customEntityDefinition.NamePlural); }
public ICustomEntityPermissionTemplate CreateImplemention(ICustomEntityDefinition customEntityDefinition) { var implementedPermission = new CustomEntityReadPermission(customEntityDefinition); return(implementedPermission); }
public CustomEntityReadPermission(ICustomEntityDefinition customEntityDefinition) { EntityDefinition = new CustomEntityDynamicEntityDefinition(customEntityDefinition); PermissionType = CommonPermissionTypes.Read(customEntityDefinition.NamePlural); }
public string List(ICustomEntityDefinition definition) { return(GetCustomEntityRoute(definition?.NamePlural)); }
public CustomEntityUpdateUrlPermission(ICustomEntityDefinition customEntityDefinition) { EntityDefinition = new CustomEntityDynamicEntityDefinition(customEntityDefinition); PermissionType = new PermissionType("UPDURL", "Update custom entity Url", "Update the url of a " + customEntityDefinition.Name); }
private IsCustomEntityUrlSlugUniqueQuery GetUniquenessQuery(UpdateCustomEntityDraftVersionCommand command, ICustomEntityDefinition definition, CustomEntityVersion dbVersion) { var query = new IsCustomEntityUrlSlugUniqueQuery(); query.CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode; query.LocaleId = dbVersion.CustomEntity.LocaleId; query.UrlSlug = SlugFormatter.ToSlug(command.Title); query.CustomEntityId = command.CustomEntityId; return(query); }
public CustomEntityPublishPermission(ICustomEntityDefinition customEntityDefinition) { EntityDefinition = new CustomEntityDynamicEntityDefinition(customEntityDefinition); PermissionType = CreatePermissionType(customEntityDefinition.Name.ToLower()); }