Initialize CustomSettings with values from appsettings.json

[weirdyang]

Hi,

I'm hoping to be able to do something like this:

On startup, check if my custom settings exists, if not, create it with values from the appsettings
https://docs.orchardcore.net/en/latest/docs/guides/run-code-on-startup/

What's I'm struggling with:

1. how do I read from the appsettings?
   I see the Email module has this function, but how do I call this? do I have to use it in the main application or can I call it from a module startup?

OrchardCore/src/OrchardCore.Modules/OrchardCore.Email/Extensions/OrchardCoreBuilderExtensions.cs

Line 9 in 87f7a43

public static OrchardCoreBuilder ConfigureEmailSettings(this OrchardCoreBuilder builder)

2. how do I add SiteSetting programatically?

[weirdyang]

I've also tried using the builder extension method like OrchardCore.Email,but no luck either;

 public class Startup : StartupBase
   {
       public IConfiguration Configuration { get; }

       public Startup(IConfiguration configuration)
       {
           Configuration = configuration;
       }

       public override void ConfigureServices(IServiceCollection services)
       {
           //services.AddTransient<IConfigureOptions<TestSettings>, TestSettingsConfiguration>();
           //services.AddTransient<IPostConfigureOptions<TestSettings>, TestSettingsConfiguration>();

           services.AddScoped<IDisplayDriver<ISite>, TestSettingsDisplayDriver>();
           services.AddScoped<INavigationProvider, AdminMenu>();

           services.AddTransient<IPostConfigureOptions<TestSettings>, TestSettingsConfiguration>();

           var site = services.BuildServiceProvider().GetRequiredService<ISiteService>();
           var settings = site
               .LoadSiteSettingsAsync()
               .GetAwaiter()
               .GetResult();

       }
   }
   class AdminMenu : INavigationProvider
   {
       private readonly IStringLocalizer S;

       public AdminMenu(IStringLocalizer<AdminMenu> localizer)
       {
           S = localizer;
       }

       public Task BuildNavigationAsync(string name, NavigationBuilder builder)
       {
           if (!String.Equals(name, "admin", StringComparison.OrdinalIgnoreCase))
               return Task.CompletedTask;

           builder
               .Add(S["Configuration"], configuration => configuration
                   .Add(S["Settings"], settings => settings
                      .Add(S["Workflow Restriction"], S["Workflow Restriction"].PrefixPosition(), entry => entry
                      .AddClass("restriction").Id("restriction")
                         .Action("Index", "Admin", new { area = "OrchardCore.Settings", groupId = TestSettingsDisplayDriver.GroupId })
                         .Permission(StandardPermissions.SiteOwner)
                         .LocalNav()
               )));

           return Task.CompletedTask;
       }
   }
   public class TestSettings
   {
       public string RandomString { get; set; }
   }
   public class TestSettingsConfiguration : 
       IPostConfigureOptions<TestSettings>
   {
       private readonly ISiteService _site;
       private readonly IShellConfiguration _shellConfiguration;
       public TestSettingsConfiguration(
           ISiteService site,
           IDataProtectionProvider dataProtectionProvider,
           ILogger<TestSettingsConfiguration> logger,
           IShellConfiguration shellConfiguration)
       {
           _site = site;
           _shellConfiguration = shellConfiguration;
       }

       public void PostConfigure(string name, TestSettings options)
       {
           _shellConfiguration
               .GetSection(nameof(TestSettings))
               .Bind(options);
       }
   }
   public class TestSettingsDisplayDriver : SectionDisplayDriver<ISite, TestSettings>
   {
       public const string GroupId = "TestSettings";
       private readonly IDataProtectionProvider _dataProtectionProvider;
       private readonly IShellHost _shellHost;
       private readonly ShellSettings _shellSettings;
       private readonly IHttpContextAccessor _httpContextAccessor;
       private readonly IAuthorizationService _authorizationService;
       private readonly ISiteService _site;
       private readonly TestSettings _settings;

       public TestSettingsDisplayDriver(
           IDataProtectionProvider dataProtectionProvider,
           IShellHost shellHost,
           ShellSettings shellSettings,
           IHttpContextAccessor httpContextAccessor,
           IAuthorizationService authorizationService,
           ISiteService site,
           IOptions<TestSettings> settings)
       {
           _dataProtectionProvider = dataProtectionProvider;
           _shellHost = shellHost;
           _shellSettings = shellSettings;
           _httpContextAccessor = httpContextAccessor;
           _authorizationService = authorizationService;
           _site = site;
           _settings = settings.Value;
       }

       public override async Task<IDisplayResult> EditAsync(TestSettings settings, BuildEditorContext context)
       {
          
           var shapes = new List<IDisplayResult>
           {
               Initialize<TestSettings>("TestSettings_Edit", model =>
               {
                   model.RandomString = _settings.RandomString ?? settings.RandomString;
               }).Location("Content:5").OnGroup(GroupId),
           };

           return Combine(shapes);
       }

       public override async Task<IDisplayResult> UpdateAsync(TestSettings section, BuildEditorContext context)
       {
           if (context.GroupId == GroupId)
           {
               await context.Updater.TryUpdateModelAsync(section, Prefix);

               // Release the tenant to apply the settings
               await _shellHost.ReleaseShellContextAsync(_shellSettings);
           }

           return await EditAsync(section, context);
       }
   }

ok I finally figured it out, but now how do i update SiteSettings from the StartupBase.cs?
Trying to get the settings throws an exception

        public override void ConfigureServices(IServiceCollection services)
        {
            //services.AddTransient<IConfigureOptions<TestSettings>, TestSettingsConfiguration>();
            //services.AddTransient<IPostConfigureOptions<TestSettings>, TestSettingsConfiguration>();

            services.AddScoped<IDisplayDriver<ISite>, TestSettingsDisplayDriver>();
            services.AddScoped<INavigationProvider, AdminMenu>();

            services.AddTransient<IPostConfigureOptions<TestSettings>, TestSettingsConfiguration>();

            var site = services.BuildServiceProvider().GetRequiredService<ISiteService>();
            var settings = site
                .LoadSiteSettingsAsync()
                .GetAwaiter()
                .GetResult();

        }

   at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService(IServiceProvider provider, Type serviceType)
   at OrchardCore.Documents.DocumentManager`1.get_DocumentStore()
   at OrchardCore.Documents.DocumentManager`1.<GetOrCreateMutableAsync>d__14.MoveNext()
   at 

[weirdyang]

Ok this is the full code to acheive what I want:

1. to initialize site settings from appsettings if it available,
2. be able to display the settings
3. allow it to be configured if the appsettings section is missing.

Hopefully someone else finds it useful

    [Feature("CustomSettings.TestSettings")]
    public class Startup : StartupBase
    {
        public IConfiguration Configuration { get; }

        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public override async void ConfigureServices(IServiceCollection services)
        {
            services.AddScoped<IDisplayDriver<ISite>, TestSettingsDisplayDriver>();
            services.AddScoped<INavigationProvider, AdminMenu>();
            services.AddTransient<IConfigureOptions<TestSettings>, TestSettingsConfiguration>();
            services.AddTransient<IPostConfigureOptions<TestSettings>, TestSettingsConfiguration>();
            services.AddScoped<IModularTenantEvents, CustomSettingStartupTaskService>();
        }
    }
    public class CustomSettingStartupTaskService : ModularTenantEvents
    {
        private readonly ILogger<CustomSettingStartupTaskService> _logger;
        private readonly ISiteService _siteService;
        private readonly IShellConfiguration _shellConfig;
        private readonly IServiceProvider _provider;
        private readonly IOptions<TestSettings> _options;
        public CustomSettingStartupTaskService(
            ILogger<CustomSettingStartupTaskService> logger,
            IShellConfiguration shellConfiguration,
            ISiteService siteService,
            IServiceProvider serviceProvider,
            IOptions<TestSettings> options)
        {
            _logger = logger;
            _shellConfig = shellConfiguration;
            _siteService = siteService;
            _provider = serviceProvider;
            _options = options;
        }

        public override Task ActivatingAsync()
        {

            return InitializeAsync();

        }

        public async Task InitializeAsync()
        {
            try
            {
                // priority:
                // 1. AppData/Tenant/appsettings.json
                // 2. AppData/appsettings.json
                // 3. appsettings.json
                if (!_shellConfig.GetSection(nameof(TestSettings)).Exists())
                {
                    _logger.LogCritical("Unable to initialize TestSettings, appsettings is missing section");
                    return;
                }
                var container = await _siteService.LoadSiteSettingsAsync();

                container.Properties[nameof(TestSettings)] = JObject
                    .FromObject(
                    _options.Value
                    );
                await _siteService.UpdateSiteSettingsAsync(container);
            }
            catch (Exception ex)
            {

                _logger.LogCritical(ex, "Unable to initialize TestSettings");
            }

        }
    }
    class AdminMenu : INavigationProvider
    {
        private readonly IStringLocalizer S;
        public AdminMenu(
            IStringLocalizer<AdminMenu> localizer)
        {
            S = localizer;
        }


        public Task BuildNavigationAsync(string name, NavigationBuilder builder)
        {
            //InitializeSettings();
            if (!String.Equals(name, "admin", StringComparison.OrdinalIgnoreCase))
                return Task.CompletedTask;

            builder
                .Add(S["Configuration"], configuration => configuration
                    .Add(S["Settings"], settings => settings
                       .Add(S["Test Settings"], S["Test Settings"].PrefixPosition(), entry => entry
                       .AddClass("restriction").Id("restriction")
                          .Action("Index", "Admin", new { area = "OrchardCore.Settings", groupId = TestSettingsDisplayDriver.GroupId })
                          .Permission(StandardPermissions.SiteOwner)
                          .LocalNav()
                )));

            return Task.CompletedTask;
        }
    }
    public class TestSettings
    {
        public string RandomString { get; set; }
    }
    public class TestSettingsConfiguration :
        IPostConfigureOptions<TestSettings>,
        IConfigureOptions<TestSettings>
    {
        private readonly ISiteService _site;
        private readonly IShellConfiguration _shellConfiguration;
        public TestSettingsConfiguration(
            ISiteService site,
            IShellConfiguration shellConfiguration)
        {
            _site = site;
            _shellConfiguration = shellConfiguration;
        }

        public void Configure(TestSettings options)
        {
            var settings = _site.GetSiteSettingsAsync()
                .GetAwaiter().GetResult()
                .As<TestSettings>();

            options = settings is null ? new TestSettings() : settings;
        }

        public void PostConfigure(string name, TestSettings options)
        {
            if (_shellConfiguration.GetSection(nameof(TestSettings)).Exists())
            {
                _shellConfiguration
                    .GetSection(nameof(TestSettings))
                    .Bind(options);
            }
        }
    }
    public class TestSettingsDisplayDriver : SectionDisplayDriver<ISite, TestSettings>
    {
        public const string GroupId = "TestSettings";
        private readonly IShellHost _shellHost;
        private readonly ShellSettings _shellSettings;
        private readonly TestSettings _settings;

        public TestSettingsDisplayDriver(
            IShellHost shellHost,
            ShellSettings shellSettings,
            IOptions<TestSettings> settings)
        {
            _shellHost = shellHost;
            _shellSettings = shellSettings;
            _settings = settings.Value;
        }

        public override async Task<IDisplayResult> EditAsync(TestSettings settings, BuildEditorContext context)
        {

            var shapes = new List<IDisplayResult>
            {
                Initialize<TestSettings>("TestSettings_Edit", model =>
                {
                    model.RandomString = _settings.RandomString ?? settings.RandomString;
                }).Location("Content:5").OnGroup(GroupId),
            };

            return Combine(shapes);
        }

        public override async Task<IDisplayResult> UpdateAsync(TestSettings section, BuildEditorContext context)
        {
            if (context.GroupId == GroupId)
            {
                await context.Updater.TryUpdateModelAsync(section, Prefix);

                // Release the tenant to apply the settings
                await _shellHost.ReleaseShellContextAsync(_shellSettings);
            }

            return await EditAsync(section, context);
        }
    }

Views/Items/TestSettings.Edit.cshtml

@model XMLParserTaskModule.TestSettings
@using Microsoft.Extensions.Configuration
@inject OrchardCore.Environment.Shell.Configuration.IShellConfiguration configuration

@{
    var disabled = configuration.GetSection("TestSettings").Exists()
            ? "disabled"
            : "";
}
<fieldset @disabled>
    <div class="form-group" asp-validation-class-for="RandomString">
        <label asp-for="RandomString">@T["Random String"]</label>
        <input asp-for="RandomString" class="form-control" type="text" />
        <span asp-validation-for="RandomString"></span>
        <span class="hint">@T["This sets a random string"]</span>
    </div>
</fieldset>