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.

Migrate 'Product attributes' region into BaseProductController (ARCH-001 Phase 1)

KrzysztofPajak5bac264607d1
diff --git a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
index 7c49015b2..d0f56b757 100644
--- a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
+++ b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
@@ -3568,4 +3568,377 @@ public class BaseProductControllerTests
await Assert.ThrowsExactlyAsync<ArgumentException>(() => _controller.TierPriceDelete(model));
}
+
+ // --- ProductAttributeMappingList -------------------------------------------------------------
+ // HasAccess applied uniformly on every action in this region. Store's original checked ownership
+ // (CanAccessProduct) on List/PopupGET/PopupPOST/Delete/ValidationRulesPopupGET but not on
+ // ValidationRulesPopup(POST). Vendor's original checked (CheckAccessToProduct/HasAccessToProduct) on
+ // List/PopupGET/Delete/ValidationRulesPopupGET, but NOT on ProductAttributeMappingPopup(POST) or
+ // ValidationRulesPopup(POST) - letting a vendor edit an attribute mapping (or its validation rules) on
+ // any product, not just their own, by posting a known productId.
+
+ [TestMethod]
+ public async Task ProductAttributeMappingList_ScopeDeniesAccess_ReturnsErrorJson()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+
+ var result = await _controller.ProductAttributeMappingList(new Grand.Web.Common.DataSource.DataSourceRequest(), "p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(
+ s => s.PrepareProductAttributeMappingModels(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeMappingList_ScopeDeniesAccess_UsesScopeResourceKeyPrefix()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+ _scopeMock.Setup(s => s.ResourceKeyPrefix).Returns("Vendor");
+
+ var result = await _controller.ProductAttributeMappingList(new Grand.Web.Common.DataSource.DataSourceRequest(), "p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Vendor.Catalog.Products.Permissions"), Times.Once);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeMappingList_ScopeGrantsAccess_ReturnsGrid()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var attributes = new List<ProductModel.ProductAttributeMappingModel> { new() { Id = "pam1" } };
+ _productViewModelServiceMock.Setup(s => s.PrepareProductAttributeMappingModels(product))
+ .ReturnsAsync(attributes);
+
+ var result = await _controller.ProductAttributeMappingList(new Grand.Web.Common.DataSource.DataSourceRequest(), "p1");
+
+ var json = result as JsonResult;
+ Assert.IsNotNull(json);
+ var gridModel = json.Value as Grand.Web.Common.DataSource.DataSourceResult;
+ Assert.IsNotNull(gridModel);
+ Assert.AreEqual(1, gridModel.Total);
+ }
+
+ // --- ProductAttributeMappingPopup (GET) ------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductAttributeMappingPopup_Get_ScopeDeniesAccess_ReturnsPermissionsContent()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+
+ var result = await _controller.ProductAttributeMappingPopup("p1", null);
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(
+ s => s.PrepareProductAttributeMappingModel(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeMappingPopup_Get_ScopeGrantsAccess_NoMappingId_PreparesNewModel()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ _productViewModelServiceMock.Setup(s => s.PrepareProductAttributeMappingModel(product))
+ .ReturnsAsync(new ProductModel.ProductAttributeMappingModel());
+
+ var result = await _controller.ProductAttributeMappingPopup("p1", null);
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(s => s.PrepareProductAttributeMappingModel(product), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeMappingPopup_Get_ScopeGrantsAccess_MappingId_PreparesEditModel()
+ {
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ var product = new Product { Id = "p1" };
+ product.ProductAttributeMappings.Add(mapping);
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ _productViewModelServiceMock.Setup(s => s.PrepareProductAttributeMappingModel(product, mapping))
+ .ReturnsAsync(new ProductModel.ProductAttributeMappingModel());
+
+ var result = await _controller.ProductAttributeMappingPopup("p1", "pam1");
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(s => s.PrepareProductAttributeMappingModel(product, mapping), Times.Once);
+ }
+
+ // --- ProductAttributeMappingPopup (POST) -----------------------------------------------------
+ // HasAccess added here: Vendor's original had no ownership check on this POST at all.
+
+ [TestMethod]
+ public async Task ProductAttributeMappingPopup_Post_ScopeDeniesAccess_DoesNotInsertOrUpdate()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+ var model = new ProductModel.ProductAttributeMappingModel { ProductId = "p1" };
+
+ var result = await _controller.ProductAttributeMappingPopup(model);
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(
+ s => s.InsertProductAttributeMappingModel(It.IsAny<ProductModel.ProductAttributeMappingModel>()),
+ Times.Never);
+ _productViewModelServiceMock.Verify(
+ s => s.UpdateProductAttributeMappingModel(It.IsAny<ProductModel.ProductAttributeMappingModel>()),
+ Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeMappingPopup_Post_ScopeGrantsAccess_NoId_Inserts()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var model = new ProductModel.ProductAttributeMappingModel { ProductId = "p1" };
+
+ var result = await _controller.ProductAttributeMappingPopup(model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _productViewModelServiceMock.Verify(s => s.InsertProductAttributeMappingModel(model), Times.Once);
+ _productViewModelServiceMock.Verify(
+ s => s.UpdateProductAttributeMappingModel(It.IsAny<ProductModel.ProductAttributeMappingModel>()),
+ Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeMappingPopup_Post_ScopeGrantsAccess_WithId_Updates()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var model = new ProductModel.ProductAttributeMappingModel { Id = "pam1", ProductId = "p1" };
+
+ var result = await _controller.ProductAttributeMappingPopup(model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _productViewModelServiceMock.Verify(s => s.UpdateProductAttributeMappingModel(model), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeMappingPopup_Post_MissingProduct_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+ var model = new ProductModel.ProductAttributeMappingModel { ProductId = "missing" };
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(() => _controller.ProductAttributeMappingPopup(model));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeMappingPopup_Post_InvalidModelState_ReturnsView_DoesNotCheckAccess()
+ {
+ _controller.ModelState.AddModelError("x", "err");
+ var model = new ProductModel.ProductAttributeMappingModel { ProductId = "p1" };
+ _productViewModelServiceMock.Setup(s => s.PrepareProductAttributeMappingModel(model)).ReturnsAsync(model);
+
+ var result = await _controller.ProductAttributeMappingPopup(model);
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productServiceMock.Verify(p => p.GetProductById(It.IsAny<string>(), It.IsAny<bool>()), Times.Never);
+ _scopeMock.Verify(s => s.HasAccess(It.IsAny<Product>()), Times.Never);
+ }
+
+ // --- ProductAttributeMappingDelete -----------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductAttributeMappingDelete_MissingProduct_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+ var attrServiceMock = new Mock<IProductAttributeService>();
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ProductAttributeMappingDelete("pam1", "missing", attrServiceMock.Object));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeMappingDelete_MappingNotFound_Throws()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ var attrServiceMock = new Mock<IProductAttributeService>();
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ProductAttributeMappingDelete("missing-pam", "p1", attrServiceMock.Object));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeMappingDelete_ScopeDeniesAccess_ReturnsErrorJson_DoesNotDelete()
+ {
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ var product = new Product { Id = "p1" };
+ product.ProductAttributeMappings.Add(mapping);
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+ var attrServiceMock = new Mock<IProductAttributeService>();
+
+ var result = await _controller.ProductAttributeMappingDelete("pam1", "p1", attrServiceMock.Object);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ attrServiceMock.Verify(
+ s => s.DeleteProductAttributeMapping(It.IsAny<ProductAttributeMapping>(), It.IsAny<string>()),
+ Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeMappingDelete_ScopeGrantsAccess_Deletes()
+ {
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ var product = new Product { Id = "p1" };
+ product.ProductAttributeMappings.Add(mapping);
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var attrServiceMock = new Mock<IProductAttributeService>();
+
+ var result = await _controller.ProductAttributeMappingDelete("pam1", "p1", attrServiceMock.Object);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ attrServiceMock.Verify(s => s.DeleteProductAttributeMapping(mapping, "p1"), Times.Once);
+ }
+
+ // --- ProductAttributeValidationRulesPopup (GET) -----------------------------------------------
+
+ [TestMethod]
+ public async Task ProductAttributeValidationRulesPopup_Get_ScopeDeniesAccess_ReturnsPermissionsContent()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+
+ var result = await _controller.ProductAttributeValidationRulesPopup("pam1", "p1");
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValidationRulesPopup_Get_ScopeGrantsAccess_MappingMissing_ReturnsContent()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+
+ var result = await _controller.ProductAttributeValidationRulesPopup("missing-pam", "p1");
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ Assert.AreEqual("No attribute value found with the specified id", content.Content);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValidationRulesPopup_Get_ScopeGrantsAccess_PreparesModel()
+ {
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ var product = new Product { Id = "p1" };
+ product.ProductAttributeMappings.Add(mapping);
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ _productViewModelServiceMock.Setup(s => s.PrepareProductAttributeMappingModel(mapping))
+ .ReturnsAsync(new ProductModel.ProductAttributeMappingModel());
+
+ var result = await _controller.ProductAttributeValidationRulesPopup("pam1", "p1");
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(s => s.PrepareProductAttributeMappingModel(mapping), Times.Once);
+ }
+
+ // --- ProductAttributeValidationRulesPopup (POST) ----------------------------------------------
+ // HasAccess added here: none of the three original hosts checked ownership on this POST at all - a
+ // store/vendor user could update an attribute mapping's validation rules on any product by posting a
+ // known productId/model.Id.
+
+ [TestMethod]
+ public async Task ProductAttributeValidationRulesPopup_Post_MissingProduct_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+ var model = new ProductModel.ProductAttributeMappingModel { ProductId = "missing" };
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ProductAttributeValidationRulesPopup(model));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValidationRulesPopup_Post_MappingNotFound_Throws()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ var model = new ProductModel.ProductAttributeMappingModel { Id = "missing-pam", ProductId = "p1" };
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ProductAttributeValidationRulesPopup(model));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValidationRulesPopup_Post_ScopeDeniesAccess_ReturnsPermissionsContent_DoesNotUpdate()
+ {
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ var product = new Product { Id = "p1" };
+ product.ProductAttributeMappings.Add(mapping);
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+ var model = new ProductModel.ProductAttributeMappingModel { Id = "pam1", ProductId = "p1" };
+
+ var result = await _controller.ProductAttributeValidationRulesPopup(model);
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(
+ s => s.UpdateProductAttributeValidationRulesModel(It.IsAny<ProductAttributeMapping>(),
+ It.IsAny<ProductModel.ProductAttributeMappingModel>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValidationRulesPopup_Post_ScopeGrantsAccess_ValidModel_Updates()
+ {
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ var product = new Product { Id = "p1" };
+ product.ProductAttributeMappings.Add(mapping);
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var model = new ProductModel.ProductAttributeMappingModel { Id = "pam1", ProductId = "p1" };
+
+ var result = await _controller.ProductAttributeValidationRulesPopup(model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _productViewModelServiceMock.Verify(
+ s => s.UpdateProductAttributeValidationRulesModel(mapping, model), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValidationRulesPopup_Post_ScopeGrantsAccess_InvalidModelState_ReturnsView()
+ {
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ var product = new Product { Id = "p1" };
+ product.ProductAttributeMappings.Add(mapping);
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ _controller.ModelState.AddModelError("x", "err");
+ var model = new ProductModel.ProductAttributeMappingModel { Id = "pam1", ProductId = "p1" };
+ _productViewModelServiceMock.Setup(s => s.PrepareProductAttributeMappingModel(mapping)).ReturnsAsync(model);
+
+ var result = await _controller.ProductAttributeValidationRulesPopup(model);
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(
+ s => s.UpdateProductAttributeValidationRulesModel(It.IsAny<ProductAttributeMapping>(),
+ It.IsAny<ProductModel.ProductAttributeMappingModel>()), Times.Never);
+ }
}
diff --git a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
index 02974a425..a8910390a 100644
--- a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
+++ b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
@@ -2327,4 +2327,154 @@ public abstract class BaseProductController(
}
#endregion
+
+ #region Product attributes
+
+ [PermissionAuthorizeAction(PermissionActionName.Preview)]
+ [HttpPost]
+ public async Task<IActionResult> ProductAttributeMappingList(DataSourceRequest command, string productId)
+ {
+ var product = await productService.GetProductById(productId);
+
+ // HasAccess applied uniformly across this region (Admin's Global scope is a no-op). Store originally
+ // checked ownership here (CanAccessProduct) and Vendor did too (CheckAccessToProduct), but neither
+ // host checked ProductAttributeMappingPopup(POST) or ProductAttributeValidationRulesPopup(POST) at
+ // all - a store/vendor user could edit an attribute mapping's name/values or its validation rules on
+ // any product (not just their own/in-scope one) by posting a known productId. Vendor's
+ // ProductAttributeMappingPopup(POST) had no check either, despite its own GET sibling checking.
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var attributesModel = await productViewModelService.PrepareProductAttributeMappingModels(product);
+ var gridModel = new DataSourceResult {
+ Data = attributesModel,
+ Total = attributesModel.Count
+ };
+
+ return Json(gridModel);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ public async Task<IActionResult> ProductAttributeMappingPopup(string productId, string productAttributeMappingId)
+ {
+ var product = await productService.GetProductById(productId);
+
+ // See the List-action comment above.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ if (string.IsNullOrEmpty(productAttributeMappingId))
+ {
+ var model = await productViewModelService.PrepareProductAttributeMappingModel(product);
+ return View(model);
+ }
+
+ var productAttributeMapping =
+ product.ProductAttributeMappings.FirstOrDefault(x => x.Id == productAttributeMappingId);
+ var editModel = await productViewModelService.PrepareProductAttributeMappingModel(product,
+ productAttributeMapping);
+ return View(editModel);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductAttributeMappingPopup(ProductModel.ProductAttributeMappingModel model)
+ {
+ if (ModelState.IsValid)
+ {
+ var product = await productService.GetProductById(model.ProductId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ // HasAccess here too: Vendor's original never checked ownership on this POST at all (only its
+ // GET sibling did), letting a vendor insert/update an attribute mapping on any product. See the
+ // List-action comment.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ if (string.IsNullOrEmpty(model.Id))
+ await productViewModelService.InsertProductAttributeMappingModel(model);
+ else
+ await productViewModelService.UpdateProductAttributeMappingModel(model);
+
+ return Content("");
+ }
+
+ Error(ModelState);
+ model = await productViewModelService.PrepareProductAttributeMappingModel(model);
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductAttributeMappingDelete(string id, string productId,
+ [FromServices] IProductAttributeService productAttributeService)
+ {
+ var product = await productService.GetProductById(productId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ var productAttributeMapping = product.ProductAttributeMappings.FirstOrDefault(x => x.Id == id);
+ if (productAttributeMapping == null)
+ throw new ArgumentException("No product attribute mapping found with the specified id");
+
+ // See the List-action comment above.
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ await productAttributeService.DeleteProductAttributeMapping(productAttributeMapping, product.Id);
+ return new JsonResult("");
+ }
+
+ //edit
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ public async Task<IActionResult> ProductAttributeValidationRulesPopup(string id, string productId)
+ {
+ var product = await productService.GetProductById(productId);
+
+ // See the List-action comment above. Store's original used ErrorForKendoGridJson here even though
+ // this action returns a View (not a grid), which would have rendered raw JSON as page content on
+ // denial - using Content(...) instead, consistent with the other popup GET action in this region.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var productAttributeMapping = product.ProductAttributeMappings.FirstOrDefault(x => x.Id == id);
+ if (productAttributeMapping == null)
+ return Content("No attribute value found with the specified id");
+
+ var model = await productViewModelService.PrepareProductAttributeMappingModel(productAttributeMapping);
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductAttributeValidationRulesPopup(
+ ProductModel.ProductAttributeMappingModel model)
+ {
+ var product = await productService.GetProductById(model.ProductId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ var productAttributeMapping = product.ProductAttributeMappings.FirstOrDefault(x => x.Id == model.Id);
+ if (productAttributeMapping == null)
+ throw new ArgumentException("No attribute value found with the specified id");
+
+ // HasAccess here too: none of the three original hosts checked ownership on this POST at all -
+ // a store/vendor user could update an attribute mapping's validation rules (min/max length,
+ // allowed file extensions, default value) on any product by posting a known productId/model.Id.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ if (ModelState.IsValid)
+ {
+ await productViewModelService.UpdateProductAttributeValidationRulesModel(productAttributeMapping, model);
+ return Content("");
+ }
+
+ Error(ModelState);
+ model = await productViewModelService.PrepareProductAttributeMappingModel(productAttributeMapping);
+ return View(model);
+ }
+
+ #endregion
}