ARCH-001 Phase 19: MessageTemplate controller/service consolidation (Admin/Store)

src/Tests/Grand.Mapping.Tests/AdminShared/SystemMappingTests.MessageTemplate_ToModel.verified.txt

@@ -11,5 +11,7 @@
   Stores: [
     store-001
   ],
+  IsReadOnly: false,
+  CanCopy: false,
   Id: mt-001
 }

src/Tests/Grand.Web.Admin.Tests/Controllers/MessageTemplateControllerAttributeTests.cs

@@ -0,0 +1,50 @@
+using System.Linq;
+using Grand.Web.Admin.Controllers;
+using Grand.Web.AdminShared.Controllers;
+using Grand.Web.Common.Filters;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Grand.Web.Admin.Tests.Controllers;
+
+[TestClass]
+public class MessageTemplateControllerAttributeTests
+{
+    [TestMethod]
+    public void IsSubclassOfBaseMessageTemplateController()
+    {
+        Assert.IsTrue(typeof(BaseMessageTemplateController).IsAssignableFrom(typeof(MessageTemplateController)));
+        Assert.AreEqual(typeof(BaseMessageTemplateController), typeof(MessageTemplateController).BaseType);
+    }
+
+    [TestMethod]
+    public void HasAuthorizeAdminAttribute()
+    {
+        var attr = typeof(MessageTemplateController).GetCustomAttributes(typeof(AuthorizeAdminAttribute), inherit: false);
+        Assert.AreEqual(1, attr.Length);
+    }
+
+    [TestMethod]
+    public void HasAreaAdminAttribute()
+    {
+        var attr = typeof(MessageTemplateController)
+            .GetCustomAttributes(typeof(AreaAttribute), inherit: false)
+            .Cast<AreaAttribute>().Single();
+        Assert.AreEqual("Admin", attr.RouteValue);
+    }
+
+    [TestMethod]
+    public void HasAutoValidateAntiforgeryTokenAttribute()
+    {
+        var attr = typeof(MessageTemplateController)
+            .GetCustomAttributes(typeof(AutoValidateAntiforgeryTokenAttribute), inherit: true);
+        Assert.AreEqual(1, attr.Length);
+    }
+
+    [TestMethod]
+    public void HasAuthorizeMenuAttribute()
+    {
+        var attr = typeof(MessageTemplateController).GetCustomAttributes(typeof(AuthorizeMenuAttribute), inherit: false);
+        Assert.AreEqual(1, attr.Length);
+    }
+}

src/Tests/Grand.Web.Admin.Tests/Controllers/RoutedMessageTemplateDataScopeTests.cs

@@ -0,0 +1,77 @@
+using Grand.Domain.Messages;
+using Grand.Web.AdminShared.Services;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Web.Admin.Tests.Controllers;
+
+[TestClass]
+public class RoutedMessageTemplateDataScopeTests
+{
+    private static RoutedMessageTemplateDataScope CreateScope(string area)
+    {
+        var httpContext = new DefaultHttpContext();
+        httpContext.Request.RouteValues = new RouteValueDictionary { ["area"] = area };
+        var httpContextAccessor = new Mock<IHttpContextAccessor>();
+        httpContextAccessor.Setup(a => a.HttpContext).Returns(httpContext);
+
+        var contextAccessor = new Mock<Grand.Infrastructure.IContextAccessor>();
+        var workContext = new Mock<Grand.Infrastructure.IWorkContext>();
+        workContext.Setup(w => w.CurrentCustomer).Returns(new Grand.Domain.Customers.Customer { StaffStoreId = "store-1" });
+        contextAccessor.Setup(c => c.WorkContext).Returns(workContext.Object);
+
+        var storeScope = new StoreMessageTemplateDataScope(contextAccessor.Object);
+        return new RoutedMessageTemplateDataScope(httpContextAccessor.Object,
+            new GlobalAdminDataScope<MessageTemplate>(), storeScope);
+    }
+
+    [TestMethod]
+    public async Task AdminArea_ResolvesToGlobalScope_HasAccessAlwaysTrue()
+    {
+        var scope = CreateScope("Admin");
+        var result = await scope.HasAccess(new MessageTemplate { LimitedToStores = true, Stores = ["store-2"] });
+        Assert.IsTrue(result);
+    }
+
+    [TestMethod]
+    public void AdminArea_DefaultStoreId_IsNull()
+    {
+        var scope = CreateScope("Admin");
+        Assert.IsNull(scope.DefaultStoreId);
+    }
+
+    [TestMethod]
+    public async Task StoreArea_ResolvesToStoreScope_HasAccessMatchesOwnership()
+    {
+        var scope = CreateScope("Store");
+        var owned = await scope.HasAccess(new MessageTemplate { LimitedToStores = true, Stores = ["store-1"] });
+        var other = await scope.HasAccess(new MessageTemplate { LimitedToStores = true, Stores = ["store-2"] });
+        Assert.IsTrue(owned);
+        Assert.IsFalse(other);
+    }
+
+    [TestMethod]
+    public void StoreArea_DefaultStoreId_IsStaffStoreId()
+    {
+        var scope = CreateScope("Store");
+        Assert.AreEqual("store-1", scope.DefaultStoreId);
+    }
+
+    [TestMethod]
+    public async Task UnrecognizedArea_ThrowsInvalidOperationException()
+    {
+        var scope = CreateScope("Vendor");
+        await Assert.ThrowsAsync<InvalidOperationException>(
+            () => scope.HasAccess(new MessageTemplate { LimitedToStores = true, Stores = ["store-1"] }));
+    }
+
+    [TestMethod]
+    public async Task MissingArea_ThrowsInvalidOperationException()
+    {
+        var scope = CreateScope(null);
+        await Assert.ThrowsAsync<InvalidOperationException>(
+            () => scope.HasAccess(new MessageTemplate { LimitedToStores = true, Stores = ["store-1"] }));
+    }
+}

src/Tests/Grand.Web.Admin.Tests/Controllers/StoreMessageTemplateDataScopeTests.cs

@@ -0,0 +1,114 @@
+using Grand.Domain.Customers;
+using Grand.Domain.Messages;
+using Grand.Infrastructure;
+using Grand.Web.AdminShared.Services;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Grand.Web.Admin.Tests.Controllers;
+
+[TestClass]
+public class StoreMessageTemplateDataScopeTests
+{
+    private static StoreMessageTemplateDataScope CreateScope(string staffStoreId)
+    {
+        var customer = new Customer { StaffStoreId = staffStoreId };
+        var workContext = new Mock<IWorkContext>();
+        workContext.Setup(w => w.CurrentCustomer).Returns(customer);
+        var contextAccessor = new Mock<IContextAccessor>();
+        contextAccessor.Setup(c => c.WorkContext).Returns(workContext.Object);
+        return new StoreMessageTemplateDataScope(contextAccessor.Object);
+    }
+
+    [TestMethod]
+    public async Task HasAccess_ExclusivelyOwnedByCurrentStore_ReturnsTrue()
+    {
+        var scope = CreateScope("store-1");
+        var template = new MessageTemplate { LimitedToStores = true, Stores = ["store-1"] };
+        Assert.IsTrue(await scope.HasAccess(template));
+    }
+
+    [TestMethod]
+    public async Task HasAccess_SharedWithMultipleStores_ReturnsFalse()
+    {
+        var scope = CreateScope("store-1");
+        var template = new MessageTemplate { LimitedToStores = true, Stores = ["store-1", "store-2"] };
+        Assert.IsFalse(await scope.HasAccess(template));
+    }
+
+    [TestMethod]
+    public async Task HasAccess_OwnedByOtherStore_ReturnsFalse()
+    {
+        var scope = CreateScope("store-1");
+        var template = new MessageTemplate { LimitedToStores = true, Stores = ["store-2"] };
+        Assert.IsFalse(await scope.HasAccess(template));
+    }
+
+    [TestMethod]
+    public async Task HasAccess_Global_ReturnsFalse()
+    {
+        var scope = CreateScope("store-1");
+        var template = new MessageTemplate { LimitedToStores = false, Stores = [] };
+        Assert.IsFalse(await scope.HasAccess(template));
+    }
+
+    [TestMethod]
+    public async Task HasAccess_NullEntity_ReturnsFalse()
+    {
+        var scope = CreateScope("store-1");
+        Assert.IsFalse(await scope.HasAccess(null));
+    }
+
+    [TestMethod]
+    public async Task CanView_ExclusivelyOwned_ReturnsTrue()
+    {
+        var scope = CreateScope("store-1");
+        var template = new MessageTemplate { LimitedToStores = true, Stores = ["store-1"] };
+        Assert.IsTrue(await scope.CanView(template));
+    }
+
+    [TestMethod]
+    public async Task CanView_SharedWithMultipleStores_IncludingCurrent_ReturnsTrue()
+    {
+        var scope = CreateScope("store-1");
+        var template = new MessageTemplate { LimitedToStores = true, Stores = ["store-1", "store-2"] };
+        Assert.IsTrue(await scope.CanView(template));
+    }
+
+    [TestMethod]
+    public async Task CanView_Global_ReturnsTrue()
+    {
+        var scope = CreateScope("store-1");
+        var template = new MessageTemplate { LimitedToStores = false, Stores = [] };
+        Assert.IsTrue(await scope.CanView(template));
+    }
+
+    [TestMethod]
+    public async Task CanView_OwnedByOtherStoreOnly_ReturnsFalse()
+    {
+        var scope = CreateScope("store-1");
+        var template = new MessageTemplate { LimitedToStores = true, Stores = ["store-2"] };
+        Assert.IsFalse(await scope.CanView(template));
+    }
+
+    [TestMethod]
+    public async Task CanView_NullEntity_ReturnsFalse()
+    {
+        var scope = CreateScope("store-1");
+        Assert.IsFalse(await scope.CanView(null));
+    }
+
+    [TestMethod]
+    public void DefaultStoreId_ReturnsStaffStoreId()
+    {
+        var scope = CreateScope("store-1");
+        Assert.AreEqual("store-1", scope.DefaultStoreId);
+    }
+
+    [TestMethod]
+    public void ShowStoreSelector_IsFalse()
+    {
+        var scope = CreateScope("store-1");
+        Assert.IsFalse(scope.ShowStoreSelector);
+    }
+}

src/Tests/Grand.Web.Store.Tests/Controllers/MessageTemplateControllerAttributeTests.cs

@@ -0,0 +1,50 @@
+using System.Linq;
+using Grand.Web.AdminShared.Controllers;
+using Grand.Web.Common.Filters;
+using Grand.Web.Store.Controllers;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Grand.Web.Store.Tests.Controllers;
+
+[TestClass]
+public class MessageTemplateControllerAttributeTests
+{
+    [TestMethod]
+    public void IsSubclassOfBaseMessageTemplateController()
+    {
+        Assert.IsTrue(typeof(BaseMessageTemplateController).IsAssignableFrom(typeof(MessageTemplateController)));
+        Assert.AreEqual(typeof(BaseMessageTemplateController), typeof(MessageTemplateController).BaseType);
+    }
+
+    [TestMethod]
+    public void HasAuthorizeStoreAttribute()
+    {
+        var attr = typeof(MessageTemplateController).GetCustomAttributes(typeof(AuthorizeStoreAttribute), inherit: false);
+        Assert.AreEqual(1, attr.Length);
+    }
+
+    [TestMethod]
+    public void HasAreaStoreAttribute()
+    {
+        var attr = typeof(MessageTemplateController)
+            .GetCustomAttributes(typeof(AreaAttribute), inherit: false)
+            .Cast<AreaAttribute>().Single();
+        Assert.AreEqual("Store", attr.RouteValue);
+    }
+
+    [TestMethod]
+    public void HasAutoValidateAntiforgeryTokenAttribute()
+    {
+        var attr = typeof(MessageTemplateController)
+            .GetCustomAttributes(typeof(AutoValidateAntiforgeryTokenAttribute), inherit: true);
+        Assert.AreEqual(1, attr.Length);
+    }
+
+    [TestMethod]
+    public void HasAuthorizeMenuAttribute()
+    {
+        var attr = typeof(MessageTemplateController).GetCustomAttributes(typeof(AuthorizeMenuAttribute), inherit: false);
+        Assert.AreEqual(1, attr.Length);
+    }
+}

src/Web/Grand.Web.Admin/Areas/Admin/Views/MessageTemplate/Partials/WidgetZone.DetailsBottom.cshtml

@@ -0,0 +1,2 @@
+@model Grand.Web.AdminShared.Models.Messages.MessageTemplateModel
+<vc:admin-widget widget-zone="message_template_details_bottom" additional-data="Model"/>

src/Web/Grand.Web.Admin/Areas/Admin/Views/MessageTemplate/Partials/WidgetZone.DetailsButtons.cshtml

@@ -0,0 +1,2 @@
+@model Grand.Web.AdminShared.Models.Messages.MessageTemplateModel
+<vc:admin-widget widget-zone="message_template_details_buttons" additional-data="Model"/>

src/Web/Grand.Web.Admin/Areas/Admin/Views/MessageTemplate/Partials/WidgetZone.DetailsTabs.cshtml

@@ -0,0 +1,2 @@
+@model Grand.Web.AdminShared.Models.Messages.MessageTemplateModel
+<vc:admin-widget widget-zone="message_template_details_tabs" additional-data="Model"/>

src/Web/Grand.Web.Admin/Areas/Admin/Views/MessageTemplate/Partials/WidgetZone.DetailsTop.cshtml

@@ -0,0 +1,2 @@
+@model Grand.Web.AdminShared.Models.Messages.MessageTemplateModel
+<vc:admin-widget widget-zone="message_template_details_top" additional-data="Model"/>