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
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.csnew file mode 100644index 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.csnew file mode 100644index 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+}