OSOE-638: Feature to edit shell settings from the admin in Lombiq.Hosting.Tenants

Lombiq.Hosting.Tenants.Management.Tests.UI/Extensions/TestCaseUITestContextExtensions.cs

@@ -19,10 +19,18 @@ public static async Task TestShellSettingsEditorFeatureAsync(this UITestContext
         await context.FillInEditorThenCheckValueAsync(
             "{\"TestKey\":{\"TestSubKey\":{\"TestSubOptions\":{\"Test\": \"TestValue\"}}}}",
             "TestValue");
+
+        await context.FillInEditorThenCheckValueAsync(
+            "{\"TestKey\":{\"TestSubKey\":{\"TestSubOptions\":{\"NewKey\": \"NewValue\"}}}}",
+            "NewValue");
+
+        await context.FillInEditorThenCheckValueAsync(
+            "{\"TestKey\":{\"TestSubKey\":{\"TestSubOptions\":{}}}}",
+            string.Empty);
 #pragma warning restore JSON002 // Probable JSON string detected
         await context.FillInEditorThenCheckValueAsync(
             string.Empty,
-            expectedValue: null);
+            string.Empty);
     }
 
     private static async Task FillInEditorThenCheckValueAsync(this UITestContext context, string text, string expectedValue)
@@ -31,13 +39,13 @@ private static async Task FillInEditorThenCheckValueAsync(this UITestContext con
         await context.ClickReliablyOnAsync(By.XPath("//button[contains(.,'Save settings')]"));
         var editorText = context.GetMonacoEditorText("Json_editor");
 
-        if (string.IsNullOrEmpty(text))
+        if (string.IsNullOrEmpty(expectedValue))
         {
-            editorText.ShouldBeAsString(text);
+            editorText.ShouldBeAsString(expectedValue);
         }
         else
         {
-            var editorValue = JObject.Parse(context.GetMonacoEditorText("Json_editor"));
+            var editorValue = JObject.Parse(editorText);
             editorValue.SelectToken("TestKey.TestSubKey.TestSubOptions.Test")?.ToString().ShouldBeAsString(expectedValue);
         }
     }

Lombiq.Hosting.Tenants.Management/Controllers/ShellSettingsEditorController.cs

@@ -3,7 +3,9 @@
 using Lombiq.Hosting.Tenants.Management.Service;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Localization;
 using Microsoft.Extensions.Configuration;
+using OrchardCore.DisplayManagement.Notify;
 using OrchardCore.Environment.Shell;
 using OrchardCore.Environment.Shell.Configuration;
 using OrchardCore.Locking.Distributed;
@@ -26,17 +28,23 @@ public class ShellSettingsEditorController : Controller
     private readonly IShellHost _shellHost;
     private readonly IShellConfigurationSources _shellConfigurationSources;
     private readonly IDistributedLock _distributedLock;
+    private readonly INotifier _notifier;
+    private readonly IHtmlLocalizer<ShellSettingsEditorController> H;
 
     public ShellSettingsEditorController(
         IAuthorizationService authorizationService,
         IShellHost shellHost,
         IShellConfigurationSources shellConfigurationSources,
-        IDistributedLock distributedLock)
+        IDistributedLock distributedLock,
+        INotifier notifier,
+        IHtmlLocalizer<ShellSettingsEditorController> htmlLocalizer)
     {
         _authorizationService = authorizationService;
         _shellHost = shellHost;
         _shellConfigurationSources = shellConfigurationSources;
         _distributedLock = distributedLock;
+        _notifier = notifier;
+        H = htmlLocalizer;
     }
 
     [HttpPost]
@@ -52,6 +60,7 @@ public async Task<IActionResult> Edit(ShellSettingsEditorViewModel model)
         model.Json ??= "{}";
         if (!IsValidJson(model.Json))
         {
+            await _notifier.ErrorAsync(H["Please provide valid JSON input for shell settings."]);
             return RedirectToAction(
                 nameof(AdminController.Edit),
                 typeof(AdminController).ControllerName(),
@@ -62,49 +71,53 @@ public async Task<IActionResult> Edit(ShellSettingsEditorViewModel model)
                 });
         }
 
-        var settingsDictionary = new JsonConfigurationParser().ParseConfiguration(model.Json);
-        var newSettings = new Dictionary<string, string>();
+        var tenantConfiguration = new JsonConfigurationParser().ParseConfiguration(model.Json);
+        var newTenantConfiguration = new Dictionary<string, string>();
 
         var tenantSettingsPrefix = $"{model.TenantId}Prefix:";
         var currentSettings = shellSettings.ShellConfiguration.AsEnumerable()
             .Where(item => item.Value != null &&
                 item.Key.Contains(tenantSettingsPrefix))
             .ToDictionary(key => key.Key.Replace(tenantSettingsPrefix, string.Empty), value => value.Value);
 
-        if (settingsDictionary?.Keys != null)
+        foreach (var key in tenantConfiguration.Keys)
         {
-            foreach (var key in settingsDictionary.Keys)
+            var tenantSettingsPrefixWithKey = $"{tenantSettingsPrefix}{key}";
+            if (shellSettings[key] != tenantConfiguration[key])
             {
-                var tenantSettingsPrefixWithKey = $"{tenantSettingsPrefix}{key}";
-                if (shellSettings[key] != settingsDictionary[key])
-                {
-                    newSettings[tenantSettingsPrefixWithKey] = settingsDictionary[key];
-                    newSettings[key] = settingsDictionary[key];
-                }
+                newTenantConfiguration[tenantSettingsPrefixWithKey] = tenantConfiguration[key];
+                newTenantConfiguration[key] = tenantConfiguration[key];
             }
         }
 
         var deletableKeys = currentSettings
-            .Where(item => settingsDictionary == null || !settingsDictionary.ContainsKey(item.Key))
+            .Where(item => !tenantConfiguration.ContainsKey(item.Key))
             .Select(item => item.Key);
 
         foreach (var key in deletableKeys)
         {
             var tenantSettingsPrefixWithKey = $"{tenantSettingsPrefix}{key}";
-            newSettings[key] = null;
-            newSettings[tenantSettingsPrefixWithKey] = null;
+            newTenantConfiguration[key] = null;
+            newTenantConfiguration[tenantSettingsPrefixWithKey] = null;
         }
 
-        var (locker, locked) = await _distributedLock.TryAcquireLockAsync("LOMBIQ_HOSTING_TENANTS_MANAGEMENT_SHELL_SETTINGS_EDITOR_LOCK", TimeSpan.FromSeconds(10));
+        var (locker, locked) =
+            await _distributedLock.TryAcquireLockAsync(
+                "LOMBIQ_HOSTING_TENANTS_MANAGEMENT_SHELL_SETTINGS_EDITOR_LOCK",
+                TimeSpan.FromSeconds(10));
+
         if (!locked)
         {
             throw new TimeoutException($"Failed to acquire a lock before saving settings to the tenant: {model.TenantId}.");
         }
 
         await using var acquiredLock = locker;
 
-        await _shellConfigurationSources.SaveAsync(shellSettings.Name, newSettings);
-        await _shellHost.ReloadShellContextAsync(shellSettings);
+        // We are using the shell configuration sources directly because using IShellHost.UpdateShellSettingsAsync would
+        // not save settings that has a key with multiple sections.
+        // See https://github.com/OrchardCMS/OrchardCore/issues/14481.
+        await _shellConfigurationSources.SaveAsync(shellSettings.Name, newTenantConfiguration);
+        await _shellHost.UpdateShellSettingsAsync(shellSettings);
 
         return RedirectToAction(
             nameof(AdminController.Edit),

Lombiq.Hosting.Tenants.Management/Service/JsonConfigurationParser.cs

@@ -1,15 +1,17 @@
-using Microsoft.Extensions.Configuration;
+// This file is a copy and slight modification of Microsoft.Extensions.Configuration.Json.JsonConfigurationFileParser
+// https://github.com/dotnet/runtime/blob/main/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonConfigurationFileParser.cs.
+// Their recommended way of using this class is to copy it. https://github.com/dotnet/runtime/issues/73946
+using Microsoft.Extensions.Configuration;
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.Text.Json;
 
 namespace Lombiq.Hosting.Tenants.Management.Service;
 
 public class JsonConfigurationParser
 {
-    private readonly Dictionary<string, string> Data = new(StringComparer.OrdinalIgnoreCase);
-    private readonly Stack<string> Paths = new();
+    private readonly Dictionary<string, string> _configurationData = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Stack<string> _paths = new();
 
     public IDictionary<string, string> ParseConfiguration(string inputJson)
     {
@@ -22,12 +24,13 @@ public IDictionary<string, string> ParseConfiguration(string inputJson)
         using var doc = JsonDocument.Parse(inputJson, jsonDocumentOptions);
         if (doc.RootElement.ValueKind != JsonValueKind.Object)
         {
-            throw new FormatException("Format Exception:" + doc.RootElement.ValueKind);
+            throw new FormatException(
+                $"Top-level JSON element must be an object. Instead, '{doc.RootElement.ValueKind}' was found.");
         }
 
         VisitObjectElement(doc.RootElement);
 
-        return Data;
+        return _configurationData;
     }
 
     private void VisitObjectElement(JsonElement element)
@@ -47,11 +50,11 @@ private void VisitObjectElement(JsonElement element)
 
     private void VisitArrayElement(JsonElement element)
     {
-        int index = 0;
+        var index = 0;
 
         foreach (var arrayElement in element.EnumerateArray())
         {
-            EnterContext(index.ToString(CultureInfo.InvariantCulture));
+            EnterContext(index.ToTechnicalString());
             VisitValue(arrayElement);
             ExitContext();
             index++;
@@ -62,9 +65,9 @@ private void VisitArrayElement(JsonElement element)
 
     private void SetNullIfElementIsEmpty(bool isEmpty)
     {
-        if (isEmpty && Paths.Count > 0)
+        if (isEmpty && _paths.Count > 0)
         {
-            Data[Paths.Peek()] = null;
+            _configurationData[_paths.Peek()] = null;
         }
     }
 
@@ -85,25 +88,25 @@ private void VisitValue(JsonElement value)
             case JsonValueKind.True:
             case JsonValueKind.False:
             case JsonValueKind.Null:
-                string key = Paths.Peek();
-                if (Data.ContainsKey(key))
+                var key = _paths.Peek();
+                if (_configurationData.ContainsKey(key))
                 {
-                    throw new FormatException("Key Is Duplicated:" + key);
+                    throw new FormatException($"A duplicate key '{key}' was found.");
                 }
 
-                Data[key] = value.ToString();
+                _configurationData[key] = value.ToString();
                 break;
 
             case JsonValueKind.Undefined:
             default:
-                throw new FormatException("Unsupported JSON Token:" + value.ValueKind);
+                throw new FormatException($"Unsupported JSON token '{value.ValueKind}' was found.");
         }
     }
 
     private void EnterContext(string context) =>
-        Paths.Push(Paths.Count > 0 ?
-            Paths.Peek() + ConfigurationPath.KeyDelimiter + context :
+        _paths.Push(_paths.Count > 0 ?
+            _paths.Peek() + ConfigurationPath.KeyDelimiter + context :
             context);
 
-    private void ExitContext() => Paths.Pop();
+    private void ExitContext() => _paths.Pop();
 }