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.

Add BaseProductController with the list/create/edit/delete region (ARCH-001 Phase 1)

KrzysztofPajak36ffd5976017
diff --git a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
new file mode 100644
index 000000000..1730311be
--- /dev/null
+++ b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
@@ -0,0 +1,350 @@
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Grand.Business.Core.Interfaces.Common.Directory;
+using Grand.Business.Core.Interfaces.Common.Localization;
+using Grand.Business.Core.Interfaces.Common.Security;
+using Grand.Business.Core.Interfaces.Storage;
+using Grand.Domain.Catalog;
+using Grand.Infrastructure.Mapper;
+using Grand.Mapping;
+using Grand.Web.AdminShared.Controllers;
+using Grand.Web.AdminShared.Interfaces;
+using Grand.Web.AdminShared.Mapper;
+using Grand.Web.AdminShared.Models.Catalog;
+using Grand.Web.Common.Localization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Web.Admin.Tests.Controllers;
+
+// Characterization tests for the merged access-check behavior in BaseProductController's
+// "Product list / create / edit / delete" region (ARCH-001 Phase 1 Task 7). These replace the
+// equivalent per-host access-check cases in Grand.Web.Admin/Store/Vendor.Tests ProductControllerTests
+// (removed in Task 13), parameterized over a mocked IAdminDataScope<Product> instead of three
+// different concrete access mechanisms (Admin: none: Store: AccessToEntityByStore; Vendor: HasAccessToProduct).
+[TestClass]
+public class BaseProductControllerTests
+{
+ // BaseProductController is abstract - it has no host until Task 11 subclasses it. This
+ // minimal subclass exists only so the actions under test can be invoked directly.
+ private class TestProductController(
+ IProductViewModelService productViewModelService,
+ IProductService productService,
+ IInventoryManageService inventoryManageService,
+ ILanguageService languageService,
+ ITranslationService translationService,
+ IProductReservationService productReservationService,
+ IAuctionService auctionService,
+ IDateTimeService dateTimeService,
+ IPermissionService permissionService,
+ IEnumTranslationService enumTranslationService,
+ IAdminDataScope<Product> scope)
+ : BaseProductController(productViewModelService, productService, inventoryManageService,
+ languageService, translationService, productReservationService, auctionService,
+ dateTimeService, permissionService, enumTranslationService, scope);
+
+ private TestProductController _controller;
+ private Mock<IProductService> _productServiceMock;
+ private Mock<IProductViewModelService> _productViewModelServiceMock;
+ private Mock<ITranslationService> _translationServiceMock;
+ private Mock<IAdminDataScope<Product>> _scopeMock;
+
+ [TestInitialize]
+ public void Setup()
+ {
+ var mapperConfig = new MapperConfiguration(cfg => { cfg.AddProfile<ProductProfile>(); });
+ AutoMapperConfig.Init(mapperConfig);
+
+ _productServiceMock = new Mock<IProductService>();
+ _productViewModelServiceMock = new Mock<IProductViewModelService>();
+ _translationServiceMock = new Mock<ITranslationService>();
+ _translationServiceMock.Setup(t => t.GetResource(It.IsAny<string>())).Returns("resource");
+
+ _scopeMock = new Mock<IAdminDataScope<Product>>();
+ _scopeMock.Setup(s => s.ResourceKeyPrefix).Returns("Admin");
+ _scopeMock.Setup(s => s.DefaultStoreId).Returns((string)null);
+
+ var languageServiceMock = new Mock<ILanguageService>();
+ languageServiceMock.Setup(l => l.GetAllLanguages(true, It.IsAny<string>())).ReturnsAsync(new List<Domain.Localization.Language>());
+
+ _controller = new TestProductController(
+ _productViewModelServiceMock.Object,
+ _productServiceMock.Object,
+ new Mock<IInventoryManageService>().Object,
+ languageServiceMock.Object,
+ _translationServiceMock.Object,
+ new Mock<IProductReservationService>().Object,
+ new Mock<IAuctionService>().Object,
+ new Mock<IDateTimeService>().Object,
+ new Mock<IPermissionService>().Object,
+ new Mock<IEnumTranslationService>().Object,
+ _scopeMock.Object);
+
+ var httpContext = new DefaultHttpContext();
+ _controller.ControllerContext = new ControllerContext { HttpContext = httpContext };
+ _controller.TempData = new TempDataDictionary(httpContext, new Mock<ITempDataProvider>().Object);
+ }
+
+ // --- Edit (GET) --------------------------------------------------------------------------------
+
+ [TestMethod]
+ public async Task EditGet_ProductNotFound_RedirectsToList()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", true)).ReturnsAsync((Product)null);
+
+ var result = await _controller.Edit("missing");
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ _scopeMock.Verify(s => s.HasAccess(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task EditGet_ScopeDeniesAccess_RedirectsToList()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", true)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+
+ var result = await _controller.Edit("p1");
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ _productViewModelServiceMock.Verify(
+ s => s.PrepareProductModel(It.IsAny<ProductModel>(), It.IsAny<Product>(), It.IsAny<bool>(), It.IsAny<bool>()),
+ Times.Never);
+ }
+
+ [TestMethod]
+ public async Task EditGet_ScopeGrantsAccess_ShowsForm()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", true)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+
+ var result = await _controller.Edit("p1");
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(
+ s => s.PrepareProductModel(It.IsAny<ProductModel>(), product, false, false), Times.Once);
+ }
+
+ // --- Edit (POST) -------------------------------------------------------------------------------
+
+ [TestMethod]
+ public async Task EditPost_ProductNotFound_RedirectsToList()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", true)).ReturnsAsync((Product)null);
+
+ var result = await _controller.Edit(new ProductModel { Id = "missing" }, continueEditing: false);
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ _productViewModelServiceMock.Verify(
+ s => s.UpdateProductModel(It.IsAny<Product>(), It.IsAny<ProductModel>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task EditPost_ScopeDeniesAccess_RedirectsToEditWithoutUpdating()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", true)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+
+ var result = await _controller.Edit(new ProductModel { Id = "p1" }, continueEditing: false);
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("Edit", redirect.ActionName);
+ Assert.AreEqual("p1", redirect.RouteValues["id"]);
+ _productViewModelServiceMock.Verify(
+ s => s.UpdateProductModel(It.IsAny<Product>(), It.IsAny<ProductModel>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task EditPost_ScopeGrantsAccess_Updates()
+ {
+ var product = new Product { Id = "p1", Ticks = 5 };
+ _productServiceMock.Setup(p => p.GetProductById("p1", true)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ _productViewModelServiceMock.Setup(s => s.UpdateProductModel(product, It.IsAny<ProductModel>()))
+ .ReturnsAsync(product);
+
+ var result = await _controller.Edit(new ProductModel { Id = "p1", Ticks = 5 }, continueEditing: false);
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ _productViewModelServiceMock.Verify(s => s.UpdateProductModel(product, It.IsAny<ProductModel>()), Times.Once);
+ }
+
+ // --- Delete --------------------------------------------------------------------------------------
+
+ [TestMethod]
+ public async Task Delete_ProductNotFound_RedirectsToList()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", true)).ReturnsAsync((Product)null);
+
+ var result = await _controller.Delete("missing");
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ _productViewModelServiceMock.Verify(s => s.DeleteProduct(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task Delete_ScopeDeniesAccess_RedirectsToEditWithoutDeleting()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", true)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+
+ var result = await _controller.Delete("p1");
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("Edit", redirect.ActionName);
+ Assert.AreEqual("p1", redirect.RouteValues["id"]);
+ _productViewModelServiceMock.Verify(s => s.DeleteProduct(product), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task Delete_ScopeGrantsAccess_DeletesAndRedirectsToList()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", true)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+
+ var result = await _controller.Delete("p1");
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ _productViewModelServiceMock.Verify(s => s.DeleteProduct(product), Times.Once);
+ }
+
+ // --- CopyProduct -----------------------------------------------------------------------------------
+
+ [TestMethod]
+ public async Task CopyProduct_ScopeDeniesAccess_RedirectsToListWithoutCopying()
+ {
+ var originalProduct = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", true)).ReturnsAsync(originalProduct);
+ _scopeMock.Setup(s => s.HasAccess(originalProduct)).ReturnsAsync(false);
+ var copyProductServiceMock = new Mock<ICopyProductService>();
+
+ var model = new ProductModel {
+ CopyProductModel = new CopyProductModel { Id = "p1", Name = "copy" }
+ };
+
+ var result = await _controller.CopyProduct(model, copyProductServiceMock.Object, new Mock<IPictureService>().Object);
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ copyProductServiceMock.Verify(
+ s => s.CopyProduct(It.IsAny<Product>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task CopyProduct_ScopeGrantsAccess_Copies()
+ {
+ var originalProduct = new Product { Id = "p1" };
+ var newProduct = new Product { Id = "p2" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", true)).ReturnsAsync(originalProduct);
+ _scopeMock.Setup(s => s.HasAccess(originalProduct)).ReturnsAsync(true);
+ var copyProductServiceMock = new Mock<ICopyProductService>();
+ copyProductServiceMock.Setup(s => s.CopyProduct(originalProduct, "copy", false)).ReturnsAsync(newProduct);
+
+ var model = new ProductModel {
+ CopyProductModel = new CopyProductModel { Id = "p1", Name = "copy", Published = false, CopyImages = false }
+ };
+
+ var result = await _controller.CopyProduct(model, copyProductServiceMock.Object, new Mock<IPictureService>().Object);
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("Edit", redirect.ActionName);
+ Assert.AreEqual("p2", redirect.RouteValues["id"]);
+ }
+
+ // --- GoToSku -----------------------------------------------------------------------------------------
+ // Deliberate behavior tightening vs. Store's pre-refactor GoToSku (see the TODO in
+ // BaseProductController.GoToSku): denial now redirects to List, not Edit.
+
+ [TestMethod]
+ public async Task GoToSku_ProductNotFound_ShowsWarningAndRedirectsToList()
+ {
+ _productServiceMock.Setup(p => p.GetProductBySku("sku1")).ReturnsAsync((Product)null);
+
+ var result = await _controller.GoToSku(new ProductListModel { GoDirectlyToSku = "sku1" });
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ Assert.AreEqual("Product", redirect.ControllerName);
+ }
+
+ [TestMethod]
+ public async Task GoToSku_ScopeDeniesAccess_RedirectsToList()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductBySku("sku1")).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+
+ var result = await _controller.GoToSku(new ProductListModel { GoDirectlyToSku = "sku1" });
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ Assert.AreEqual("Product", redirect.ControllerName);
+ }
+
+ [TestMethod]
+ public async Task GoToSku_ScopeGrantsAccess_RedirectsToEdit()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductBySku("sku1")).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+
+ var result = await _controller.GoToSku(new ProductListModel { GoDirectlyToSku = "sku1" });
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("Edit", redirect.ActionName);
+ Assert.AreEqual("p1", redirect.RouteValues["id"]);
+ }
+
+ // --- List / Create default store-scoping -----------------------------------------------------------
+
+ [TestMethod]
+ public async Task List_UsesScopeDefaultStoreId()
+ {
+ _scopeMock.Setup(s => s.DefaultStoreId).Returns("store-1");
+ _productViewModelServiceMock.Setup(s => s.PrepareProductListModel("store-1")).ReturnsAsync(new ProductListModel());
+
+ var result = await _controller.List();
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(s => s.PrepareProductListModel("store-1"), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task Create_Get_DefaultsModelStoreIdFromScope()
+ {
+ _scopeMock.Setup(s => s.DefaultStoreId).Returns("store-1");
+
+ var result = await _controller.Create() as ViewResult;
+
+ Assert.IsNotNull(result);
+ var model = result.Model as ProductModel;
+ Assert.IsNotNull(model);
+ Assert.AreEqual("store-1", model.StoreId);
+ }
+}
diff --git a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
new file mode 100644
index 000000000..a20b0c64e
--- /dev/null
+++ b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
@@ -0,0 +1,296 @@
+using Grand.Business.Core.Dto;
+using Grand.Business.Core.Extensions;
+using Grand.Business.Core.Interfaces.Catalog.Products;
+using Grand.Business.Core.Interfaces.Common.Directory;
+using Grand.Business.Core.Interfaces.Common.Localization;
+using Grand.Business.Core.Interfaces.Common.Security;
+using Grand.Business.Core.Interfaces.ExportImport;
+using Grand.Business.Core.Interfaces.Storage;
+using Grand.Domain.Catalog;
+using Grand.Domain.Common;
+using Grand.Domain.Media;
+using Grand.Domain.Permissions;
+using Grand.SharedKernel.Extensions;
+using Grand.Web.AdminShared.Extensions.Mapping;
+using Grand.Web.AdminShared.Interfaces;
+using Grand.Web.AdminShared.Models.Catalog;
+using Grand.Web.AdminShared.Models.Orders;
+using Grand.Web.Common.Controllers;
+using Grand.Web.Common.DataSource;
+using Grand.Web.Common.Extensions;
+using Grand.Web.Common.Filters;
+using Grand.Web.Common.Helpers;
+using Grand.Web.Common.Localization;
+using Grand.Web.Common.Security.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Microsoft.AspNetCore.StaticFiles;
+
+namespace Grand.Web.AdminShared.Controllers;
+
+// Resource-key-prefix audit (2026-08-16, ARCH-001 Phase 1 Task 6, corrected after review):
+// 28 unique "Admin.<suffix>"/"Vendor.<suffix>" GetResource(...) suffixes were found across
+// Grand.Web.Admin/Controllers/ProductController.cs, Grand.Web.Store/Controllers/ProductController.cs,
+// Grand.Web.Vendor/Controllers/ProductController.cs, Grand.Web.AdminShared/Services/ProductViewModelService.cs
+// and Grand.Web.Vendor/Services/ProductViewModelService.cs (multi-line-aware extraction; the brief's
+// original line-bound grep undercounted this at 23). Of the 28:
+// - 22 are Templated: both an "Admin.<suffix>" and a "Vendor.<suffix>" call site exist, so these are
+// safe to write as $"{scope.ResourceKeyPrefix}.<suffix>" - e.g. Catalog.Products.Added/Updated/Deleted,
+// Catalog.Products.Fields.ChangedWarning, Catalog.Products.List.SkuNotFound, Common.All, Customers.Guest,
+// and 15 more (see task-6-resource-prefix-table.md for the full list).
+// - 6 are Admin-only literals with no Vendor call site (keep as literal "Admin.<suffix>", do not
+// template): Catalog.Products.Permissions, Catalog.Products.Imported,
+// Catalog.Products.List.SearchPublished.ShowOnHomePage, Catalog.Products.TierPrices.Fields.CustomerGroup.All,
+// Catalog.Products.TierPrices.Fields.Store.All, Common.UploadFile.
+// - 0 are host-specific-not-templated (every "Vendor.<suffix>" call site has a matching "Admin.<suffix>"
+// one, so none needed a scope.ResourceKeyPrefix == "Vendor" special case).
+// Store makes no separate resource lookups at all - every Store call site uses the literal "Admin.*" key
+// directly, which is what scope.ResourceKeyPrefix == "Admin" (StoreAdminDataScope) already produces.
+// Within this region (list/create/edit/delete/CopyProduct), every suffix used
+// (Catalog.Products.List.SkuNotFound, Catalog.Products.Added, Catalog.Products.Updated,
+// Catalog.Products.Deleted, Catalog.Products.Fields.ChangedWarning) is in the Templated set above.
+
+[PermissionAuthorize(PermissionSystemName.Products)]
+public abstract class BaseProductController(
+ IProductViewModelService productViewModelService,
+ IProductService productService,
+ IInventoryManageService inventoryManageService,
+ ILanguageService languageService,
+ ITranslationService translationService,
+ IProductReservationService productReservationService,
+ IAuctionService auctionService,
+ IDateTimeService dateTimeService,
+ IPermissionService permissionService,
+ IEnumTranslationService enumTranslationService,
+ IAdminDataScope<Product> scope)
+ : BaseController
+{
+ /// <summary>Hook for host-specific UI-copy warnings that aren't access-scope decisions.
+ /// Overridden by the Store subclass; no-op everywhere else.</summary>
+ protected virtual void EditWarningCheck(Product product) { }
+
+ #region Product list / create / edit / delete
+
+ public IActionResult Index() => RedirectToAction("List");
+
+ public async Task<IActionResult> List()
+ {
+ var model = await productViewModelService.PrepareProductListModel(scope.DefaultStoreId ?? "");
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.List)]
+ [HttpPost]
+ public async Task<IActionResult> ProductList(DataSourceRequest command, ProductListModel model)
+ {
+ if (scope.DefaultStoreId is not null) model.SearchStoreId = scope.DefaultStoreId;
+
+ var (productModels, totalCount) =
+ await productViewModelService.PrepareProductsModel(model, command.Page, command.PageSize);
+ return Json(new DataSourceResult { Data = productModels.ToList(), Total = totalCount });
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Preview)]
+ [HttpPost]
+ public async Task<IActionResult> GoToSku(ProductListModel model)
+ {
+ var product = await productService.GetProductBySku(model.GoDirectlyToSku);
+ if (product != null)
+ {
+ // TODO(ARCH-001-followup): Store's pre-refactor code had a security-relevant bug here -
+ // on access denial it fell into `if (!CanAccessProduct(product)) return RedirectToAction("Edit", ...)`,
+ // i.e. it redirected an unauthorized caller straight to the Edit screen of a product outside
+ // their store. (On access *granted* the old code had a separate, non-security bug: it fell
+ // through to the "not found" Warning + redirect-to-List below instead of going to Edit.)
+ // The merged behavior below deliberately tightens this: deny -> List (matching Vendor's
+ // stricter pattern), grant -> Edit. This is an intentional behavior change, not a faithful
+ // port - call it out in the PR description.
+ if (!await scope.HasAccess(product))
+ return RedirectToAction("List", "Product");
+ return RedirectToAction("Edit", "Product", new { id = product.Id });
+ }
+
+ Warning(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.List.SkuNotFound"));
+ return RedirectToAction("List", "Product");
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Create)]
+ public async Task<IActionResult> Create()
+ {
+ var model = new ProductModel { StoreId = scope.DefaultStoreId };
+ await productViewModelService.PrepareProductModel(model, null, true, true);
+ await AddLocales(languageService, model.Locales);
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ [ArgumentNameFilter(KeyName = "save-continue", Argument = "continueEditing")]
+ public async Task<IActionResult> Create(ProductModel model, bool continueEditing)
+ {
+ if (ModelState.IsValid)
+ {
+ if (scope.DefaultStoreId is not null)
+ {
+ model.Stores = [scope.DefaultStoreId];
+ model.StoreId = scope.DefaultStoreId;
+ }
+
+ var product = await productViewModelService.InsertProductModel(model);
+ Success(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Added"));
+ return continueEditing ? RedirectToAction("Edit", new { id = product.Id }) : RedirectToAction("List");
+ }
+
+ if (scope.DefaultStoreId is not null) model.StoreId = scope.DefaultStoreId;
+ await productViewModelService.PrepareProductModel(model, null, false, true);
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Preview)]
+ public async Task<IActionResult> Edit(string id)
+ {
+ var product = await productService.GetProductById(id, true);
+ if (product == null) return RedirectToAction("List");
+
+ EditWarningCheck(product);
+ if (!await scope.HasAccess(product)) return RedirectToAction("List");
+
+ var model = product.ToModel(dateTimeService);
+ if (scope.DefaultStoreId is not null) model.StoreId = scope.DefaultStoreId;
+ await productViewModelService.PrepareProductModel(model, product, false, false);
+ await AddLocales(languageService, model.Locales, (locale, languageId) =>
+ {
+ locale.Name = product.GetTranslation(x => x.Name, languageId, false);
+ locale.ShortDescription = product.GetTranslation(x => x.ShortDescription, languageId, false);
+ locale.FullDescription = product.GetTranslation(x => x.FullDescription, languageId, false);
+ locale.MetaKeywords = product.GetTranslation(x => x.MetaKeywords, languageId, false);
+ locale.MetaDescription = product.GetTranslation(x => x.MetaDescription, languageId, false);
+ locale.MetaTitle = product.GetTranslation(x => x.MetaTitle, languageId, false);
+ locale.SeName = product.GetSeName(languageId, false);
+ });
+
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ [ArgumentNameFilter(KeyName = "save-continue", Argument = "continueEditing")]
+ public async Task<IActionResult> Edit(ProductModel model, bool continueEditing)
+ {
+ var product = await productService.GetProductById(model.Id, true);
+ if (product == null) return RedirectToAction("List");
+ if (!await scope.HasAccess(product)) return RedirectToAction("Edit", new { id = product.Id });
+
+ if (model.Ticks != product.Ticks)
+ {
+ Error(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Fields.ChangedWarning"));
+ return RedirectToAction("Edit", new { id = product.Id });
+ }
+
+ if (ModelState.IsValid)
+ {
+ if (scope.DefaultStoreId is not null)
+ {
+ model.Stores = [scope.DefaultStoreId];
+ model.StoreId = scope.DefaultStoreId;
+ }
+
+ product = await productViewModelService.UpdateProductModel(product, model);
+ Success(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Updated"));
+ if (continueEditing)
+ {
+ await SaveSelectedTabIndex();
+ return RedirectToAction("Edit", new { id = product.Id });
+ }
+
+ return RedirectToAction("List");
+ }
+
+ if (scope.DefaultStoreId is not null) model.StoreId = scope.DefaultStoreId;
+ await productViewModelService.PrepareProductModel(model, product, false, true);
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Delete)]
+ [HttpPost]
+ public async Task<IActionResult> Delete(string id)
+ {
+ var product = await productService.GetProductById(id, true);
+ if (product == null) return RedirectToAction("List");
+ if (!await scope.HasAccess(product)) return RedirectToAction("Edit", new { id });
+
+ if (ModelState.IsValid)
+ {
+ await productViewModelService.DeleteProduct(product);
+ Success(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Deleted"));
+ return RedirectToAction("List");
+ }
+
+ Error(ModelState);
+ return RedirectToAction("Edit", new { id });
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Delete)]
+ [HttpPost]
+ public async Task<IActionResult> DeleteSelected(ICollection<string> selectedIds)
+ {
+ if (selectedIds != null) await productViewModelService.DeleteSelected(selectedIds.ToList());
+ return Json(new { Result = true });
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Create)]
+ [HttpPost]
+ public async Task<IActionResult> CopyProduct(ProductModel model,
+ [FromServices] ICopyProductService copyProductService, [FromServices] IPictureService pictureService)
+ {
+ var copyModel = model.CopyProductModel;
+ try
+ {
+ var originalProduct = await productService.GetProductById(copyModel.Id, true);
+ if (!await scope.HasAccess(originalProduct)) return RedirectToAction("List");
+
+ if (scope.DefaultStoreId is not null)
+ {
+ originalProduct.LimitedToStores = true;
+ originalProduct.Stores.Clear();
+ originalProduct.Stores.Add(scope.DefaultStoreId);
+ }
+
+ var newProduct = await copyProductService.CopyProduct(originalProduct, copyModel.Name, copyModel.Published);
+ if (copyModel.CopyImages) await CopyImages(originalProduct, newProduct, pictureService);
+
+ Success("The product has been copied successfully");
+ return RedirectToAction("Edit", new { id = newProduct.Id });
+ }
+ catch (Exception exc)
+ {
+ Error(exc.Message);
+ return RedirectToAction("Edit", new { id = copyModel.Id });
+ }
+ }
+
+ private async Task CopyImages(Product originalProduct, Product newProduct, IPictureService pictureService)
+ {
+ foreach (var productPicture in originalProduct.ProductPictures)
+ {
+ var picture = await pictureService.GetPictureById(productPicture.PictureId);
+ var pictureCopy = await pictureService.InsertPicture(
+ await pictureService.LoadPictureBinary(picture),
+ picture.MimeType,
+ pictureService.GetPictureSeName(newProduct.Name),
+ picture.AltAttribute,
+ picture.TitleAttribute,
+ false,
+ Reference.Product,
+ newProduct.Id);
+
+ await productService.InsertProductPicture(new ProductPicture {
+ PictureId = pictureCopy.Id,
+ DisplayOrder = productPicture.DisplayOrder,
+ IsDefault = productPicture.IsDefault
+ }, newProduct.Id);
+ }
+ }
+
+ #endregion
+}