Merge pull request #7845 from abpframework/cms-kit/blogs-refactorings

Cms Kit - BlogPosts & BlogFeatures Refactoring

modules/cms-kit/src/Volo.CmsKit.Admin.Application.Contracts/Volo/CmsKit/Admin/Blogs/IBlogPostAdminAppService.cs

@@ -14,8 +14,6 @@ public interface IBlogPostAdminAppService
             CreateBlogPostDto,
             UpdateBlogPostDto>
     {
-        Task<BlogPostDto> GetBySlugAsync(string blogSlug, string slug);
-
         Task SetCoverImageAsync(Guid id, RemoteStreamContent streamContent);
 
         Task<RemoteStreamContent> GetCoverImageAsync(Guid id);

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

@@ -18,13 +18,13 @@ public class BlogFeatureAdminAppService : CmsKitAdminAppServiceBase, IBlogFeatur
     {
         protected IBlogFeatureRepository BlogFeatureRepository { get; }
 
-        protected IBlogFeatureManager BlogFeatureManager { get; }
+        protected BlogFeatureManager BlogFeatureManager { get; }
 
         protected IDistributedEventBus EventBus { get; }
 
         public BlogFeatureAdminAppService(
             IBlogFeatureRepository blogFeatureRepository,
-            IBlogFeatureManager blogFeatureManager,
+            BlogFeatureManager blogFeatureManager,
             IDistributedEventBus eventBus)
         {
             BlogFeatureRepository = blogFeatureRepository;
@@ -33,15 +33,15 @@ public class BlogFeatureAdminAppService : CmsKitAdminAppServiceBase, IBlogFeatur
         }
 
         [Authorize(CmsKitAdminPermissions.Blogs.Features)]
-        public async Task<List<BlogFeatureDto>> GetListAsync(Guid blogId)
+        public virtual async Task<List<BlogFeatureDto>> GetListAsync(Guid blogId)
         {
             var blogFeatures = await BlogFeatureManager.GetListAsync(blogId);
 
             return ObjectMapper.Map<List<BlogFeature>, List<BlogFeatureDto>>(blogFeatures);
         }
 
         [Authorize(CmsKitAdminPermissions.Blogs.Features)]
-        public Task SetAsync(Guid blogId, BlogFeatureInputDto dto)
+        public virtual Task SetAsync(Guid blogId, BlogFeatureInputDto dto)
         {
             return BlogFeatureManager.SetAsync(blogId, dto.FeatureName, dto.IsEnabled);
         }

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

@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore.Authorization;
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.Application.Services;
@@ -17,103 +18,115 @@ namespace Volo.CmsKit.Admin.Blogs
 {
     [RequiresGlobalFeature(typeof(BlogsFeature))]
     [Authorize(CmsKitAdminPermissions.BlogPosts.Default)]
-    public class BlogPostAdminAppService
-        : CrudAppService<
-            BlogPost,
-            BlogPostDto,
-            Guid,
-            PagedAndSortedResultRequestDto,
-            CreateBlogPostDto,
-            UpdateBlogPostDto>
-        , IBlogPostAdminAppService
+    public class BlogPostAdminAppService: CmsKitAppServiceBase, IBlogPostAdminAppService
     {
-        protected IBlogPostManager BlogPostManager { get; }
+        protected BlogPostManager BlogPostManager { get; }
         protected IBlogPostRepository BlogPostRepository { get; }
         protected IBlogRepository BlogRepository { get; }
         protected IBlobContainer<BlogPostCoverImageContainer> BlobContainer { get; }
         protected ICmsUserLookupService UserLookupService { get; }
 
         public BlogPostAdminAppService(
-            IRepository<BlogPost, Guid> repository,
-            IBlogPostManager blogPostManager,
+            BlogPostManager blogPostManager,
             IBlogPostRepository blogPostRepository,
             IBlogRepository blogRepository,
             IBlobContainer<BlogPostCoverImageContainer> blobContainer,
-            ICmsUserLookupService userLookupService) : base(repository)
+            ICmsUserLookupService userLookupService)
         {
             BlogPostManager = blogPostManager;
             BlogPostRepository = blogPostRepository;
             BlogRepository = blogRepository;
             BlobContainer = blobContainer;
             UserLookupService = userLookupService;
 
-            GetListPolicyName = CmsKitAdminPermissions.BlogPosts.Default;
-            GetPolicyName = CmsKitAdminPermissions.BlogPosts.Default;
-            CreatePolicyName = CmsKitAdminPermissions.BlogPosts.Create;
-            UpdatePolicyName = CmsKitAdminPermissions.BlogPosts.Update;
-            DeletePolicyName = CmsKitAdminPermissions.BlogPosts.Delete;
         }
 
-        public virtual async Task<BlogPostDto> GetBySlugAsync(string blogSlug, string blogPostSlug)
+        [Authorize(CmsKitAdminPermissions.BlogPosts.Create)]
+        public virtual async Task<BlogPostDto> CreateAsync(CreateBlogPostDto input)
         {
-            var blog = await BlogRepository.GetBySlugAsync(blogSlug);
+            var author = await UserLookupService.GetByIdAsync(CurrentUser.GetId());
 
-            var blogPost = await BlogPostRepository.GetBySlugAsync(blog.Id, blogPostSlug);
+            var blog = await BlogRepository.GetAsync(input.BlogId);
 
-            return await MapToGetOutputDtoAsync(blogPost);
-        }
+            var blogPost = await BlogPostManager.CreateAsync(
+                                                        author,
+                                                        blog,
+                                                        input.Title,
+                                                        input.Slug,
+                                                        input.ShortDescription,
+                                                        CurrentTenant.Id);
 
-        [Authorize(CmsKitAdminPermissions.BlogPosts.Create)]
-        public override async Task<BlogPostDto> CreateAsync(CreateBlogPostDto input)
-        {
-            _ = await UserLookupService.GetByIdAsync(CurrentUser.GetId());
-
-            var entity = await BlogPostManager
-                                    .CreateAsync(
-                                        new BlogPost(
-                                            GuidGenerator.Create(),
-                                            input.BlogId,
-                                            input.Title,
-                                            input.Slug,
-                                            input.ShortDescription));
-
-            return await MapToGetOutputDtoAsync(entity);
+            await BlogPostRepository.InsertAsync(blogPost);
+
+            return ObjectMapper.Map<BlogPost, BlogPostDto>(blogPost);
         }
 
         [Authorize(CmsKitAdminPermissions.BlogPosts.Update)]
-        public override async Task<BlogPostDto> UpdateAsync(Guid id, UpdateBlogPostDto input)
+        public virtual async Task<BlogPostDto> UpdateAsync(Guid id, UpdateBlogPostDto input)
         {
             var blogPost = await BlogPostRepository.GetAsync(id);
 
             blogPost.SetTitle(input.Title);
+            blogPost.SetShortDescription(input.ShortDescription);
 
             if (blogPost.Slug != input.Slug)
             {
                 await BlogPostManager.SetSlugUrlAsync(blogPost, input.Slug);
             }
 
-            MapToEntity(input, blogPost);
-
-            await BlogPostManager.UpdateAsync(blogPost);
+            await BlogPostRepository.UpdateAsync(blogPost);
 
-            return await MapToGetOutputDtoAsync(blogPost);
+            return ObjectMapper.Map<BlogPost,BlogPostDto>(blogPost);
         }
 
+        [Authorize(CmsKitAdminPermissions.BlogPosts.Update)]
         public virtual async Task SetCoverImageAsync(Guid id, RemoteStreamContent streamContent)
         {
-            await Repository.GetAsync(id);
+            await BlogPostRepository.GetAsync(id);
 
             using (var stream = streamContent.GetStream())
             {
                 await BlobContainer.SaveAsync(id.ToString(), stream, overrideExisting: true);
             }
         }
 
+        [Authorize(CmsKitAdminPermissions.BlogPosts.Default)]
         public virtual async Task<RemoteStreamContent> GetCoverImageAsync(Guid id)
         {
             var stream = await BlobContainer.GetAsync(id.ToString());
 
             return new RemoteStreamContent(stream);
         }
+
+        [Authorize(CmsKitAdminPermissions.BlogPosts.Default)]
+        public virtual async Task<BlogPostDto> GetAsync(Guid id)
+        {
+            var blogPost = await BlogPostRepository.GetAsync(id);
+
+            return ObjectMapper.Map<BlogPost, BlogPostDto>(blogPost);
+        }
+
+        [Authorize(CmsKitAdminPermissions.BlogPosts.Default)]
+        public virtual async Task<PagedResultDto<BlogPostDto>> GetListAsync(PagedAndSortedResultRequestDto input)
+        {
+            if (input.Sorting.IsNullOrEmpty())
+            {
+                input.Sorting = nameof(BlogPost.CreationTime) + " desc";
+            }
+
+            var blogPosts = await BlogPostRepository.GetPagedListAsync(input.SkipCount, input.MaxResultCount, input.Sorting, includeDetails: true);
+
+            var count = await BlogPostRepository.GetCountAsync();
+
+            return new PagedResultDto<BlogPostDto>(
+                count,
+                ObjectMapper.Map<List<BlogPost>, List<BlogPostDto>>(blogPosts));
+        }
+
+        [Authorize(CmsKitAdminPermissions.BlogPosts.Delete)]
+        public virtual async Task DeleteAsync(Guid id)
+        {
+            await BlogPostRepository.DeleteAsync(id);
+        }
     }
 }

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

@@ -39,8 +39,6 @@ public CmsKitAdminApplicationAutoMapperProfile()
 
             CreateMap<Blog, BlogDto>();
 
-            CreateMap<BlogFeature, BlogFeatureDto>();
-
             CreateMap<TagEntityTypeDefiniton, TagDefinitionDto>(MemberList.Destination);
 
             CreateMap<MediaDescriptor, MediaDescriptorDto>();

modules/cms-kit/src/Volo.CmsKit.Admin.HttpApi/Volo/CmsKit/Admin/Blogs/BlogPostAdminController.cs

@@ -52,14 +52,6 @@ public virtual Task<BlogPostDto> GetAsync(Guid id)
             return BlogPostAdminAppService.GetAsync(id);
         }
 
-        [HttpGet]
-        [Route("{blogSlug}/{blogPostSlug}")]
-        [Authorize(CmsKitAdminPermissions.BlogPosts.Default)]
-        public virtual Task<BlogPostDto> GetBySlugAsync(string blogSlug, string blogPostSlug)
-        {
-            return BlogPostAdminAppService.GetBySlugAsync(blogSlug, blogPostSlug);
-        }
-
         [HttpGet]
         [Route("{id}/cover-image")]
         [Authorize(CmsKitAdminPermissions.BlogPosts.Default)]

modules/cms-kit/src/Volo.CmsKit.Common.Application.Contracts/Volo/CmsKit/Blogs/BlogFeatureCacheItem.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace Volo.CmsKit.Blogs
+{
+    [Serializable]
+    public class BlogFeatureCacheItem
+    {
+        public Guid Id { get; set; }
+        public string FeatureName { get; set; }
+        public bool IsEnabled { get; set; }
+    }
+}

modules/cms-kit/src/Volo.CmsKit.Common.Application.Contracts/Volo/CmsKit/Blogs/BlogFeatureCacheKey.cs

@@ -0,0 +1,24 @@
+using JetBrains.Annotations;
+using System;
+using Volo.Abp;
+
+namespace Volo.CmsKit.Blogs
+{
+    public class BlogFeatureCacheKey
+    {
+        public BlogFeatureCacheKey(Guid id, [NotNull] string featureName)
+        {
+            Id = id;
+            FeatureName = Check.NotNullOrEmpty(featureName, nameof(featureName));
+        }
+
+        public Guid Id { get; set; }
+
+        public string FeatureName { get; set; }
+
+        public override string ToString()
+        {
+            return $"BlogFeature_{Id}_{FeatureName}";
+        }
+    }
+}

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

@@ -2,40 +2,38 @@
 using System;
 using System.Threading.Tasks;
 using Volo.Abp.Caching;
-using Volo.Abp.EventBus.Distributed;
 
 namespace Volo.CmsKit.Blogs
 {
     public class BlogFeatureAppService : CmsKitAppServiceBase, IBlogFeatureAppService
     {
         protected virtual IBlogFeatureRepository BlogFeatureRepository { get; }
 
-        protected virtual IBlogFeatureCacheManager BlogFeatureCacheManager { get; }
+        protected virtual IDistributedCache<BlogFeatureCacheItem, BlogFeatureCacheKey> Cache { get; }
 
         public BlogFeatureAppService(
             IBlogFeatureRepository blogFeatureRepository,
-            IBlogFeatureCacheManager blogFeatureCacheManager)
+            IDistributedCache<BlogFeatureCacheItem, BlogFeatureCacheKey> blogFeatureCacheManager)
         {
             BlogFeatureRepository = blogFeatureRepository;
-            BlogFeatureCacheManager = blogFeatureCacheManager;
+            Cache = blogFeatureCacheManager;
         }
 
-        public virtual Task<BlogFeatureDto> GetOrDefaultAsync(Guid blogId, string featureName)
+        public virtual async Task<BlogFeatureDto> GetOrDefaultAsync(Guid blogId, string featureName)
         {
-            return BlogFeatureCacheManager
-                    .AddOrGetAsync(
-                        blogId,
-                        featureName,
-                        ()=> GetOrDefaultFroRepositoryAsync(blogId, featureName)
-                        );
+            var cacheItem = await Cache.GetOrAddAsync(
+                                    new BlogFeatureCacheKey(blogId, featureName),
+                                    ()=> GetOrDefaultFroRepositoryAsync(blogId, featureName));
+
+            return ObjectMapper.Map<BlogFeatureCacheItem, BlogFeatureDto>(cacheItem);
         }
 
-        protected virtual async Task<BlogFeatureDto> GetOrDefaultFroRepositoryAsync(Guid blogId, string featureName)
+        protected virtual async Task<BlogFeatureCacheItem> GetOrDefaultFroRepositoryAsync(Guid blogId, string featureName)
         {
             var feature = await BlogFeatureRepository.FindAsync(blogId, featureName);
             var blogFeature = feature ?? new BlogFeature(blogId, featureName);
 
-            return ObjectMapper.Map<BlogFeature, BlogFeatureDto>(blogFeature);
+            return ObjectMapper.Map<BlogFeature, BlogFeatureCacheItem>(blogFeature);
         }
     }
 }