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

KrzysztofPajake8d2bc760fb8
diff --git a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
index 3f51ccb35..a806d7e3b 100644
--- a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
+++ b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
@@ -1926,4 +1926,290 @@ public class BaseProductControllerTests
Assert.AreSame(reprepared, view.Model);
_productViewModelServiceMock.Verify(s => s.InsertRecommendedProductModel(It.IsAny<ProductModel.AddRecommendedProductModel>()), Times.Never);
}
+
+ // --- AssociatedProductList -----------------------------------------------------------------------
+ // HasAccess (strict), not CanView: same shape as RelatedProductList above. Admin's original had no
+ // check at all.
+
+ [TestMethod]
+ public async Task AssociatedProductList_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.AssociatedProductList(new Grand.Web.Common.DataSource.DataSourceRequest(), "p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task AssociatedProductList_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);
+ _productServiceMock.Setup(p => p.GetAssociatedProducts("p1", "", "", true))
+ .ReturnsAsync(new List<Product> { new() { Id = "a1", Name = "Assoc", DisplayOrder = 1 } });
+
+ var result = await _controller.AssociatedProductList(new Grand.Web.Common.DataSource.DataSourceRequest(), "p1");
+
+ var json = result as JsonResult;
+ Assert.IsNotNull(json);
+ var gridModel = json.Value as Grand.Web.Common.DataSource.DataSourceResult;
+ Assert.IsNotNull(gridModel);
+ Assert.AreEqual(1, gridModel.Total);
+ }
+
+ // --- AssociatedProductUpdate ---------------------------------------------------------------------
+
+ [TestMethod]
+ public async Task AssociatedProductUpdate_NotFound_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("a1", false)).ReturnsAsync((Product)null);
+ var model = new ProductModel.AssociatedProductModel { Id = "a1" };
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(() => _controller.AssociatedProductUpdate(model));
+ }
+
+ [TestMethod]
+ public async Task AssociatedProductUpdate_ScopeDeniesAccess_ReturnsErrorJson_DoesNotUpdate()
+ {
+ var associatedProduct = new Product { Id = "a1" };
+ _productServiceMock.Setup(p => p.GetProductById("a1", false)).ReturnsAsync(associatedProduct);
+ _scopeMock.Setup(s => s.HasAccess(associatedProduct)).ReturnsAsync(false);
+ var model = new ProductModel.AssociatedProductModel { Id = "a1" };
+
+ var result = await _controller.AssociatedProductUpdate(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productServiceMock.Verify(p => p.UpdateAssociatedProduct(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task AssociatedProductUpdate_ScopeGrantsAccess_ValidModel_Updates()
+ {
+ var associatedProduct = new Product { Id = "a1" };
+ _productServiceMock.Setup(p => p.GetProductById("a1", false)).ReturnsAsync(associatedProduct);
+ _scopeMock.Setup(s => s.HasAccess(associatedProduct)).ReturnsAsync(true);
+ var model = new ProductModel.AssociatedProductModel { Id = "a1", DisplayOrder = 5 };
+
+ var result = await _controller.AssociatedProductUpdate(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ Assert.AreEqual(5, associatedProduct.DisplayOrder);
+ _productServiceMock.Verify(p => p.UpdateAssociatedProduct(associatedProduct), Times.Once);
+ }
+
+ // --- AssociatedProductDelete ---------------------------------------------------------------------
+
+ [TestMethod]
+ public async Task AssociatedProductDelete_NotFound_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("a1", false)).ReturnsAsync((Product)null);
+ var model = new ProductModel.AssociatedProductModel { Id = "a1" };
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(() => _controller.AssociatedProductDelete(model));
+ }
+
+ [TestMethod]
+ public async Task AssociatedProductDelete_ScopeDeniesAccess_ReturnsErrorJson_DoesNotDelete()
+ {
+ var product = new Product { Id = "a1" };
+ _productServiceMock.Setup(p => p.GetProductById("a1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+ var model = new ProductModel.AssociatedProductModel { Id = "a1" };
+
+ var result = await _controller.AssociatedProductDelete(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(s => s.DeleteAssociatedProduct(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task AssociatedProductDelete_ScopeGrantsAccess_ValidModel_Deletes()
+ {
+ var product = new Product { Id = "a1" };
+ _productServiceMock.Setup(p => p.GetProductById("a1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var model = new ProductModel.AssociatedProductModel { Id = "a1" };
+
+ var result = await _controller.AssociatedProductDelete(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productViewModelServiceMock.Verify(s => s.DeleteAssociatedProduct(product), Times.Once);
+ }
+
+ // --- AssociatedProductAddPopup (GET) -------------------------------------------------------------
+
+ [TestMethod]
+ public async Task AssociatedProductAddPopupGet_UsesScopeDefaultStoreId()
+ {
+ _scopeMock.Setup(s => s.DefaultStoreId).Returns("store-1");
+ _productViewModelServiceMock.Setup(s => s.PrepareAssociatedProductModel("store-1"))
+ .ReturnsAsync(new ProductModel.AddAssociatedProductModel());
+
+ var result = await _controller.AssociatedProductAddPopup("p1") as ViewResult;
+
+ Assert.IsNotNull(result);
+ var model = result.Model as ProductModel.AddAssociatedProductModel;
+ Assert.IsNotNull(model);
+ Assert.AreEqual("p1", model.ProductId);
+ _productViewModelServiceMock.Verify(s => s.PrepareAssociatedProductModel("store-1"), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task AssociatedProductAddPopupGet_NoDefaultStoreId_PassesEmptyString()
+ {
+ _scopeMock.Setup(s => s.DefaultStoreId).Returns((string)null);
+ _productViewModelServiceMock.Setup(s => s.PrepareAssociatedProductModel(""))
+ .ReturnsAsync(new ProductModel.AddAssociatedProductModel());
+
+ var result = await _controller.AssociatedProductAddPopup("p1") as ViewResult;
+
+ Assert.IsNotNull(result);
+ _productViewModelServiceMock.Verify(s => s.PrepareAssociatedProductModel(""), Times.Once);
+ }
+
+ // --- AssociatedProductAddPopupList ---------------------------------------------------------------
+
+ [TestMethod]
+ public async Task AssociatedProductAddPopupList_UsesScopeDefaultStoreId()
+ {
+ _scopeMock.Setup(s => s.DefaultStoreId).Returns("store-1");
+ _productViewModelServiceMock
+ .Setup(s => s.PrepareProductModel(It.IsAny<ProductModel.AddAssociatedProductModel>(), 0, 10))
+ .ReturnsAsync((new List<ProductModel>(), 0));
+
+ var model = new ProductModel.AddAssociatedProductModel();
+ var result = await _controller.AssociatedProductAddPopupList(
+ new Grand.Web.Common.DataSource.DataSourceRequest { Page = 0, PageSize = 10 }, model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ Assert.AreEqual("store-1", model.SearchStoreId);
+ }
+
+ [TestMethod]
+ public async Task AssociatedProductAddPopupList_NoDefaultStoreId_DoesNotOverrideModelSearchStoreId()
+ {
+ _scopeMock.Setup(s => s.DefaultStoreId).Returns((string)null);
+ _productViewModelServiceMock
+ .Setup(s => s.PrepareProductModel(It.IsAny<ProductModel.AddAssociatedProductModel>(), 0, 10))
+ .ReturnsAsync((new List<ProductModel>(), 0));
+
+ var model = new ProductModel.AddAssociatedProductModel { SearchStoreId = "explicit" };
+ var result = await _controller.AssociatedProductAddPopupList(
+ new Grand.Web.Common.DataSource.DataSourceRequest { Page = 0, PageSize = 10 }, model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ Assert.AreEqual("explicit", model.SearchStoreId);
+ }
+
+ // --- AssociatedProductAddPopup (POST) ------------------------------------------------------------
+ // HasAccess (strict) on the parent product: closes a real gap - Vendor's controller had no ownership
+ // check on the parent product (model.ProductId) at all, in either layer. Vendor's own (host-specific)
+ // service already filtered each selected product via HasAccessToProduct before reparenting it
+ // (Grand.Web.Vendor/Services/ProductViewModelService.cs InsertAssociatedProductModel), but the parent
+ // was never checked anywhere, letting a vendor attach their own products under another vendor's
+ // grouped product. This controller-level fix (parent HasAccess + per-selected-id HasAccess, matching
+ // Store's original controller-level filtering) is necessary regardless of that pre-existing severity,
+ // since BaseProductController uses AdminShared's unfiltered IProductViewModelService - once Vendor is
+ // subclassed onto this base (Task 11), it loses its own service's per-id filter entirely, so the
+ // controller must enforce both checks itself.
+
+ [TestMethod]
+ public async Task AssociatedProductAddPopupPost_ScopeDeniesAccessToParent_ReturnsContentMessage_DoesNotInsert()
+ {
+ var parent = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(parent);
+ _scopeMock.Setup(s => s.HasAccess(parent)).ReturnsAsync(false);
+ var model = new ProductModel.AddAssociatedProductModel { ProductId = "p1", SelectedProductIds = ["a1"] };
+
+ var result = await _controller.AssociatedProductAddPopup(model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(s => s.InsertAssociatedProductModel(It.IsAny<ProductModel.AddAssociatedProductModel>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task AssociatedProductAddPopupPost_ScopeGrantsAccess_AllSelectedIdsAllowed_InsertsAll()
+ {
+ var parent = new Product { Id = "p1" };
+ var selected = new Product { Id = "a1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(parent);
+ _productServiceMock.Setup(p => p.GetProductById("a1", false)).ReturnsAsync(selected);
+ _scopeMock.Setup(s => s.HasAccess(parent)).ReturnsAsync(true);
+ _scopeMock.Setup(s => s.HasAccess(selected)).ReturnsAsync(true);
+ var model = new ProductModel.AddAssociatedProductModel { ProductId = "p1", SelectedProductIds = ["a1"] };
+
+ var result = await _controller.AssociatedProductAddPopup(model);
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ Assert.AreEqual("", content.Content);
+ CollectionAssert.AreEqual(new[] { "a1" }, model.SelectedProductIds);
+ _productViewModelServiceMock.Verify(s => s.InsertAssociatedProductModel(model), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task AssociatedProductAddPopupPost_ScopeGrantsAccessToParent_FiltersOutDeniedSelectedIds()
+ {
+ var parent = new Product { Id = "p1" };
+ var allowed = new Product { Id = "a1" };
+ var denied = new Product { Id = "a2" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(parent);
+ _productServiceMock.Setup(p => p.GetProductById("a1", false)).ReturnsAsync(allowed);
+ _productServiceMock.Setup(p => p.GetProductById("a2", false)).ReturnsAsync(denied);
+ _scopeMock.Setup(s => s.HasAccess(parent)).ReturnsAsync(true);
+ _scopeMock.Setup(s => s.HasAccess(allowed)).ReturnsAsync(true);
+ _scopeMock.Setup(s => s.HasAccess(denied)).ReturnsAsync(false);
+ var model = new ProductModel.AddAssociatedProductModel { ProductId = "p1", SelectedProductIds = ["a1", "a2"] };
+
+ var result = await _controller.AssociatedProductAddPopup(model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ CollectionAssert.AreEqual(new[] { "a1" }, model.SelectedProductIds);
+ _productViewModelServiceMock.Verify(s => s.InsertAssociatedProductModel(model), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task AssociatedProductAddPopupPost_AllSelectedIdsDenied_DoesNotInsert()
+ {
+ var parent = new Product { Id = "p1" };
+ var denied = new Product { Id = "a1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(parent);
+ _productServiceMock.Setup(p => p.GetProductById("a1", false)).ReturnsAsync(denied);
+ _scopeMock.Setup(s => s.HasAccess(parent)).ReturnsAsync(true);
+ _scopeMock.Setup(s => s.HasAccess(denied)).ReturnsAsync(false);
+ var model = new ProductModel.AddAssociatedProductModel { ProductId = "p1", SelectedProductIds = ["a1"] };
+
+ var result = await _controller.AssociatedProductAddPopup(model);
+
+ Assert.IsInstanceOfType<ContentResult>(result);
+ _productViewModelServiceMock.Verify(s => s.InsertAssociatedProductModel(It.IsAny<ProductModel.AddAssociatedProductModel>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task AssociatedProductAddPopupPost_ScopeGrantsAccess_InvalidModel_ReturnsViewWithRepreparedModel()
+ {
+ var parent = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(parent);
+ _scopeMock.Setup(s => s.HasAccess(parent)).ReturnsAsync(true);
+ _scopeMock.Setup(s => s.DefaultStoreId).Returns("store-1");
+ var reprepared = new ProductModel.AddAssociatedProductModel();
+ _productViewModelServiceMock.Setup(s => s.PrepareAssociatedProductModel("store-1")).ReturnsAsync(reprepared);
+ var model = new ProductModel.AddAssociatedProductModel { ProductId = "p1" };
+ _controller.ModelState.AddModelError("x", "error");
+
+ var result = await _controller.AssociatedProductAddPopup(model);
+
+ var view = result as ViewResult;
+ Assert.IsNotNull(view);
+ Assert.AreSame(reprepared, view.Model);
+ _productViewModelServiceMock.Verify(s => s.InsertAssociatedProductModel(It.IsAny<ProductModel.AddAssociatedProductModel>()), Times.Never);
+ }
}
diff --git a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
index 28ce74b39..3442e4c44 100644
--- a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
+++ b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
@@ -1224,4 +1224,181 @@ public abstract class BaseProductController(
}
#endregion
+
+ #region Associated products
+
+ [PermissionAuthorizeAction(PermissionActionName.Preview)]
+ [HttpPost]
+ public async Task<IActionResult> AssociatedProductList(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 had no check at all - GlobalAdminDataScope.HasAccess
+ // is a no-op there, so this closes that gap the same way as every other row in this task.
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ // AssociatedProductVendorId (hook below): Vendor's original also passed CurrentVendor.Id into
+ // GetAssociatedProducts(vendorId:) so a vendor only sees, among a grouped product's full
+ // associated-product set, the ones they themselves own. That vendor filter is unconditional in
+ // GetAssociatedProducts regardless of showHidden, unlike its storeId parameter (which only applies
+ // when showHidden is false - moot here since all three hosts pass showHidden: true).
+ var associatedProducts = await productService.GetAssociatedProducts(productId,
+ vendorId: AssociatedProductVendorId, showHidden: true);
+ var associatedProductsModel = associatedProducts
+ .Select(x => new ProductModel.AssociatedProductModel {
+ Id = x.Id,
+ ProductId = productId,
+ ProductName = x.Name,
+ DisplayOrder = x.DisplayOrder
+ })
+ .ToList();
+
+ var gridModel = new DataSourceResult {
+ Data = associatedProductsModel,
+ Total = associatedProductsModel.Count
+ };
+
+ return Json(gridModel);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> AssociatedProductUpdate(ProductModel.AssociatedProductModel model)
+ {
+ var associatedProduct = await productService.GetProductById(model.Id);
+ if (associatedProduct == null)
+ throw new ArgumentException("No associated product found with the specified id");
+
+ // HasAccess (strict): mirrors Vendor's inline HasAccessToProduct(associatedProduct) check and
+ // Store's CanAccessProduct. Admin's original had no check at all.
+ if (!await scope.HasAccess(associatedProduct))
+ return ErrorForKendoGridJson(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ if (ModelState.IsValid)
+ {
+ associatedProduct.DisplayOrder = model.DisplayOrder;
+ await productService.UpdateAssociatedProduct(associatedProduct);
+
+ return new JsonResult("");
+ }
+
+ return ErrorForKendoGridJson(ModelState);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> AssociatedProductDelete(ProductModel.AssociatedProductModel model)
+ {
+ var product = await productService.GetProductById(model.Id);
+ if (product == null)
+ throw new ArgumentException("No associated product found with the specified id");
+
+ // HasAccess (strict): mirrors Vendor's inline HasAccessToProduct(product) check and Store's
+ // CanAccessProduct. Admin's original had no check at all.
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ if (ModelState.IsValid)
+ {
+ await productViewModelService.DeleteAssociatedProduct(product);
+ return new JsonResult("");
+ }
+
+ return ErrorForKendoGridJson(ModelState);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ public async Task<IActionResult> AssociatedProductAddPopup(string productId)
+ {
+ // No access check here in any of the three original hosts (all open this popup unconditionally
+ // once the Edit permission is satisfied) - only the mutating actions below tie access to a
+ // specific product. scope.DefaultStoreId ?? "" matches Store's
+ // PrepareAssociatedProductModel(StaffStoreId) call and Admin/Vendor's parameterless call.
+ var model = await productViewModelService.PrepareAssociatedProductModel(scope.DefaultStoreId ?? "");
+ model.ProductId = productId;
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> AssociatedProductAddPopupList(DataSourceRequest command,
+ ProductModel.AddAssociatedProductModel 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> AssociatedProductAddPopup(ProductModel.AddAssociatedProductModel model)
+ {
+ var parentProduct = await productService.GetProductById(model.ProductId);
+ // HasAccess (strict): mirrors Store's CanAccessProduct(parentProduct) check on this action.
+ // Vendor's controller had NO check on the parent product at all (see below for the selected-ids
+ // side). Vendor's own service-layer InsertAssociatedProductModel already filtered each selected
+ // product via HasAccessToProduct before reparenting it, but never checked the parent - so a vendor
+ // could attach their own products under another vendor's grouped product (cross-vendor storefront
+ // pollution / data-integrity issue, not a write to someone else's product record). Closed here the
+ // same way as every other AddPopup(POST) in this task.
+ if (!await scope.HasAccess(parentProduct))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ if (ModelState.IsValid)
+ {
+ // InsertAssociatedProductModel reparents each selected product - it writes
+ // ParentGroupedProductId directly onto that product's own record - unlike
+ // Related/Similar/Bundle/Cross-sell/Recommended, whose Insert*ProductModel only adds a mapping
+ // entry that references the selected product's id from the parent's own list; the selected
+ // product's record is never itself modified there. So here, unlike those simpler regions,
+ // every selected id must independently pass HasAccess too - the same per-id filtering Store's
+ // controller-level original already did, and which Vendor's original also had, but only at the
+ // service layer (Grand.Web.Vendor/Services/ProductViewModelService.cs InsertAssociatedProductModel:
+ // `if (product == null || !HasAccessToProduct(product)) continue;`). BaseProductController
+ // injects AdminShared's IProductViewModelService - the unfiltered variant - not Vendor's own, so
+ // once Vendor is subclassed onto this base (Task 11) it loses that service-layer filter
+ // entirely. Enforcing the per-id check here at the controller level is what preserves the
+ // invariant going forward.
+ if (model.SelectedProductIds != null)
+ {
+ var validIds = new List<string>();
+ foreach (var id in model.SelectedProductIds)
+ {
+ var selected = await productService.GetProductById(id);
+ if (await scope.HasAccess(selected)) validIds.Add(id);
+ }
+
+ model.SelectedProductIds = validIds.ToArray();
+ if (validIds.Count > 0) await productViewModelService.InsertAssociatedProductModel(model);
+ }
+
+ return Content("");
+ }
+
+ // Unlike Related/Similar/Bundle/Cross-sell/Recommended, all three original hosts share the exact
+ // same invalid-model-state handling here (Error(ModelState) + re-prepare + View) - Vendor's
+ // AssociatedProductAddPopup(POST) does not use the Content(ModelState.GetErrors()) shortcut it
+ // uses in those other regions, so no host-specific hook is needed for this action.
+ Error(ModelState);
+ model = await productViewModelService.PrepareAssociatedProductModel(scope.DefaultStoreId ?? "");
+ return View(model);
+ }
+
+ /// <summary>Vendor id to filter the associated-products grid by, in addition to the HasAccess gate in
+ /// AssociatedProductList above. Vendor's original passed CurrentVendor.Id into
+ /// GetAssociatedProducts(vendorId:) so a vendor only sees the subset of a grouped product's associated
+ /// products that they themselves own. Admin/Store passed no vendorId (both show every associated
+ /// product on the parent). Empty here, matching Admin/Store; a future Vendor subclass overrides it
+ /// once hosts are subclassed onto BaseProductController (Task 11).</summary>
+ protected virtual string AssociatedProductVendorId => "";
+
+ #endregion
}