Merge pull request #7908 from abpframework/cotur/cms-kit/media

Cms Kit - MediaDescriptor EntityType Definitions

modules/cms-kit/host/Volo.CmsKit.Web.Unified/Migrations/20210302064229_Added_EntityType_to_Media.cs

@@ -0,0 +1,25 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Volo.CmsKit.Migrations
+{
+    public partial class Added_EntityType_to_Media : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "EntityType",
+                table: "CmsMediaDescriptors",
+                type: "nvarchar(64)",
+                maxLength: 64,
+                nullable: false,
+                defaultValue: "");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "EntityType",
+                table: "CmsMediaDescriptors");
+        }
+    }
+}

modules/cms-kit/host/Volo.CmsKit.Web.Unified/Migrations/UnifiedDbContextModelSnapshot.cs

@@ -1475,6 +1475,11 @@ namespace Volo.CmsKit.Migrations
                         .HasColumnType("datetime2")
                         .HasColumnName("DeletionTime");
 
+                    b.Property<string>("EntityType")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
                     b.Property<string>("ExtraProperties")
                         .HasColumnType("nvarchar(max)")
                         .HasColumnName("ExtraProperties");

modules/cms-kit/src/Volo.CmsKit.Admin.Application.Contracts/Volo/CmsKit/Admin/MediaDescriptors/CreateMediaInputStream.cs

@@ -8,6 +8,10 @@ namespace Volo.CmsKit.Admin.MediaDescriptors
 {
     public class CreateMediaInputStream : RemoteStreamContent
     {
+        [Required]
+        [DynamicStringLength(typeof(MediaDescriptorConsts), nameof(MediaDescriptorConsts.MaxEntityTypeLength))]
+        public string EntityType { get; set; }
+        
         [Required]
         [DynamicStringLength(typeof(MediaDescriptorConsts), nameof(MediaDescriptorConsts.MaxNameLength))]
         public string Name { get; set; }

modules/cms-kit/src/Volo.CmsKit.Admin.Application.Contracts/Volo/CmsKit/Permissions/CmsKitAdminPermissionDefinitionProvider.cs

@@ -56,13 +56,6 @@ namespace Volo.CmsKit.Permissions
                 blogManagement.AddChild(CmsKitAdminPermissions.BlogPosts.Update, L("Permission:BlogPostManagement.Update"));
                 blogManagement.AddChild(CmsKitAdminPermissions.BlogPosts.Delete, L("Permission:BlogPostManagement.Delete"));
             }
-            
-            if (GlobalFeatureManager.Instance.IsEnabled<MediaFeature>())
-            {
-                var mediaDescriptorManagement = cmsGroup.AddPermission(CmsKitAdminPermissions.MediaDescriptors.Default, L("Permission:MediaDescriptorManagement"));
-                mediaDescriptorManagement.AddChild(CmsKitAdminPermissions.MediaDescriptors.Create, L("Permission:MediaDescriptorManagement:Create"));
-                mediaDescriptorManagement.AddChild(CmsKitAdminPermissions.MediaDescriptors.Delete, L("Permission:MediaDescriptorManagement:Delete"));
-            }
         }
 
         private static LocalizableString L(string name)

modules/cms-kit/src/Volo.CmsKit.Admin.Application.Contracts/Volo/CmsKit/Permissions/CmsKitAdminPermissions.cs

@@ -5,13 +5,13 @@ namespace Volo.CmsKit.Permissions
     public class CmsKitAdminPermissions
     {
         public const string GroupName = "CmsKit";
-        
+
         public static class Comments
         {
             public const string Default = GroupName + ".Comments";
             public const string Delete = Default + ".Delete";
         }
-        
+
         public static class Tags
         {
             public const string Default = GroupName + ".Tags";
@@ -19,7 +19,7 @@ namespace Volo.CmsKit.Permissions
             public const string Update = Default + ".Update";
             public const string Delete = Default + ".Delete";
         }
-        
+
         public static class Contents
         {
             public const string Default = GroupName + ".Contents";
@@ -52,12 +52,5 @@ namespace Volo.CmsKit.Permissions
             public const string Update = Default + ".Update";
             public const string Delete = Default + ".Delete";
         }
-        
-        public static class MediaDescriptors
-        {
-            public const string Default = GroupName + ".MediaDescriptors";
-            public const string Create = Default + ".Create";
-            public const string Delete = Default + ".Delete";
-        }
     }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.Application/Volo/CmsKit/Admin/CmsKitAdminAppServiceBase.cs

@@ -1,4 +1,13 @@
-namespace Volo.CmsKit.Admin
+using JetBrains.Annotations;
+using Microsoft.AspNetCore.Authorization;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices.ComTypes;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Authorization;
+
+namespace Volo.CmsKit.Admin
 {
     public abstract class CmsKitAdminAppServiceBase : CmsKitAppServiceBase
     {
@@ -6,5 +15,25 @@
         {
             ObjectMapperContext = typeof(CmsKitAdminApplicationModule);
         }
+
+        /// <summary>
+        /// Checks given policies until finding granted policy. If none of them is granted, throws <see cref="AbpAuthorizationException"/>
+        /// </summary>
+        /// <param name="policies">Policies to be checked.</param>
+        /// <exception cref="AbpAuthorizationException">Thrown when none of policies is granted.</exception>
+        protected async Task CheckAnyOfPoliciesAsync([NotNull] IEnumerable<string> policies)
+        {
+            Check.NotNull(policies, nameof(policies));
+
+            foreach (var policy in policies)
+            {
+                if (await AuthorizationService.IsGrantedAsync(policy))
+                {
+                    return;
+                }
+            }
+
+            throw new AbpAuthorizationException();
+        }
     }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.Application/Volo/CmsKit/Admin/CmsKitAdminApplicationModule.cs

@@ -7,6 +7,8 @@ using Volo.Abp.Modularity;
 using Volo.CmsKit.Blogs;
 using Volo.CmsKit.GlobalFeatures;
 using Volo.CmsKit.Localization;
+using Volo.CmsKit.MediaDescriptors;
+using Volo.CmsKit.Pages;
 using Volo.CmsKit.Permissions;
 using Volo.CmsKit.Tags;
 
@@ -44,11 +46,65 @@ namespace Volo.CmsKit.Admin
                         new TagEntityTypeDefiniton(
                             BlogPostConsts.EntityType,
                             LocalizableString.Create<CmsKitResource>("BlogPost"),
-                            CmsKitAdminPermissions.BlogPosts.Update,
+                            createPolicies: new[] 
-                            CmsKitAdminPermissions.BlogPosts.Update,
+                            {
-                            CmsKitAdminPermissions.BlogPosts.Update));
+                                CmsKitAdminPermissions.BlogPosts.Create, 
+                                CmsKitAdminPermissions.BlogPosts.Update 
+                            },
+                            updatePolicies: new[] 
+                            { 
+                                CmsKitAdminPermissions.BlogPosts.Create, 
+                                CmsKitAdminPermissions.BlogPosts.Update 
+                            },
+                            deletePolicies: new[] 
+                            { 
+                                CmsKitAdminPermissions.BlogPosts.Create, 
+                                CmsKitAdminPermissions.BlogPosts.Update 
+                            }));
                 }
             });
+
+            if (GlobalFeatureManager.Instance.IsEnabled<MediaFeature>())
+            {
+                Configure<CmsKitMediaOptions>(options =>
+                {
+                    if (GlobalFeatureManager.Instance.IsEnabled<BlogsFeature>())
+                    {
+                        options.EntityTypes.AddIfNotContains(
+                            new MediaDescriptorDefinition(
+                                BlogPostConsts.EntityType,
+                                createPolicies: new[] 
+                                { 
+                                    CmsKitAdminPermissions.BlogPosts.Create, 
+                                    CmsKitAdminPermissions.BlogPosts.Update
+                                },
+                                deletePolicies: new[]
+                                {
+                                    CmsKitAdminPermissions.BlogPosts.Create,
+                                    CmsKitAdminPermissions.BlogPosts.Update,
+                                    CmsKitAdminPermissions.BlogPosts.Delete
+                                }));
+                    }
+
+                    if (GlobalFeatureManager.Instance.IsEnabled<PagesFeature>())
+                    {
+                        options.EntityTypes.AddIfNotContains(
+                            new MediaDescriptorDefinition(
+                                PageConsts.EntityType,
+                                createPolicies: new[] 
+                                {
+                                    CmsKitAdminPermissions.Pages.Create,
+                                    CmsKitAdminPermissions.Pages.Update 
+                                },
+                                deletePolicies: new[]
+                                {
+                                    CmsKitAdminPermissions.Pages.Create,
+                                    CmsKitAdminPermissions.Pages.Update,
+                                    CmsKitAdminPermissions.Pages.Delete 
+                                }));
+                    }
+                });
+            }
         }
     }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.Application/Volo/CmsKit/Admin/MediaDescriptors/MediaDescriptorAdminAppService.cs

@@ -10,34 +10,51 @@ using Volo.CmsKit.Permissions;
 namespace Volo.CmsKit.Admin.MediaDescriptors
 {
     [RequiresGlobalFeature(typeof(MediaFeature))]
-    [Authorize(CmsKitAdminPermissions.MediaDescriptors.Default)]
     public class MediaDescriptorAdminAppService : CmsKitAdminAppServiceBase, IMediaDescriptorAdminAppService
     {
-        protected readonly IBlobContainer<MediaContainer> MediaContainer;
+        protected IBlobContainer<MediaContainer> MediaContainer { get; }
-        protected readonly IMediaDescriptorRepository MediaDescriptorRepository;
+        protected IMediaDescriptorRepository MediaDescriptorRepository { get; }
-        
+        protected MediaDescriptorManager MediaDescriptorManager { get; }
-        public MediaDescriptorAdminAppService(IBlobContainer<MediaContainer> mediaContainer, IMediaDescriptorRepository mediaDescriptorRepository)
+        protected IMediaDescriptorDefinitionStore MediaDescriptorDefinitionStore { get; }
+
+        public MediaDescriptorAdminAppService(
+            IBlobContainer<MediaContainer> mediaContainer,
+            IMediaDescriptorRepository mediaDescriptorRepository,
+            MediaDescriptorManager mediaDescriptorManager, 
+            IMediaDescriptorDefinitionStore mediaDescriptorDefinitionStore)
         {
             MediaContainer = mediaContainer;
             MediaDescriptorRepository = mediaDescriptorRepository;
+            MediaDescriptorManager = mediaDescriptorManager;
+            MediaDescriptorDefinitionStore = mediaDescriptorDefinitionStore;
         }
 
-        [Authorize(CmsKitAdminPermissions.MediaDescriptors.Create)]
         public virtual async Task<MediaDescriptorDto> CreateAsync(CreateMediaInputStream inputStream)
         {
+            var definition = await MediaDescriptorDefinitionStore.GetDefinitionAsync(inputStream.EntityType);
+
+            await CheckAnyOfPoliciesAsync(definition.CreatePolicies);
+
             var newId = GuidGenerator.Create();
-            var stream = inputStream.GetStream();
+            using (var stream = inputStream.GetStream())
-            var newEntity = new MediaDescriptor(newId, inputStream.Name, inputStream.ContentType, stream.Length, CurrentTenant.Id);
+            {
+                var newEntity = await MediaDescriptorManager.CreateAsync(inputStream.EntityType, inputStream.Name, inputStream.ContentType, inputStream.ContentLength ?? 0);
 
-            await MediaContainer.SaveAsync(newId.ToString(), stream);
+                await MediaContainer.SaveAsync(newId.ToString(), stream);
-            await MediaDescriptorRepository.InsertAsync(newEntity);
+                await MediaDescriptorRepository.InsertAsync(newEntity);
 
-            return ObjectMapper.Map<MediaDescriptor, MediaDescriptorDto>(newEntity);
+                return ObjectMapper.Map<MediaDescriptor, MediaDescriptorDto>(newEntity);
+            }
         }
 
-        [Authorize(CmsKitAdminPermissions.MediaDescriptors.Delete)]
         public virtual async Task DeleteAsync(Guid id)
         {
+            var mediaDescriptor = await MediaDescriptorRepository.GetAsync(id);
+
+            var definition = await MediaDescriptorDefinitionStore.GetDefinitionAsync(mediaDescriptor.EntityType);
+
+            await CheckAnyOfPoliciesAsync(definition.DeletePolicies);
+
             await MediaContainer.DeleteAsync(id.ToString());
             await MediaDescriptorRepository.DeleteAsync(id);
         }

modules/cms-kit/src/Volo.CmsKit.Admin.Application/Volo/CmsKit/Admin/Tags/EntityTagAdminAppService.cs

@@ -31,7 +31,7 @@ namespace Volo.CmsKit.Admin.Tags
         {
             var definition = await TagDefinitionStore.GetTagEntityTypeDefinitionAsync(input.EntityType);
 
-            await CheckPolicyAsync(definition.CreatePolicy);
+            await CheckAnyOfPoliciesAsync(definition.CreatePolicies);
 
             var tag = await TagManager.GetOrAddAsync(input.EntityType, input.TagName);
 
@@ -46,7 +46,7 @@ namespace Volo.CmsKit.Admin.Tags
         {
             var definition = await TagDefinitionStore.GetTagEntityTypeDefinitionAsync(input.EntityType);
 
-            await CheckPolicyAsync(definition.DeletePolicy);
+            await CheckAnyOfPoliciesAsync(definition.DeletePolicies);
 
             await EntityTagManager.RemoveTagFromEntityAsync(
                 input.TagId,
@@ -59,7 +59,7 @@ namespace Volo.CmsKit.Admin.Tags
         {
             var definition = await TagDefinitionStore.GetTagEntityTypeDefinitionAsync(input.EntityType);
 
-            await CheckPolicyAsync(definition.UpdatePolicy);
+            await CheckAnyOfPoliciesAsync(definition.UpdatePolicies);
 
             await EntityTagManager.SetEntityTagsAsync(input.EntityType, input.EntityId, input.Tags);
         }

modules/cms-kit/src/Volo.CmsKit.Admin.HttpApi/Volo/CmsKit/Admin/MediaDescriptors/MediaDescriptorAdminController.cs

@@ -13,7 +13,6 @@ namespace Volo.CmsKit.Admin.MediaDescriptors
 {
     [RequiresGlobalFeature(typeof(MediaFeature))]
     [RemoteService(Name = CmsKitCommonRemoteServiceConsts.RemoteServiceName)]
-    [Authorize(CmsKitAdminPermissions.MediaDescriptors.Default)]
     [Area("cms-kit")]
     [Route("api/cms-kit-admin/media")]
     public class MediaDescriptorAdminController : CmsKitAdminController, IMediaDescriptorAdminAppService
@@ -26,7 +25,6 @@ namespace Volo.CmsKit.Admin.MediaDescriptors
         }
 
         [HttpPost]
-        [Authorize(CmsKitAdminPermissions.MediaDescriptors.Create)]
         [NonAction]
         public virtual Task<MediaDescriptorDto> CreateAsync(CreateMediaInputStream inputStream)
         {
@@ -35,15 +33,14 @@ namespace Volo.CmsKit.Admin.MediaDescriptors
 
         [HttpDelete]
         [Route("{id}")]
-        [Authorize(CmsKitAdminPermissions.MediaDescriptors.Delete)]
         public virtual Task DeleteAsync(Guid id)
         {
             return MediaDescriptorAdminAppService.DeleteAsync(id);
         }
 
         [HttpPost]
-        [Authorize(CmsKitAdminPermissions.MediaDescriptors.Create)]
+        [Route("{entityType}")]
-        public virtual async Task<IActionResult> UploadAsync(IFormFile file)
+        public virtual async Task<IActionResult> UploadAsync(string entityType, IFormFile file)
         {
             if (file == null)
             {
@@ -52,6 +49,7 @@ namespace Volo.CmsKit.Admin.MediaDescriptors
 
             var inputStream = new CreateMediaInputStream(file.OpenReadStream())
                               {
+                                  EntityType = entityType,
                                   ContentType = file.ContentType,
                                   Name = file.FileName
                               };

modules/cms-kit/src/Volo.CmsKit.Common.Application/Volo/CmsKit/CmsKitCommonApplicationModule.cs

@@ -1,6 +1,11 @@
 using Volo.Abp.Application;
 using Volo.Abp.AutoMapper;
+using Volo.Abp.GlobalFeatures;
 using Volo.Abp.Modularity;
+using Volo.CmsKit.Blogs;
+using Volo.CmsKit.GlobalFeatures;
+using Volo.CmsKit.MediaDescriptors;
+using Volo.CmsKit.Permissions;
 
 namespace Volo.CmsKit
 {

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/CmsKit/CmsKitErrorCodes.cs

@@ -28,6 +28,7 @@
         public static class MediaDescriptors
         {
             public const string InvalidName = "CmsKit:Media:0001";
+            public const string EntityTypeDoesntExist = "CmsKit:Media:0002";
         }
     }
 }

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/CmsKit/Localization/Resources/en.json

@@ -20,6 +20,7 @@
     "CmsKit:Media:0001": "'{Name}' is not a valid media name.",
     "CmsKit:Page:0001": "The given url ({0}) already exists.",
     "CmsKit:Tag:0002": "The entity is not taggable!",
+    "CmsKit:Media:0002": "The entity can't have media.",
     "CommentAuthorizationExceptionMessage": "Those comments are not allowed for public display.",
     "CommentDeletionConfirmationMessage": "This comment and all replies will be deleted!",
     "Comments": "Comments",

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/CmsKit/Localization/Resources/tr.json

@@ -16,6 +16,7 @@
     "CmsKit:0002": "İçerik zaten mevcut!",
     "CmsKit:0003": "{0} ögesi etiketlenebilir değil.",
     "CmsKit:BlogPost:0001": "Aynı url etiketi zaten mevcut.",
+    "CmsKit:Media:0002": "Bu öge için medya eklenemez.",
     "CmsKit:Page:0001": "Girilen url ({0}) kullanımdadır.",
     "CmsKit:Tag:0002": "Bu öge etiketlenebilir değil.",
     "CommentAuthorizationExceptionMessage": "Bu yorumları görebilmek için yetki gerekir.",

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/CmsKit/MediaDescriptors/MediaDescriptorConsts.cs

@@ -1,7 +1,11 @@
-namespace Volo.CmsKit.MediaDescriptors
+using Volo.CmsKit.Entities;
+
+namespace Volo.CmsKit.MediaDescriptors
 {
     public class MediaDescriptorConsts
     {
+        public static int MaxEntityTypeLength { get; set; } = CmsEntityConsts.MaxEntityTypeLength;
+        
         public static int MaxNameLength { get; set; } = 255;
         
         public static int MaxMimeTypeLength { get; set; } = 128;

modules/cms-kit/src/Volo.CmsKit.Domain.Shared/Volo/CmsKit/Pages/PageConsts.cs

@@ -2,6 +2,8 @@
 {
     public class PageConsts
     {
+        public const string EntityType = "Page";
+
         public static int MaxTitleLength { get; set; } = 256;
 
         public static int MaxSlugLength { get; set; } = 256;

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/AssemblyInfo.cs

@@ -0,0 +1,4 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Volo.CmsKit.Domain.Tests", AllInternalsVisible = true)] 
+[assembly: InternalsVisibleTo("Volo.CmsKit.TestBase", AllInternalsVisible = true)] 

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/MediaDescriptors/CmsKitMediaOptions.cs

@@ -0,0 +1,15 @@
+using JetBrains.Annotations;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Volo.CmsKit.MediaDescriptors
+{
+    public class CmsKitMediaOptions
+    {
+        [NotNull]
+        public List<MediaDescriptorDefinition> EntityTypes { get; } = new();
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/MediaDescriptors/DefaultMediaDescriptorDefinitionStore.cs

@@ -0,0 +1,47 @@
+using JetBrains.Annotations;
+using Microsoft.Extensions.Options;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.DependencyInjection;
+
+namespace Volo.CmsKit.MediaDescriptors
+{
+    public class DefaultMediaDescriptorDefinitionStore : IMediaDescriptorDefinitionStore, ITransientDependency
+    {
+        protected CmsKitMediaOptions Options { get; }
+
+        public DefaultMediaDescriptorDefinitionStore(IOptions<CmsKitMediaOptions> options)
+        {
+            Options = options.Value;
+        }
+
+        /// <summary>
+        /// Gets single <see cref="MediaDescriptorDefinition"/> by entityType.
+        /// </summary>
+        /// <param name="entityType">EntityType to get definition.</param>
+        /// <exception cref="EntityCantHaveMediaException">Thrown when EntityType is not configured as taggable.</exception>
+        /// <exception cref="InvalidOperationException">More than one element satisfies the condition in predicate.</exception>
+        public virtual Task<MediaDescriptorDefinition> GetDefinitionAsync([NotNull] string entityType)
+        {
+            Check.NotNullOrWhiteSpace(entityType, nameof(entityType));
+
+            var result = Options.EntityTypes.SingleOrDefault(x => x.EntityType == entityType) ??
+                         throw new EntityCantHaveMediaException(entityType);
+
+            return Task.FromResult(result);
+        }
+
+        public virtual Task<bool> IsDefinedAsync([NotNull] string entityType)
+        {
+            Check.NotNullOrEmpty(entityType, nameof(entityType));
+
+            var isDefined = Options.EntityTypes.Any(a => a.EntityType == entityType);
+
+            return Task.FromResult(isDefined);
+        }
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/MediaDescriptors/EntityCantHaveMediaException.cs

@@ -0,0 +1,21 @@
+using System.Runtime.Serialization;
+using Volo.Abp;
+
+namespace Volo.CmsKit.MediaDescriptors
+{
+    public class EntityCantHaveMediaException : BusinessException
+    {
+        public EntityCantHaveMediaException(SerializationInfo serializationInfo, StreamingContext context) : base(serializationInfo, context)
+        {
+        }
+
+        public EntityCantHaveMediaException(string entityType) 
+        {
+            EntityType = entityType;
+            Code = CmsKitErrorCodes.MediaDescriptors.EntityTypeDoesntExist;
+            WithData(nameof(entityType), EntityType);
+        }
+
+        public string EntityType { get; }
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/MediaDescriptors/IMediaDescriptorDefinitionStore.cs

@@ -0,0 +1,12 @@
+using JetBrains.Annotations;
+using System.Threading.Tasks;
+
+namespace Volo.CmsKit.MediaDescriptors
+{
+    public interface IMediaDescriptorDefinitionStore
+    {
+        Task<bool> IsDefinedAsync([NotNull] string entityType);
+
+        Task<MediaDescriptorDefinition> GetDefinitionAsync([NotNull] string entityType);
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/MediaDescriptors/MediaDescriptor.cs

@@ -2,13 +2,14 @@
 using Volo.Abp;
 using Volo.Abp.Domain.Entities.Auditing;
 using Volo.Abp.MultiTenancy;
-using Volo.CmsKit.MediaDescriptors.Extensions;
 
 namespace Volo.CmsKit.MediaDescriptors
 {
     public class MediaDescriptor : FullAuditedAggregateRoot<Guid>, IMultiTenant
     {
         public Guid? TenantId { get; protected set; }
+
+        public string EntityType { get; protected set; }
         
         public string Name { get; protected set; }
 
@@ -21,10 +22,11 @@ namespace Volo.CmsKit.MediaDescriptors
             
         }
 
-        public MediaDescriptor(Guid id, string name, string mimeType, long size, Guid? tenantId = null) : base(id)
+        internal MediaDescriptor(Guid id, string entityType, string name, string mimeType, long size, Guid? tenantId = null) : base(id)
         {
             TenantId = tenantId;
             
+            EntityType = Check.NotNullOrEmpty(entityType, nameof(entityType), MediaDescriptorConsts.MaxEntityTypeLength);
             MimeType = Check.NotNullOrWhiteSpace(mimeType, nameof(name), MediaDescriptorConsts.MaxMimeTypeLength);
             Size = size;
             
@@ -33,7 +35,7 @@ namespace Volo.CmsKit.MediaDescriptors
 
         public void SetName(string name)
         {
-            if (!MediaDescriptorCheck.IsValidMediaFileName(name))
+            if (!MediaDescriptorChecks.IsValidMediaFileName(name))
             {
                 throw new InvalidMediaDescriptorNameException(name);
             }

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/MediaDescriptors/MediaDescriptorCheck.cs → modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/MediaDescriptors/MediaDescriptorChecks.cs

@@ -1,9 +1,9 @@
 using System.IO;
 using System.Linq;
 
-namespace Volo.CmsKit.MediaDescriptors.Extensions
+namespace Volo.CmsKit.MediaDescriptors
 {
-    public static class MediaDescriptorCheck
+    public static class MediaDescriptorChecks
     {
         public static bool IsValidMediaFileName(string name)
         {

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/MediaDescriptors/MediaDescriptorDefinition.cs

@@ -0,0 +1,20 @@
+using JetBrains.Annotations;
+using System;
+using System.Collections.Generic;
+
+namespace Volo.CmsKit.MediaDescriptors
+{
+    public class MediaDescriptorDefinition : PolicySpecifiedDefinition
+    {
+        public MediaDescriptorDefinition(
+            [NotNull] string entityType,
+            IEnumerable<string> createPolicies = null,
+            IEnumerable<string> updatePolicies = null,
+            IEnumerable<string> deletePolicies = null) : base(entityType,
+                                                              createPolicies,
+                                                              updatePolicies,
+                                                              deletePolicies)
+        {
+        }
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/MediaDescriptors/MediaDescriptorManager.cs

@@ -0,0 +1,31 @@
+using System.Threading.Tasks;
+using Volo.Abp.Domain.Services;
+
+namespace Volo.CmsKit.MediaDescriptors
+{
+    public class MediaDescriptorManager : DomainService
+    {
+        protected IMediaDescriptorDefinitionStore MediaDescriptorDefinitionStore { get; }
+
+        public MediaDescriptorManager(IMediaDescriptorDefinitionStore mediaDescriptorDefinitionStore)
+        {
+            MediaDescriptorDefinitionStore = mediaDescriptorDefinitionStore;
+        }
+
+        public virtual async Task<MediaDescriptor> CreateAsync(string entityType, string name, string mimeType, long size)
+        {
+            if(!await MediaDescriptorDefinitionStore.IsDefinedAsync(entityType))
+            {
+                throw new EntityCantHaveMediaException(entityType);
+            }
+
+            return new MediaDescriptor(
+                GuidGenerator.Create(),
+                entityType,
+                name,
+                mimeType,
+                size,
+                CurrentTenant.Id);
+        }
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/PolicySpecifiedDefinition.cs

@@ -1,30 +1,56 @@
 using JetBrains.Annotations;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Volo.Abp;
 
 namespace Volo.CmsKit
 {
-    public abstract class PolicySpecifiedDefinition
+    public abstract class PolicySpecifiedDefinition : IEquatable<PolicySpecifiedDefinition>
     {
         protected PolicySpecifiedDefinition()
         {
         }
 
         public PolicySpecifiedDefinition(
-            [CanBeNull] string createPolicy = null,
+            [NotNull] string entityType,
-            [CanBeNull] string updatePolicy = null,
+            IEnumerable<string> createPolicies = null,
-            [CanBeNull] string deletePolicy = null)
+            IEnumerable<string> updatePolicies = null,
+            IEnumerable<string> deletePolicies = null)
         {
-            CreatePolicy = createPolicy;
+            EntityType = Check.NotNullOrEmpty(entityType, nameof(entityType));
-            DeletePolicy = deletePolicy;
+
-            UpdatePolicy = updatePolicy;
+            if (createPolicies != null)
+            {
+                CreatePolicies = CreatePolicies.Concat(createPolicies).ToList();
+            }
+
+            if (updatePolicies != null)
+            {
+                UpdatePolicies = UpdatePolicies.Concat(updatePolicies).ToList();
+            }
+
+            if (deletePolicies != null)
+            {
+                DeletePolicies = DeletePolicies.Concat(deletePolicies).ToList();
+            }
         }
 
-        [CanBeNull]
+        [NotNull]
-        public virtual string CreatePolicy { get; set; }
+        public string EntityType { get; set; }
+
+        [NotNull]
+        public virtual ICollection<string> CreatePolicies { get; } = new List<string>();
 
-        [CanBeNull]
+        [NotNull]
-        public virtual string UpdatePolicy { get; set; }
+        public virtual ICollection<string> UpdatePolicies { get; } = new List<string>();
 
-        [CanBeNull]
+        [NotNull]
-        public virtual string DeletePolicy { get; set; }
+        public virtual ICollection<string> DeletePolicies { get; } = new List<string>();
+
+        public bool Equals(PolicySpecifiedDefinition other)
+        {
+            return other?.EntityType == EntityType;
+        }
     }
 }

modules/cms-kit/src/Volo.CmsKit.Domain/Volo/CmsKit/Tags/TagEntityTypeDefiniton.cs

@@ -1,5 +1,6 @@
 using JetBrains.Annotations;
 using System;
+using System.Collections.Generic;
 using Volo.Abp;
 using Volo.Abp.Localization;
 
@@ -7,8 +8,6 @@ namespace Volo.CmsKit.Tags
 {
     public class TagEntityTypeDefiniton : PolicySpecifiedDefinition, IEquatable<TagEntityTypeDefiniton>
     {
-        public string EntityType { get; }
-
         [CanBeNull]
         public virtual ILocalizableString DisplayName { get; }
 
@@ -19,12 +18,12 @@ namespace Volo.CmsKit.Tags
         public TagEntityTypeDefiniton(
             [NotNull] string entityType,
             [CanBeNull] ILocalizableString displayName = null,
-            [CanBeNull] string createPolicy = null,
+            IEnumerable<string> createPolicies = null,
-            [CanBeNull] string updatePolicy = null,
+            IEnumerable<string> updatePolicies = null,
-            [CanBeNull] string deletePolicy = null) : base(createPolicy, updatePolicy, deletePolicy)
+            IEnumerable<string> deletePolicies = null) : base(entityType, createPolicies, updatePolicies, deletePolicies)
         {
-            EntityType = Check.NotNullOrWhiteSpace(entityType, nameof(entityType));
             DisplayName = displayName;
+
         }
 
         public bool Equals(TagEntityTypeDefiniton other)

modules/cms-kit/src/Volo.CmsKit.EntityFrameworkCore/Volo/CmsKit/EntityFrameworkCore/CmsKitDbContextModelCreatingExtensions.cs

@@ -242,6 +242,7 @@ namespace Volo.CmsKit.EntityFrameworkCore
 
                     b.ConfigureByConvention();
 
+                    b.Property(x => x.EntityType).IsRequired().HasMaxLength(MediaDescriptorConsts.MaxEntityTypeLength);
                     b.Property(x => x.Name).IsRequired().HasMaxLength(MediaDescriptorConsts.MaxNameLength);
                     b.Property(x => x.MimeType).IsRequired().HasMaxLength(MediaDescriptorConsts.MaxMimeTypeLength);
                     b.Property(x => x.Size).HasMaxLength(MediaDescriptorConsts.MaxSizeLength);

modules/cms-kit/test/Volo.CmsKit.Application.Tests/MediaDescriptors/MediaDescriptorAdminAppService_Tests.cs

@@ -34,7 +34,8 @@ namespace Volo.CmsKit.MediaDescriptors
             var inputStream = new CreateMediaInputStream(stream)
             {
                 ContentType = mediaType,
-                Name = mediaName
+                Name = mediaName,
+                EntityType = _cmsKitTestData.Media_1_EntityType
             };
 
             var media = await _mediaDescriptorAdminAppService.CreateAsync(inputStream);

modules/cms-kit/test/Volo.CmsKit.Domain.Tests/MediaDescriptors/MediaDescriptorManager_Test.cs

@@ -0,0 +1,44 @@
+using Shouldly;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Volo.CmsKit.Blogs;
+using Xunit;
+
+namespace Volo.CmsKit.MediaDescriptors
+{
+    public class MediaDescriptorManager_Test : CmsKitDomainTestBase
+    {
+        private readonly MediaDescriptorManager manager;
+        private readonly CmsKitTestData testData;
+
+        public MediaDescriptorManager_Test()
+        {
+            manager = GetRequiredService<MediaDescriptorManager>();
+            testData = GetRequiredService<CmsKitTestData>();
+        }
+
+        [Fact]
+        public async Task CreateAsync_ShouldWorkProperly_WithDefinedEntityType()
+        {
+            var created = await manager.CreateAsync(testData.Media_1_EntityType, "MyAwesomeImage.png", "image/png", 128000);
+
+            created.ShouldNotBeNull();
+            created.Id.ShouldNotBe(Guid.Empty);
+        }
+
+        [Fact]
+        public async Task CreateAsync_ShouldThrowException_WithUndefinedEntityType()
+        {
+            var undefinedEntityType = "My.Any.EntityType";
+
+            var exception = await Should.ThrowAsync<EntityCantHaveMediaException>(async () =>
+                                await manager.CreateAsync(undefinedEntityType, "import.json", "application/json", 256000));
+
+            exception.ShouldNotBeNull();
+            exception.EntityType.ShouldBe(undefinedEntityType);
+        }
+    }
+}

modules/cms-kit/test/Volo.CmsKit.Domain.Tests/Tags/TagEntityTypeDefinitionDictionary_Tests.cs

@@ -42,11 +42,11 @@ namespace Volo.CmsKit.Tags
         {
             cmsKitTagOptions.EntityTypes.Add(
                 new TagEntityTypeDefiniton(
-                    "My.Entity.Type", 
+                    "My.Entity.Type",
                     LocalizableString.Create<CmsKitResource>("MyEntity"),
-                    "SomeCreatePolicy",
+                    new[] { "SomeCreatePolicy" },
-                    "SomeUpdatePolicy",
+                    new[] { "SomeUpdatePolicy" },
-                    "SomeDeletePolicy"
+                    new[] { "SomeDeletePolicy" }
                     ));
         }
 

modules/cms-kit/test/Volo.CmsKit.TestBase/CmsKitDataSeedContributor.cs

@@ -48,6 +48,7 @@ namespace Volo.CmsKit
         private readonly IMediaDescriptorRepository _mediaDescriptorRepository;
         private readonly IBlobContainer<MediaContainer> _mediaBlobContainer;
         private readonly BlogManager _blogManager;
+        private readonly IOptions<CmsKitMediaOptions> _mediaOptions;
 
         public CmsKitDataSeedContributor(
             IGuidGenerator guidGenerator,
@@ -71,7 +72,8 @@ namespace Volo.CmsKit
             IOptions<CmsKitTagOptions> tagOptions, 
             IMediaDescriptorRepository mediaDescriptorRepository, 
             IBlobContainer<MediaContainer> mediaBlobContainer, 
-            BlogManager blogManager)
+            BlogManager blogManager,
+            IOptions<CmsKitMediaOptions> cmsMediaOptions)
         {
             _guidGenerator = guidGenerator;
             _cmsUserRepository = cmsUserRepository;
@@ -95,6 +97,7 @@ namespace Volo.CmsKit
             _mediaDescriptorRepository = mediaDescriptorRepository;
             _mediaBlobContainer = mediaBlobContainer;
             _blogManager = blogManager;
+            _mediaOptions = cmsMediaOptions;
         }
 
         public async Task SeedAsync(DataSeedContext context)
@@ -133,6 +136,12 @@ namespace Volo.CmsKit
             _tagOptions.Value.EntityTypes.AddIfNotContains(new TagEntityTypeDefiniton(_cmsKitTestData.Content_2_EntityType));
             _tagOptions.Value.EntityTypes.AddIfNotContains(new TagEntityTypeDefiniton(_cmsKitTestData.TagDefinition_1_EntityType));
 
+            _mediaOptions.Value.EntityTypes.AddIfNotContains(
+                new MediaDescriptorDefinition(
+                    _cmsKitTestData.Media_1_EntityType, 
+                    createPolicies: new[] { "SomeCreatePolicy" },
+                    deletePolicies: new[] { "SomeDeletePolicy" }));
+
             return Task.CompletedTask;
         }
 
@@ -402,7 +411,7 @@ namespace Volo.CmsKit
         {
             using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(_cmsKitTestData.Media_1_Content)))
             {
-                var media = new MediaDescriptor(_cmsKitTestData.Media_1_Id, _cmsKitTestData.Media_1_Name, _cmsKitTestData.Media_1_ContentType, stream.Length);
+                var media = new MediaDescriptor(_cmsKitTestData.Media_1_Id, _cmsKitTestData.Media_1_EntityType, _cmsKitTestData.Media_1_Name, _cmsKitTestData.Media_1_ContentType, stream.Length);
 
                 await _mediaDescriptorRepository.InsertAsync(media);
 

modules/cms-kit/test/Volo.CmsKit.TestBase/CmsKitTestData.cs

@@ -1,6 +1,7 @@
 using System;
 using JetBrains.Annotations;
 using Volo.Abp.DependencyInjection;
+using Volo.CmsKit.Blogs;
 
 namespace Volo.CmsKit
 {
@@ -100,11 +101,13 @@ namespace Volo.CmsKit
         public bool BlogFeature_2_Enabled => false;
 
         public Guid Media_1_Id { get; } = Guid.NewGuid();
-        
-        public string Media_1_Content = "Hi, this is text file";
 
-        public string Media_1_Name = "hello.txt";
+        public string Media_1_EntityType => nameof(Blog);
 
-        public string Media_1_ContentType = "text/plain";
+        public string Media_1_Content { get; } = "Hi, this is text file";
+
+        public string Media_1_Name { get; } = "hello.txt";
+
+        public string Media_1_ContentType { get; } = "text/plain";
     }
 }