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
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.csindex 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.csindex 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}