Skip to content

Open-source eCommerce platform for C# and ASP.NET Core 10 with MongoDB. Build multi-store shops and multi-vendor marketplaces with B2B/B2C, REST API, plugins, Vue 3 and Docker.

Grand.Business.Cms - Code cleanup (ReSharper)

support6983be0db765
diff --git a/src/Business/Grand.Business.Cms/Events/BlogPostDeletedEventHandler.cs b/src/Business/Grand.Business.Cms/Events/BlogPostDeletedEventHandler.cs
index 756fa570d..2ec6f2845 100644
--- a/src/Business/Grand.Business.Cms/Events/BlogPostDeletedEventHandler.cs
+++ b/src/Business/Grand.Business.Cms/Events/BlogPostDeletedEventHandler.cs
@@ -1,22 +1,22 @@
using Grand.Business.Core.Interfaces.Common.Seo;
-using Grand.Infrastructure.Events;
using Grand.Domain.Blogs;
+using Grand.Infrastructure.Events;
using MediatR;
-namespace Grand.Business.Cms.Events
+namespace Grand.Business.Cms.Events;
+
+public class BlogPostDeletedEventHandler : INotificationHandler<EntityDeleted<BlogPost>>
{
- public class BlogPostDeletedEventHandler : INotificationHandler<EntityDeleted<BlogPost>>
+ private readonly ISlugService _slugService;
+
+ public BlogPostDeletedEventHandler(ISlugService slugService)
{
- private readonly ISlugService _slugService;
+ _slugService = slugService;
+ }
- public BlogPostDeletedEventHandler(ISlugService slugService)
- {
- _slugService = slugService;
- }
- public async Task Handle(EntityDeleted<BlogPost> notification, CancellationToken cancellationToken)
- {
- var urlToDelete = await _slugService.GetBySlug(notification.Entity.SeName);
- await _slugService.DeleteEntityUrl(urlToDelete);
- }
+ public async Task Handle(EntityDeleted<BlogPost> notification, CancellationToken cancellationToken)
+ {
+ var urlToDelete = await _slugService.GetBySlug(notification.Entity.SeName);
+ await _slugService.DeleteEntityUrl(urlToDelete);
}
-}
+}
\ No newline at end of file
diff --git a/src/Business/Grand.Business.Cms/Services/BlogService.cs b/src/Business/Grand.Business.Cms/Services/BlogService.cs
index 2cf52a11e..c08db149c 100644
--- a/src/Business/Grand.Business.Cms/Services/BlogService.cs
+++ b/src/Business/Grand.Business.Cms/Services/BlogService.cs
@@ -1,474 +1,468 @@
using Grand.Business.Core.Interfaces.Cms;
+using Grand.Data;
using Grand.Domain;
using Grand.Domain.Blogs;
-using Grand.Data;
using Grand.Infrastructure.Configuration;
using Grand.Infrastructure.Extensions;
using MediatR;
-namespace Grand.Business.Cms.Services
+namespace Grand.Business.Cms.Services;
+
+/// <summary>
+/// Blog service
+/// </summary>
+public class BlogService : IBlogService
{
- /// <summary>
- /// Blog service
- /// </summary>
- public class BlogService : IBlogService
+ #region Ctor
+
+ public BlogService(IRepository<BlogPost> blogPostRepository,
+ IRepository<BlogComment> blogCommentRepository,
+ IRepository<BlogCategory> blogCategoryRepository,
+ IRepository<BlogProduct> blogProductRepository,
+ IMediator mediator, AccessControlConfig accessControlConfig)
{
- #region Fields
+ _blogPostRepository = blogPostRepository;
+ _blogCommentRepository = blogCommentRepository;
+ _blogCategoryRepository = blogCategoryRepository;
+ _blogProductRepository = blogProductRepository;
+ _mediator = mediator;
+ _accessControlConfig = accessControlConfig;
+ }
- private readonly IRepository<BlogPost> _blogPostRepository;
- private readonly IRepository<BlogComment> _blogCommentRepository;
- private readonly IRepository<BlogCategory> _blogCategoryRepository;
- private readonly IRepository<BlogProduct> _blogProductRepository;
- private readonly AccessControlConfig _accessControlConfig;
- private readonly IMediator _mediator;
+ #endregion
- #endregion
+ #region Fields
- #region Ctor
+ private readonly IRepository<BlogPost> _blogPostRepository;
+ private readonly IRepository<BlogComment> _blogCommentRepository;
+ private readonly IRepository<BlogCategory> _blogCategoryRepository;
+ private readonly IRepository<BlogProduct> _blogProductRepository;
+ private readonly AccessControlConfig _accessControlConfig;
+ private readonly IMediator _mediator;
- public BlogService(IRepository<BlogPost> blogPostRepository,
- IRepository<BlogComment> blogCommentRepository,
- IRepository<BlogCategory> blogCategoryRepository,
- IRepository<BlogProduct> blogProductRepository,
- IMediator mediator, AccessControlConfig accessControlConfig)
- {
- _blogPostRepository = blogPostRepository;
- _blogCommentRepository = blogCommentRepository;
- _blogCategoryRepository = blogCategoryRepository;
- _blogProductRepository = blogProductRepository;
- _mediator = mediator;
- _accessControlConfig = accessControlConfig;
- }
+ #endregion
- #endregion
+ #region Methods
- #region Methods
+ /// <summary>
+ /// Gets a blog post
+ /// </summary>
+ /// <param name="blogPostId">Blog post identifier</param>
+ /// <returns>Blog post</returns>
+ public virtual Task<BlogPost> GetBlogPostById(string blogPostId)
+ {
+ return _blogPostRepository.GetByIdAsync(blogPostId);
+ }
- /// <summary>
- /// Gets a blog post
- /// </summary>
- /// <param name="blogPostId">Blog post identifier</param>
- /// <returns>Blog post</returns>
- public virtual Task<BlogPost> GetBlogPostById(string blogPostId)
- {
- return _blogPostRepository.GetByIdAsync(blogPostId);
- }
+ /// <summary>
+ /// Gets all blog posts
+ /// </summary>
+ /// <param name="storeId">The store identifier; pass "" to load all records</param>
+ /// <param name="dateFrom">Filter by created date; null if you want to get all records</param>
+ /// <param name="dateTo">Filter by created date; null if you want to get all records</param>
+ /// <param name="pageIndex">Page index</param>
+ /// <param name="pageSize">Page size</param>
+ /// <param name="showHidden">A value indicating whether to show hidden records</param>
+ /// <param name="tag">Tag</param>
+ /// <param name="blogPostName">Blog post name</param>
+ /// <param name="categoryId">Category ident</param>
+ /// <returns>Blog posts</returns>
+ public virtual async Task<IPagedList<BlogPost>> GetAllBlogPosts(string storeId = "",
+ DateTime? dateFrom = null, DateTime? dateTo = null,
+ int pageIndex = 0, int pageSize = int.MaxValue, bool showHidden = false, string tag = null,
+ string blogPostName = "", string categoryId = "")
+ {
+ var query = from p in _blogPostRepository.Table
+ select p;
- /// <summary>
- /// Gets all blog posts
- /// </summary>
- /// <param name="storeId">The store identifier; pass "" to load all records</param>
- /// <param name="dateFrom">Filter by created date; null if you want to get all records</param>
- /// <param name="dateTo">Filter by created date; null if you want to get all records</param>
- /// <param name="pageIndex">Page index</param>
- /// <param name="pageSize">Page size</param>
- /// <param name="showHidden">A value indicating whether to show hidden records</param>
- /// <param name="tag">Tag</param>
- /// <param name="blogPostName">Blog post name</param>
- /// <param name="categoryId">Category ident</param>
- /// <returns>Blog posts</returns>
- public virtual async Task<IPagedList<BlogPost>> GetAllBlogPosts(string storeId = "",
- DateTime? dateFrom = null, DateTime? dateTo = null,
- int pageIndex = 0, int pageSize = int.MaxValue, bool showHidden = false, string tag = null, string blogPostName = "", string categoryId = "")
+ if (!string.IsNullOrEmpty(categoryId))
{
-
- var query = from p in _blogPostRepository.Table
- select p;
-
- if (!string.IsNullOrEmpty(categoryId))
+ var category = await _blogCategoryRepository.GetOneAsync(x => x.Id == categoryId);
+ if (category != null)
{
- var category = await _blogCategoryRepository.GetOneAsync(x => x.Id == categoryId);
- if (category != null)
- {
- var postsIds = category.BlogPosts.Select(x => x.BlogPostId);
- query = query.Where(x => postsIds.Contains(x.Id));
- }
+ var postsIds = category.BlogPosts.Select(x => x.BlogPostId);
+ query = query.Where(x => postsIds.Contains(x.Id));
}
+ }
- if (!string.IsNullOrWhiteSpace(blogPostName))
- {
- query = query.Where
- (b => (b.Title != null && b.Title.ToLower().Contains(blogPostName.ToLower())) ||
- (b.BodyOverview != null && b.BodyOverview.ToLower().Contains(blogPostName.ToLower())));
- }
- if (dateFrom.HasValue)
- query = query.Where(b => dateFrom.Value <= b.CreatedOnUtc);
- if (dateTo.HasValue)
- query = query.Where(b => dateTo.Value >= b.CreatedOnUtc);
+ if (!string.IsNullOrWhiteSpace(blogPostName))
+ query = query.Where
+ (b => (b.Title != null && b.Title.ToLower().Contains(blogPostName.ToLower())) ||
+ (b.BodyOverview != null && b.BodyOverview.ToLower().Contains(blogPostName.ToLower())));
+ if (dateFrom.HasValue)
+ query = query.Where(b => dateFrom.Value <= b.CreatedOnUtc);
+ if (dateTo.HasValue)
+ query = query.Where(b => dateTo.Value >= b.CreatedOnUtc);
- if (!showHidden)
- {
- var utcNow = DateTime.UtcNow;
- query = query.Where(b => !b.StartDateUtc.HasValue || b.StartDateUtc <= utcNow);
- query = query.Where(b => !b.EndDateUtc.HasValue || b.EndDateUtc >= utcNow);
- }
+ if (!showHidden)
+ {
+ var utcNow = DateTime.UtcNow;
+ query = query.Where(b => !b.StartDateUtc.HasValue || b.StartDateUtc <= utcNow);
+ query = query.Where(b => !b.EndDateUtc.HasValue || b.EndDateUtc >= utcNow);
+ }
- if (!string.IsNullOrEmpty(storeId) && !_accessControlConfig.IgnoreStoreLimitations)
- {
- query = query.Where(b => b.Stores.Contains(storeId) || !b.LimitedToStores);
- }
- if (!string.IsNullOrEmpty(tag))
- {
- query = query.Where(x => x.Tags.Contains(tag));
- }
+ if (!string.IsNullOrEmpty(storeId) && !_accessControlConfig.IgnoreStoreLimitations)
+ query = query.Where(b => b.Stores.Contains(storeId) || !b.LimitedToStores);
+ if (!string.IsNullOrEmpty(tag)) query = query.Where(x => x.Tags.Contains(tag));
- query = query.OrderByDescending(b => b.CreatedOnUtc);
+ query = query.OrderByDescending(b => b.CreatedOnUtc);
- return await PagedList<BlogPost>.Create(query, pageIndex, pageSize);
+ return await PagedList<BlogPost>.Create(query, pageIndex, pageSize);
+ }
- }
+ /// <summary>
+ /// Gets all blog posts
+ /// </summary>
+ /// <param name="storeId">The store identifier; pass "" to load all records</param>
+ /// <param name="tag">Tag</param>
+ /// <param name="pageIndex">Page index</param>
+ /// <param name="pageSize">Page size</param>
+ /// <param name="showHidden">A value indicating whether to show hidden records</param>
+ /// <returns>Blog posts</returns>
+ public virtual async Task<IPagedList<BlogPost>> GetAllBlogPostsByTag(string storeId = "",
+ string tag = "",
+ int pageIndex = 0, int pageSize = int.MaxValue, bool showHidden = false)
+ {
+ tag = tag.Trim();
- /// <summary>
- /// Gets all blog posts
- /// </summary>
- /// <param name="storeId">The store identifier; pass "" to load all records</param>
- /// <param name="tag">Tag</param>
- /// <param name="pageIndex">Page index</param>
- /// <param name="pageSize">Page size</param>
- /// <param name="showHidden">A value indicating whether to show hidden records</param>
- /// <returns>Blog posts</returns>
- public virtual async Task<IPagedList<BlogPost>> GetAllBlogPostsByTag(string storeId = "",
- string tag = "",
- int pageIndex = 0, int pageSize = int.MaxValue, bool showHidden = false)
- {
- tag = tag.Trim();
+ //we load all records and only then filter them by tag
+ var blogPostsAll = await GetAllBlogPosts(storeId, showHidden: showHidden, tag: tag);
+ var taggedBlogPosts = (from blogPost in blogPostsAll
+ let tags = blogPost.ParseTags()
+ where !string.IsNullOrEmpty(tags.FirstOrDefault(t => t.Equals(tag, StringComparison.OrdinalIgnoreCase)))
+ select blogPost).ToList();
- //we load all records and only then filter them by tag
- var blogPostsAll = await GetAllBlogPosts(storeId: storeId, showHidden: showHidden, tag: tag);
- var taggedBlogPosts = (from blogPost in blogPostsAll let tags = blogPost.ParseTags() where !string.IsNullOrEmpty(tags.FirstOrDefault(t => t.Equals(tag, StringComparison.OrdinalIgnoreCase))) select blogPost).ToList();
+ //server-side paging
+ return new PagedList<BlogPost>(taggedBlogPosts, pageIndex, pageSize);
+ }
- //server-side paging
- return new PagedList<BlogPost>(taggedBlogPosts, pageIndex, pageSize);
- }
+ /// <summary>
+ /// Gets all blog post tags
+ /// </summary>
+ /// <param name="storeId">The store identifier; pass "" to load all records</param>
+ /// <param name="showHidden">A value indicating whether to show hidden records</param>
+ /// <returns>Blog post tags</returns>
+ public virtual async Task<IList<BlogPostTag>> GetAllBlogPostTags(string storeId, bool showHidden = false)
+ {
+ var blogPostTags = new List<BlogPostTag>();
- /// <summary>
- /// Gets all blog post tags
- /// </summary>
- /// <param name="storeId">The store identifier; pass "" to load all records</param>
- /// <param name="showHidden">A value indicating whether to show hidden records</param>
- /// <returns>Blog post tags</returns>
- public virtual async Task<IList<BlogPostTag>> GetAllBlogPostTags(string storeId, bool showHidden = false)
+ var blogPosts = await GetAllBlogPosts(storeId, showHidden: showHidden);
+ foreach (var blogPost in blogPosts)
{
- var blogPostTags = new List<BlogPostTag>();
-
- var blogPosts = await GetAllBlogPosts(storeId: storeId, showHidden: showHidden);
- foreach (var blogPost in blogPosts)
+ var tags = blogPost.ParseTags();
+ foreach (var tag in tags)
{
- var tags = blogPost.ParseTags();
- foreach (var tag in tags)
+ var foundBlogPostTag =
+ blogPostTags.Find(bpt => bpt.Name.Equals(tag, StringComparison.OrdinalIgnoreCase));
+ if (foundBlogPostTag == null)
+ {
+ foundBlogPostTag = new BlogPostTag {
+ Name = tag,
+ BlogPostCount = 1
+ };
+ blogPostTags.Add(foundBlogPostTag);
+ }
+ else
{
- var foundBlogPostTag = blogPostTags.Find(bpt => bpt.Name.Equals(tag, StringComparison.OrdinalIgnoreCase));
- if (foundBlogPostTag == null)
- {
- foundBlogPostTag = new BlogPostTag
- {
- Name = tag,
- BlogPostCount = 1
- };
- blogPostTags.Add(foundBlogPostTag);
- }
- else
- foundBlogPostTag.BlogPostCount++;
+ foundBlogPostTag.BlogPostCount++;
}
}
-
- return blogPostTags;
}
- /// <summary>
- /// Inserts an blog post
- /// </summary>
- /// <param name="blogPost">Blog post</param>
- public virtual async Task InsertBlogPost(BlogPost blogPost)
- {
- ArgumentNullException.ThrowIfNull(blogPost);
-
- await _blogPostRepository.InsertAsync(blogPost);
+ return blogPostTags;
+ }
- //event notification
- await _mediator.EntityInserted(blogPost);
- }
+ /// <summary>
+ /// Inserts an blog post
+ /// </summary>
+ /// <param name="blogPost">Blog post</param>
+ public virtual async Task InsertBlogPost(BlogPost blogPost)
+ {
+ ArgumentNullException.ThrowIfNull(blogPost);
- /// <summary>
- /// Updates the blog post
- /// </summary>
- /// <param name="blogPost">Blog post</param>
- public virtual async Task UpdateBlogPost(BlogPost blogPost)
- {
- ArgumentNullException.ThrowIfNull(blogPost);
+ await _blogPostRepository.InsertAsync(blogPost);
- await _blogPostRepository.UpdateAsync(blogPost);
+ //event notification
+ await _mediator.EntityInserted(blogPost);
+ }
- //event notification
- await _mediator.EntityUpdated(blogPost);
- }
- /// <summary>
- /// Deletes a blog post
- /// </summary>
- /// <param name="blogPost">Blog post</param>
- public virtual async Task DeleteBlogPost(BlogPost blogPost)
- {
- ArgumentNullException.ThrowIfNull(blogPost);
+ /// <summary>
+ /// Updates the blog post
+ /// </summary>
+ /// <param name="blogPost">Blog post</param>
+ public virtual async Task UpdateBlogPost(BlogPost blogPost)
+ {
+ ArgumentNullException.ThrowIfNull(blogPost);
- await _blogPostRepository.DeleteAsync(blogPost);
+ await _blogPostRepository.UpdateAsync(blogPost);
- //event notification
- await _mediator.EntityDeleted(blogPost);
- }
+ //event notification
+ await _mediator.EntityUpdated(blogPost);
+ }
- /// <summary>
- /// Gets all comments
- /// </summary>
- /// <param name="customerId">Customer identifier; "" to load all records</param>
- /// <param name="storeId">Store ident</param>
- /// <returns>Comments</returns>
- public virtual async Task<IList<BlogComment>> GetAllComments(string customerId, string storeId)
- {
- var query = from c in _blogCommentRepository.Table
- orderby c.CreatedOnUtc
- where (customerId == "" || c.CustomerId == customerId) && (storeId == "" || c.StoreId == storeId)
- select c;
+ /// <summary>
+ /// Deletes a blog post
+ /// </summary>
+ /// <param name="blogPost">Blog post</param>
+ public virtual async Task DeleteBlogPost(BlogPost blogPost)
+ {
+ ArgumentNullException.ThrowIfNull(blogPost);
- return await Task.FromResult(query.ToList());
- }
+ await _blogPostRepository.DeleteAsync(blogPost);
- /// <summary>
- /// Gets a blog comment
- /// </summary>
- /// <param name="blogCommentId">Blog comment identifier</param>
- /// <returns>Blog comment</returns>
- public virtual Task<BlogComment> GetBlogCommentById(string blogCommentId)
- {
- return _blogCommentRepository.GetByIdAsync(blogCommentId);
- }
+ //event notification
+ await _mediator.EntityDeleted(blogPost);
+ }
- public virtual async Task<IList<BlogComment>> GetBlogCommentsByBlogPostId(string blogPostId)
- {
- var query = from c in _blogCommentRepository.Table
- where c.BlogPostId == blogPostId
- orderby c.CreatedOnUtc
- select c;
+ /// <summary>
+ /// Gets all comments
+ /// </summary>
+ /// <param name="customerId">Customer identifier; "" to load all records</param>
+ /// <param name="storeId">Store ident</param>
+ /// <returns>Comments</returns>
+ public virtual async Task<IList<BlogComment>> GetAllComments(string customerId, string storeId)
+ {
+ var query = from c in _blogCommentRepository.Table
+ orderby c.CreatedOnUtc
+ where (customerId == "" || c.CustomerId == customerId) && (storeId == "" || c.StoreId == storeId)
+ select c;
- return await Task.FromResult(query.ToList());
- }
- /// <summary>
- /// Get blog comments by identifiers
- /// </summary>
- /// <param name="commentIds">Blog comment identifiers</param>
- /// <returns>Blog comments</returns>
- public virtual async Task<IList<BlogComment>> GetBlogCommentsByIds(string[] commentIds)
- {
- if (commentIds == null || commentIds.Length == 0)
- return new List<BlogComment>();
-
- var query = from bc in _blogCommentRepository.Table
- where commentIds.Contains(bc.Id)
- select bc;
- var comments = query.ToList();
- //sort by passed identifiers
- var sortedComments = commentIds.Select(id => comments.Find(x => x.Id == id)).Where(comment => comment != null).ToList();
- return await Task.FromResult(sortedComments);
- }
+ return await Task.FromResult(query.ToList());
+ }
- /// <summary>
- /// Inserts a blog post comment
- /// </summary>
- /// <param name="blogComment">Blog post comment</param>
- public virtual async Task InsertBlogComment(BlogComment blogComment)
- {
- ArgumentNullException.ThrowIfNull(blogComment);
+ /// <summary>
+ /// Gets a blog comment
+ /// </summary>
+ /// <param name="blogCommentId">Blog comment identifier</param>
+ /// <returns>Blog comment</returns>
+ public virtual Task<BlogComment> GetBlogCommentById(string blogCommentId)
+ {
+ return _blogCommentRepository.GetByIdAsync(blogCommentId);
+ }
- await _blogCommentRepository.InsertAsync(blogComment);
+ public virtual async Task<IList<BlogComment>> GetBlogCommentsByBlogPostId(string blogPostId)
+ {
+ var query = from c in _blogCommentRepository.Table
+ where c.BlogPostId == blogPostId
+ orderby c.CreatedOnUtc
+ select c;
- //event notification
- await _mediator.EntityInserted(blogComment);
- }
+ return await Task.FromResult(query.ToList());
+ }
- public virtual async Task DeleteBlogComment(BlogComment blogComment)
- {
- ArgumentNullException.ThrowIfNull(blogComment);
+ /// <summary>
+ /// Get blog comments by identifiers
+ /// </summary>
+ /// <param name="commentIds">Blog comment identifiers</param>
+ /// <returns>Blog comments</returns>
+ public virtual async Task<IList<BlogComment>> GetBlogCommentsByIds(string[] commentIds)
+ {
+ if (commentIds == null || commentIds.Length == 0)
+ return new List<BlogComment>();
+
+ var query = from bc in _blogCommentRepository.Table
+ where commentIds.Contains(bc.Id)
+ select bc;
+ var comments = query.ToList();
+ //sort by passed identifiers
+ var sortedComments = commentIds.Select(id => comments.Find(x => x.Id == id)).Where(comment => comment != null)
+ .ToList();
+ return await Task.FromResult(sortedComments);
+ }
- await _blogCommentRepository.DeleteAsync(blogComment);
- }
+ /// <summary>
+ /// Inserts a blog post comment
+ /// </summary>
+ /// <param name="blogComment">Blog post comment</param>
+ public virtual async Task InsertBlogComment(BlogComment blogComment)
+ {
+ ArgumentNullException.ThrowIfNull(blogComment);
- #region Blog category
+ await _blogCommentRepository.InsertAsync(blogComment);
- /// <summary>
- /// Get category by id
- /// </summary>
- /// <param name="blogCategoryId">Blog category id</param>
- /// <returns></returns>
- public virtual Task<BlogCategory> GetBlogCategoryById(string blogCategoryId)
- {
- return _blogCategoryRepository.GetByIdAsync(blogCategoryId);
- }
+ //event notification
+ await _mediator.EntityInserted(blogComment);
+ }
- /// <summary>
- /// Get categories by post id
- /// </summary>
- /// <param name="blogPostId">Blog post id</param>
- /// <returns></returns>
- public virtual async Task<IList<BlogCategory>> GetBlogCategoryByPostId(string blogPostId)
- {
- return await Task.FromResult(_blogCategoryRepository.Table.Where(x => x.BlogPosts.Any(x => x.BlogPostId == blogPostId)).ToList());
- }
+ public virtual async Task DeleteBlogComment(BlogComment blogComment)
+ {
+ ArgumentNullException.ThrowIfNull(blogComment);
- /// <summary>
- /// Get category by se-name
- /// </summary>
- /// <param name="blogCategorySeName">Blog category se-name</param>
- /// <returns></returns>
- public virtual async Task<BlogCategory> GetBlogCategoryBySeName(string blogCategorySeName)
- {
- if (string.IsNullOrEmpty(blogCategorySeName))
- throw new ArgumentNullException(nameof(blogCategorySeName));
+ await _blogCommentRepository.DeleteAsync(blogComment);
+ }
- return await _blogCategoryRepository.GetOneAsync(x => x.SeName == blogCategorySeName.ToLowerInvariant());
- }
+ #region Blog category
- /// <summary>
- /// Get all blog categories
- /// </summary>
- /// <returns></returns>
- public virtual async Task<IList<BlogCategory>> GetAllBlogCategories(string storeId = "")
- {
- var query = from c in _blogCategoryRepository.Table
- select c;
+ /// <summary>
+ /// Get category by id
+ /// </summary>
+ /// <param name="blogCategoryId">Blog category id</param>
+ /// <returns></returns>
+ public virtual Task<BlogCategory> GetBlogCategoryById(string blogCategoryId)
+ {
+ return _blogCategoryRepository.GetByIdAsync(blogCategoryId);
+ }
- if (!string.IsNullOrEmpty(storeId) && !_accessControlConfig.IgnoreStoreLimitations)
- {
- query = query.Where(b => b.Stores.Contains(storeId) || !b.LimitedToStores);
- }
+ /// <summary>
+ /// Get categories by post id
+ /// </summary>
+ /// <param name="blogPostId">Blog post id</param>
+ /// <returns></returns>
+ public virtual async Task<IList<BlogCategory>> GetBlogCategoryByPostId(string blogPostId)
+ {
+ return await Task.FromResult(_blogCategoryRepository.Table
+ .Where(x => x.BlogPosts.Any(x => x.BlogPostId == blogPostId)).ToList());
+ }
- return await Task.FromResult(query.OrderBy(x => x.DisplayOrder).ToList());
- }
+ /// <summary>
+ /// Get category by se-name
+ /// </summary>
+ /// <param name="blogCategorySeName">Blog category se-name</param>
+ /// <returns></returns>
+ public virtual async Task<BlogCategory> GetBlogCategoryBySeName(string blogCategorySeName)
+ {
+ if (string.IsNullOrEmpty(blogCategorySeName))
+ throw new ArgumentNullException(nameof(blogCategorySeName));
- /// <summary>
- /// Inserts an blog category
- /// </summary>
- /// <param name="blogCategory">Blog category</param>
- public virtual async Task<BlogCategory> InsertBlogCategory(BlogCategory blogCategory)
- {
- ArgumentNullException.ThrowIfNull(blogCategory);
+ return await _blogCategoryRepository.GetOneAsync(x => x.SeName == blogCategorySeName.ToLowerInvariant());
+ }
- await _blogCategoryRepository.InsertAsync(blogCategory);
+ /// <summary>
+ /// Get all blog categories
+ /// </summary>
+ /// <returns></returns>
+ public virtual async Task<IList<BlogCategory>> GetAllBlogCategories(string storeId = "")
+ {
+ var query = from c in _blogCategoryRepository.Table
+ select c;
- //event notification
- await _mediator.EntityInserted(blogCategory);
+ if (!string.IsNullOrEmpty(storeId) && !_accessControlConfig.IgnoreStoreLimitations)
+ query = query.Where(b => b.Stores.Contains(storeId) || !b.LimitedToStores);
- return blogCategory;
- }
+ return await Task.FromResult(query.OrderBy(x => x.DisplayOrder).ToList());
+ }
- /// <summary>
- /// Updates the blog category
- /// </summary>
- /// <param name="blogCategory">Blog category</param>
- public virtual async Task<BlogCategory> UpdateBlogCategory(BlogCategory blogCategory)
- {
- ArgumentNullException.ThrowIfNull(blogCategory);
+ /// <summary>
+ /// Inserts an blog category
+ /// </summary>
+ /// <param name="blogCategory">Blog category</param>
+ public virtual async Task<BlogCategory> InsertBlogCategory(BlogCategory blogCategory)
+ {
+ ArgumentNullException.ThrowIfNull(blogCategory);
- await _blogCategoryRepository.UpdateAsync(blogCategory);
+ await _blogCategoryRepository.InsertAsync(blogCategory);
- //event notification
- await _mediator.EntityUpdated(blogCategory);
+ //event notification
+ await _mediator.EntityInserted(blogCategory);
- return blogCategory;
- }
+ return blogCategory;
+ }
- /// <summary>
- /// Delete blog category
- /// </summary>
- /// <param name="blogCategory">Blog category</param>
- public virtual async Task DeleteBlogCategory(BlogCategory blogCategory)
- {
- ArgumentNullException.ThrowIfNull(blogCategory);
+ /// <summary>
+ /// Updates the blog category
+ /// </summary>
+ /// <param name="blogCategory">Blog category</param>
+ public virtual async Task<BlogCategory> UpdateBlogCategory(BlogCategory blogCategory)
+ {
+ ArgumentNullException.ThrowIfNull(blogCategory);
- await _blogCategoryRepository.DeleteAsync(blogCategory);
+ await _blogCategoryRepository.UpdateAsync(blogCategory);
- //event notification
- await _mediator.EntityDeleted(blogCategory);
- }
+ //event notification
+ await _mediator.EntityUpdated(blogCategory);
- #endregion
+ return blogCategory;
+ }
- #region Blog post product
+ /// <summary>
+ /// Delete blog category
+ /// </summary>
+ /// <param name="blogCategory">Blog category</param>
+ public virtual async Task DeleteBlogCategory(BlogCategory blogCategory)
+ {
+ ArgumentNullException.ThrowIfNull(blogCategory);
- /// <summary>
- /// Gets a blog product
- /// </summary>
- /// <param name="id">id</param>
- /// <returns>Blog product</returns>
- public virtual Task<BlogProduct> GetBlogProductById(string id)
- {
- return _blogProductRepository.GetByIdAsync(id);
- }
+ await _blogCategoryRepository.DeleteAsync(blogCategory);
- /// <summary>
- /// Insert an blog product
- /// </summary>
- /// <param name="blogProduct">Blog product</param>
- public virtual async Task InsertBlogProduct(BlogProduct blogProduct)
- {
- ArgumentNullException.ThrowIfNull(blogProduct);
+ //event notification
+ await _mediator.EntityDeleted(blogCategory);
+ }
- await _blogProductRepository.InsertAsync(blogProduct);
+ #endregion
- //event notification
- await _mediator.EntityInserted(blogProduct);
+ #region Blog post product
- }
+ /// <summary>
+ /// Gets a blog product
+ /// </summary>
+ /// <param name="id">id</param>
+ /// <returns>Blog product</returns>
+ public virtual Task<BlogProduct> GetBlogProductById(string id)
+ {
+ return _blogProductRepository.GetByIdAsync(id);
+ }
- /// <summary>
- /// Update an blog product
- /// </summary>
- /// <param name="blogProduct">Blog product</param>
- public virtual async Task UpdateBlogProduct(BlogProduct blogProduct)
- {
- ArgumentNullException.ThrowIfNull(blogProduct);
+ /// <summary>
+ /// Insert an blog product
+ /// </summary>
+ /// <param name="blogProduct">Blog product</param>
+ public virtual async Task InsertBlogProduct(BlogProduct blogProduct)
+ {
+ ArgumentNullException.ThrowIfNull(blogProduct);
- await _blogProductRepository.UpdateAsync(blogProduct);
+ await _blogProductRepository.InsertAsync(blogProduct);
- //event notification
- await _mediator.EntityUpdated(blogProduct);
+ //event notification
+ await _mediator.EntityInserted(blogProduct);
+ }
- }
+ /// <summary>
+ /// Update an blog product
+ /// </summary>
+ /// <param name="blogProduct">Blog product</param>
+ public virtual async Task UpdateBlogProduct(BlogProduct blogProduct)
+ {
+ ArgumentNullException.ThrowIfNull(blogProduct);
- /// <summary>
- /// Delete an blog product
- /// </summary>
- /// <param name="blogProduct">Blog product</param>
- public virtual async Task DeleteBlogProduct(BlogProduct blogProduct)
- {
- ArgumentNullException.ThrowIfNull(blogProduct);
+ await _blogProductRepository.UpdateAsync(blogProduct);
- await _blogProductRepository.DeleteAsync(blogProduct);
+ //event notification
+ await _mediator.EntityUpdated(blogProduct);
+ }
- //event notification
- await _mediator.EntityDeleted(blogProduct);
+ /// <summary>
+ /// Delete an blog product
+ /// </summary>
+ /// <param name="blogProduct">Blog product</param>
+ public virtual async Task DeleteBlogProduct(BlogProduct blogProduct)
+ {
+ ArgumentNullException.ThrowIfNull(blogProduct);
- }
+ await _blogProductRepository.DeleteAsync(blogProduct);
- /// <summary>
- /// Get all product by blog post id
- /// </summary>
- /// <returns></returns>
- public virtual async Task<IList<BlogProduct>> GetProductsByBlogPostId(string blogPostId)
- {
- if (string.IsNullOrEmpty(blogPostId))
- return new List<BlogProduct>();
+ //event notification
+ await _mediator.EntityDeleted(blogProduct);
+ }
- var query = from bp in _blogProductRepository.Table
- where bp.BlogPostId == blogPostId
- orderby bp.DisplayOrder
- select bp;
+ /// <summary>
+ /// Get all product by blog post id
+ /// </summary>
+ /// <returns></returns>
+ public virtual async Task<IList<BlogProduct>> GetProductsByBlogPostId(string blogPostId)
+ {
+ if (string.IsNullOrEmpty(blogPostId))
+ return new List<BlogProduct>();
- return await Task.FromResult(query.ToList());
- }
+ var query = from bp in _blogProductRepository.Table
+ where bp.BlogPostId == blogPostId
+ orderby bp.DisplayOrder
+ select bp;
- #endregion
+ return await Task.FromResult(query.ToList());
+ }
+ #endregion
- #endregion
- }
-}
+ #endregion
+}
\ No newline at end of file
diff --git a/src/Business/Grand.Business.Cms/Services/CookiePreference.cs b/src/Business/Grand.Business.Cms/Services/CookiePreference.cs
index 48bccaae5..a25d5810f 100644
--- a/src/Business/Grand.Business.Cms/Services/CookiePreference.cs
+++ b/src/Business/Grand.Business.Cms/Services/CookiePreference.cs
@@ -3,35 +3,36 @@ using Grand.Business.Core.Interfaces.Common.Directory;
using Grand.Domain.Customers;
using Grand.Domain.Stores;
-namespace Grand.Business.Cms.Services
+namespace Grand.Business.Cms.Services;
+
+public class CookiePreference : ICookiePreference
{
- public class CookiePreference : ICookiePreference
- {
- private readonly IUserFieldService _userFieldService;
- private readonly IEnumerable<IConsentCookie> _consentCookies;
+ private readonly IEnumerable<IConsentCookie> _consentCookies;
+ private readonly IUserFieldService _userFieldService;
- public CookiePreference(IUserFieldService userFieldService,
- IEnumerable<IConsentCookie> consentCookies)
- {
- _userFieldService = userFieldService;
- _consentCookies = consentCookies;
- }
+ public CookiePreference(IUserFieldService userFieldService,
+ IEnumerable<IConsentCookie> consentCookies)
+ {
+ _userFieldService = userFieldService;
+ _consentCookies = consentCookies;
+ }
- public virtual IList<IConsentCookie> GetConsentCookies()
- {
- return _consentCookies.OrderBy(x => x.DisplayOrder).ToList();
- }
+ public virtual IList<IConsentCookie> GetConsentCookies()
+ {
+ return _consentCookies.OrderBy(x => x.DisplayOrder).ToList();
+ }
- public virtual async Task<bool?> IsEnable(Customer customer, Store store, string cookieSystemName)
- {
- var result = default(bool?);
- var savedCookiesConsent = await _userFieldService.GetFieldsForEntity<Dictionary<string, bool>>(customer, SystemCustomerFieldNames.ConsentCookies, store.Id);
- if (savedCookiesConsent == null) return null;
- if (savedCookiesConsent.ContainsKey(cookieSystemName))
- result = savedCookiesConsent[cookieSystemName];
+ public virtual async Task<bool?> IsEnable(Customer customer, Store store, string cookieSystemName)
+ {
+ var result = default(bool?);
+ var savedCookiesConsent =
+ await _userFieldService.GetFieldsForEntity<Dictionary<string, bool>>(customer,
+ SystemCustomerFieldNames.ConsentCookies, store.Id);
+ if (savedCookiesConsent == null) return null;
+ if (savedCookiesConsent.ContainsKey(cookieSystemName))
+ result = savedCookiesConsent[cookieSystemName];
- return result;
- }
+ return result;
}
-}
+}
\ No newline at end of file
diff --git a/src/Business/Grand.Business.Cms/Services/KnowledgebaseService.cs b/src/Business/Grand.Business.Cms/Services/KnowledgebaseService.cs
index 4c07eb75b..77d5c1ea3 100644
--- a/src/Business/Grand.Business.Cms/Services/KnowledgebaseService.cs
+++ b/src/Business/Grand.Business.Cms/Services/KnowledgebaseService.cs
@@ -1,7 +1,7 @@
using Grand.Business.Core.Interfaces.Cms;
+using Grand.Data;
using Grand.Domain;
using Grand.Domain.Customers;
-using Grand.Data;
using Grand.Domain.Knowledgebase;
using Grand.Infrastructure;
using Grand.Infrastructure.Caching;
@@ -10,611 +10,602 @@ using Grand.Infrastructure.Configuration;
using Grand.Infrastructure.Extensions;
using MediatR;
-namespace Grand.Business.Cms.Services
+namespace Grand.Business.Cms.Services;
+
+public class KnowledgebaseService : IKnowledgebaseService
{
- public class KnowledgebaseService : IKnowledgebaseService
+ private readonly AccessControlConfig _accessControlConfig;
+ private readonly IRepository<KnowledgebaseArticleComment> _articleCommentRepository;
+ private readonly ICacheBase _cacheBase;
+ private readonly IRepository<KnowledgebaseArticle> _knowledgebaseArticleRepository;
+ private readonly IRepository<KnowledgebaseCategory> _knowledgebaseCategoryRepository;
+ private readonly IMediator _mediator;
+ private readonly IWorkContext _workContext;
+
+ /// <summary>
+ /// Ctor
+ /// </summary>
+ public KnowledgebaseService
+ (IRepository<KnowledgebaseCategory> knowledgebaseCategoryRepository,
+ IRepository<KnowledgebaseArticle> knowledgebaseArticleRepository,
+ IRepository<KnowledgebaseArticleComment> articleCommentRepository,
+ IMediator mediator,
+ IWorkContext workContext,
+ ICacheBase cacheBase, AccessControlConfig accessControlConfig)
{
- private readonly IRepository<KnowledgebaseCategory> _knowledgebaseCategoryRepository;
- private readonly IRepository<KnowledgebaseArticle> _knowledgebaseArticleRepository;
- private readonly IRepository<KnowledgebaseArticleComment> _articleCommentRepository;
- private readonly IMediator _mediator;
- private readonly IWorkContext _workContext;
- private readonly ICacheBase _cacheBase;
- private readonly AccessControlConfig _accessControlConfig;
-
- /// <summary>
- /// Ctor
- /// </summary>
- public KnowledgebaseService
- (IRepository<KnowledgebaseCategory> knowledgebaseCategoryRepository,
- IRepository<KnowledgebaseArticle> knowledgebaseArticleRepository,
- IRepository<KnowledgebaseArticleComment> articleCommentRepository,
- IMediator mediator,
- IWorkContext workContext,
- ICacheBase cacheBase, AccessControlConfig accessControlConfig)
+ _knowledgebaseCategoryRepository = knowledgebaseCategoryRepository;
+ _knowledgebaseArticleRepository = knowledgebaseArticleRepository;
+ _articleCommentRepository = articleCommentRepository;
+ _mediator = mediator;
+ _workContext = workContext;
+ _cacheBase = cacheBase;
+ _accessControlConfig = accessControlConfig;
+ }
+
+ /// <summary>
+ /// Deletes knowledge base category
+ /// </summary>
+ /// <param name="kc"></param>
+ public virtual async Task DeleteKnowledgebaseCategory(KnowledgebaseCategory kc)
+ {
+ var children = _knowledgebaseCategoryRepository.Table.Where(x => x.ParentCategoryId == kc.Id).ToList();
+ await _knowledgebaseCategoryRepository.DeleteAsync(kc);
+ foreach (var child in children)
{
- _knowledgebaseCategoryRepository = knowledgebaseCategoryRepository;
- _knowledgebaseArticleRepository = knowledgebaseArticleRepository;
- _articleCommentRepository = articleCommentRepository;
- _mediator = mediator;
- _workContext = workContext;
- _cacheBase = cacheBase;
- _accessControlConfig = accessControlConfig;
+ child.ParentCategoryId = "";
+ await UpdateKnowledgebaseCategory(child);
}
- /// <summary>
- /// Deletes knowledge base category
- /// </summary>
- /// <param name="kc"></param>
- public virtual async Task DeleteKnowledgebaseCategory(KnowledgebaseCategory kc)
+ await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
+ await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
+
+ await _mediator.EntityDeleted(kc);
+ }
+
+ /// <summary>
+ /// Edits knowledge base category
+ /// </summary>
+ /// <param name="kc"></param>
+ public virtual async Task UpdateKnowledgebaseCategory(KnowledgebaseCategory kc)
+ {
+ await _knowledgebaseCategoryRepository.UpdateAsync(kc);
+ await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
+ await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
+ await _mediator.EntityUpdated(kc);
+ }
+
+ /// <summary>
+ /// Gets knowledge base category
+ /// </summary>
+ /// <param name="id"></param>
+ /// <returns>knowledge base category</returns>
+ public virtual async Task<KnowledgebaseCategory> GetKnowledgebaseCategory(string id)
+ {
+ return await _knowledgebaseCategoryRepository.GetOneAsync(x => x.Id == id);
+ }
+
+ /// <summary>
+ /// Gets knowledge base category
+ /// </summary>
+ /// <param name="id"></param>
+ /// <returns>knowledge base category</returns>
+ public virtual async Task<KnowledgebaseCategory> GetPublicKnowledgebaseCategory(string id)
+ {
+ var key = string.Format(CacheKey.KNOWLEDGEBASE_CATEGORY_BY_ID, id,
+ _workContext.CurrentCustomer.GetCustomerGroupIds(),
+ _workContext.CurrentStore.Id);
+ return await _cacheBase.GetAsync(key, async () =>
{
- var children = _knowledgebaseCategoryRepository.Table.Where(x => x.ParentCategoryId == kc.Id).ToList();
- await _knowledgebaseCategoryRepository.DeleteAsync(kc);
- foreach (var child in children)
+ var query = from p in _knowledgebaseCategoryRepository.Table
+ select p;
+
+ query = query.Where(x => x.Published);
+ query = query.Where(x => x.Id == id);
+
+ if (!_accessControlConfig.IgnoreAcl)
{
- child.ParentCategoryId = "";
- await UpdateKnowledgebaseCategory(child);
+ //Limited to customer groups rules
+ var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
+ query = from p in query
+ where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
+ select p;
}
- await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
- await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
+ if (!_accessControlConfig.IgnoreStoreLimitations)
+ //Store acl
+ query = from p in query
+ where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
+ select p;
- await _mediator.EntityDeleted(kc);
- }
+ var toReturn = await Task.FromResult(query.FirstOrDefault());
+ return toReturn;
+ });
+ }
- /// <summary>
- /// Edits knowledge base category
- /// </summary>
- /// <param name="kc"></param>
- public virtual async Task UpdateKnowledgebaseCategory(KnowledgebaseCategory kc)
- {
- await _knowledgebaseCategoryRepository.UpdateAsync(kc);
- await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
- await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
- await _mediator.EntityUpdated(kc);
- }
+ /// <summary>
+ /// Inserts knowledge base category
+ /// </summary>
+ /// <param name="kc"></param>
+ public virtual async Task InsertKnowledgebaseCategory(KnowledgebaseCategory kc)
+ {
+ await _knowledgebaseCategoryRepository.InsertAsync(kc);
- /// <summary>
- /// Gets knowledge base category
- /// </summary>
- /// <param name="id"></param>
- /// <returns>knowledge base category</returns>
- public virtual async Task<KnowledgebaseCategory> GetKnowledgebaseCategory(string id)
- {
- return await _knowledgebaseCategoryRepository.GetOneAsync(x => x.Id == id);
- }
+ await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
+ await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
+
+ await _mediator.EntityInserted(kc);
+ }
+
+ /// <summary>
+ /// Gets knowledge base categories
+ /// </summary>
+ /// <returns>List of knowledge base categories</returns>
+ public virtual async Task<List<KnowledgebaseCategory>> GetKnowledgebaseCategories()
+ {
+ var categories = _knowledgebaseCategoryRepository.Table.OrderBy(x => x.ParentCategoryId)
+ .ThenBy(x => x.DisplayOrder).ToList();
+ return await Task.FromResult(categories);
+ }
+
+ /// <summary>
+ /// Gets knowledge base article
+ /// </summary>
+ /// <param name="id"></param>
+ /// <returns>knowledge base article</returns>
+ public virtual Task<KnowledgebaseArticle> GetKnowledgebaseArticle(string id)
+ {
+ return _knowledgebaseArticleRepository.GetByIdAsync(id);
+ }
- /// <summary>
- /// Gets knowledge base category
- /// </summary>
- /// <param name="id"></param>
- /// <returns>knowledge base category</returns>
- public virtual async Task<KnowledgebaseCategory> GetPublicKnowledgebaseCategory(string id)
+ /// <summary>
+ /// Gets knowledge base articles
+ /// </summary>
+ /// <returns>List of knowledge base articles</returns>
+ /// <param name="storeId">Store ident</param>
+ public virtual async Task<List<KnowledgebaseArticle>> GetKnowledgebaseArticles(string storeId = "")
+ {
+ var query = from p in _knowledgebaseArticleRepository.Table
+ select p;
+ if (!_accessControlConfig.IgnoreAcl)
{
- var key = string.Format(CacheKey.KNOWLEDGEBASE_CATEGORY_BY_ID, id, _workContext.CurrentCustomer.GetCustomerGroupIds(),
- _workContext.CurrentStore.Id);
- return await _cacheBase.GetAsync(key, async () =>
- {
- var query = from p in _knowledgebaseCategoryRepository.Table
- select p;
-
- query = query.Where(x => x.Published);
- query = query.Where(x => x.Id == id);
-
- if (!_accessControlConfig.IgnoreAcl)
- {
- //Limited to customer groups rules
- var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
- query = from p in query
- where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
- select p;
- }
-
- if (!_accessControlConfig.IgnoreStoreLimitations)
- {
- //Store acl
- query = from p in query
- where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
- select p;
- }
-
- var toReturn = await Task.FromResult(query.FirstOrDefault());
- return toReturn;
- });
+ var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
+ query = from p in query
+ where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
+ select p;
}
- /// <summary>
- /// Inserts knowledge base category
- /// </summary>
- /// <param name="kc"></param>
- public virtual async Task InsertKnowledgebaseCategory(KnowledgebaseCategory kc)
- {
- await _knowledgebaseCategoryRepository.InsertAsync(kc);
+ if (!_accessControlConfig.IgnoreStoreLimitations && !string.IsNullOrEmpty(storeId))
+ //Limited to stores rules
+ query = from p in query
+ where !p.LimitedToStores || p.Stores.Contains(storeId)
+ select p;
+ query = query.OrderBy(x => x.DisplayOrder);
+ return await Task.FromResult(query.ToList());
+ }
- await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
- await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
+ /// <summary>
+ /// Inserts knowledge base article
+ /// </summary>
+ /// <param name="ka"></param>
+ public virtual async Task InsertKnowledgebaseArticle(KnowledgebaseArticle ka)
+ {
+ await _knowledgebaseArticleRepository.InsertAsync(ka);
+ await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
+ await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
+ await _mediator.EntityInserted(ka);
+ }
- await _mediator.EntityInserted(kc);
- }
+ /// <summary>
+ /// Edits knowledge base article
+ /// </summary>
+ /// <param name="ka"></param>
+ public virtual async Task UpdateKnowledgebaseArticle(KnowledgebaseArticle ka)
+ {
+ await _knowledgebaseArticleRepository.UpdateAsync(ka);
+ await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
+ await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
+ await _mediator.EntityUpdated(ka);
+ }
- /// <summary>
- /// Gets knowledge base categories
- /// </summary>
- /// <returns>List of knowledge base categories</returns>
- public virtual async Task<List<KnowledgebaseCategory>> GetKnowledgebaseCategories()
- {
- var categories = _knowledgebaseCategoryRepository.Table.OrderBy(x => x.ParentCategoryId).ThenBy(x => x.DisplayOrder).ToList();
- return await Task.FromResult(categories);
- }
+ /// <summary>
+ /// Deletes knowledge base article
+ /// </summary>
+ /// <param name="ka"></param>
+ public virtual async Task DeleteKnowledgebaseArticle(KnowledgebaseArticle ka)
+ {
+ await _knowledgebaseArticleRepository.DeleteAsync(ka);
+ await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
+ await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
+ await _mediator.EntityDeleted(ka);
+ }
- /// <summary>
- /// Gets knowledge base article
- /// </summary>
- /// <param name="id"></param>
- /// <returns>knowledge base article</returns>
- public virtual Task<KnowledgebaseArticle> GetKnowledgebaseArticle(string id)
- {
- return _knowledgebaseArticleRepository.GetByIdAsync(id);
- }
+ /// <summary>
+ /// Gets knowledge base articles by category id
+ /// </summary>
+ /// <param name="id"></param>
+ /// <param name="pageIndex"></param>
+ /// <param name="pageSize"></param>
+ public virtual async Task<IPagedList<KnowledgebaseArticle>> GetKnowledgebaseArticlesByCategoryId(string id,
+ int pageIndex = 0, int pageSize = int.MaxValue)
+ {
+ var articles = await Task.FromResult(_knowledgebaseArticleRepository.Table.Where(x => x.ParentCategoryId == id)
+ .OrderBy(x => x.DisplayOrder).ToList());
+ return new PagedList<KnowledgebaseArticle>(articles, pageIndex, pageSize);
+ }
- /// <summary>
- /// Gets knowledge base articles
- /// </summary>
- /// <returns>List of knowledge base articles</returns>
- /// <param name="storeId">Store ident</param>
- public virtual async Task<List<KnowledgebaseArticle>> GetKnowledgebaseArticles(string storeId = "")
+ /// <summary>
+ /// Gets public(published etc) knowledge base categories
+ /// </summary>
+ /// <returns>List of public knowledgebase categories</returns>
+ public virtual async Task<List<KnowledgebaseCategory>> GetPublicKnowledgebaseCategories()
+ {
+ var key = string.Format(CacheKey.KNOWLEDGEBASE_CATEGORIES,
+ string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
+ _workContext.CurrentStore.Id);
+ return await _cacheBase.GetAsync(key, async () =>
{
- var query = from p in _knowledgebaseArticleRepository.Table
- select p;
+ var query = from p in _knowledgebaseCategoryRepository.Table
+ select p;
+
+ query = query.Where(x => x.Published);
+
if (!_accessControlConfig.IgnoreAcl)
{
var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
query = from p in query
- where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
- select p;
+ where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
+ select p;
}
- if (!_accessControlConfig.IgnoreStoreLimitations && !string.IsNullOrEmpty(storeId))
- {
- //Limited to stores rules
+ if (!_accessControlConfig.IgnoreStoreLimitations)
+ //Store acl
query = from p in query
- where !p.LimitedToStores || p.Stores.Contains(storeId)
- select p;
- }
+ where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
+ select p;
query = query.OrderBy(x => x.DisplayOrder);
return await Task.FromResult(query.ToList());
- }
-
- /// <summary>
- /// Inserts knowledge base article
- /// </summary>
- /// <param name="ka"></param>
- public virtual async Task InsertKnowledgebaseArticle(KnowledgebaseArticle ka)
- {
- await _knowledgebaseArticleRepository.InsertAsync(ka);
- await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
- await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
- await _mediator.EntityInserted(ka);
- }
+ });
+ }
- /// <summary>
- /// Edits knowledge base article
- /// </summary>
- /// <param name="ka"></param>
- public virtual async Task UpdateKnowledgebaseArticle(KnowledgebaseArticle ka)
- {
- await _knowledgebaseArticleRepository.UpdateAsync(ka);
- await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
- await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
- await _mediator.EntityUpdated(ka);
- }
+ /// <summary>
+ /// Gets public(published etc) knowledge base articles
+ /// </summary>
+ /// <returns>List of public knowledge base articles</returns>
+ public virtual async Task<List<KnowledgebaseArticle>> GetPublicKnowledgebaseArticles()
+ {
+ var key = string.Format(CacheKey.ARTICLES, string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
+ _workContext.CurrentStore.Id);
- /// <summary>
- /// Deletes knowledge base article
- /// </summary>
- /// <param name="ka"></param>
- public virtual async Task DeleteKnowledgebaseArticle(KnowledgebaseArticle ka)
+ return await _cacheBase.GetAsync(key, async () =>
{
- await _knowledgebaseArticleRepository.DeleteAsync(ka);
- await _cacheBase.RemoveByPrefix(CacheKey.ARTICLES_PATTERN_KEY);
- await _cacheBase.RemoveByPrefix(CacheKey.KNOWLEDGEBASE_CATEGORIES_PATTERN_KEY);
- await _mediator.EntityDeleted(ka);
- }
+ var query = from p in _knowledgebaseArticleRepository.Table
+ select p;
- /// <summary>
- /// Gets knowledge base articles by category id
- /// </summary>
- /// <param name="id"></param>
- /// <param name="pageIndex"></param>
- /// <param name="pageSize"></param>
- public virtual async Task<IPagedList<KnowledgebaseArticle>> GetKnowledgebaseArticlesByCategoryId(string id, int pageIndex = 0, int pageSize = int.MaxValue)
- {
- var articles = await Task.FromResult(_knowledgebaseArticleRepository.Table.Where(x => x.ParentCategoryId == id).OrderBy(x => x.DisplayOrder).ToList());
- return new PagedList<KnowledgebaseArticle>(articles, pageIndex, pageSize);
- }
+ query = query.Where(x => x.Published);
- /// <summary>
- /// Gets public(published etc) knowledge base categories
- /// </summary>
- /// <returns>List of public knowledgebase categories</returns>
- public virtual async Task<List<KnowledgebaseCategory>> GetPublicKnowledgebaseCategories()
- {
- var key = string.Format(CacheKey.KNOWLEDGEBASE_CATEGORIES, string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
- _workContext.CurrentStore.Id);
- return await _cacheBase.GetAsync(key, async () =>
+ if (!_accessControlConfig.IgnoreAcl)
{
- var query = from p in _knowledgebaseCategoryRepository.Table
- select p;
-
- query = query.Where(x => x.Published);
-
- if (!_accessControlConfig.IgnoreAcl)
- {
- var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
- query = from p in query
- where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
- select p;
- }
-
- if (!_accessControlConfig.IgnoreStoreLimitations)
- {
- //Store acl
- query = from p in query
- where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
- select p;
- }
- query = query.OrderBy(x => x.DisplayOrder);
- return await Task.FromResult(query.ToList());
-
- });
- }
-
- /// <summary>
- /// Gets public(published etc) knowledge base articles
- /// </summary>
- /// <returns>List of public knowledge base articles</returns>
- public virtual async Task<List<KnowledgebaseArticle>> GetPublicKnowledgebaseArticles()
- {
- var key = string.Format(CacheKey.ARTICLES, string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
- _workContext.CurrentStore.Id);
+ var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
+ query = from p in query
+ where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
+ select p;
+ }
- return await _cacheBase.GetAsync(key, async () =>
- {
- var query = from p in _knowledgebaseArticleRepository.Table
- select p;
-
- query = query.Where(x => x.Published);
-
- if (!_accessControlConfig.IgnoreAcl)
- {
- var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
- query = from p in query
- where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
- select p;
- }
-
- if (!_accessControlConfig.IgnoreStoreLimitations)
- {
- //Store acl
- query = from p in query
- where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
- select p;
- }
-
- query = query.OrderBy(x => x.DisplayOrder);
- return await Task.FromResult(query.ToList());
- });
- }
+ if (!_accessControlConfig.IgnoreStoreLimitations)
+ //Store acl
+ query = from p in query
+ where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
+ select p;
- /// <summary>
- /// Gets knowledge base article if it is published etc
- /// </summary>
- /// <returns>knowledge base article</returns>
- public virtual async Task<KnowledgebaseArticle> GetPublicKnowledgebaseArticle(string id)
- {
- var key = string.Format(CacheKey.ARTICLE_BY_ID, id, string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
- _workContext.CurrentStore.Id);
- return await _cacheBase.GetAsync(key, async () =>
- {
- var query = from p in _knowledgebaseArticleRepository.Table
- select p;
-
- query = query.Where(x => x.Published);
- query = query.Where(x => x.Id == id);
-
- if (!_accessControlConfig.IgnoreAcl)
- {
- var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
- query = from p in query
- where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
- select p;
- }
-
- if (!_accessControlConfig.IgnoreStoreLimitations)
- {
- //Store acl
- query = from p in query
- where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
- select p;
- }
-
- return await Task.FromResult(query.FirstOrDefault());
- });
- }
+ query = query.OrderBy(x => x.DisplayOrder);
+ return await Task.FromResult(query.ToList());
+ });
+ }
- /// <summary>
- /// Gets public(published etc) knowledge base articles for category id
- /// </summary>
- /// <returns>List of public knowledge base articles</returns>
- public virtual async Task<List<KnowledgebaseArticle>> GetPublicKnowledgebaseArticlesByCategory(string categoryId)
+ /// <summary>
+ /// Gets knowledge base article if it is published etc
+ /// </summary>
+ /// <returns>knowledge base article</returns>
+ public virtual async Task<KnowledgebaseArticle> GetPublicKnowledgebaseArticle(string id)
+ {
+ var key = string.Format(CacheKey.ARTICLE_BY_ID, id,
+ string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
+ _workContext.CurrentStore.Id);
+ return await _cacheBase.GetAsync(key, async () =>
{
- var key = string.Format(CacheKey.ARTICLES_BY_CATEGORY_ID, categoryId, string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
- _workContext.CurrentStore.Id);
- return await _cacheBase.GetAsync(key, async () =>
- {
- var query = from p in _knowledgebaseArticleRepository.Table
- select p;
-
- query = query.Where(x => x.Published);
- query = query.Where(x => x.ParentCategoryId == categoryId);
-
- if (!_accessControlConfig.IgnoreAcl)
- {
- var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
- query = from p in query
- where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
- select p;
- }
-
- if (!_accessControlConfig.IgnoreStoreLimitations)
- {
- //Store acl
- query = from p in query
- where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
- select p;
- }
- query = query.OrderBy(x => x.DisplayOrder);
- return await Task.FromResult(query.ToList());
- });
- }
+ var query = from p in _knowledgebaseArticleRepository.Table
+ select p;
- /// <summary>
- /// Gets public(published etc) knowledge base articles for keyword
- /// </summary>
- /// <returns>List of public knowledge base articles</returns>
- public virtual async Task<List<KnowledgebaseArticle>> GetPublicKnowledgebaseArticlesByKeyword(string keyword)
- {
- var key = string.Format(CacheKey.ARTICLES_BY_KEYWORD, keyword, string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
- _workContext.CurrentStore.Id);
+ query = query.Where(x => x.Published);
+ query = query.Where(x => x.Id == id);
- return await _cacheBase.GetAsync(key, async () =>
+ if (!_accessControlConfig.IgnoreAcl)
{
- var query = from p in _knowledgebaseArticleRepository.Table
- select p;
-
- query = query.Where(x => x.Published);
-
- query = query.Where(p => p.Locales.Any(x => x.LocaleValue != null && x.LocaleValue.ToLower().Contains(keyword.ToLower()))
- || p.Name.ToLower().Contains(keyword.ToLower()) || p.Content.ToLower().Contains(keyword.ToLower()));
-
- if (!_accessControlConfig.IgnoreAcl)
- {
- var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
- query = from p in query
- where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
- select p;
- }
-
- if (!_accessControlConfig.IgnoreStoreLimitations)
- {
- //Store acl
- query = from p in query
- where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
- select p;
- }
- query = query.OrderBy(x => x.DisplayOrder);
- return await Task.FromResult(query.ToList());
- });
- }
+ var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
+ query = from p in query
+ where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
+ select p;
+ }
- /// <summary>
- /// Gets public(published etc) knowledge base categories for keyword
- /// </summary>
- /// <returns>List of public knowledge base categories</returns>
- public virtual async Task<List<KnowledgebaseCategory>> GetPublicKnowledgebaseCategoriesByKeyword(string keyword)
- {
- var key = string.Format(CacheKey.KNOWLEDGEBASE_CATEGORIES_BY_KEYWORD, keyword, string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
- _workContext.CurrentStore.Id);
- return await _cacheBase.GetAsync(key, async () =>
- {
- var query = from p in _knowledgebaseCategoryRepository.Table
- select p;
-
- query = query.Where(x => x.Published);
-
- query = query.Where(p => p.Locales.Any(x => x.LocaleValue != null && x.LocaleValue.ToLower().Contains(keyword.ToLower()))
- || p.Name.ToLower().Contains(keyword.ToLower()) || p.Description.ToLower().Contains(keyword.ToLower()));
-
- if (!_accessControlConfig.IgnoreAcl)
- {
- var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
- query = from p in query
- where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
- select p;
- }
-
- if (!_accessControlConfig.IgnoreStoreLimitations)
- {
- //Store acl
- query = from p in query
- where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
- select p;
- }
- query = query.OrderBy(x => x.DisplayOrder);
- return await Task.FromResult(query.ToList());
-
- });
- }
+ if (!_accessControlConfig.IgnoreStoreLimitations)
+ //Store acl
+ query = from p in query
+ where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
+ select p;
- /// <summary>
- /// Gets homepage knowledge base articles
- /// </summary>
- /// <returns>List of homepage knowledge base articles</returns>
- public virtual async Task<List<KnowledgebaseArticle>> GetHomepageKnowledgebaseArticles()
- {
- var key = string.Format(CacheKey.HOMEPAGE_ARTICLES, string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
- _workContext.CurrentStore.Id);
- return await _cacheBase.GetAsync(key, async () =>
- {
- var query = from p in _knowledgebaseArticleRepository.Table
- select p;
-
- query = query.Where(x => x.Published);
- query = query.Where(x => x.ShowOnHomepage);
-
- if (!_accessControlConfig.IgnoreAcl)
- {
- var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
- query = from p in query
- where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
- select p;
- }
-
- if (!_accessControlConfig.IgnoreStoreLimitations)
- {
- //Store acl
- query = from p in query
- where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
- select p;
- }
- query = query.OrderBy(x => x.DisplayOrder);
- return await Task.FromResult(query.ToList());
-
- });
- }
+ return await Task.FromResult(query.FirstOrDefault());
+ });
+ }
- /// <summary>
- /// Gets knowledge base articles by name
- /// </summary>
- /// <param name="name"></param>
- /// <param name="pageIndex"></param>
- /// <param name="pageSize"></param>
- public virtual async Task<IPagedList<KnowledgebaseArticle>> GetKnowledgebaseArticlesByName(string name, int pageIndex = 0, int pageSize = int.MaxValue)
+ /// <summary>
+ /// Gets public(published etc) knowledge base articles for category id
+ /// </summary>
+ /// <returns>List of public knowledge base articles</returns>
+ public virtual async Task<List<KnowledgebaseArticle>> GetPublicKnowledgebaseArticlesByCategory(string categoryId)
+ {
+ var key = string.Format(CacheKey.ARTICLES_BY_CATEGORY_ID, categoryId,
+ string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
+ _workContext.CurrentStore.Id);
+ return await _cacheBase.GetAsync(key, async () =>
{
var query = from p in _knowledgebaseArticleRepository.Table
- select p;
-
+ select p;
query = query.Where(x => x.Published);
+ query = query.Where(x => x.ParentCategoryId == categoryId);
- if (!string.IsNullOrEmpty(name))
+ if (!_accessControlConfig.IgnoreAcl)
{
-
- query = query.Where(p => p.Locales.Any(x => x.LocaleKey == "Name" && x.LocaleValue != null && x.LocaleValue.ToLower().Contains(name.ToLower()))
- || p.Name.ToLower().Contains(name.ToLower()));
-
+ var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
+ query = from p in query
+ where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
+ select p;
}
+ if (!_accessControlConfig.IgnoreStoreLimitations)
+ //Store acl
+ query = from p in query
+ where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
+ select p;
query = query.OrderBy(x => x.DisplayOrder);
- var toReturn = await Task.FromResult(query.ToList());
+ return await Task.FromResult(query.ToList());
+ });
+ }
- return new PagedList<KnowledgebaseArticle>(toReturn, pageIndex, pageSize);
- }
+ /// <summary>
+ /// Gets public(published etc) knowledge base articles for keyword
+ /// </summary>
+ /// <returns>List of public knowledge base articles</returns>
+ public virtual async Task<List<KnowledgebaseArticle>> GetPublicKnowledgebaseArticlesByKeyword(string keyword)
+ {
+ var key = string.Format(CacheKey.ARTICLES_BY_KEYWORD, keyword,
+ string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
+ _workContext.CurrentStore.Id);
- /// <summary>
- /// Gets related knowledge base articles
- /// </summary>
- public virtual async Task<IPagedList<KnowledgebaseArticle>> GetRelatedKnowledgebaseArticles(string articleId, int pageIndex = 0, int pageSize = int.MaxValue)
+ return await _cacheBase.GetAsync(key, async () =>
{
- var article = await GetKnowledgebaseArticle(articleId);
- List<KnowledgebaseArticle> toReturn = new List<KnowledgebaseArticle>();
+ var query = from p in _knowledgebaseArticleRepository.Table
+ select p;
- foreach (var id in article.RelatedArticles)
+ query = query.Where(x => x.Published);
+
+ query = query.Where(p =>
+ p.Locales.Any(x => x.LocaleValue != null && x.LocaleValue.ToLower().Contains(keyword.ToLower()))
+ || p.Name.ToLower().Contains(keyword.ToLower()) || p.Content.ToLower().Contains(keyword.ToLower()));
+
+ if (!_accessControlConfig.IgnoreAcl)
{
- var relatedArticle = await GetKnowledgebaseArticle(id);
- if (relatedArticle != null)
- toReturn.Add(relatedArticle);
+ var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
+ query = from p in query
+ where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
+ select p;
}
- return new PagedList<KnowledgebaseArticle>(toReturn.ToList(), pageIndex, pageSize);
- }
+ if (!_accessControlConfig.IgnoreStoreLimitations)
+ //Store acl
+ query = from p in query
+ where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
+ select p;
+ query = query.OrderBy(x => x.DisplayOrder);
+ return await Task.FromResult(query.ToList());
+ });
+ }
- /// <summary>
- /// Inserts an article comment
- /// </summary>
- /// <param name="articleComment">Article comment</param>
- public virtual async Task InsertArticleComment(KnowledgebaseArticleComment articleComment)
+ /// <summary>
+ /// Gets public(published etc) knowledge base categories for keyword
+ /// </summary>
+ /// <returns>List of public knowledge base categories</returns>
+ public virtual async Task<List<KnowledgebaseCategory>> GetPublicKnowledgebaseCategoriesByKeyword(string keyword)
+ {
+ var key = string.Format(CacheKey.KNOWLEDGEBASE_CATEGORIES_BY_KEYWORD, keyword,
+ string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
+ _workContext.CurrentStore.Id);
+ return await _cacheBase.GetAsync(key, async () =>
{
- ArgumentNullException.ThrowIfNull(articleComment);
+ var query = from p in _knowledgebaseCategoryRepository.Table
+ select p;
- await _articleCommentRepository.InsertAsync(articleComment);
+ query = query.Where(x => x.Published);
- //event notification
- await _mediator.EntityInserted(articleComment);
- }
+ query = query.Where(p =>
+ p.Locales.Any(x => x.LocaleValue != null && x.LocaleValue.ToLower().Contains(keyword.ToLower()))
+ || p.Name.ToLower().Contains(keyword.ToLower()) || p.Description.ToLower().Contains(keyword.ToLower()));
- /// <summary>
- /// Gets all comments
- /// </summary>
- /// <param name="customerId">Customer identifier; "" to load all records</param>
- /// <returns>Comments</returns>
- public virtual async Task<IList<KnowledgebaseArticleComment>> GetAllComments(string customerId)
- {
- var query = from c in _articleCommentRepository.Table
- orderby c.CreatedOnUtc
- where customerId == "" || c.CustomerId == customerId
- select c;
+ if (!_accessControlConfig.IgnoreAcl)
+ {
+ var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
+ query = from p in query
+ where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
+ select p;
+ }
+
+ if (!_accessControlConfig.IgnoreStoreLimitations)
+ //Store acl
+ query = from p in query
+ where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
+ select p;
+ query = query.OrderBy(x => x.DisplayOrder);
return await Task.FromResult(query.ToList());
- }
+ });
+ }
- /// <summary>
- /// Gets an article comment
- /// </summary>
- /// <param name="articleId">Article identifier</param>
- /// <returns>Article comment</returns>
- public virtual Task<KnowledgebaseArticleComment> GetArticleCommentById(string articleId)
+ /// <summary>
+ /// Gets homepage knowledge base articles
+ /// </summary>
+ /// <returns>List of homepage knowledge base articles</returns>
+ public virtual async Task<List<KnowledgebaseArticle>> GetHomepageKnowledgebaseArticles()
+ {
+ var key = string.Format(CacheKey.HOMEPAGE_ARTICLES,
+ string.Join(",", _workContext.CurrentCustomer.GetCustomerGroupIds()),
+ _workContext.CurrentStore.Id);
+ return await _cacheBase.GetAsync(key, async () =>
{
- return _articleCommentRepository.GetByIdAsync(articleId);
- }
+ var query = from p in _knowledgebaseArticleRepository.Table
+ select p;
- /// <summary>
- /// Get article comments by identifiers
- /// </summary>
- /// <returns>Article comments</returns>
- public virtual async Task<IList<KnowledgebaseArticleComment>> GetArticleCommentsByIds(string[] commentIds)
- {
- if (commentIds == null || commentIds.Length == 0)
- return new List<KnowledgebaseArticleComment>();
-
- var query = from bc in _articleCommentRepository.Table
- where commentIds.Contains(bc.Id)
- select bc;
- var comments = query.ToList();
- //sort by passed identifiers
- var sortedComments = new List<KnowledgebaseArticleComment>();
- foreach (var id in commentIds)
+ query = query.Where(x => x.Published);
+ query = query.Where(x => x.ShowOnHomepage);
+
+ if (!_accessControlConfig.IgnoreAcl)
{
- var comment = comments.Find(x => x.Id == id);
- if (comment != null)
- sortedComments.Add(comment);
+ var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
+ query = from p in query
+ where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
+ select p;
}
- return await Task.FromResult(sortedComments);
- }
- public virtual async Task<IList<KnowledgebaseArticleComment>> GetArticleCommentsByArticleId(string articleId)
- {
- var query = from c in _articleCommentRepository.Table
- where c.ArticleId == articleId
- orderby c.CreatedOnUtc
- select c;
+ if (!_accessControlConfig.IgnoreStoreLimitations)
+ //Store acl
+ query = from p in query
+ where !p.LimitedToStores || p.Stores.Contains(_workContext.CurrentStore.Id)
+ select p;
+ query = query.OrderBy(x => x.DisplayOrder);
return await Task.FromResult(query.ToList());
- }
+ });
+ }
+
+ /// <summary>
+ /// Gets knowledge base articles by name
+ /// </summary>
+ /// <param name="name"></param>
+ /// <param name="pageIndex"></param>
+ /// <param name="pageSize"></param>
+ public virtual async Task<IPagedList<KnowledgebaseArticle>> GetKnowledgebaseArticlesByName(string name,
+ int pageIndex = 0, int pageSize = int.MaxValue)
+ {
+ var query = from p in _knowledgebaseArticleRepository.Table
+ select p;
+
+
+ query = query.Where(x => x.Published);
+
+ if (!string.IsNullOrEmpty(name))
+ query = query.Where(p =>
+ p.Locales.Any(x =>
+ x.LocaleKey == "Name" && x.LocaleValue != null && x.LocaleValue.ToLower().Contains(name.ToLower()))
+ || p.Name.ToLower().Contains(name.ToLower()));
+
+ query = query.OrderBy(x => x.DisplayOrder);
+ var toReturn = await Task.FromResult(query.ToList());
+
+ return new PagedList<KnowledgebaseArticle>(toReturn, pageIndex, pageSize);
+ }
+
+ /// <summary>
+ /// Gets related knowledge base articles
+ /// </summary>
+ public virtual async Task<IPagedList<KnowledgebaseArticle>> GetRelatedKnowledgebaseArticles(string articleId,
+ int pageIndex = 0, int pageSize = int.MaxValue)
+ {
+ var article = await GetKnowledgebaseArticle(articleId);
+ var toReturn = new List<KnowledgebaseArticle>();
- public virtual async Task DeleteArticleComment(KnowledgebaseArticleComment articleComment)
+ foreach (var id in article.RelatedArticles)
{
- ArgumentNullException.ThrowIfNull(articleComment);
+ var relatedArticle = await GetKnowledgebaseArticle(id);
+ if (relatedArticle != null)
+ toReturn.Add(relatedArticle);
+ }
+
+ return new PagedList<KnowledgebaseArticle>(toReturn.ToList(), pageIndex, pageSize);
+ }
+
+ /// <summary>
+ /// Inserts an article comment
+ /// </summary>
+ /// <param name="articleComment">Article comment</param>
+ public virtual async Task InsertArticleComment(KnowledgebaseArticleComment articleComment)
+ {
+ ArgumentNullException.ThrowIfNull(articleComment);
+
+ await _articleCommentRepository.InsertAsync(articleComment);
+
+ //event notification
+ await _mediator.EntityInserted(articleComment);
+ }
+
+ public virtual async Task<IList<KnowledgebaseArticleComment>> GetArticleCommentsByArticleId(string articleId)
+ {
+ var query = from c in _articleCommentRepository.Table
+ where c.ArticleId == articleId
+ orderby c.CreatedOnUtc
+ select c;
+ return await Task.FromResult(query.ToList());
+ }
+
+ public virtual async Task DeleteArticleComment(KnowledgebaseArticleComment articleComment)
+ {
+ ArgumentNullException.ThrowIfNull(articleComment);
+
+ await _articleCommentRepository.DeleteAsync(articleComment);
+ }
+
+ /// <summary>
+ /// Gets all comments
+ /// </summary>
+ /// <param name="customerId">Customer identifier; "" to load all records</param>
+ /// <returns>Comments</returns>
+ public virtual async Task<IList<KnowledgebaseArticleComment>> GetAllComments(string customerId)
+ {
+ var query = from c in _articleCommentRepository.Table
+ orderby c.CreatedOnUtc
+ where customerId == "" || c.CustomerId == customerId
+ select c;
+ return await Task.FromResult(query.ToList());
+ }
- await _articleCommentRepository.DeleteAsync(articleComment);
+ /// <summary>
+ /// Gets an article comment
+ /// </summary>
+ /// <param name="articleId">Article identifier</param>
+ /// <returns>Article comment</returns>
+ public virtual Task<KnowledgebaseArticleComment> GetArticleCommentById(string articleId)
+ {
+ return _articleCommentRepository.GetByIdAsync(articleId);
+ }
+
+ /// <summary>
+ /// Get article comments by identifiers
+ /// </summary>
+ /// <returns>Article comments</returns>
+ public virtual async Task<IList<KnowledgebaseArticleComment>> GetArticleCommentsByIds(string[] commentIds)
+ {
+ if (commentIds == null || commentIds.Length == 0)
+ return new List<KnowledgebaseArticleComment>();
+
+ var query = from bc in _articleCommentRepository.Table
+ where commentIds.Contains(bc.Id)
+ select bc;
+ var comments = query.ToList();
+ //sort by passed identifiers
+ var sortedComments = new List<KnowledgebaseArticleComment>();
+ foreach (var id in commentIds)
+ {
+ var comment = comments.Find(x => x.Id == id);
+ if (comment != null)
+ sortedComments.Add(comment);
}
+
+ return await Task.FromResult(sortedComments);
}
-}
+}
\ No newline at end of file
diff --git a/src/Business/Grand.Business.Cms/Services/NewsService.cs b/src/Business/Grand.Business.Cms/Services/NewsService.cs
index 84fa97c6e..08de1ea1c 100644
--- a/src/Business/Grand.Business.Cms/Services/NewsService.cs
+++ b/src/Business/Grand.Business.Cms/Services/NewsService.cs
@@ -1,165 +1,165 @@
using Grand.Business.Core.Interfaces.Cms;
+using Grand.Data;
using Grand.Domain;
using Grand.Domain.Customers;
-using Grand.Data;
using Grand.Domain.News;
using Grand.Infrastructure;
using Grand.Infrastructure.Configuration;
using Grand.Infrastructure.Extensions;
using MediatR;
-namespace Grand.Business.Cms.Services
+namespace Grand.Business.Cms.Services;
+
+/// <summary>
+/// News service
+/// </summary>
+public class NewsService : INewsService
{
- /// <summary>
- /// News service
- /// </summary>
- public class NewsService : INewsService
+ #region Ctor
+
+ public NewsService(IRepository<NewsItem> newsItemRepository,
+ IMediator mediator,
+ IWorkContext workContext, AccessControlConfig accessControlConfig)
{
- #region Fields
+ _newsItemRepository = newsItemRepository;
+ _mediator = mediator;
+ _workContext = workContext;
+ _accessControlConfig = accessControlConfig;
+ }
- private readonly IRepository<NewsItem> _newsItemRepository;
- private readonly IMediator _mediator;
- private readonly IWorkContext _workContext;
- private readonly AccessControlConfig _accessControlConfig;
-
- #endregion
+ #endregion
- #region Ctor
+ #region Fields
- public NewsService(IRepository<NewsItem> newsItemRepository,
- IMediator mediator,
- IWorkContext workContext, AccessControlConfig accessControlConfig)
- {
- _newsItemRepository = newsItemRepository;
- _mediator = mediator;
- _workContext = workContext;
- _accessControlConfig = accessControlConfig;
- }
+ private readonly IRepository<NewsItem> _newsItemRepository;
+ private readonly IMediator _mediator;
+ private readonly IWorkContext _workContext;
+ private readonly AccessControlConfig _accessControlConfig;
- #endregion
+ #endregion
+
+ #region Methods
+
+ /// <summary>
+ /// Gets a news
+ /// </summary>
+ /// <param name="newsId">The news identifier</param>
+ /// <returns>News</returns>
+ public virtual Task<NewsItem> GetNewsById(string newsId)
+ {
+ return _newsItemRepository.GetByIdAsync(newsId);
+ }
- #region Methods
+ /// <summary>
+ /// Gets all news
+ /// </summary>
+ /// <param name="storeId">Store identifier; 0 if you want to get all records</param>
+ /// <param name="pageIndex">Page index</param>
+ /// <param name="pageSize">Page size</param>
+ /// <param name="ignoreAcl"></param>
+ /// <param name="showHidden">A value indicating whether to show hidden records</param>
+ /// <param name="newsTitle">News title</param>
+ /// <returns>News items</returns>
+ public virtual async Task<IPagedList<NewsItem>> GetAllNews(string storeId = "",
+ int pageIndex = 0, int pageSize = int.MaxValue, bool ignoreAcl = false, bool showHidden = false,
+ string newsTitle = "")
+ {
+ var query = from p in _newsItemRepository.Table
+ select p;
+ if (!string.IsNullOrWhiteSpace(newsTitle))
+ query = query.Where(n => n.Title != null && n.Title.ToLower().Contains(newsTitle.ToLower()));
- /// <summary>
- /// Gets a news
- /// </summary>
- /// <param name="newsId">The news identifier</param>
- /// <returns>News</returns>
- public virtual Task<NewsItem> GetNewsById(string newsId)
+ if (!showHidden)
{
- return _newsItemRepository.GetByIdAsync(newsId);
+ var utcNow = DateTime.UtcNow;
+ query = query.Where(n => n.Published);
+ query = query.Where(n => !n.StartDateUtc.HasValue || n.StartDateUtc <= utcNow);
+ query = query.Where(n => !n.EndDateUtc.HasValue || n.EndDateUtc >= utcNow);
}
- /// <summary>
- /// Gets all news
- /// </summary>
- /// <param name="storeId">Store identifier; 0 if you want to get all records</param>
- /// <param name="pageIndex">Page index</param>
- /// <param name="pageSize">Page size</param>
- /// <param name="ignoreAcl"></param>
- /// <param name="showHidden">A value indicating whether to show hidden records</param>
- /// <param name="newsTitle">News title</param>
- /// <returns>News items</returns>
- public virtual async Task<IPagedList<NewsItem>> GetAllNews(string storeId = "",
- int pageIndex = 0, int pageSize = int.MaxValue, bool ignoreAcl = false, bool showHidden = false, string newsTitle = "")
+ if ((!string.IsNullOrEmpty(storeId) && !_accessControlConfig.IgnoreStoreLimitations) ||
+ (!ignoreAcl && !_accessControlConfig.IgnoreAcl))
{
- var query = from p in _newsItemRepository.Table
- select p;
-
- if (!string.IsNullOrWhiteSpace(newsTitle))
- query = query.Where(n => n.Title != null && n.Title.ToLower().Contains(newsTitle.ToLower()));
-
- if (!showHidden)
+ if (!ignoreAcl && !_accessControlConfig.IgnoreAcl)
{
- var utcNow = DateTime.UtcNow;
- query = query.Where(n => n.Published);
- query = query.Where(n => !n.StartDateUtc.HasValue || n.StartDateUtc <= utcNow);
- query = query.Where(n => !n.EndDateUtc.HasValue || n.EndDateUtc >= utcNow);
+ var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
+ query = from p in query
+ where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
+ select p;
}
- if ((!string.IsNullOrEmpty(storeId) && !_accessControlConfig.IgnoreStoreLimitations) ||
- (!ignoreAcl && !_accessControlConfig.IgnoreAcl))
- {
- if (!ignoreAcl && !_accessControlConfig.IgnoreAcl)
- {
- var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
- query = from p in query
- where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
- select p;
- }
- //Store acl
- if (!string.IsNullOrEmpty(storeId) && !_accessControlConfig.IgnoreStoreLimitations)
- {
- query = from p in query
- where !p.LimitedToStores || p.Stores.Contains(storeId)
- select p;
- }
- }
- query = query.OrderByDescending(n => n.CreatedOnUtc);
- return await PagedList<NewsItem>.Create(query, pageIndex, pageSize);
+ //Store acl
+ if (!string.IsNullOrEmpty(storeId) && !_accessControlConfig.IgnoreStoreLimitations)
+ query = from p in query
+ where !p.LimitedToStores || p.Stores.Contains(storeId)
+ select p;
}
- /// <summary>
- /// Inserts a news item
- /// </summary>
- /// <param name="news">News item</param>
- public virtual async Task InsertNews(NewsItem news)
- {
- ArgumentNullException.ThrowIfNull(news);
+ query = query.OrderByDescending(n => n.CreatedOnUtc);
+ return await PagedList<NewsItem>.Create(query, pageIndex, pageSize);
+ }
- await _newsItemRepository.InsertAsync(news);
+ /// <summary>
+ /// Inserts a news item
+ /// </summary>
+ /// <param name="news">News item</param>
+ public virtual async Task InsertNews(NewsItem news)
+ {
+ ArgumentNullException.ThrowIfNull(news);
- //event notification
- await _mediator.EntityInserted(news);
- }
+ await _newsItemRepository.InsertAsync(news);
- /// <summary>
- /// Updates the news item
- /// </summary>
- /// <param name="news">News item</param>
- public virtual async Task UpdateNews(NewsItem news)
- {
- ArgumentNullException.ThrowIfNull(news);
+ //event notification
+ await _mediator.EntityInserted(news);
+ }
- await _newsItemRepository.UpdateAsync(news);
+ /// <summary>
+ /// Updates the news item
+ /// </summary>
+ /// <param name="news">News item</param>
+ public virtual async Task UpdateNews(NewsItem news)
+ {
+ ArgumentNullException.ThrowIfNull(news);
- //event notification
- await _mediator.EntityUpdated(news);
- }
- /// <summary>
- /// Deletes a news
- /// </summary>
- /// <param name="newsItem">News item</param>
- public virtual async Task DeleteNews(NewsItem newsItem)
- {
- ArgumentNullException.ThrowIfNull(newsItem);
+ await _newsItemRepository.UpdateAsync(news);
+
+ //event notification
+ await _mediator.EntityUpdated(news);
+ }
- await _newsItemRepository.DeleteAsync(newsItem);
+ /// <summary>
+ /// Deletes a news
+ /// </summary>
+ /// <param name="newsItem">News item</param>
+ public virtual async Task DeleteNews(NewsItem newsItem)
+ {
+ ArgumentNullException.ThrowIfNull(newsItem);
- //event notification
- await _mediator.EntityDeleted(newsItem);
- }
+ await _newsItemRepository.DeleteAsync(newsItem);
- /// <summary>
- /// Gets all comments
- /// </summary>
- /// <param name="customerId">Customer identifier; "" to load all records</param>
- /// <returns>Comments</returns>
- public virtual async Task<IList<NewsComment>> GetAllComments(string customerId)
- {
- var query = from n in _newsItemRepository.Table
- from c in n.NewsComments
- select c;
+ //event notification
+ await _mediator.EntityDeleted(newsItem);
+ }
- var query2 = from c in query
- orderby c.CreatedOnUtc
- where customerId == "" || c.CustomerId == customerId
- select c;
+ /// <summary>
+ /// Gets all comments
+ /// </summary>
+ /// <param name="customerId">Customer identifier; "" to load all records</param>
+ /// <returns>Comments</returns>
+ public virtual async Task<IList<NewsComment>> GetAllComments(string customerId)
+ {
+ var query = from n in _newsItemRepository.Table
+ from c in n.NewsComments
+ select c;
- return await Task.FromResult(query2.ToList());
- }
+ var query2 = from c in query
+ orderby c.CreatedOnUtc
+ where customerId == "" || c.CustomerId == customerId
+ select c;
- #endregion
+ return await Task.FromResult(query2.ToList());
}
-}
+
+ #endregion
+}
\ No newline at end of file
diff --git a/src/Business/Grand.Business.Cms/Services/PageLayoutService.cs b/src/Business/Grand.Business.Cms/Services/PageLayoutService.cs
index 9463b15c0..acd49de2b 100644
--- a/src/Business/Grand.Business.Cms/Services/PageLayoutService.cs
+++ b/src/Business/Grand.Business.Cms/Services/PageLayoutService.cs
@@ -6,120 +6,119 @@ using Grand.Infrastructure.Caching.Constants;
using Grand.Infrastructure.Extensions;
using MediatR;
-namespace Grand.Business.Cms.Services
+namespace Grand.Business.Cms.Services;
+
+/// <summary>
+/// Page layout service
+/// </summary>
+public class PageLayoutService : IPageLayoutService
{
+ #region Ctor
+
/// <summary>
- /// Page layout service
+ /// Ctor
/// </summary>
- public class PageLayoutService : IPageLayoutService
+ /// <param name="pageLayoutRepository">Page layout repository</param>
+ /// <param name="cacheBase">cache base</param>
+ /// <param name="mediator">Mediator</param>
+ public PageLayoutService(IRepository<PageLayout> pageLayoutRepository,
+ ICacheBase cacheBase,
+ IMediator mediator)
{
- #region Fields
+ _pageLayoutRepository = pageLayoutRepository;
+ _cacheBase = cacheBase;
+ _mediator = mediator;
+ }
+
+ #endregion
- private readonly IRepository<PageLayout> _pageLayoutRepository;
- private readonly ICacheBase _cacheBase;
- private readonly IMediator _mediator;
+ #region Fields
- #endregion
+ private readonly IRepository<PageLayout> _pageLayoutRepository;
+ private readonly ICacheBase _cacheBase;
+ private readonly IMediator _mediator;
- #region Ctor
+ #endregion
- /// <summary>
- /// Ctor
- /// </summary>
- /// <param name="pageLayoutRepository">Page layout repository</param>
- /// <param name="cacheBase">cache base</param>
- /// <param name="mediator">Mediator</param>
- public PageLayoutService(IRepository<PageLayout> pageLayoutRepository,
- ICacheBase cacheBase,
- IMediator mediator)
+ #region Methods
+
+ /// <summary>
+ /// Gets all page layouts
+ /// </summary>
+ /// <returns>Page layouts</returns>
+ public virtual async Task<IList<PageLayout>> GetAllPageLayouts()
+ {
+ return await _cacheBase.GetAsync(CacheKey.PAGE_LAYOUT_ALL, async () =>
{
- _pageLayoutRepository = pageLayoutRepository;
- _cacheBase = cacheBase;
- _mediator = mediator;
- }
+ var query = from pt in _pageLayoutRepository.Table
+ orderby pt.DisplayOrder
+ select pt;
- #endregion
+ return await Task.FromResult(query.ToList());
+ });
+ }
- #region Methods
+ /// <summary>
+ /// Gets a page layout
+ /// </summary>
+ /// <param name="pageLayoutId">Page layout identifier</param>
+ /// <returns>Page layout</returns>
+ public virtual Task<PageLayout> GetPageLayoutById(string pageLayoutId)
+ {
+ var key = string.Format(CacheKey.PAGE_LAYOUT_BY_ID_KEY, pageLayoutId);
+ return _cacheBase.GetAsync(key, () => _pageLayoutRepository.GetByIdAsync(pageLayoutId));
+ }
-
- /// <summary>
- /// Gets all page layouts
- /// </summary>
- /// <returns>Page layouts</returns>
- public virtual async Task<IList<PageLayout>> GetAllPageLayouts()
- {
- return await _cacheBase.GetAsync(CacheKey.PAGE_LAYOUT_ALL, async () =>
- {
- var query = from pt in _pageLayoutRepository.Table
- orderby pt.DisplayOrder
- select pt;
-
- return await Task.FromResult(query.ToList());
- });
- }
-
- /// <summary>
- /// Gets a page layout
- /// </summary>
- /// <param name="pageLayoutId">Page layout identifier</param>
- /// <returns>Page layout</returns>
- public virtual Task<PageLayout> GetPageLayoutById(string pageLayoutId)
- {
- var key = string.Format(CacheKey.PAGE_LAYOUT_BY_ID_KEY, pageLayoutId);
- return _cacheBase.GetAsync(key, () => _pageLayoutRepository.GetByIdAsync(pageLayoutId));
- }
-
- /// <summary>
- /// Inserts page layout
- /// </summary>
- /// <param name="pageLayout">Page layout</param>
- public virtual async Task InsertPageLayout(PageLayout pageLayout)
- {
- ArgumentNullException.ThrowIfNull(pageLayout);
+ /// <summary>
+ /// Inserts page layout
+ /// </summary>
+ /// <param name="pageLayout">Page layout</param>
+ public virtual async Task InsertPageLayout(PageLayout pageLayout)
+ {
+ ArgumentNullException.ThrowIfNull(pageLayout);
- await _pageLayoutRepository.InsertAsync(pageLayout);
+ await _pageLayoutRepository.InsertAsync(pageLayout);
- //clear cache
- await _cacheBase.RemoveByPrefix(CacheKey.PAGE_LAYOUT_PATTERN_KEY);
+ //clear cache
+ await _cacheBase.RemoveByPrefix(CacheKey.PAGE_LAYOUT_PATTERN_KEY);
- //event notification
- await _mediator.EntityInserted(pageLayout);
- }
+ //event notification
+ await _mediator.EntityInserted(pageLayout);
+ }
- /// <summary>
- /// Updates the page layout
- /// </summary>
- /// <param name="pageLayout">Page layout</param>
- public virtual async Task UpdatePageLayout(PageLayout pageLayout)
- {
- ArgumentNullException.ThrowIfNull(pageLayout);
+ /// <summary>
+ /// Updates the page layout
+ /// </summary>
+ /// <param name="pageLayout">Page layout</param>
+ public virtual async Task UpdatePageLayout(PageLayout pageLayout)
+ {
+ ArgumentNullException.ThrowIfNull(pageLayout);
- await _pageLayoutRepository.UpdateAsync(pageLayout);
+ await _pageLayoutRepository.UpdateAsync(pageLayout);
- //clear cache
- await _cacheBase.RemoveByPrefix(CacheKey.PAGE_LAYOUT_PATTERN_KEY);
+ //clear cache
+ await _cacheBase.RemoveByPrefix(CacheKey.PAGE_LAYOUT_PATTERN_KEY);
- //event notification
- await _mediator.EntityUpdated(pageLayout);
- }
- /// <summary>
- /// Delete page layout
- /// </summary>
- /// <param name="pageLayout">Page layout</param>
- public virtual async Task DeletePageLayout(PageLayout pageLayout)
- {
- ArgumentNullException.ThrowIfNull(pageLayout);
+ //event notification
+ await _mediator.EntityUpdated(pageLayout);
+ }
- await _pageLayoutRepository.DeleteAsync(pageLayout);
+ /// <summary>
+ /// Delete page layout
+ /// </summary>
+ /// <param name="pageLayout">Page layout</param>
+ public virtual async Task DeletePageLayout(PageLayout pageLayout)
+ {
+ ArgumentNullException.ThrowIfNull(pageLayout);
- //clear cache
- await _cacheBase.RemoveByPrefix(CacheKey.PAGE_LAYOUT_PATTERN_KEY);
+ await _pageLayoutRepository.DeleteAsync(pageLayout);
- //event notification
- await _mediator.EntityDeleted(pageLayout);
- }
+ //clear cache
+ await _cacheBase.RemoveByPrefix(CacheKey.PAGE_LAYOUT_PATTERN_KEY);
- #endregion
+ //event notification
+ await _mediator.EntityDeleted(pageLayout);
}
-}
+
+ #endregion
+}
\ No newline at end of file
diff --git a/src/Business/Grand.Business.Cms/Services/PageService.cs b/src/Business/Grand.Business.Cms/Services/PageService.cs
index 7c9f52623..36a0faeee 100644
--- a/src/Business/Grand.Business.Cms/Services/PageService.cs
+++ b/src/Business/Grand.Business.Cms/Services/PageService.cs
@@ -1,7 +1,7 @@
using Grand.Business.Core.Interfaces.Cms;
using Grand.Business.Core.Interfaces.Common.Security;
-using Grand.Domain.Customers;
using Grand.Data;
+using Grand.Domain.Customers;
using Grand.Domain.Pages;
using Grand.Infrastructure;
using Grand.Infrastructure.Caching;
@@ -10,170 +10,168 @@ using Grand.Infrastructure.Configuration;
using Grand.Infrastructure.Extensions;
using MediatR;
-namespace Grand.Business.Cms.Services
+namespace Grand.Business.Cms.Services;
+
+/// <summary>
+/// Page service
+/// </summary>
+public class PageService : IPageService
{
+ #region Ctor
+
+ public PageService(IRepository<Page> pageRepository,
+ IWorkContext workContext,
+ IAclService aclService,
+ IMediator mediator,
+ ICacheBase cacheBase, AccessControlConfig accessControlConfig)
+ {
+ _pageRepository = pageRepository;
+ _workContext = workContext;
+ _aclService = aclService;
+ _mediator = mediator;
+ _cacheBase = cacheBase;
+ _accessControlConfig = accessControlConfig;
+ }
+
+ #endregion
+
+ #region Fields
+
+ private readonly IRepository<Page> _pageRepository;
+ private readonly IWorkContext _workContext;
+ private readonly IAclService _aclService;
+ private readonly IMediator _mediator;
+ private readonly ICacheBase _cacheBase;
+ private readonly AccessControlConfig _accessControlConfig;
+
+ #endregion
+
+ #region Methods
+
/// <summary>
- /// Page service
+ /// Gets a page
/// </summary>
- public class PageService : IPageService
+ /// <param name="pageId">The page identifier</param>
+ /// <returns>Page</returns>
+ public virtual Task<Page> GetPageById(string pageId)
{
- #region Fields
-
- private readonly IRepository<Page> _pageRepository;
- private readonly IWorkContext _workContext;
- private readonly IAclService _aclService;
- private readonly IMediator _mediator;
- private readonly ICacheBase _cacheBase;
- private readonly AccessControlConfig _accessControlConfig;
-
- #endregion
-
- #region Ctor
-
- public PageService(IRepository<Page> pageRepository,
- IWorkContext workContext,
- IAclService aclService,
- IMediator mediator,
- ICacheBase cacheBase, AccessControlConfig accessControlConfig)
- {
- _pageRepository = pageRepository;
- _workContext = workContext;
- _aclService = aclService;
- _mediator = mediator;
- _cacheBase = cacheBase;
- _accessControlConfig = accessControlConfig;
- }
-
- #endregion
-
- #region Methods
-
- /// <summary>
- /// Gets a page
- /// </summary>
- /// <param name="pageId">The page identifier</param>
- /// <returns>Page</returns>
- public virtual Task<Page> GetPageById(string pageId)
- {
- var key = string.Format(CacheKey.PAGES_BY_ID_KEY, pageId);
- return _cacheBase.GetAsync(key, () => _pageRepository.GetByIdAsync(pageId));
- }
-
- /// <summary>
- /// Gets a page
- /// </summary>
- /// <param name="systemName">The page system name</param>
- /// <param name="storeId">Store identifier; pass 0 to ignore filtering by store and load the first one</param>
- /// <returns>Page</returns>
- public virtual async Task<Page> GetPageBySystemName(string systemName, string storeId = "")
- {
- if (string.IsNullOrEmpty(systemName))
- return null;
+ var key = string.Format(CacheKey.PAGES_BY_ID_KEY, pageId);
+ return _cacheBase.GetAsync(key, () => _pageRepository.GetByIdAsync(pageId));
+ }
- var key = string.Format(CacheKey.PAGES_BY_SYSTEMNAME, systemName, storeId);
- return await _cacheBase.GetAsync(key, async () =>
- {
+ /// <summary>
+ /// Gets a page
+ /// </summary>
+ /// <param name="systemName">The page system name</param>
+ /// <param name="storeId">Store identifier; pass 0 to ignore filtering by store and load the first one</param>
+ /// <returns>Page</returns>
+ public virtual async Task<Page> GetPageBySystemName(string systemName, string storeId = "")
+ {
+ if (string.IsNullOrEmpty(systemName))
+ return null;
- var query = from p in _pageRepository.Table
- select p;
+ var key = string.Format(CacheKey.PAGES_BY_SYSTEMNAME, systemName, storeId);
+ return await _cacheBase.GetAsync(key, async () =>
+ {
+ var query = from p in _pageRepository.Table
+ select p;
+
+ query = query.Where(t => t.SystemName.ToLower() == systemName.ToLower());
+ query = query.OrderBy(t => t.Id);
+ var pages = await Task.FromResult(query.ToList());
+ if (!string.IsNullOrEmpty(storeId)) pages = pages.Where(x => _aclService.Authorize(x, storeId)).ToList();
+ return pages.FirstOrDefault();
+ });
+ }
- query = query.Where(t => t.SystemName.ToLower() == systemName.ToLower());
- query = query.OrderBy(t => t.Id);
- var pages = await Task.FromResult(query.ToList());
- if (!string.IsNullOrEmpty(storeId))
- {
- pages = pages.Where(x => _aclService.Authorize(x, storeId)).ToList();
- }
- return pages.FirstOrDefault();
- });
- }
-
- /// <summary>
- /// Gets all pages
- /// </summary>
- /// <param name="storeId">Store identifier; pass "" to load all records</param>
- /// <param name="ignoreAcl"></param>
- /// <returns>Pages</returns>
- public virtual async Task<IList<Page>> GetAllPages(string storeId, bool ignoreAcl = false)
+ /// <summary>
+ /// Gets all pages
+ /// </summary>
+ /// <param name="storeId">Store identifier; pass "" to load all records</param>
+ /// <param name="ignoreAcl"></param>
+ /// <returns>Pages</returns>
+ public virtual async Task<IList<Page>> GetAllPages(string storeId, bool ignoreAcl = false)
+ {
+ var key = string.Format(CacheKey.PAGES_ALL_KEY, storeId, ignoreAcl);
+ return await _cacheBase.GetAsync(key, async () =>
{
- var key = string.Format(CacheKey.PAGES_ALL_KEY, storeId, ignoreAcl);
- return await _cacheBase.GetAsync(key, async () =>
- {
- var query = from p in _pageRepository.Table
- select p;
+ var query = from p in _pageRepository.Table
+ select p;
- query = query.OrderBy(t => t.DisplayOrder).ThenBy(t => t.SystemName);
+ query = query.OrderBy(t => t.DisplayOrder).ThenBy(t => t.SystemName);
- if ((string.IsNullOrEmpty(storeId) || _accessControlConfig.IgnoreStoreLimitations) &&
- (ignoreAcl || _accessControlConfig.IgnoreAcl)) return await Task.FromResult(query.ToList());
+ if ((string.IsNullOrEmpty(storeId) || _accessControlConfig.IgnoreStoreLimitations) &&
+ (ignoreAcl || _accessControlConfig.IgnoreAcl)) return await Task.FromResult(query.ToList());
+ {
+ if (!ignoreAcl && !_accessControlConfig.IgnoreAcl)
{
- if (!ignoreAcl && !_accessControlConfig.IgnoreAcl)
- {
- var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
- query = from p in query
- where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
- select p;
- }
- //Store acl
- if (string.IsNullOrEmpty(storeId) || _accessControlConfig.IgnoreStoreLimitations)
- return await Task.FromResult(query.ToList());
+ var allowedCustomerGroupsIds = _workContext.CurrentCustomer.GetCustomerGroupIds();
query = from p in query
- where !p.LimitedToStores || p.Stores.Contains(storeId)
+ where !p.LimitedToGroups || allowedCustomerGroupsIds.Any(x => p.CustomerGroups.Contains(x))
select p;
-
- query = query.OrderBy(t => t.SystemName);
}
- return await Task.FromResult(query.ToList());
- });
- }
-
- /// <summary>
- /// Inserts a page
- /// </summary>
- /// <param name="page">Page</param>
- public virtual async Task InsertPage(Page page)
- {
- ArgumentNullException.ThrowIfNull(page);
- await _pageRepository.InsertAsync(page);
+ //Store acl
+ if (string.IsNullOrEmpty(storeId) || _accessControlConfig.IgnoreStoreLimitations)
+ return await Task.FromResult(query.ToList());
+ query = from p in query
+ where !p.LimitedToStores || p.Stores.Contains(storeId)
+ select p;
+
+ query = query.OrderBy(t => t.SystemName);
+ }
+ return await Task.FromResult(query.ToList());
+ });
+ }
+
+ /// <summary>
+ /// Inserts a page
+ /// </summary>
+ /// <param name="page">Page</param>
+ public virtual async Task InsertPage(Page page)
+ {
+ ArgumentNullException.ThrowIfNull(page);
- //cache
- await _cacheBase.RemoveByPrefix(CacheKey.PAGES_PATTERN_KEY);
- //event notification
- await _mediator.EntityInserted(page);
- }
+ await _pageRepository.InsertAsync(page);
- /// <summary>
- /// Updates the page
- /// </summary>
- /// <param name="page">Page</param>
- public virtual async Task UpdatePage(Page page)
- {
- ArgumentNullException.ThrowIfNull(page);
+ //cache
+ await _cacheBase.RemoveByPrefix(CacheKey.PAGES_PATTERN_KEY);
+ //event notification
+ await _mediator.EntityInserted(page);
+ }
+
+ /// <summary>
+ /// Updates the page
+ /// </summary>
+ /// <param name="page">Page</param>
+ public virtual async Task UpdatePage(Page page)
+ {
+ ArgumentNullException.ThrowIfNull(page);
- await _pageRepository.UpdateAsync(page);
+ await _pageRepository.UpdateAsync(page);
- //cache
- await _cacheBase.RemoveByPrefix(CacheKey.PAGES_PATTERN_KEY);
+ //cache
+ await _cacheBase.RemoveByPrefix(CacheKey.PAGES_PATTERN_KEY);
- //event notification
- await _mediator.EntityUpdated(page);
- }
- /// <summary>
- /// Deletes a page
- /// </summary>
- /// <param name="page">Page</param>
- public virtual async Task DeletePage(Page page)
- {
- ArgumentNullException.ThrowIfNull(page);
+ //event notification
+ await _mediator.EntityUpdated(page);
+ }
+
+ /// <summary>
+ /// Deletes a page
+ /// </summary>
+ /// <param name="page">Page</param>
+ public virtual async Task DeletePage(Page page)
+ {
+ ArgumentNullException.ThrowIfNull(page);
- await _pageRepository.DeleteAsync(page);
+ await _pageRepository.DeleteAsync(page);
- //cache
- await _cacheBase.RemoveByPrefix(CacheKey.PAGES_PATTERN_KEY);
- //event notification
- await _mediator.EntityDeleted(page);
- }
- #endregion
+ //cache
+ await _cacheBase.RemoveByPrefix(CacheKey.PAGES_PATTERN_KEY);
+ //event notification
+ await _mediator.EntityDeleted(page);
}
-}
+
+ #endregion
+}
\ No newline at end of file
diff --git a/src/Business/Grand.Business.Cms/Services/RobotsTxtService.cs b/src/Business/Grand.Business.Cms/Services/RobotsTxtService.cs
index 94c1b9128..db9469005 100644
--- a/src/Business/Grand.Business.Cms/Services/RobotsTxtService.cs
+++ b/src/Business/Grand.Business.Cms/Services/RobotsTxtService.cs
@@ -1,108 +1,105 @@
using Grand.Business.Core.Interfaces.Cms;
-using Grand.Domain.Common;
using Grand.Data;
+using Grand.Domain.Common;
using Grand.Infrastructure.Caching;
using Grand.Infrastructure.Caching.Constants;
using Grand.Infrastructure.Extensions;
using MediatR;
-namespace Grand.Business.Cms.Services
+namespace Grand.Business.Cms.Services;
+
+public class RobotsTxtService : IRobotsTxtService
{
- public class RobotsTxtService : IRobotsTxtService
+ #region Ctor
+
+ /// <summary>
+ /// Ctor
+ /// </summary>
+ /// <param name="robotsRepository">Robots repository</param>
+ /// <param name="mediator">Mediator</param>
+ /// <param name="cacheBase">Cache manager</param>
+ public RobotsTxtService(
+ IRepository<RobotsTxt> robotsRepository,
+ IMediator mediator,
+ ICacheBase cacheBase)
{
+ _robotsRepository = robotsRepository;
+ _mediator = mediator;
+ _cacheBase = cacheBase;
+ }
- #region Fields
-
- private readonly IRepository<RobotsTxt> _robotsRepository;
- private readonly IMediator _mediator;
- private readonly ICacheBase _cacheBase;
+ #endregion
- #endregion
- #region Ctor
+ /// <summary>
+ /// get robotsTXT by store ident
+ /// </summary>
+ /// <param name="storeId"></param>
+ /// <returns></returns>
+ public virtual async Task<RobotsTxt> GetRobotsTxt(string storeId = "")
+ {
+ var key = string.Format(CacheKey.ROBOTS_BY_STORE, storeId);
- /// <summary>
- /// Ctor
- /// </summary>
- /// <param name="robotsRepository">Robots repository</param>
- /// <param name="mediator">Mediator</param>
- /// <param name="cacheBase">Cache manager</param>
- public RobotsTxtService(
- IRepository<RobotsTxt> robotsRepository,
- IMediator mediator,
- ICacheBase cacheBase)
+ return await _cacheBase.GetAsync(key, async () =>
{
- _robotsRepository = robotsRepository;
- _mediator = mediator;
- _cacheBase = cacheBase;
- }
+ var robotsTxt = await _robotsRepository.GetOneAsync(x => x.StoreId == storeId);
+ return robotsTxt;
+ });
+ }
- #endregion
+ /// <summary>
+ /// Insert a robotsTxt
+ /// </summary>
+ /// <param name="robotsTxt">robotsTxt</param>
+ public virtual async Task InsertRobotsTxt(RobotsTxt robotsTxt)
+ {
+ ArgumentNullException.ThrowIfNull(robotsTxt);
+ await _robotsRepository.InsertAsync(robotsTxt);
- /// <summary>
- /// get robotsTXT by store ident
- /// </summary>
- /// <param name="storeId"></param>
- /// <returns></returns>
- public virtual async Task<RobotsTxt> GetRobotsTxt(string storeId = "")
- {
- var key = string.Format(CacheKey.ROBOTS_BY_STORE, storeId);
-
- return await _cacheBase.GetAsync(key, async () =>
- {
- var robotsTxt = await _robotsRepository.GetOneAsync(x=>x.StoreId == storeId);
- return robotsTxt;
- });
- }
-
- /// <summary>
- /// Insert a robotsTxt
- /// </summary>
- /// <param name="robotsTxt">robotsTxt</param>
- public virtual async Task InsertRobotsTxt(RobotsTxt robotsTxt)
- {
- ArgumentNullException.ThrowIfNull(robotsTxt);
+ await _cacheBase.RemoveByPrefix(CacheKey.ROBOTS_ALL_KEY);
- await _robotsRepository.InsertAsync(robotsTxt);
+ //event notification
+ await _mediator.EntityInserted(robotsTxt);
+ }
- await _cacheBase.RemoveByPrefix(CacheKey.ROBOTS_ALL_KEY);
+ /// <summary>
+ /// Update a robotsTxt
+ /// </summary>
+ /// <param name="robotsTxt">robotsTxt</param>
+ public virtual async Task UpdateRobotsTxt(RobotsTxt robotsTxt)
+ {
+ ArgumentNullException.ThrowIfNull(robotsTxt);
- //event notification
- await _mediator.EntityInserted(robotsTxt);
- }
+ await _robotsRepository.UpdateAsync(robotsTxt);
- /// <summary>
- /// Update a robotsTxt
- /// </summary>
- /// <param name="robotsTxt">robotsTxt</param>
- public virtual async Task UpdateRobotsTxt(RobotsTxt robotsTxt)
- {
- ArgumentNullException.ThrowIfNull(robotsTxt);
+ await _cacheBase.RemoveByPrefix(CacheKey.ROBOTS_ALL_KEY);
- await _robotsRepository.UpdateAsync(robotsTxt);
+ //event notification
+ await _mediator.EntityUpdated(robotsTxt);
+ }
- await _cacheBase.RemoveByPrefix(CacheKey.ROBOTS_ALL_KEY);
+ /// <summary>
+ /// Delete a robotsTxt
+ /// </summary>
+ /// <param name="robotsTxt">robotsTxt</param>
+ public virtual async Task DeleteRobotsTxt(RobotsTxt robotsTxt)
+ {
+ ArgumentNullException.ThrowIfNull(robotsTxt);
- //event notification
- await _mediator.EntityUpdated(robotsTxt);
- }
+ await _robotsRepository.DeleteAsync(robotsTxt);
- /// <summary>
- /// Delete a robotsTxt
- /// </summary>
- /// <param name="robotsTxt">robotsTxt</param>
- public virtual async Task DeleteRobotsTxt(RobotsTxt robotsTxt)
- {
- ArgumentNullException.ThrowIfNull(robotsTxt);
+ await _cacheBase.RemoveByPrefix(CacheKey.ROBOTS_ALL_KEY);
- await _robotsRepository.DeleteAsync(robotsTxt);
+ //event notification
+ await _mediator.EntityDeleted(robotsTxt);
+ }
- await _cacheBase.RemoveByPrefix(CacheKey.ROBOTS_ALL_KEY);
+ #region Fields
- //event notification
- await _mediator.EntityDeleted(robotsTxt);
- }
+ private readonly IRepository<RobotsTxt> _robotsRepository;
+ private readonly IMediator _mediator;
+ private readonly ICacheBase _cacheBase;
- }
-}
+ #endregion
+}
\ No newline at end of file
diff --git a/src/Business/Grand.Business.Cms/Services/WidgetService.cs b/src/Business/Grand.Business.Cms/Services/WidgetService.cs
index 8ae4f155a..c82fd63ab 100644
--- a/src/Business/Grand.Business.Cms/Services/WidgetService.cs
+++ b/src/Business/Grand.Business.Cms/Services/WidgetService.cs
@@ -3,99 +3,101 @@ using Grand.Domain.Cms;
using Grand.Domain.Customers;
using Grand.Infrastructure.Extensions;
-namespace Grand.Business.Cms.Services
+namespace Grand.Business.Cms.Services;
+
+/// <summary>
+/// Widget service
+/// </summary>
+public class WidgetService : IWidgetService
{
+ #region Ctor
+
/// <summary>
- /// Widget service
+ /// Ctor
/// </summary>
- public class WidgetService : IWidgetService
+ public WidgetService(
+ IEnumerable<IWidgetProvider> widgetProviders,
+ WidgetSettings widgetSettings)
{
- #region Fields
+ _widgetProviders = widgetProviders;
+ _widgetSettings = widgetSettings;
+ }
- private readonly IEnumerable<IWidgetProvider> _widgetProviders;
- private readonly WidgetSettings _widgetSettings;
+ #endregion
- #endregion
+ #region Fields
- #region Ctor
+ private readonly IEnumerable<IWidgetProvider> _widgetProviders;
+ private readonly WidgetSettings _widgetSettings;
- /// <summary>
- /// Ctor
- /// </summary>
- public WidgetService(
- IEnumerable<IWidgetProvider> widgetProviders,
- WidgetSettings widgetSettings)
- {
- _widgetProviders = widgetProviders;
- _widgetSettings = widgetSettings;
- }
+ #endregion
- #endregion
+ #region Methods
- #region Methods
+ /// <summary>
+ /// Load active widgets
+ /// </summary>
+ /// <param name="storeId">Store ident</param>
+ /// <param name="customer">Customer</param>
+ /// <returns>Widgets</returns>
+ public virtual IList<IWidgetProvider> LoadActiveWidgets(string storeId = "", Customer customer = null)
+ {
+ return LoadAllWidgets(storeId, customer)
+ .Where(x =>
+ _widgetSettings.ActiveWidgetSystemNames.Contains(x.SystemName, StringComparer.OrdinalIgnoreCase))
+ .ToList();
+ }
- /// <summary>
- /// Load active widgets
- /// </summary>
- /// <param name="storeId">Store ident</param>
- /// <param name="customer">Customer</param>
- /// <returns>Widgets</returns>
- public virtual IList<IWidgetProvider> LoadActiveWidgets(string storeId = "", Customer customer = null)
- {
- return LoadAllWidgets(storeId, customer)
- .Where(x =>
- _widgetSettings.ActiveWidgetSystemNames.Contains(x.SystemName, StringComparer.OrdinalIgnoreCase))
- .ToList();
- }
+ /// <summary>
+ /// Load active widgets
+ /// </summary>
+ /// <param name="widgetZone">Widget zone</param>
+ /// <param name="storeId">Store ident</param>
+ /// <param name="customer">Customer</param>
+ /// <returns>Widgets</returns>
+ public virtual async Task<IList<IWidgetProvider>> LoadActiveWidgetsByWidgetZone(string widgetZone,
+ string storeId = "", Customer customer = null)
+ {
+ if (string.IsNullOrWhiteSpace(widgetZone))
+ return new List<IWidgetProvider>();
- /// <summary>
- /// Load active widgets
- /// </summary>
- /// <param name="widgetZone">Widget zone</param>
- /// <param name="storeId">Store ident</param>
- /// <param name="customer">Customer</param>
- /// <returns>Widgets</returns>
- public virtual async Task<IList<IWidgetProvider>> LoadActiveWidgetsByWidgetZone(string widgetZone, string storeId = "", Customer customer = null)
+ var activeWidgets = new List<IWidgetProvider>();
+ var widgets = LoadActiveWidgets(storeId, customer).ToList();
+ foreach (var widget in widgets)
{
- if (string.IsNullOrWhiteSpace(widgetZone))
- return new List<IWidgetProvider>();
-
- var activeWidgets = new List<IWidgetProvider>();
- var widgets = LoadActiveWidgets(storeId, customer).ToList();
- foreach (var widget in widgets)
- {
- var widgetZones = await widget.GetWidgetZones();
- if (widgetZones.Contains(widgetZone, StringComparer.OrdinalIgnoreCase))
- activeWidgets.Add(widget);
- }
- return activeWidgets;
+ var widgetZones = await widget.GetWidgetZones();
+ if (widgetZones.Contains(widgetZone, StringComparer.OrdinalIgnoreCase))
+ activeWidgets.Add(widget);
}
- /// <summary>
- /// Load widget by system name
- /// </summary>
- /// <param name="systemName">System name</param>
- /// <returns>Found widget</returns>
- public virtual IWidgetProvider LoadWidgetBySystemName(string systemName)
- {
- return _widgetProviders.FirstOrDefault(x => x.SystemName.Equals(systemName, StringComparison.OrdinalIgnoreCase));
- }
+ return activeWidgets;
+ }
- /// <summary>
- /// Load all widgets
- /// </summary>
- /// <param name="storeId">Store ident</param>
- /// <param name="customer">Customer</param>
- /// <returns>Widgets</returns>
- public virtual IList<IWidgetProvider> LoadAllWidgets(string storeId = "", Customer customer = null)
- {
- return _widgetProviders
- .Where(x =>
- x.IsAuthenticateStore(storeId) &&
- x.IsAuthenticateGroup(customer))
- .OrderBy(x => x.Priority).ToList();
- }
+ /// <summary>
+ /// Load widget by system name
+ /// </summary>
+ /// <param name="systemName">System name</param>
+ /// <returns>Found widget</returns>
+ public virtual IWidgetProvider LoadWidgetBySystemName(string systemName)
+ {
+ return _widgetProviders.FirstOrDefault(x =>
+ x.SystemName.Equals(systemName, StringComparison.OrdinalIgnoreCase));
+ }
- #endregion
+ /// <summary>
+ /// Load all widgets
+ /// </summary>
+ /// <param name="storeId">Store ident</param>
+ /// <param name="customer">Customer</param>
+ /// <returns>Widgets</returns>
+ public virtual IList<IWidgetProvider> LoadAllWidgets(string storeId = "", Customer customer = null)
+ {
+ return _widgetProviders
+ .Where(x =>
+ x.IsAuthenticateStore(storeId) &&
+ x.IsAuthenticateGroup(customer))
+ .OrderBy(x => x.Priority).ToList();
}
-}
+
+ #endregion
+}
\ No newline at end of file
diff --git a/src/Business/Grand.Business.Cms/Startup/StartupApplication.cs b/src/Business/Grand.Business.Cms/Startup/StartupApplication.cs
index 4e9b458cd..761a32c74 100644
--- a/src/Business/Grand.Business.Cms/Startup/StartupApplication.cs
+++ b/src/Business/Grand.Business.Cms/Startup/StartupApplication.cs
@@ -1,34 +1,31 @@
-using Grand.Business.Core.Interfaces.Cms;
-using Grand.Business.Cms.Services;
+using Grand.Business.Cms.Services;
+using Grand.Business.Core.Interfaces.Cms;
using Grand.Infrastructure;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
-namespace Grand.Business.Cms.Startup
+namespace Grand.Business.Cms.Startup;
+
+public class StartupApplication : IStartupApplication
{
- public class StartupApplication : IStartupApplication
+ public void ConfigureServices(IServiceCollection services, IConfiguration configuration)
{
- public void ConfigureServices(IServiceCollection services, IConfiguration configuration)
- {
- services.AddScoped<IBlogService, BlogService>();
- services.AddScoped<IWidgetService, WidgetService>();
- services.AddScoped<INewsService, NewsService>();
- services.AddScoped<IKnowledgebaseService, KnowledgebaseService>();
- services.AddScoped<IPageLayoutService, PageLayoutService>();
- services.AddScoped<IPageService, PageService>();
- services.AddScoped<ICookiePreference, CookiePreference>();
- services.AddScoped<IRobotsTxtService, RobotsTxtService>();
-
- }
- public void Configure(IApplicationBuilder application, IWebHostEnvironment webHostEnvironment)
- {
-
- }
- public int Priority => 100;
- public bool BeforeConfigure => false;
-
+ services.AddScoped<IBlogService, BlogService>();
+ services.AddScoped<IWidgetService, WidgetService>();
+ services.AddScoped<INewsService, NewsService>();
+ services.AddScoped<IKnowledgebaseService, KnowledgebaseService>();
+ services.AddScoped<IPageLayoutService, PageLayoutService>();
+ services.AddScoped<IPageService, PageService>();
+ services.AddScoped<ICookiePreference, CookiePreference>();
+ services.AddScoped<IRobotsTxtService, RobotsTxtService>();
+ }
+ public void Configure(IApplicationBuilder application, IWebHostEnvironment webHostEnvironment)
+ {
}
-}
+
+ public int Priority => 100;
+ public bool BeforeConfigure => false;
+}
\ No newline at end of file