/// <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);
        }
Ejemplo n.º 2
0
 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);
     }
 }
Ejemplo n.º 3
0
        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();
 }
Ejemplo n.º 5
0
        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));
        }
Ejemplo n.º 8
0
        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);
        }
Ejemplo n.º 11
0
        /// <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);
            }
        }
Ejemplo n.º 13
0
        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());
 }
Ejemplo n.º 16
0
        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);
 }
Ejemplo n.º 22
0
 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());
 }