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

KrzysztofPajakecf4ca23427c
diff --git a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
index ac1ad9f62..2f35338e9 100644
--- a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
+++ b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
@@ -3,6 +3,7 @@ using Grand.Business.Core.Interfaces.Common.Directory;
using Grand.Business.Core.Interfaces.Common.Localization;
using Grand.Business.Core.Interfaces.Common.Security;
using Grand.Business.Core.Interfaces.Storage;
+using Grand.Domain;
using Grand.Domain.Catalog;
using Grand.Domain.Media;
using Grand.Infrastructure.Mapper;
@@ -55,7 +56,11 @@ public class BaseProductControllerTests
[TestInitialize]
public void Setup()
{
- var mapperConfig = new MapperConfiguration(cfg => { cfg.AddProfile<ProductProfile>(); });
+ var mapperConfig = new MapperConfiguration(cfg =>
+ {
+ cfg.AddProfile<ProductProfile>();
+ cfg.AddProfile<ProductSpecificationProfile>();
+ });
AutoMapperConfig.Init(mapperConfig);
_productServiceMock = new Mock<IProductService>();
@@ -2431,4 +2436,253 @@ public class BaseProductControllerTests
Assert.IsInstanceOfType<JsonResult>(result);
_productViewModelServiceMock.Verify(s => s.DeleteProductPicture(It.IsAny<ProductModel.ProductPictureModel>()), Times.Never);
}
+
+ // --- Product specification attributes -----------------------------------------------------------
+ // GetOptionsByAttributeId is deliberately not covered here (same rationale as Product pictures'
+ // ProductPictureAdd note): identical, unscoped across all three hosts, no access check involved.
+
+ // --- ProductSpecAttrList --------------------------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductSpecAttrList_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.ProductSpecAttrList(new Grand.Web.Common.DataSource.DataSourceRequest(), "p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productViewModelServiceMock.Verify(s => s.PrepareProductSpecificationAttributeModel(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductSpecAttrList_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);
+ _productViewModelServiceMock.Setup(s => s.PrepareProductSpecificationAttributeModel(product))
+ .ReturnsAsync(new List<ProductSpecificationAttributeModel> { new() { Id = "psa1" } });
+
+ var result = await _controller.ProductSpecAttrList(new Grand.Web.Common.DataSource.DataSourceRequest(), "p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ var json = (JsonResult)result;
+ var grid = (Grand.Web.Common.DataSource.DataSourceResult)json.Value;
+ Assert.AreEqual(1, grid.Total);
+ }
+
+ // --- ProductSpecAttrPopup (GET) -----------------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductSpecAttrPopupGet_ScopeDeniesAccess_ReturnsContent()
+ {
+ 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.ProductSpecAttrPopup(new Mock<ISpecificationAttributeService>().Object, "p1", "psa1");
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _productViewModelServiceMock.Verify(
+ s => s.PrepareProductSpecificationAttributeModel(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductSpecAttrPopupGet_ScopeGrantsAccess_NewAttribute_ReturnsView()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var specAttrServiceMock = new Mock<ISpecificationAttributeService>();
+ specAttrServiceMock.Setup(s => s.GetSpecificationAttributes(It.IsAny<string>(), 0, int.MaxValue))
+ .ReturnsAsync(new PagedList<SpecificationAttribute>(new List<SpecificationAttribute>(), 0, int.MaxValue));
+
+ var result = await _controller.ProductSpecAttrPopup(specAttrServiceMock.Object, "p1", "");
+
+ var view = result as ViewResult;
+ Assert.IsNotNull(view);
+ var model = view.Model as ProductModel.AddProductSpecificationAttributeModel;
+ Assert.IsNotNull(model);
+ Assert.IsTrue(model.ShowOnProductPage);
+ }
+
+ [TestMethod]
+ public async Task ProductSpecAttrPopupGet_ScopeGrantsAccess_ExistingAttribute_ReturnsPopulatedView()
+ {
+ var psa = new ProductSpecificationAttribute { Id = "psa1", SpecificationAttributeOptionId = "opt1" };
+ var product = new Product { Id = "p1" };
+ product.ProductSpecificationAttributes.Add(psa);
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var specAttrServiceMock = new Mock<ISpecificationAttributeService>();
+ specAttrServiceMock.Setup(s => s.GetSpecificationAttributes(It.IsAny<string>(), 0, int.MaxValue))
+ .ReturnsAsync(new PagedList<SpecificationAttribute>(new List<SpecificationAttribute>(), 0, int.MaxValue));
+
+ var result = await _controller.ProductSpecAttrPopup(specAttrServiceMock.Object, "p1", "psa1");
+
+ var view = result as ViewResult;
+ Assert.IsNotNull(view);
+ var model = view.Model as ProductModel.AddProductSpecificationAttributeModel;
+ Assert.IsNotNull(model);
+ Assert.AreEqual("psa1", model.Id);
+ }
+
+ // --- ProductSpecAttrPopup (POST) ----------------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductSpecAttrPopupPost_ProductNotFound_ReturnsContent()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync((Product)null);
+ var model = new ProductModel.AddProductSpecificationAttributeModel { ProductId = "p1", Id = "psa1" };
+
+ var result = await _controller.ProductSpecAttrPopup(new Mock<ISpecificationAttributeService>().Object, model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _productViewModelServiceMock.Verify(
+ s => s.UpdateProductSpecificationAttributeModel(It.IsAny<Product>(), It.IsAny<ProductSpecificationAttribute>(),
+ It.IsAny<ProductModel.AddProductSpecificationAttributeModel>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductSpecAttrPopupPost_ScopeDeniesAccess_ReturnsContent_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.AddProductSpecificationAttributeModel { ProductId = "p1", Id = "psa1" };
+
+ // Regression guard: Vendor's original ProductSpecAttrPopup(POST) had no access check at all,
+ // letting any vendor add/edit specification attributes on another vendor's product by posting
+ // its id.
+ var result = await _controller.ProductSpecAttrPopup(new Mock<ISpecificationAttributeService>().Object, model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _productViewModelServiceMock.Verify(
+ s => s.InsertProductSpecificationAttributeModel(It.IsAny<ProductModel.AddProductSpecificationAttributeModel>(),
+ It.IsAny<Product>()), Times.Never);
+ _productViewModelServiceMock.Verify(
+ s => s.UpdateProductSpecificationAttributeModel(It.IsAny<Product>(), It.IsAny<ProductSpecificationAttribute>(),
+ It.IsAny<ProductModel.AddProductSpecificationAttributeModel>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductSpecAttrPopupPost_ScopeGrantsAccess_NewAttribute_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.AddProductSpecificationAttributeModel { ProductId = "p1", Id = "psa-new" };
+
+ var result = await _controller.ProductSpecAttrPopup(new Mock<ISpecificationAttributeService>().Object, model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productViewModelServiceMock.Verify(s => s.InsertProductSpecificationAttributeModel(model, product), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ProductSpecAttrPopupPost_ScopeGrantsAccess_ExistingAttribute_Updates()
+ {
+ var psa = new ProductSpecificationAttribute { Id = "psa1" };
+ var product = new Product { Id = "p1" };
+ product.ProductSpecificationAttributes.Add(psa);
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var model = new ProductModel.AddProductSpecificationAttributeModel { ProductId = "p1", Id = "psa1" };
+
+ var result = await _controller.ProductSpecAttrPopup(new Mock<ISpecificationAttributeService>().Object, model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productViewModelServiceMock.Verify(s => s.UpdateProductSpecificationAttributeModel(product, psa, model), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ProductSpecAttrPopupPost_InvalidModelState_ReturnsView_DoesNotAccessProduct()
+ {
+ var model = new ProductModel.AddProductSpecificationAttributeModel { ProductId = "p1", Id = "psa1" };
+ _controller.ModelState.AddModelError("x", "error");
+ var specAttrServiceMock = new Mock<ISpecificationAttributeService>();
+ specAttrServiceMock.Setup(s => s.GetSpecificationAttributes(It.IsAny<string>(), 0, int.MaxValue))
+ .ReturnsAsync(new PagedList<SpecificationAttribute>(new List<SpecificationAttribute>(), 0, int.MaxValue));
+
+ var result = await _controller.ProductSpecAttrPopup(specAttrServiceMock.Object, model);
+
+ Assert.IsInstanceOfType<ViewResult>(result);
+ _productServiceMock.Verify(p => p.GetProductById(It.IsAny<string>(), It.IsAny<bool>()), Times.Never);
+ }
+
+ // --- ProductSpecAttrDelete ------------------------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductSpecAttrDelete_ProductNotFound_ReturnsContent()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync((Product)null);
+ var model = new ProductSpecificationAttributeModel { ProductId = "p1", Id = "psa1" };
+
+ var result = await _controller.ProductSpecAttrDelete(model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _productViewModelServiceMock.Verify(
+ s => s.DeleteProductSpecificationAttribute(It.IsAny<Product>(), It.IsAny<ProductSpecificationAttribute>()),
+ Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductSpecAttrDelete_ScopeDeniesAccess_ReturnsContent_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 model = new ProductSpecificationAttributeModel { ProductId = "p1", Id = "psa1" };
+
+ // Regression guard: Vendor's original ProductSpecAttrDelete had no access check at all, letting
+ // any vendor delete another vendor's specification attribute mapping by posting its
+ // productId/model.Id.
+ var result = await _controller.ProductSpecAttrDelete(model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _productViewModelServiceMock.Verify(
+ s => s.DeleteProductSpecificationAttribute(It.IsAny<Product>(), It.IsAny<ProductSpecificationAttribute>()),
+ Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductSpecAttrDelete_ScopeGrantsAccess_ValidModel_Deletes()
+ {
+ var psa = new ProductSpecificationAttribute { Id = "psa1" };
+ var product = new Product { Id = "p1" };
+ product.ProductSpecificationAttributes.Add(psa);
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var model = new ProductSpecificationAttributeModel { ProductId = "p1", Id = "psa1" };
+
+ var result = await _controller.ProductSpecAttrDelete(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productViewModelServiceMock.Verify(s => s.DeleteProductSpecificationAttribute(product, psa), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ProductSpecAttrDelete_ScopeGrantsAccess_AttributeNotFound_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 model = new ProductSpecificationAttributeModel { ProductId = "p1", Id = "missing" };
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(() => _controller.ProductSpecAttrDelete(model));
+ }
+
+ [TestMethod]
+ public async Task ProductSpecAttrDelete_InvalidModelState_ReturnsKendoGridError_DoesNotAccessProduct()
+ {
+ var model = new ProductSpecificationAttributeModel { ProductId = "p1", Id = "psa1" };
+ _controller.ModelState.AddModelError("x", "error");
+
+ var result = await _controller.ProductSpecAttrDelete(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productServiceMock.Verify(p => p.GetProductById(It.IsAny<string>(), It.IsAny<bool>()), Times.Never);
+ }
}
diff --git a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
index cdabe1ed8..aaee900df 100644
--- a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
+++ b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
@@ -1587,4 +1587,156 @@ public abstract class BaseProductController(
}
#endregion
+
+ #region Product specification attributes
+
+ //ajax
+ [AcceptVerbs("GET")]
+ public async Task<IActionResult> GetOptionsByAttributeId(string attributeId,
+ [FromServices] ISpecificationAttributeService specificationAttributeService)
+ {
+ if (string.IsNullOrEmpty(attributeId))
+ return Json("");
+
+ var options =
+ (await specificationAttributeService.GetSpecificationAttributeById(attributeId))
+ .SpecificationAttributeOptions.OrderBy(x => x.DisplayOrder);
+ var result = (from o in options
+ select new { id = o.Id, name = o.Name }).ToList();
+ return Json(result);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Preview)]
+ [HttpPost]
+ public async Task<IActionResult> ProductSpecAttrList(DataSourceRequest command, string productId)
+ {
+ var product = await productService.GetProductById(productId);
+
+ // HasAccess (strict): mirrors Store's CanAccessProduct and Vendor's CheckAccessToProduct gating
+ // this action on both hosts. Admin's original ProductSpecAttrList had no check at all - applying
+ // HasAccess uniformly also closes that gap without changing Admin's superuser behaviour (HasAccess
+ // is a no-op for Admin's scope). Vendor's original signature also dropped the DataSourceRequest
+ // command parameter entirely (unused by the body on any host either way) - kept here for parity
+ // with Admin/Store.
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var productrSpecsModel = await productViewModelService.PrepareProductSpecificationAttributeModel(product);
+ var gridModel = new DataSourceResult {
+ Data = productrSpecsModel,
+ Total = productrSpecsModel.Count
+ };
+ return Json(gridModel);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ public async Task<IActionResult> ProductSpecAttrPopup(
+ [FromServices] ISpecificationAttributeService specificationAttributeService,
+ string productId, string id)
+ {
+ var product = await productService.GetProductById(productId);
+
+ // HasAccess (strict): mirrors Store's CanAccessProduct and Vendor's CheckAccessToProduct check on
+ // this action. Admin's original ProductSpecAttrPopup(GET) had no check at all - closed the same
+ // way as ProductSpecAttrList above.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var model = new ProductModel.AddProductSpecificationAttributeModel {
+ //default specs values
+ ShowOnProductPage = true
+ };
+
+ if (!string.IsNullOrEmpty(id))
+ {
+ var specification = product.ProductSpecificationAttributes.FirstOrDefault(x => x.Id == id);
+ if (specification != null) model = specification.ToModel();
+ }
+
+ model.AvailableAttributes = await PrepareAvailableAttributes(specificationAttributeService);
+
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductSpecAttrPopup(
+ [FromServices] ISpecificationAttributeService specificationAttributeService,
+ ProductModel.AddProductSpecificationAttributeModel model)
+ {
+ if (ModelState.IsValid)
+ {
+ var product = await productService.GetProductById(model.ProductId);
+ if (product == null)
+ return Content("Product not exists");
+
+ // HasAccess (strict): mirrors Store's CanAccessProduct check on this action. Vendor's original
+ // ProductSpecAttrPopup(POST) had no check at all, letting any vendor add/edit specification
+ // attributes on another vendor's product by posting its id - closed here the same way as the
+ // GET popup above. Vendor's original call also used a two-arg
+ // UpdateProductSpecificationAttributeModel(psa, model) overload that does not exist on the
+ // shared IProductViewModelService; the shared three-arg (product, psa, model) overload -
+ // already used by Admin/Store - is used here instead.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var psa = product.ProductSpecificationAttributes.FirstOrDefault(x => x.Id == model.Id);
+ if (psa == null)
+ await productViewModelService.InsertProductSpecificationAttributeModel(model, product);
+ else
+ await productViewModelService.UpdateProductSpecificationAttributeModel(product, psa, model);
+
+ return new JsonResult("");
+ }
+
+ Error(ModelState);
+ model.AvailableAttributes = await PrepareAvailableAttributes(specificationAttributeService);
+
+ return View(model);
+ }
+
+ /// <summary>scope.DefaultStoreId ?? "" matches Store's PrepareAvailableAttributes(StaffStoreId) call
+ /// and Admin/Vendor's parameterless call (both pass an empty storeId, seeing every specification
+ /// attribute regardless of store).</summary>
+ private async Task<List<SelectListItem>> PrepareAvailableAttributes(
+ ISpecificationAttributeService specificationAttributeService)
+ {
+ var availableSpecificationAttributes = new List<SelectListItem>();
+ foreach (var sa in await specificationAttributeService.GetSpecificationAttributes(scope.DefaultStoreId ?? ""))
+ availableSpecificationAttributes.Add(new SelectListItem {
+ Text = sa.Name,
+ Value = sa.Id
+ });
+ return availableSpecificationAttributes;
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductSpecAttrDelete(ProductSpecificationAttributeModel model)
+ {
+ if (ModelState.IsValid)
+ {
+ var product = await productService.GetProductById(model.ProductId);
+ if (product == null)
+ return Content("Product not exists");
+
+ // HasAccess (strict): mirrors Store's CanAccessProduct check on this action. Vendor's original
+ // ProductSpecAttrDelete had no check at all, letting any vendor delete another vendor's
+ // specification attribute mapping by posting its productId/model.Id - closed here the same
+ // way as ProductSpecAttrPopup(POST) above.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var psa = product.ProductSpecificationAttributes.FirstOrDefault(x => x.Id == model.Id);
+ if (psa == null)
+ throw new ArgumentException("No specification attribute found with the specified id");
+
+ await productViewModelService.DeleteProductSpecificationAttribute(product, psa);
+ return new JsonResult("");
+ }
+
+ return ErrorForKendoGridJson(ModelState);
+ }
+
+ #endregion
}