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

KrzysztofPajak5b5d73bd758b
diff --git a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
index 84af9fced..ad82e2ce6 100644
--- a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
+++ b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
@@ -3155,4 +3155,158 @@ public class BaseProductControllerTests
_productViewModelServiceMock.Verify(
s => s.UpdateBulkEdit(It.IsAny<IEnumerable<BulkEditProductModel>>()), Times.Never);
}
+
+ // --- ProductPriceList -------------------------------------------------------------------------
+ // HasAccess (strict), not CanView: mirrors Store's CanAccessProduct check on this action. Applying it
+ // uniformly also closes real gaps on the mutate actions below: Store's original checked access only on
+ // List/Insert (Update/Delete had no check at all), and Vendor's original checked access only on List
+ // (Insert/Update/Delete had no check at all).
+
+ [TestMethod]
+ public async Task ProductPriceList_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.ProductPriceList(
+ 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 ProductPriceList_ScopeDeniesAccess_UsesScopeResourceKeyPrefix()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+ _scopeMock.Setup(s => s.ResourceKeyPrefix).Returns("Vendor");
+
+ var result = await _controller.ProductPriceList(
+ new Grand.Web.Common.DataSource.DataSourceRequest(), "p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Vendor.Catalog.Products.Permissions"), Times.Once);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductPriceList_ScopeGrantsAccess_ReturnsGrid()
+ {
+ var product = new Product { Id = "p1" };
+ product.ProductPrices.Add(new ProductPrice { Id = "pp1", CurrencyCode = "EUR", Price = 9.99 });
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+
+ var result = await _controller.ProductPriceList(
+ 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);
+ }
+
+ // --- ProductPriceInsert -----------------------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductPriceInsert_ScopeDeniesAccess_ReturnsErrorJson_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.ProductPriceModel { ProductId = "p1", CurrencyCode = "EUR", Price = 9.99 };
+
+ var result = await _controller.ProductPriceInsert(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productServiceMock.Verify(s => s.InsertProductPrice(It.IsAny<ProductPrice>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductPriceInsert_ScopeGrantsAccess_ValidModel_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.ProductPriceModel { ProductId = "p1", CurrencyCode = "EUR", Price = 9.99 };
+
+ var result = await _controller.ProductPriceInsert(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productServiceMock.Verify(s => s.InsertProductPrice(It.Is<ProductPrice>(
+ pp => pp.ProductId == "p1" && pp.CurrencyCode == "EUR" && pp.Price == 9.99)), Times.Once);
+ }
+
+ // --- ProductPriceUpdate -----------------------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductPriceUpdate_ScopeDeniesAccess_ReturnsErrorJson_DoesNotUpdate()
+ {
+ var product = new Product { Id = "p1" };
+ product.ProductPrices.Add(new ProductPrice { Id = "pp1", CurrencyCode = "EUR", Price = 9.99 });
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+ var model = new ProductModel.ProductPriceModel { Id = "pp1", ProductId = "p1", CurrencyCode = "USD", Price = 19.99 };
+
+ var result = await _controller.ProductPriceUpdate(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productServiceMock.Verify(s => s.UpdateProductPrice(It.IsAny<ProductPrice>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductPriceUpdate_ScopeGrantsAccess_ValidModel_Updates()
+ {
+ var product = new Product { Id = "p1" };
+ product.ProductPrices.Add(new ProductPrice { Id = "pp1", CurrencyCode = "EUR", Price = 9.99 });
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var model = new ProductModel.ProductPriceModel { Id = "pp1", ProductId = "p1", CurrencyCode = "USD", Price = 19.99 };
+
+ var result = await _controller.ProductPriceUpdate(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productServiceMock.Verify(s => s.UpdateProductPrice(It.Is<ProductPrice>(
+ pp => pp.Id == "pp1" && pp.CurrencyCode == "USD" && pp.Price == 19.99 && pp.ProductId == "p1")), Times.Once);
+ }
+
+ // --- ProductPriceDelete -----------------------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductPriceDelete_ScopeDeniesAccess_ReturnsErrorJson_DoesNotDelete()
+ {
+ var product = new Product { Id = "p1" };
+ product.ProductPrices.Add(new ProductPrice { Id = "pp1", CurrencyCode = "EUR", Price = 9.99 });
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(false);
+ var model = new ProductModel.ProductPriceModel { Id = "pp1", ProductId = "p1" };
+
+ var result = await _controller.ProductPriceDelete(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productServiceMock.Verify(s => s.DeleteProductPrice(It.IsAny<ProductPrice>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductPriceDelete_ScopeGrantsAccess_ValidModel_Deletes()
+ {
+ var product = new Product { Id = "p1" };
+ product.ProductPrices.Add(new ProductPrice { Id = "pp1", CurrencyCode = "EUR", Price = 9.99 });
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ var model = new ProductModel.ProductPriceModel { Id = "pp1", ProductId = "p1" };
+
+ var result = await _controller.ProductPriceDelete(model);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productServiceMock.Verify(s => s.DeleteProductPrice(It.Is<ProductPrice>(
+ pp => pp.Id == "pp1" && pp.ProductId == "p1")), Times.Once);
+ }
}
diff --git a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
index 5d8f43d2a..677a01770 100644
--- a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
+++ b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
@@ -2046,4 +2046,139 @@ public abstract class BaseProductController(
}
#endregion
+
+ #region Product currency price
+
+ [PermissionAuthorizeAction(PermissionActionName.Preview)]
+ [HttpPost]
+ public async Task<IActionResult> ProductPriceList(DataSourceRequest command, string productId)
+ {
+ var product = await productService.GetProductById(productId);
+
+ // HasAccess (strict), not CanView: mirrors Store's CanAccessProduct (AccessToEntityByStore) check
+ // on this action. Applying it uniformly also closes real gaps on the mutate actions below: Store's
+ // original checked access only on List/Insert (ProductPriceUpdate/ProductPriceDelete had no check
+ // at all), and Vendor's original checked access only on List (ProductPriceInsert/Update/Delete had
+ // no check at all) - both let another party's product prices be updated/deleted by id.
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var items = new List<ProductModel.ProductPriceModel>();
+ foreach (var item in product.ProductPrices)
+ items.Add(new ProductModel.ProductPriceModel {
+ Id = item.Id,
+ CurrencyCode = item.CurrencyCode,
+ Price = item.Price,
+ ProductId = product.Id
+ });
+
+ var gridModel = new DataSourceResult {
+ Data = items,
+ Total = items.Count
+ };
+
+ return Json(gridModel);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductPriceInsert(ProductModel.ProductPriceModel model)
+ {
+ var product = await productService.GetProductById(model.ProductId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ if (product.ProductPrices.Any(x => x.CurrencyCode == model.CurrencyCode))
+ throw new ArgumentException("Currency code exists");
+
+ if (ModelState.IsValid)
+ try
+ {
+ await productService.InsertProductPrice(new ProductPrice {
+ ProductId = product.Id,
+ CurrencyCode = model.CurrencyCode,
+ Price = model.Price
+ });
+ return new JsonResult("");
+ }
+ catch (Exception ex)
+ {
+ return ErrorForKendoGridJson(ex.Message);
+ }
+
+ return ErrorForKendoGridJson(ModelState);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductPriceUpdate(ProductModel.ProductPriceModel model)
+ {
+ var product = await productService.GetProductById(model.ProductId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var productPrice = product.ProductPrices.FirstOrDefault(x => x.Id == model.Id);
+ if (productPrice == null)
+ throw new ArgumentException("Product price model not exists");
+
+ if (product.ProductPrices.Any(x => x.Id != model.Id && x.CurrencyCode == model.CurrencyCode))
+ throw new ArgumentException("You can't use this currency code");
+
+ if (ModelState.IsValid)
+ try
+ {
+ productPrice!.CurrencyCode = model.CurrencyCode;
+ productPrice.Price = model.Price;
+ productPrice.ProductId = model.ProductId;
+
+ await productService.UpdateProductPrice(productPrice);
+
+ return new JsonResult("");
+ }
+ catch (Exception ex)
+ {
+ return ErrorForKendoGridJson(ex.Message);
+ }
+
+ return ErrorForKendoGridJson(ModelState);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductPriceDelete(ProductModel.ProductPriceModel model)
+ {
+ var product = await productService.GetProductById(model.ProductId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var productPrice = product.ProductPrices.FirstOrDefault(x => x.Id == model.Id);
+ if (productPrice == null)
+ throw new ArgumentException("Product price model not exists");
+
+ if (ModelState.IsValid)
+ {
+ productPrice!.ProductId = model.ProductId;
+ await productService.DeleteProductPrice(productPrice);
+
+ return new JsonResult("");
+ }
+
+ // ErrorForKendoGridJson(ModelState), not Content(ModelState.GetErrors()): matches Admin/Store.
+ // Vendor's original used the Vendor-only GetErrors() extension here (and inconsistently, since
+ // several of Vendor's *other* grid actions in this same file already use ErrorForKendoGridJson) -
+ // not a deliberate host-specific contract, just Vendor's own inconsistency. AdminShared cannot
+ // reference Grand.Web.Vendor.Extensions.ModelStateExtensions.GetErrors() from this project anyway.
+ return ErrorForKendoGridJson(ModelState);
+ }
+
+ #endregion
}