Skip to content

Open-source eCommerce platform for C# and ASP.NET Core 10 with MongoDB. Build multi-store shops and multi-vendor marketplaces with B2B/B2C, REST API, plugins, Vue 3 and Docker.

Migrate 'Product attribute combinations' region into BaseProductController (ARCH-001 Phase 1)

KrzysztofPajakbc9727d74e71
diff --git a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
index 9b57a660a..eab161216 100644
--- a/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
+++ b/src/Tests/Grand.Web.Admin.Tests/Controllers/BaseProductControllerTests.cs
@@ -16,6 +16,7 @@ using Grand.Web.AdminShared.Interfaces;
using Grand.Web.AdminShared.Mapper;
using Grand.Web.AdminShared.Models.Catalog;
using Grand.Web.AdminShared.Models.Orders;
+using Grand.Web.Common.DataSource;
using Grand.Web.Common.Localization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
@@ -4697,4 +4698,296 @@ public class BaseProductControllerTests
var content = result as ContentResult;
Assert.AreEqual("", content.Content);
}
+
+ // --- ProductAttributeCombinationList (POST) -------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductAttributeCombinationList_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.ProductAttributeCombinationList(new DataSourceRequest(), "p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(
+ s => s.PrepareProductAttributeCombinationModel(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeCombinationList_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.PrepareProductAttributeCombinationModel(product))
+ .ReturnsAsync(new List<ProductModel.ProductAttributeCombinationModel> { new() });
+
+ var result = await _controller.ProductAttributeCombinationList(new DataSourceRequest(), "p1");
+
+ var json = result as JsonResult;
+ Assert.IsNotNull(json);
+ var gridModel = json.Value as DataSourceResult;
+ Assert.AreEqual(1, gridModel.Total);
+ }
+
+ // --- ProductAttributeCombinationDelete -------------------------------------------------------------
+
+ [TestMethod]
+ public async Task ProductAttributeCombinationDelete_MissingProduct_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+ var attrServiceMock = new Mock<IProductAttributeService>();
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ProductAttributeCombinationDelete("c1", "missing", attrServiceMock.Object));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeCombinationDelete_ScopeDeniesAccess_ReturnsErrorJson_DoesNotDelete()
+ {
+ var product = new Product { Id = "p1" };
+ product.ProductAttributeCombinations.Add(new ProductAttributeCombination { Id = "c1" });
+ _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.ProductAttributeCombinationDelete("c1", "p1", attrServiceMock.Object);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ attrServiceMock.Verify(
+ s => s.DeleteProductAttributeCombination(It.IsAny<ProductAttributeCombination>(), It.IsAny<string>()),
+ Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeCombinationDelete_ScopeGrantsAccess_CombinationMissing_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.ProductAttributeCombinationDelete("missing-c", "p1", attrServiceMock.Object));
+ }
+
+ [TestMethod]
+ public async Task ProductAttributeCombinationDelete_ScopeGrantsAccess_Deletes()
+ {
+ var product = new Product { Id = "p1", ManageInventoryMethodId = ManageInventoryMethod.DontManageStock };
+ var combination = new ProductAttributeCombination { Id = "c1" };
+ product.ProductAttributeCombinations.Add(combination);
+ _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.ProductAttributeCombinationDelete("c1", "p1", attrServiceMock.Object);
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ attrServiceMock.Verify(s => s.DeleteProductAttributeCombination(combination, "p1"), Times.Once);
+ }
+
+ // --- AttributeCombinationPopup (GET) ---------------------------------------------------------------
+
+ [TestMethod]
+ public async Task AttributeCombinationPopupGet_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.AttributeCombinationPopup("p1", "c1");
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(
+ s => s.PrepareProductAttributeCombinationModel(It.IsAny<Product>(), It.IsAny<string>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task AttributeCombinationPopupGet_ScopeGrantsAccess_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 model = new ProductAttributeCombinationModel { Id = "c1" };
+ _productViewModelServiceMock.Setup(s => s.PrepareProductAttributeCombinationModel(product, "c1"))
+ .ReturnsAsync(model);
+
+ var result = await _controller.AttributeCombinationPopup("p1", "c1");
+
+ var view = result as ViewResult;
+ Assert.IsNotNull(view);
+ Assert.AreSame(model, view.Model);
+ _productViewModelServiceMock.Verify(s => s.PrepareAddProductAttributeCombinationModel(model, product),
+ Times.Once);
+ }
+
+ // --- AttributeCombinationPopup (POST) --------------------------------------------------------------
+
+ [TestMethod]
+ public async Task AttributeCombinationPopupPost_MissingProduct_RedirectsToList()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+ var model = new ProductAttributeCombinationModel();
+
+ var result = await _controller.AttributeCombinationPopup("missing", model);
+
+ var redirect = result as RedirectToActionResult;
+ Assert.IsNotNull(redirect);
+ Assert.AreEqual("List", redirect.ActionName);
+ _scopeMock.Verify(s => s.HasAccess(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task AttributeCombinationPopupPost_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 ProductAttributeCombinationModel();
+
+ var result = await _controller.AttributeCombinationPopup("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.InsertOrUpdateProductAttributeCombinationPopup(It.IsAny<Product>(),
+ It.IsAny<ProductAttributeCombinationModel>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task AttributeCombinationPopupPost_ScopeGrantsAccess_NoWarnings_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 ProductAttributeCombinationModel();
+ _productViewModelServiceMock.Setup(s => s.InsertOrUpdateProductAttributeCombinationPopup(product, model))
+ .ReturnsAsync(new List<string>());
+
+ var result = await _controller.AttributeCombinationPopup("p1", model);
+
+ var content = result as ContentResult;
+ Assert.IsNotNull(content);
+ Assert.AreEqual("", content.Content);
+ }
+
+ [TestMethod]
+ public async Task AttributeCombinationPopupPost_ScopeGrantsAccess_WithWarnings_ReturnsViewWithWarnings()
+ {
+ 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 ProductAttributeCombinationModel();
+ _productViewModelServiceMock.Setup(s => s.InsertOrUpdateProductAttributeCombinationPopup(product, model))
+ .ReturnsAsync(new List<string> { "warning" });
+
+ var result = await _controller.AttributeCombinationPopup("p1", model);
+
+ var view = result as ViewResult;
+ Assert.IsNotNull(view);
+ Assert.AreSame(model, view.Model);
+ CollectionAssert.Contains(model.Warnings.ToList(), "warning");
+ _productViewModelServiceMock.Verify(s => s.PrepareAddProductAttributeCombinationModel(model, product),
+ Times.Once);
+ }
+
+ // --- GenerateAllAttributeCombinations ---------------------------------------------------------------
+
+ [TestMethod]
+ public async Task GenerateAllAttributeCombinations_MissingProduct_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.GenerateAllAttributeCombinations("missing"));
+ }
+
+ [TestMethod]
+ public async Task GenerateAllAttributeCombinations_ScopeDeniesAccess_ReturnsErrorJson_DoesNotGenerate()
+ {
+ 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.GenerateAllAttributeCombinations("p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(s => s.GenerateAllAttributeCombinations(It.IsAny<Product>()),
+ Times.Never);
+ }
+
+ [TestMethod]
+ public async Task GenerateAllAttributeCombinations_ScopeGrantsAccess_Generates()
+ {
+ 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.GenerateAllAttributeCombinations("p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productViewModelServiceMock.Verify(s => s.GenerateAllAttributeCombinations(product), Times.Once);
+ }
+
+ // --- ClearAllAttributeCombinations -----------------------------------------------------------------
+
+ [TestMethod]
+ public async Task ClearAllAttributeCombinations_MissingProduct_Throws()
+ {
+ _productServiceMock.Setup(p => p.GetProductById("missing", false)).ReturnsAsync((Product)null);
+
+ await Assert.ThrowsExactlyAsync<ArgumentException>(
+ () => _controller.ClearAllAttributeCombinations("missing"));
+ }
+
+ [TestMethod]
+ public async Task ClearAllAttributeCombinations_ScopeDeniesAccess_ReturnsErrorJson_DoesNotClear()
+ {
+ 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.ClearAllAttributeCombinations("p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _translationServiceMock.Verify(t => t.GetResource("Admin.Catalog.Products.Permissions"), Times.Once);
+ _productViewModelServiceMock.Verify(s => s.ClearAllAttributeCombinations(It.IsAny<Product>()), Times.Never);
+ }
+
+ [TestMethod]
+ public async Task ClearAllAttributeCombinations_ScopeGrantsAccess_ValidModel_Clears()
+ {
+ var product = new Product
+ { Id = "p1", ManageInventoryMethodId = ManageInventoryMethod.DontManageStock };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+
+ var result = await _controller.ClearAllAttributeCombinations("p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productViewModelServiceMock.Verify(s => s.ClearAllAttributeCombinations(product), Times.Once);
+ }
+
+ [TestMethod]
+ public async Task ClearAllAttributeCombinations_ScopeGrantsAccess_InvalidModelState_ReturnsErrorJson_DoesNotClear()
+ {
+ var product = new Product { Id = "p1" };
+ _productServiceMock.Setup(p => p.GetProductById("p1", false)).ReturnsAsync(product);
+ _scopeMock.Setup(s => s.HasAccess(product)).ReturnsAsync(true);
+ _controller.ModelState.AddModelError("x", "err");
+
+ var result = await _controller.ClearAllAttributeCombinations("p1");
+
+ Assert.IsInstanceOfType<JsonResult>(result);
+ _productViewModelServiceMock.Verify(s => s.ClearAllAttributeCombinations(It.IsAny<Product>()), Times.Never);
+ }
}
diff --git a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
index 98a80fef5..8079fc428 100644
--- a/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
+++ b/src/Web/Grand.Web.AdminShared/Controllers/BaseProductController.cs
@@ -2811,4 +2811,171 @@ public abstract class BaseProductController(
}
#endregion
+
+ #region Product attribute combinations
+
+ [PermissionAuthorizeAction(PermissionActionName.Preview)]
+ [HttpPost]
+ public async Task<IActionResult> ProductAttributeCombinationList(DataSourceRequest command, string productId)
+ {
+ var product = await productService.GetProductById(productId);
+
+ // HasAccess added here: Admin's original had no ownership check on this grid at all. Store's
+ // original used CanAccessProduct + a hardcoded "Admin.Catalog.Products.Permissions" resource key
+ // (even though it's the Store host); Vendor's original used a local CheckAccessToProduct helper
+ // that returned a plain hardcoded string ("This is not your product" / "Product not exists")
+ // rather than a resource key. scope.HasAccess plus the scope.ResourceKeyPrefix-qualified resource
+ // key normalizes all three to the convention used throughout this file.
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(
+ translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var combinationsModel = await productViewModelService.PrepareProductAttributeCombinationModel(product);
+ var gridModel = new DataSourceResult {
+ Data = combinationsModel,
+ Total = combinationsModel.Count
+ };
+ return Json(gridModel);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ProductAttributeCombinationDelete(string id, 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, checked before the combination lookup: matches the
+ // ProductAttributeValueDelete precedent above (deny before revealing whether the sub-entity
+ // exists). Vendor's original combined the null-check and the ownership check into a single throw
+ // (an unhandled exception on denial); normalized here to the file's ErrorForKendoGridJson
+ // convention - this is a Kendo grid row-delete action - matching how Store's original reported
+ // denial (though Store checked access after the combination lookup, not before).
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(
+ translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var combination = product.ProductAttributeCombinations.FirstOrDefault(x => x.Id == id);
+ if (combination == null)
+ throw new ArgumentException("No product attribute combination found with the specified id");
+
+ await productAttributeService.DeleteProductAttributeCombination(combination, productId);
+ if (product.ManageInventoryMethodId == ManageInventoryMethod.ManageStockByAttributes)
+ {
+ var pr = await productService.GetProductById(productId);
+ pr.StockQuantity = pr.ProductAttributeCombinations.Sum(x => x.StockQuantity);
+ pr.ReservedQuantity = pr.ProductAttributeCombinations.Sum(x => x.ReservedQuantity);
+ await inventoryManageService.UpdateStockProduct(pr, false);
+ }
+
+ return new JsonResult("");
+ }
+
+ //edit
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ public async Task<IActionResult> AttributeCombinationPopup(string productId, string id)
+ {
+ var product = await productService.GetProductById(productId);
+
+ // Content(...), not ErrorForKendoGridJson: Store's original used ErrorForKendoGridJson here even
+ // though this action returns a View inside a magnificPopup modal (not a grid), which would render
+ // raw JSON as page content on denial - using Content(...) instead, consistent with the
+ // EditAttributeValues GET popup correction in region "Product attribute values" above.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var model = await productViewModelService.PrepareProductAttributeCombinationModel(product, id);
+ await productViewModelService.PrepareAddProductAttributeCombinationModel(model, product);
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> AttributeCombinationPopup(string productId,
+ ProductAttributeCombinationModel model)
+ {
+ var product = await productService.GetProductById(productId);
+ if (product == null)
+ //No product found with the specified id
+ return RedirectToAction("List", "Product");
+
+ // Content(...) on denial, matching Store's original. Vendor's original folded denial into the
+ // same redirect used for a missing product; Content(...) surfaces the permissions message instead
+ // of silently redirecting, matching every other Edit-scoped action in this region.
+ // ProductAttributeCombinationModel (Grand.Web.AdminShared.Models.Catalog) does not implement
+ // IProductValidVendor and has no registered FluentValidation validator, so there is no
+ // validator-layer ownership check being displaced here - scope.HasAccess is the only guard.
+ if (!await scope.HasAccess(product))
+ return Content(translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ var warnings = await productViewModelService.InsertOrUpdateProductAttributeCombinationPopup(product, model);
+ if (!warnings.Any()) return Content("");
+ //If we got this far, something failed, redisplay form
+ await productViewModelService.PrepareAddProductAttributeCombinationModel(model, product);
+ model.Warnings = warnings;
+ return View(model);
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> GenerateAllAttributeCombinations(string productId)
+ {
+ var product = await productService.GetProductById(productId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ // ErrorForKendoGridJson(...), not Content(...): this action is invoked via a dataType:'json' ajax
+ // call (see CreateOrUpdate.ProductAttributes.TabAttributeCombinations.cshtml). Store's original
+ // returned Content(resource) on denial - a plain string the client's dataType:'json' parser
+ // cannot parse - which threw a JSON-parse exception and fell into the ajax error callback,
+ // showing a generic "Error while generating attribute combinations" alert. Vendor's original
+ // folded denial into the null-product throw (also an unhandled exception). Normalized here to a
+ // real JSON response, which avoids that parse-exception/generic-alert path - but note the
+ // .cshtml's ajax success callback for this action ignores the response body entirely (it just
+ // unconditionally refreshes the grid), so the denial still isn't surfaced to the user; it's a
+ // silent no-op instead of a visible (if wrong) error. Server-side enforcement is correct either
+ // way - nothing is generated on denial - this is a pre-existing view-layer gap, out of scope for
+ // this controller-only row (flagged for Phase 2 view work).
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(
+ translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ await productViewModelService.GenerateAllAttributeCombinations(product);
+
+ return Json(new { Success = true });
+ }
+
+ [PermissionAuthorizeAction(PermissionActionName.Edit)]
+ [HttpPost]
+ public async Task<IActionResult> ClearAllAttributeCombinations(string productId)
+ {
+ var product = await productService.GetProductById(productId);
+ if (product == null)
+ throw new ArgumentException("No product found with the specified id");
+
+ // See the GenerateAllAttributeCombinations comment above - same dataType:'json' contract, same fix.
+ if (!await scope.HasAccess(product))
+ return ErrorForKendoGridJson(
+ translationService.GetResource($"{scope.ResourceKeyPrefix}.Catalog.Products.Permissions"));
+
+ if (ModelState.IsValid)
+ {
+ await productViewModelService.ClearAllAttributeCombinations(product);
+
+ if (product.ManageInventoryMethodId == ManageInventoryMethod.ManageStockByAttributes)
+ {
+ product.StockQuantity = 0;
+ product.ReservedQuantity = 0;
+ await inventoryManageService.UpdateStockProduct(product, false);
+ }
+
+ return Json(new { Success = true });
+ }
+
+ return ErrorForKendoGridJson(ModelState);
+ }
+
+ #endregion
}