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.
C# aspnet-corecsharpdockerdotnetecommerceecommerce-platformmongodbmulti-storemulti-vendornosqlonline-shopshoppingcart
using Grand.Business.Core.Interfaces.Catalog.Categories;
using Grand.Business.Core.Interfaces.Catalog.Discounts;
using Grand.Business.Core.Interfaces.Catalog.Products;
using Grand.Business.Core.Interfaces.Common.Localization;
using Grand.Business.Core.Interfaces.Common.Seo;
using Grand.Business.Core.Interfaces.Common.Stores;
using Grand.Business.Core.Interfaces.Customers;
using Grand.Business.Core.Interfaces.Storage;
using Grand.Domain.Catalog;
using Grand.Domain.Discounts;
using Grand.Web.AdminShared.Extensions;
using Grand.Web.AdminShared.Extensions.Mapping;
using Grand.Web.AdminShared.Interfaces;
using Grand.Web.AdminShared.Models.Catalog;
using Grand.Web.Common.Extensions;
using Grand.Web.Common.Localization;
using Microsoft.AspNetCore.Mvc.Rendering;
namespace Grand.Web.AdminShared.Services;
public class CategoryViewModelService : ICategoryViewModelService
{
private readonly CatalogSettings _catalogSettings;
private readonly ICategoryLayoutService _categoryLayoutService;
private readonly ICategoryService _categoryService;
private readonly IDiscountService _discountService;
private readonly IPictureService _pictureService;
private readonly IProductCategoryService _productCategoryService;
private readonly IProductService _productService;
private readonly IStoreService _storeService;
private readonly ITranslationService _translationService;
private readonly IVendorService _vendorService;
private readonly ISeNameService _seNameService;
private readonly IEnumTranslationService _enumTranslationService;
public CategoryViewModelService(
ICategoryService categoryService,
IProductCategoryService productCategoryService,
ICategoryLayoutService categoryLayoutService,
IDiscountService discountService,
ITranslationService translationService,
IStoreService storeService,
IPictureService pictureService,
IProductService productService,
IVendorService vendorService,
CatalogSettings catalogSettings,
ISeNameService seNameService,
IEnumTranslationService enumTranslationService)
{
_categoryService = categoryService;
_productCategoryService = productCategoryService;
_categoryLayoutService = categoryLayoutService;
_discountService = discountService;
_translationService = translationService;
_storeService = storeService;
_productService = productService;
_pictureService = pictureService;
_vendorService = vendorService;
_catalogSettings = catalogSettings;
_seNameService = seNameService;
_enumTranslationService = enumTranslationService;
}
public virtual async Task<CategoryListModel> PrepareCategoryListModel(string storeId)
{
var model = new CategoryListModel();
model.AvailableStores.Add(new SelectListItem
{ Text = _translationService.GetResource("Admin.Common.All"), Value = "" });
foreach (var s in (await _storeService.GetAllStores()).Where(x =>
x.Id == storeId || string.IsNullOrWhiteSpace(storeId)))
model.AvailableStores.Add(new SelectListItem { Text = s.Shortcut, Value = s.Id });
return model;
}
public virtual async Task<(IEnumerable<CategoryModel> categoryListModel, int totalCount)> PrepareCategoryListModel(
CategoryListModel model, int pageIndex, int pageSize)
{
var categories = await _categoryService.GetAllCategories(
parentId: null,
categoryName: model.SearchCategoryName,
storeId: model.SearchStoreId,
pageSize: pageSize,
pageIndex: pageIndex - 1,
showHidden: true);
var categoryListModel = new List<CategoryModel>();
foreach (var x in categories)
{
var categoryModel = x.ToModel();
categoryModel.Breadcrumb = await _categoryService.GetFormattedBreadCrumb(x);
categoryListModel.Add(categoryModel);
}
return (categoryListModel, categories.TotalCount);
}
public virtual async Task<CategoryModel> PrepareCategoryModel(string storeId)
{
var model = new CategoryModel();
//sort options
PrepareSortOptionsModel(model);
//layouts
await PrepareLayoutsModel(model);
//discounts
await PrepareDiscountModel(model, null, true, storeId);
//default values
model.PageSize = _catalogSettings.DefaultPageSize;
model.PageSizeOptions = _catalogSettings.DefaultPageSizeOptions;
model.Published = true;
model.IncludeInMenu = true;
model.AllowCustomersToSelectPageSize = true;
return model;
}
public virtual async Task<CategoryModel> PrepareCategoryModel(CategoryModel model, Category category,
string storeId)
{
//sort options
PrepareSortOptionsModel(model);
//layouts
await PrepareLayoutsModel(model);
//discounts
await PrepareDiscountModel(model, category, false, storeId);
return model;
}
public async Task<Category> InsertCategoryModel(CategoryModel model)
{
var category = model.ToEntity();
var allDiscounts = await _discountService.GetDiscountsQuery(DiscountType.AssignedToCategories);
foreach (var discount in allDiscounts)
if (model.SelectedDiscountIds != null && model.SelectedDiscountIds.Contains(discount.Id))
category.AppliedDiscounts.Add(discount.Id);
//locales
category.Locales = await _seNameService.TranslationSeNameProperties(model.Locales, category, x => x.Name);
category.SeName = await _seNameService.ValidateSeName(category, model.SeName, category.Name, true);
await _categoryService.InsertCategory(category);
await _seNameService.SaveSeName(category);
//update picture seo file name
await _pictureService.UpdatePictureSeoNames(category.PictureId, category.Name);
return category;
}
public virtual async Task<Category> UpdateCategoryModel(Category category, CategoryModel model)
{
var prevPictureId = category.PictureId;
category = model.ToEntity(category);
category.Locales = await _seNameService.TranslationSeNameProperties(model.Locales, category, x => x.Name);
category.SeName = await _seNameService.ValidateSeName(category, model.SeName, category.Name, true);
//discounts
var allDiscounts = await _discountService.GetDiscountsQuery(DiscountType.AssignedToCategories);
foreach (var discount in allDiscounts)
if (model.SelectedDiscountIds != null && model.SelectedDiscountIds.Contains(discount.Id))
{
//new discount
if (category.AppliedDiscounts.Count(d => d == discount.Id) == 0)
category.AppliedDiscounts.Add(discount.Id);
}
else
{
//remove discount
if (category.AppliedDiscounts.Count(d => d == discount.Id) > 0)
category.AppliedDiscounts.Remove(discount.Id);
}
await _categoryService.UpdateCategory(category);
//search engine name
await _seNameService.SaveSeName(category);
//delete an old picture (if deleted or updated)
if (!string.IsNullOrEmpty(prevPictureId) && prevPictureId != category.PictureId)
{
var prevPicture = await _pictureService.GetPictureById(prevPictureId);
if (prevPicture != null)
await _pictureService.DeletePicture(prevPicture);
}
//update picture seo file name
await _pictureService.UpdatePictureSeoNames(category.PictureId, category.Name);
return category;
}
public virtual async Task DeleteCategory(Category category)
{
await _categoryService.DeleteCategory(category);
}
public virtual async Task<(IEnumerable<CategoryModel.CategoryProductModel> categoryProductModels, int totalCount)>
PrepareCategoryProductModel(string categoryId, int pageIndex, int pageSize)
{
var productCategories = await _productCategoryService.GetProductCategoriesByCategoryId(categoryId,
pageIndex - 1, pageSize, true);
var categoryproducts = new List<CategoryModel.CategoryProductModel>();
foreach (var item in productCategories)
{
var pc = new CategoryModel.CategoryProductModel {
Id = item.Id,
CategoryId = item.CategoryId,
ProductId = item.ProductId,
ProductName = (await _productService.GetProductById(item.ProductId))?.Name,
IsFeaturedProduct = item.IsFeaturedProduct,
DisplayOrder = item.DisplayOrder
};
categoryproducts.Add(pc);
}
return (categoryproducts, productCategories.TotalCount);
}
public virtual async Task<ProductCategory> UpdateProductCategoryModel(CategoryModel.CategoryProductModel model)
{
var product = await _productService.GetProductById(model.ProductId);
var productCategory = product.ProductCategories.FirstOrDefault(x => x.Id == model.Id);
if (productCategory == null)
throw new ArgumentException("No product category mapping found with the specified id");
productCategory.IsFeaturedProduct = model.IsFeaturedProduct;
productCategory.DisplayOrder = model.DisplayOrder;
await _productCategoryService.UpdateProductCategory(productCategory, product.Id);
return productCategory;
}
public virtual async Task DeleteProductCategoryModel(string id, string productId)
{
var product = await _productService.GetProductById(productId);
if (product == null)
throw new ArgumentException("No product found with the specified id");
var productCategory = product.ProductCategories.FirstOrDefault(x => x.Id == id);
if (productCategory == null)
throw new ArgumentException("No product category mapping found with the specified id");
await _productCategoryService.DeleteProductCategory(productCategory, product.Id);
}
public virtual async Task<CategoryModel.AddCategoryProductModel> PrepareAddCategoryProductModel(string storeId)
{
var model = new CategoryModel.AddCategoryProductModel();
//stores
model.AvailableStores.Add(new SelectListItem
{ Text = _translationService.GetResource("Admin.Common.All"), Value = " " });
foreach (var s in (await _storeService.GetAllStores()).Where(x =>
x.Id == storeId || string.IsNullOrWhiteSpace(storeId)))
model.AvailableStores.Add(new SelectListItem { Text = s.Shortcut, Value = s.Id });
//vendors
model.AvailableVendors.Add(new SelectListItem
{ Text = _translationService.GetResource("Admin.Common.All"), Value = " " });
foreach (var v in await _vendorService.GetAllVendors(showHidden: true))
model.AvailableVendors.Add(new SelectListItem { Text = v.Name, Value = v.Id });
//product types
model.AvailableProductTypes = _enumTranslationService.ToSelectList(ProductType.SimpleProduct).ToList();
model.AvailableProductTypes.Insert(0,
new SelectListItem { Text = _translationService.GetResource("Admin.Common.All"), Value = "0" });
return model;
}
public virtual async Task InsertCategoryProductModel(CategoryModel.AddCategoryProductModel model)
{
foreach (var id in model.SelectedProductIds)
{
var product = await _productService.GetProductById(id);
if (product != null)
if (!product.ProductCategories.Any(x => x.CategoryId == model.CategoryId))
await _productCategoryService.InsertProductCategory(
new ProductCategory {
CategoryId = model.CategoryId,
IsFeaturedProduct = false,
DisplayOrder = 1
}, product.Id);
}
}
public virtual async Task<(IList<ProductModel> products, int totalCount)> PrepareProductModel(
CategoryModel.AddCategoryProductModel model, int pageIndex, int pageSize)
{
var products = await _productService.PrepareProductList(model.SearchCategoryId, model.SearchBrandId,
model.SearchCollectionId, model.SearchStoreId, model.SearchVendorId, model.SearchProductTypeId,
model.SearchProductName, pageIndex, pageSize);
return (products.Select(x => x.ToModel()).ToList(), products.TotalCount);
}
protected virtual async Task PrepareLayoutsModel(CategoryModel model)
{
ArgumentNullException.ThrowIfNull(model);
var layouts = await _categoryLayoutService.GetAllCategoryLayouts();
foreach (var layout in layouts)
model.AvailableCategoryLayouts.Add(new SelectListItem {
Text = layout.Name,
Value = layout.Id
});
}
protected virtual async Task PrepareDiscountModel(CategoryModel model, Category category, bool excludeProperties, string storeId)
{
ArgumentNullException.ThrowIfNull(model);
model.AvailableDiscounts = (await _discountService.GetDiscountsQuery(DiscountType.AssignedToCategories, storeId))
.Select(d => d.ToModel())
.ToList();
if (!excludeProperties && category != null) model.SelectedDiscountIds = category.AppliedDiscounts.ToArray();
}
protected virtual void PrepareSortOptionsModel(CategoryModel model)
{
ArgumentNullException.ThrowIfNull(model);
model.AvailableSortOptions = _enumTranslationService.ToSelectList(ProductSortingEnum.Position).ToList();
model.AvailableSortOptions.Insert(0, new SelectListItem { Text = "None", Value = "-1" });
}
}