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 attribute values' region into BaseProductController (ARCH-001 Phase 1)

KrzysztofPajakf7f64c37f0cf
diff --git a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
index 534e478cd..d849739eb 100644
--- a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
+++ b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
@@ -4079,4 +4079,596 @@ public class BaseProductControllerTests
_productViewModelServiceMock.Verify(s => s.UpdateProductAttributeConditionModel(product, mapping, model),
Times.Once);
}
+
+ // --- EditAttributeValues (GET) ------------------------------------------------------------------
+ // HasAccess applied uniformly. Admin's original had no ownership check on this action at all.
+
+ [TestMethod]
+ public async Task EditAttributeValues_MissingProduct_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+ var attrServiceMock = new Mock<IProductAttributeService>();
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.EditAttributeValues("pam1", "missing", attrServiceMock.Object));
+ }
+
+ [TestMethod]
+ public async Task EditAttributeValues_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 attrServiceMock = new Mock<IProductAttributeService>();
+
+ var result = await _controller.EditAttributeValues("pam1", "p1", attrServiceMock.Object);
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task EditAttributeValues_ScopeGrantsAccess_MappingMissing_Throws()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var attrServiceMock = new Mock<IProductAttributeService>();
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.EditAttributeValues("missing-pam", "p1", attrServiceMock.Object));
+ }
+
+ [TestMethod]
+ public async Task EditAttributeValues_ScopeGrantsAccess_PreparesListModel()
+ {
+ var mapping = new ProductAttributeMapping { Id = "pam1", ProductAttributeId = "pa1" };
+ var product = new Product { Id = "p1", Name = "Product 1" };
+ 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>();
+ attrServiceMock.Setup(s => s.GetProductAttributeById("pa1"))
+ .ReturnsAsync(new ProductAttribute { Id = "pa1", Name = "Color" });
+
+ var result = await _controller.EditAttributeValues("pam1", "p1", attrServiceMock.Object);
+
+ var view = result as ViewResult;
+ Assert.IsNotNull(view);
+ var model = view.Model as ProductModel.ProductAttributeValueListModel;
+ Assert.IsNotNull(model);
+ Assert.AreEqual("p1", model.ProductId);
+ Assert.AreEqual("Product 1", model.ProductName);
+ Assert.AreEqual("Color", model.ProductAttributeName);
+ Assert.AreEqual("pam1", model.ProductAttributeMappingId);
+ }
+
+ // --- ProductAttributeValueList (POST) -----------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductAttributeValueList_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.ProductAttributeValueList("pam1", "p1", new Grand.Web.Common.DataSource.DataSourceRequest());
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(
+ s => s.PrepareProductAttributeValueModels(It.IsAny<Product>(), It.IsAny<ProductAttributeMapping>()),
+ Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueList_ScopeGrantsAccess_MappingMissing_Throws()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ProductAttributeValueList("missing-pam", "p1", new Grand.Web.Common.DataSource.DataSourceRequest()));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueList_ScopeGrantsAccess_ReturnsGrid()
+ {
+ 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 values = new List<ProductModel.ProductAttributeValueModel> { new() { Id = "pav1" } };
+ _productViewModelServiceMock.Setup(s => s.PrepareProductAttributeValueModels(product, mapping))
+ .ReturnsAsync(values);
+
+ var result = await _controller.ProductAttributeValueList("pam1", "p1", new Grand.Web.Common.DataSource.DataSourceRequest());
+
+ 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);
+ }
+
+ // --- ProductAttributeValueCreatePopup (GET) -----------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductAttributeValueCreatePopup_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.ProductAttributeValueCreatePopup("pam1", "p1");
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(
+ s => s.PrepareProductAttributeValueModel(It.IsAny<Product>(), It.IsAny<ProductAttributeMapping>()),
+ Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueCreatePopup_Get_ScopeGrantsAccess_MappingMissing_Throws()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ProductAttributeValueCreatePopup("missing-pam", "p1"));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueCreatePopup_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.PrepareProductAttributeValueModel(product, mapping))
+ .ReturnsAsync(new ProductModel.ProductAttributeValueModel());
+
+ var result = await _controller.ProductAttributeValueCreatePopup("pam1", "p1");
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(s => s.PrepareProductAttributeValueModel(product, mapping), Times.Once);
+ }
+
+ // --- ProductAttributeValueCreatePopup (POST) ----------------------------------------------------
+ // HasAccess added explicitly: Admin's original had no ownership check on this action at all (neither
+ // explicit nor via validator). Vendor's original relied solely on IProductValidVendor + ModelState -
+ // no explicit action-level check.
+
+ [TestMethod]
+ public async Task ProductAttributeValueCreatePopup_Post_MissingProduct_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+ var model = new ProductModel.ProductAttributeValueModel { ProductId = "missing" };
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ProductAttributeValueCreatePopup(model));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueCreatePopup_Post_ScopeDeniesAccess_ReturnsPermissionsContent_DoesNotInsert()
+ {
+ 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.ProductAttributeValueModel { ProductId = "p1" };
+
+ var result = await _controller.ProductAttributeValueCreatePopup(model);
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(
+ s => s.InsertProductAttributeValueModel(It.IsAny<ProductModel.ProductAttributeValueModel>()),
+ Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueCreatePopup_Post_ScopeGrantsAccess_MappingMissing_RedirectsToList()
+ {
+ 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.ProductAttributeValueModel { ProductId = "p1", ProductAttributeMappingId = "missing-pam" };
+
+ var result = await _controller.ProductAttributeValueCreatePopup(model);
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ Assert.AreEqual("Product", redirect.ControllerName);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueCreatePopup_Post_ScopeGrantsAccess_ValidModel_Inserts()
+ {
+ 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.ProductAttributeValueModel { ProductId = "p1", ProductAttributeMappingId = "pam1" };
+
+ var result = await _controller.ProductAttributeValueCreatePopup(model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _productViewModelServiceMock.Verify(s => s.InsertProductAttributeValueModel(model), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueCreatePopup_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.ProductAttributeValueModel { ProductId = "p1", ProductAttributeMappingId = "pam1" };
+
+ var result = await _controller.ProductAttributeValueCreatePopup(model);
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(
+ s => s.InsertProductAttributeValueModel(It.IsAny<ProductModel.ProductAttributeValueModel>()),
+ Times.Never);
+ _productViewModelServiceMock.Verify(s => s.PrepareProductAttributeValueModel(product, model), Times.Once);
+ }
+
+ // --- ProductAttributeValueEditPopup (GET) -------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductAttributeValueEditPopup_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.ProductAttributeValueEditPopup("pav1", "p1", "pam1");
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueEditPopup_Get_ScopeGrantsAccess_MappingMissing_RedirectsToList()
+ {
+ 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.ProductAttributeValueEditPopup("pav1", "p1", "missing-pam");
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueEditPopup_Get_ScopeGrantsAccess_ValueMissing_RedirectsToList()
+ {
+ 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 result = await _controller.ProductAttributeValueEditPopup("missing-pav", "p1", "pam1");
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueEditPopup_Get_ScopeGrantsAccess_PreparesModel()
+ {
+ var pav = new ProductAttributeValue { Id = "pav1" };
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ mapping.ProductAttributeValues.Add(pav);
+ 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.ProductAttributeValueModel();
+ _productViewModelServiceMock.Setup(s => s.PrepareProductAttributeValueModel(mapping, pav))
+ .ReturnsAsync(model);
+
+ var result = await _controller.ProductAttributeValueEditPopup("pav1", "p1", "pam1");
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(s => s.PrepareProductAttributeValueModel(mapping, pav), Times.Once);
+ _productViewModelServiceMock.Verify(s => s.PrepareProductAttributeValueModel(product, model), Times.Once);
+ }
+
+ // --- ProductAttributeValueEditPopup (POST) ------------------------------------------------------
+ // HasAccess added here: Vendor's original never checked ownership on this POST at all (only its GET
+ // sibling did); Admin's original had no check on either action.
+
+ [TestMethod]
+ public async Task ProductAttributeValueEditPopup_Post_MissingProduct_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+ var model = new ProductModel.ProductAttributeValueModel();
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ProductAttributeValueEditPopup("missing", model));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueEditPopup_Post_ScopeDeniesAccess_ReturnsPermissionsContent_DoesNotUpdate()
+ {
+ 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.ProductAttributeValueModel { Id = "pav1", ProductAttributeMappingId = "pam1" };
+
+ var result = await _controller.ProductAttributeValueEditPopup("p1", model);
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(
+ s => s.UpdateProductAttributeValueModel(It.IsAny<ProductAttributeValue>(),
+ It.IsAny<ProductModel.ProductAttributeValueModel>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueEditPopup_Post_ScopeGrantsAccess_ValueMissing_RedirectsToList()
+ {
+ 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.ProductAttributeValueModel { Id = "missing-pav", ProductAttributeMappingId = "pam1" };
+
+ var result = await _controller.ProductAttributeValueEditPopup("p1", model);
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueEditPopup_Post_ScopeGrantsAccess_ValidModel_Updates()
+ {
+ var pav = new ProductAttributeValue { Id = "pav1" };
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ mapping.ProductAttributeValues.Add(pav);
+ 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.ProductAttributeValueModel { Id = "pav1", ProductAttributeMappingId = "pam1" };
+
+ var result = await _controller.ProductAttributeValueEditPopup("p1", model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _productViewModelServiceMock.Verify(s => s.UpdateProductAttributeValueModel(pav, model), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueEditPopup_Post_ScopeGrantsAccess_InvalidModelState_ReturnsView()
+ {
+ var pav = new ProductAttributeValue { Id = "pav1" };
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ mapping.ProductAttributeValues.Add(pav);
+ 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.ProductAttributeValueModel { Id = "pav1", ProductAttributeMappingId = "pam1" };
+
+ var result = await _controller.ProductAttributeValueEditPopup("p1", model);
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(
+ s => s.UpdateProductAttributeValueModel(It.IsAny<ProductAttributeValue>(),
+ It.IsAny<ProductModel.ProductAttributeValueModel>()), Times.Never);
+ _productViewModelServiceMock.Verify(s => s.PrepareProductAttributeValueModel(product, model), Times.Once);
+ }
+
+ // --- ProductAttributeValueDelete -----------------------------------------------------------------
+ // HasAccess added here: this action takes only simple string parameters, so no model-level validator
+ // ever runs for it. Admin's original had no ownership check at all.
+
+ [TestMethod]
+ public async Task ProductAttributeValueDelete_MissingProduct_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+ var attrServiceMock = new Mock<IProductAttributeService>();
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ProductAttributeValueDelete("pav1", "pam1", "missing", attrServiceMock.Object));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueDelete_ScopeDeniesAccess_ReturnsErrorJson_DoesNotDelete()
+ {
+ var product = new Product { Id = "p1" };
+ _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.ProductAttributeValueDelete("pav1", "pam1", "p1", attrServiceMock.Object);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ attrServiceMock.Verify(
+ s => s.DeleteProductAttributeValue(It.IsAny<ProductAttributeValue>(), It.IsAny<string>(),
+ It.IsAny<string>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueDelete_ScopeGrantsAccess_ValueMissing_Throws()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var attrServiceMock = new Mock<IProductAttributeService>();
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ProductAttributeValueDelete("missing-pav", "pam1", "p1", attrServiceMock.Object));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueDelete_ScopeGrantsAccess_ValidModel_Deletes()
+ {
+ var pav = new ProductAttributeValue { Id = "pav1" };
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ mapping.ProductAttributeValues.Add(pav);
+ 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.ProductAttributeValueDelete("pav1", "pam1", "p1", attrServiceMock.Object);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ attrServiceMock.Verify(s => s.DeleteProductAttributeValue(pav, "p1", "pam1"), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeValueDelete_ScopeGrantsAccess_InvalidModelState_ReturnsErrorJson_DoesNotDelete()
+ {
+ var pav = new ProductAttributeValue { Id = "pav1" };
+ var mapping = new ProductAttributeMapping { Id = "pam1" };
+ mapping.ProductAttributeValues.Add(pav);
+ 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 attrServiceMock = new Mock<IProductAttributeService>();
+
+ var result = await _controller.ProductAttributeValueDelete("pav1", "pam1", "p1", attrServiceMock.Object);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ attrServiceMock.Verify(
+ s => s.DeleteProductAttributeValue(It.IsAny<ProductAttributeValue>(), It.IsAny<string>(),
+ It.IsAny<string>()), Times.Never);
+ }
+
+ // --- AssociateProductToAttributeValuePopup (GET) ------------------------------------------------
+
+ [TestMethod]
+ public async Task AssociateProductToAttributeValuePopup_Get_PassesScopeDefaultStoreId()
+ {
+ _scopeMock.Setup(s => s.DefaultStoreId).Returns("store1");
+ _productViewModelServiceMock.Setup(s => s.PrepareAssociateProductToAttributeValueModel("store1"))
+ .ReturnsAsync(new ProductModel.ProductAttributeValueModel.AssociateProductToAttributeValueModel());
+
+ var result = await _controller.AssociateProductToAttributeValuePopup();
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(s => s.PrepareAssociateProductToAttributeValueModel("store1"),
+ Times.Once);
+ }
+
+ [TestMethod]
+ public async Task AssociateProductToAttributeValuePopup_Get_NullDefaultStoreId_PassesEmptyString()
+ {
+ _productViewModelServiceMock.Setup(s => s.PrepareAssociateProductToAttributeValueModel(""))
+ .ReturnsAsync(new ProductModel.ProductAttributeValueModel.AssociateProductToAttributeValueModel());
+
+ var result = await _controller.AssociateProductToAttributeValuePopup();
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productViewModelServiceMock.Verify(s => s.PrepareAssociateProductToAttributeValueModel(""), Times.Once);
+ }
+
+ // --- AssociateProductToAttributeValuePopupList (POST) -------------------------------------------
+
+ [TestMethod]
+ public async Task AssociateProductToAttributeValuePopupList_DefaultStoreIdSet_AppliesSearchStoreId()
+ {
+ _scopeMock.Setup(s => s.DefaultStoreId).Returns("store1");
+ var model = new ProductModel.ProductAttributeValueModel.AssociateProductToAttributeValueModel();
+ _productViewModelServiceMock.Setup(s => s.PrepareProductModel(model, 1, 10))
+ .ReturnsAsync((new List<ProductModel>(), 0));
+
+ var result = await _controller.AssociateProductToAttributeValuePopupList(
+ new Grand.Web.Common.DataSource.DataSourceRequest { Page = 1, PageSize = 10 }, model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ Assert.AreEqual("store1", model.SearchStoreId);
+ }
+
+ [TestMethod]
+ public async Task AssociateProductToAttributeValuePopupList_DefaultStoreIdNull_LeavesSearchStoreIdUntouched()
+ {
+ var model = new ProductModel.ProductAttributeValueModel.AssociateProductToAttributeValueModel
+ { SearchStoreId = "preset" };
+ _productViewModelServiceMock.Setup(s => s.PrepareProductModel(model, 1, 10))
+ .ReturnsAsync((new List<ProductModel>(), 0));
+
+ var result = await _controller.AssociateProductToAttributeValuePopupList(
+ new Grand.Web.Common.DataSource.DataSourceRequest { Page = 1, PageSize = 10 }, model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ Assert.AreEqual("preset", model.SearchStoreId);
+ }
+
+ // --- AssociateProductToAttributeValuePopup (POST) -----------------------------------------------
+ // HasAccess added here: Admin's original had no ownership check on the associated product at all.
+
+ [TestMethod]
+ public async Task AssociateProductToAttributeValuePopup_Post_AssociatedProductMissing_ReturnsContent()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+ var model = new ProductModel.ProductAttributeValueModel.AssociateProductToAttributeValueModel
+ { AssociatedToProductId = "missing" };
+
+ var result = await _controller.AssociateProductToAttributeValuePopup(model);
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ Assert.AreEqual("Cannot load a product", content.Content);
+ _scopeMock.Verify(s => s.HasAccess(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task AssociateProductToAttributeValuePopup_Post_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 model = new ProductModel.ProductAttributeValueModel.AssociateProductToAttributeValueModel
+ { AssociatedToProductId = "p1" };
+
+ var result = await _controller.AssociateProductToAttributeValuePopup(model);
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task AssociateProductToAttributeValuePopup_Post_ScopeGrantsAccess_ReturnsEmptyContent()
+ {
+ 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.ProductAttributeValueModel.AssociateProductToAttributeValueModel
+ { AssociatedToProductId = "p1" };
+
+ var result = await _controller.AssociateProductToAttributeValuePopup(model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ var content = result as ContentResult;
+ Assert.AreEqual("", content.Content);
+ }
}
diff --git a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
index 3b3041c6b..571d78216 100644
--- a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
+++ b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
@@ -2537,4 +2537,274 @@ public abstract class BaseProductController(
}
#endregion
+
+ #region Product attribute values
+
+ //list
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ public async Task<IActionResult> EditAttributeValues(string productAttributeMappingId, string productId,
+ [FromServices] IProductAttributeService productAttributeService)
+ {
+ var product = await productService.GetProductById(productId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ // HasAccess applied uniformly across this region (Admin's Global scope is a no-op). Admin's
+ // original had no ownership check on this action at all.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var productAttributeMapping =
+ product.ProductAttributeMappings.FirstOrDefault(x => x.Id == productAttributeMappingId);
+ if (productAttributeMapping == null)
+ throw new ArgumentException("No product attribute mapping found with the specified id");
+
+ var productAttribute =
+ await productAttributeService.GetProductAttributeById(productAttributeMapping.ProductAttributeId);
+ var model = new ProductModel.ProductAttributeValueListModel {
+ ProductName = product.Name,
+ ProductId = product.Id,
+ ProductAttributeName = productAttribute.Name,
+ ProductAttributeMappingId = productAttributeMappingId
+ };
+
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductAttributeValueList(string productAttributeMappingId, string productId,
+ DataSourceRequest command)
+ {
+ var product = await productService.GetProductById(productId);
+
+ // See the EditAttributeValues comment above.
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(
+ translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var productAttributeMapping =
+ product.ProductAttributeMappings.FirstOrDefault(x => x.Id == productAttributeMappingId);
+ if (productAttributeMapping == null)
+ throw new ArgumentException("No product attribute mapping found with the specified id");
+
+ var values =
+ await productViewModelService.PrepareProductAttributeValueModels(product, productAttributeMapping);
+ var gridModel = new DataSourceResult {
+ Data = values,
+ Total = values.Count
+ };
+ return Json(gridModel);
+ }
+
+ //create
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ public async Task<IActionResult> ProductAttributeValueCreatePopup(string productAttributeMappingId,
+ string productId)
+ {
+ var product = await productService.GetProductById(productId);
+
+ // Content(...), not ErrorForKendoGridJson: 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 sibling GET popup actions
+ // in this region and elsewhere in this file.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var productAttributeMapping =
+ product.ProductAttributeMappings.FirstOrDefault(x => x.Id == productAttributeMappingId);
+ if (productAttributeMapping == null)
+ throw new ArgumentException("No product attribute mapping found with the specified id");
+
+ var model =
+ await productViewModelService.PrepareProductAttributeValueModel(product, productAttributeMapping);
+ //locales
+ await AddLocales(languageService, model.Locales);
+
+ return View(model);
+ }
+
+ [HttpPost]
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ public async Task<IActionResult> ProductAttributeValueCreatePopup(ProductModel.ProductAttributeValueModel model)
+ {
+ var product = await productService.GetProductById(model.ProductId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ // HasAccess added explicitly rather than relying on validation-layer side effects: Admin's and
+ // Store's shared ProductAttributeValueModelValidator (BaseStoreAccessValidator<...>) only enforces
+ // ownership when StaffStoreId is set - i.e. it's active for Store, a no-op for Admin. Vendor's
+ // model implements IProductValidVendor, so the global ValidationFilter resolves
+ // IValidator<IProductValidVendor> (ProductValidVendor) and adds a ModelState error when
+ // product.VendorId doesn't match the current vendor - a real check, not a no-op - but
+ // ValidationFilter never short-circuits a non-JSON POST (see ValidationFilter.OnActionExecutionAsync),
+ // so that protection only actually held because Vendor's original action gated the insert behind
+ // `if (ModelState.IsValid)`. Admin's original had neither an explicit check nor that validator
+ // wired up, so this was a real, unguarded IDOR: any caller reaching this shared action without the
+ // Vendor marker-interface model could insert an attribute value onto a product they don't own.
+ // scope.HasAccess makes the check explicit and uniform across all three hosts instead of leaning on
+ // ModelState side effects that only covered one of them.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var productAttributeMapping =
+ product.ProductAttributeMappings.FirstOrDefault(x => x.Id == model.ProductAttributeMappingId);
+ if (productAttributeMapping == null)
+ //No product attribute found with the specified id
+ return RedirectToAction("List", "Product");
+
+ if (ModelState.IsValid)
+ {
+ await productViewModelService.InsertProductAttributeValueModel(model);
+ return Content("");
+ }
+
+ //If we got this far, something failed, redisplay form
+ await productViewModelService.PrepareProductAttributeValueModel(product, model);
+ return View(model);
+ }
+
+ //edit
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ public async Task<IActionResult> ProductAttributeValueEditPopup(string id, string productId,
+ string productAttributeMappingId)
+ {
+ var product = await productService.GetProductById(productId);
+
+ // See the EditAttributeValues comment above.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var pa = product.ProductAttributeMappings.FirstOrDefault(x => x.Id == productAttributeMappingId);
+ if (pa == null)
+ return RedirectToAction("List", "Product");
+
+ var pav = pa.ProductAttributeValues.FirstOrDefault(x => x.Id == id);
+ if (pav == null)
+ //No attribute value found with the specified id
+ return RedirectToAction("List", "Product");
+
+ var model = await productViewModelService.PrepareProductAttributeValueModel(pa, pav);
+ //locales
+ await AddLocales(languageService, model.Locales, (locale, languageId) =>
+ {
+ locale.Name = pav.GetTranslation(x => x.Name, languageId, false);
+ });
+ //pictures
+ await productViewModelService.PrepareProductAttributeValueModel(product, model);
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductAttributeValueEditPopup(string productId,
+ ProductModel.ProductAttributeValueModel model)
+ {
+ var product = await productService.GetProductById(productId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ // See the ProductAttributeValueCreatePopup(POST) comment above re: the validator's coverage gap -
+ // the same applies here (this action shares the same model type). Vendor's original never checked
+ // ownership on this POST at all (only its GET sibling did, via CheckAccessToProduct/HasAccessToProduct);
+ // Admin's original had no check on either action.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var pav = product.ProductAttributeMappings.FirstOrDefault(x => x.Id == model.ProductAttributeMappingId)
+ ?.ProductAttributeValues.FirstOrDefault(x => x.Id == model.Id);
+ if (pav == null)
+ //No attribute value found with the specified id
+ return RedirectToAction("List", "Product");
+
+ if (ModelState.IsValid)
+ {
+ await productViewModelService.UpdateProductAttributeValueModel(pav, model);
+ return Content("");
+ }
+
+ //If we got this far, something failed, redisplay form
+ await productViewModelService.PrepareProductAttributeValueModel(product, model);
+ return View(model);
+ }
+
+ //delete
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductAttributeValueDelete(string id, string pam, string productId,
+ [FromServices] IProductAttributeService productAttributeService)
+ {
+ var product = await productService.GetProductById(productId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ // HasAccess added here: this action takes only simple string parameters (no complex-typed POST
+ // body), so none of the model-level validators discussed above ever run for it. Admin's original
+ // had no ownership check at all; Vendor's/Store's explicit inline checks are what scope.HasAccess
+ // now replaces uniformly.
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(
+ translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var pav = product.ProductAttributeMappings.FirstOrDefault(x => x.Id == pam)?.ProductAttributeValues
+ .FirstOrDefault(x => x.Id == id);
+ if (pav == null)
+ throw new ArgumentException("No product attribute value found with the specified id");
+
+ if (ModelState.IsValid)
+ {
+ await productAttributeService.DeleteProductAttributeValue(pav, productId, pam);
+ return new JsonResult("");
+ }
+
+ return ErrorForKendoGridJson(ModelState);
+ }
+
+ public async Task<IActionResult> AssociateProductToAttributeValuePopup()
+ {
+ // scope.DefaultStoreId ?? "": matches Store's original (passed StaffStoreId to scope the search to
+ // the staff member's store); null for Admin/Vendor (no store concept), matching their originals
+ // (no argument, defaulting to "").
+ var model =
+ await productViewModelService.PrepareAssociateProductToAttributeValueModel(scope.DefaultStoreId ?? "");
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> AssociateProductToAttributeValuePopupList(DataSourceRequest command,
+ ProductModel.ProductAttributeValueModel.AssociateProductToAttributeValueModel model)
+ {
+ if (scope.DefaultStoreId is not null) model.SearchStoreId = scope.DefaultStoreId;
+
+ var (products, totalCount) =
+ await productViewModelService.PrepareProductModel(model, command.Page, command.PageSize);
+ var gridModel = new DataSourceResult {
+ Data = products.ToList(),
+ Total = totalCount
+ };
+ return Json(gridModel);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> AssociateProductToAttributeValuePopup(
+ ProductModel.ProductAttributeValueModel.AssociateProductToAttributeValueModel model)
+ {
+ var associatedProduct = await productService.GetProductById(model.AssociatedToProductId);
+ if (associatedProduct == null)
+ return Content("Cannot load a product");
+
+ // HasAccess on the associated product: Admin's original had no check here. Vendor's/Store's
+ // originals checked ownership of the *associated* product (the one about to be referenced as an
+ // AssociatedToProductId value) - there is no separate "owning" product in scope for this action, so
+ // the associated product is the only entity available to check.
+ if (!await scope.HasAccess(associatedProduct))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ return Content("");
+ }
+
+ #endregion
}