From 53f98d4e3c8c406478e329683fccbabadc34ebc2 Mon Sep 17 00:00:00 2001 From: Thorsten Sommer Date: Tue, 1 Nov 2022 12:28:51 +0100 Subject: [PATCH] Refactored setting processing --- I18N Commander/Processor/AppSettings.cs | 934 +++++------------------- 1 file changed, 180 insertions(+), 754 deletions(-) diff --git a/I18N Commander/Processor/AppSettings.cs b/I18N Commander/Processor/AppSettings.cs index 20051b7..fc3e43f 100644 --- a/I18N Commander/Processor/AppSettings.cs +++ b/I18N Commander/Processor/AppSettings.cs @@ -7,312 +7,200 @@ namespace Processor; public static class AppSettings { + #region Common DB Code + + private static readonly Dictionary CACHES = new(); + private static readonly Dictionary CACHE_LOADED = new(); + + private static async Task GetSetting(string settingName, T defaultValue) + { + // When possible, use the cache: + if (CACHE_LOADED.ContainsKey(settingName) && CACHE_LOADED[settingName]) + return (T)CACHES[settingName]; + + var settingValue = defaultValue; + try + { + // Get the database: + await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); + + // Check, if the setting is already set: + if (await db.Settings.FirstOrDefaultAsync(n => n.Code == settingName) is { } existingSetting) + { + settingValue = settingValue switch + { + bool => (T)(object)existingSetting.BoolValue, + string => (T)(object)existingSetting.TextValue, + int => (T)(object)existingSetting.IntegerValue, + Guid => (T)(object)existingSetting.GuidValue, + + SettingDeepLMode or + SettingDeepLAction or + SettingGeneratorMode => (T)(object)existingSetting.IntegerValue, + + _ => defaultValue, + }; + return settingValue; + } + + // Does not exist, so create it: + var setting = new Setting + { + Code = settingName, + }; + + switch (settingValue) + { + case bool: + setting.BoolValue = (bool)(object)settingValue; + break; + + case string: + setting.TextValue = (string)(object)settingValue; + break; + + case int: + setting.IntegerValue = (int)(object)settingValue; + break; + + case Guid: + setting.GuidValue = (Guid)(object)settingValue; + break; + + case SettingDeepLMode: + case SettingDeepLAction: + case SettingGeneratorMode: + setting.IntegerValue = (int)(object)settingValue; + break; + } + + await db.Settings.AddAsync(setting); + await db.SaveChangesAsync(); + return settingValue; + } + finally + { + CACHE_LOADED[settingName] = true; + CACHES[settingName] = settingValue!; + } + } + + public static async Task SetSetting(string settingName, T settingValue) + { + // Update the cache: + CACHES[settingName] = settingValue!; + CACHE_LOADED[settingName] = true; + + // Get the database: + await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); + + // Check, if the setting is already set: + if (await db.Settings.FirstOrDefaultAsync(n => n.Code == settingName) is { } existingSetting) + { + switch (settingValue) + { + case bool: + existingSetting.BoolValue = (bool)(object)settingValue; + break; + + case string: + existingSetting.TextValue = (string)(object)settingValue; + break; + + case int: + existingSetting.IntegerValue = (int)(object)settingValue; + break; + + case Guid: + existingSetting.GuidValue = (Guid)(object)settingValue; + break; + + case SettingDeepLMode: + case SettingDeepLAction: + case SettingGeneratorMode: + existingSetting.IntegerValue = (int)(object)settingValue; + break; + } + await db.SaveChangesAsync(); + } + + // Does not exist, so create it: + else + { + var setting = new Setting + { + Code = SettingNames.GENERATOR_DOTNET_ENABLED, + }; + + switch (settingValue) + { + case bool: + setting.BoolValue = (bool)(object)settingValue; + break; + + case string: + setting.TextValue = (string)(object)settingValue; + break; + + case int: + setting.IntegerValue = (int)(object)settingValue; + break; + + case Guid: + setting.GuidValue = (Guid)(object)settingValue; + break; + + case SettingDeepLMode: + case SettingDeepLAction: + case SettingGeneratorMode: + setting.IntegerValue = (int)(object)settingValue; + break; + } + + await db.Settings.AddAsync(setting); + await db.SaveChangesAsync(); + } + } + + #endregion + #region DeepL Settings #region DeepL Mode - private static SettingDeepLMode CACHE_DEEPL_MODE = SettingDeepLMode.DISABLED; - private static bool CACHE_DEEPL_MODE_IS_LOADED = false; - - public static async Task SetDeepLMode(SettingDeepLMode mode) - { - // Convert the enum to its int value: - var intValue = (int)mode; - - // Update the cache: - CACHE_DEEPL_MODE = mode; - CACHE_DEEPL_MODE_IS_LOADED = true; - - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_MODE) is {} existingSetting) - { - existingSetting.IntegerValue = intValue; - await db.SaveChangesAsync(); - } - - // Does not exist, so create it: - else - { - var setting = new Setting - { - Code = SettingNames.DEEPL_MODE, - IntegerValue = intValue, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - } - } + public static async Task SetDeepLMode(SettingDeepLMode mode) => await AppSettings.SetSetting(SettingNames.DEEPL_MODE, mode); - public static async Task GetDeepLMode() - { - if (CACHE_DEEPL_MODE_IS_LOADED) - return CACHE_DEEPL_MODE; - - var mode = SettingDeepLMode.DISABLED; - try - { - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_MODE) is { } existingSetting) - { - mode = (SettingDeepLMode) existingSetting.IntegerValue; - return mode; - } - - // Does not exist, so create it: - var setting = new Setting - { - Code = SettingNames.DEEPL_MODE, - IntegerValue = (int) mode, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - return mode; - } - finally - { - CACHE_DEEPL_MODE = mode; - CACHE_DEEPL_MODE_IS_LOADED = true; - } - } + public static async Task GetDeepLMode() => await AppSettings.GetSetting(SettingNames.DEEPL_MODE, SettingDeepLMode.DISABLED); #endregion #region DeepL API Key - - private static string CACHE_DEEPL_API_KEY = string.Empty; - private static bool CACHE_DEEPL_API_KEY_IS_LOADED = false; - - public static async Task SetDeepLAPIKey(string apiKey) - { - // Update the cache: - CACHE_DEEPL_API_KEY = apiKey; - CACHE_DEEPL_API_KEY_IS_LOADED = true; - - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_API_KEY) is {} existingSetting) - { - existingSetting.TextValue = apiKey; - await db.SaveChangesAsync(); - } - - // Does not exist, so create it: - else - { - var setting = new Setting - { - Code = SettingNames.DEEPL_API_KEY, - TextValue = apiKey, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - } - } - - public static async Task GetDeepLAPIKey() - { - // Check the cache: - if (CACHE_DEEPL_API_KEY_IS_LOADED) - return CACHE_DEEPL_API_KEY; - var key = string.Empty; - try - { - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); + public static async Task SetDeepLAPIKey(string apiKey) => await AppSettings.SetSetting(SettingNames.DEEPL_API_KEY, apiKey); - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_API_KEY) is { } existingSetting) - { - key = existingSetting.TextValue; - return key; - } + public static async Task GetDeepLAPIKey() => await AppSettings.GetSetting(SettingNames.DEEPL_API_KEY, string.Empty); - // Does not exist, so create it: - var setting = new Setting - { - Code = SettingNames.DEEPL_API_KEY, - TextValue = key, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - return key; - } - finally - { - CACHE_DEEPL_API_KEY = key; - CACHE_DEEPL_API_KEY_IS_LOADED = true; - } - } - #endregion #region DeepL Action - - private static SettingDeepLAction CACHE_DEEPL_ACTION = SettingDeepLAction.MANUAL; - private static bool CACHE_DEEPL_ACTION_IS_LOADED = false; - public static async Task SetDeepLAction(SettingDeepLAction action) - { - // Convert the enum to its int value: - var intValue = (int)action; - - // Update the cache: - CACHE_DEEPL_ACTION = action; - CACHE_DEEPL_ACTION_IS_LOADED = true; - - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_ACTION) is {} existingSetting) - { - existingSetting.IntegerValue = intValue; - await db.SaveChangesAsync(); - } - - // Does not exist, so create it: - else - { - var setting = new Setting - { - Code = SettingNames.DEEPL_ACTION, - IntegerValue = intValue, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - } - } - - public static async Task GetDeepLAction() - { - // Check the cache: - if (CACHE_DEEPL_ACTION_IS_LOADED) - return CACHE_DEEPL_ACTION; - - var action = SettingDeepLAction.MANUAL; - try - { - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); + public static async Task SetDeepLAction(SettingDeepLAction action) => await AppSettings.SetSetting(SettingNames.DEEPL_ACTION, action); - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_ACTION) is { } existingSetting) - { - action = (SettingDeepLAction) existingSetting.IntegerValue; - return action; - } + public static async Task GetDeepLAction() => await AppSettings.GetSetting(SettingNames.DEEPL_ACTION, SettingDeepLAction.MANUAL); - // Does not exist, so create it: - var setting = new Setting - { - Code = SettingNames.DEEPL_ACTION, - IntegerValue = (int) action, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - return action; - } - finally - { - CACHE_DEEPL_ACTION = action; - CACHE_DEEPL_ACTION_IS_LOADED = true; - } - } - #endregion #region DeepL Source Culture - private static int CACHE_DEEPL_SOURCE_CULTURE = -1; - private static bool CACHE_DEEPL_SOURCE_CULTURE_IS_LOADED = false; - - public static async Task SetDeepLSourceCultureIndex(int cultureIndex) - { - // Update the cache: - CACHE_DEEPL_SOURCE_CULTURE = cultureIndex; - CACHE_DEEPL_SOURCE_CULTURE_IS_LOADED = true; - - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_SOURCE_CULTURE) is {} existingSetting) - { - existingSetting.IntegerValue = cultureIndex; - await db.SaveChangesAsync(); - } - - // Does not exist, so create it: - else - { - var setting = new Setting - { - Code = SettingNames.DEEPL_SOURCE_CULTURE, - IntegerValue = cultureIndex, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - } - } - - public static async Task GetDeepLSourceCultureIndex() - { - // Check the cache: - if (CACHE_DEEPL_SOURCE_CULTURE_IS_LOADED) - return CACHE_DEEPL_SOURCE_CULTURE; - - var cultureIndex = -1; - try - { - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); + public static async Task SetDeepLSourceCultureIndex(int cultureIndex) => await AppSettings.SetSetting(SettingNames.DEEPL_SOURCE_CULTURE, cultureIndex); - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_SOURCE_CULTURE) is { } existingSetting) - { - cultureIndex = existingSetting.IntegerValue; - return cultureIndex; - } + public static async Task GetDeepLSourceCultureIndex() => await AppSettings.GetSetting(SettingNames.DEEPL_SOURCE_CULTURE, -1); - // Does not exist, so create it: - var setting = new Setting - { - Code = SettingNames.DEEPL_SOURCE_CULTURE, - IntegerValue = cultureIndex, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - return cultureIndex; - } - finally - { - CACHE_DEEPL_SOURCE_CULTURE = cultureIndex; - CACHE_DEEPL_SOURCE_CULTURE_IS_LOADED = true; - } - } - #endregion #endregion - #region Translation Settings + #region Culture Settings #region List of culture indices @@ -465,519 +353,57 @@ public static class AppSettings #region Generator Mode - private static SettingGeneratorMode CACHE_GENERATOR_MODE = SettingGeneratorMode.MANUAL; - private static bool CACHE_GENERATOR_MODE_IS_LOADED = false; + public static async Task GetGeneratorMode() => await AppSettings.GetSetting(SettingNames.GENERATOR_MODE, SettingGeneratorMode.MANUAL); - public static async Task GetGeneratorMode() - { - // When possible, use the cache: - if (CACHE_GENERATOR_MODE_IS_LOADED) - return CACHE_GENERATOR_MODE; + public static async Task SetGeneratorMode(SettingGeneratorMode mode) => await AppSettings.SetSetting(SettingNames.GENERATOR_MODE, mode); - var generatorMode = SettingGeneratorMode.MANUAL; - try - { - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_MODE) is { } existingSetting) - { - generatorMode = (SettingGeneratorMode) existingSetting.IntegerValue; - return generatorMode; - } - - // Does not exist, so create it: - var setting = new Setting - { - Code = SettingNames.GENERATOR_MODE, - IntegerValue = (int) generatorMode, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - return generatorMode; - } - finally - { - CACHE_GENERATOR_MODE_IS_LOADED = true; - CACHE_GENERATOR_MODE = generatorMode; - } - } - - public static async Task SetGeneratorMode(SettingGeneratorMode mode) - { - // Update the cache: - CACHE_GENERATOR_MODE = mode; - CACHE_GENERATOR_MODE_IS_LOADED = true; - - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_MODE) is { } existingSetting) - { - existingSetting.IntegerValue = (int) mode; - await db.SaveChangesAsync(); - } - - // Does not exist, so create it: - else - { - var setting = new Setting - { - Code = SettingNames.GENERATOR_MODE, - IntegerValue = (int) mode, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - } - } - #endregion #region .NET Generator Enabled/Disabled - private static bool CACHE_GENERATOR_DOTNET_ENABLED = true; - private static bool CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED = false; - - public static async Task GetGeneratorDotnetEnabled() - { - // When possible, use the cache: - if (CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED) - return CACHE_GENERATOR_DOTNET_ENABLED; + public static async Task GetGeneratorDotnetEnabled() => await AppSettings.GetSetting(SettingNames.GENERATOR_DOTNET_ENABLED, false); - var generatorDotnetEnabled = false; - try - { - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_ENABLED) is { } existingSetting) - { - generatorDotnetEnabled = existingSetting.BoolValue; - return generatorDotnetEnabled; - } - - // Does not exist, so create it: - var setting = new Setting - { - Code = SettingNames.GENERATOR_DOTNET_ENABLED, - BoolValue = generatorDotnetEnabled, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - return generatorDotnetEnabled; - } - finally - { - CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED = true; - CACHE_GENERATOR_DOTNET_ENABLED = generatorDotnetEnabled; - } - } - - public static async Task SetGeneratorDotnetEnabled(bool enabled) - { - // Update the cache: - CACHE_GENERATOR_DOTNET_ENABLED = enabled; - CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED = true; - - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_ENABLED) is { } existingSetting) - { - existingSetting.BoolValue = enabled; - await db.SaveChangesAsync(); - } - - // Does not exist, so create it: - else - { - var setting = new Setting - { - Code = SettingNames.GENERATOR_DOTNET_ENABLED, - BoolValue = enabled, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - } - } + public static async Task SetGeneratorDotnetEnabled(bool enabled) => await AppSettings.SetSetting(SettingNames.GENERATOR_DOTNET_ENABLED, enabled); #endregion #region .NET Generator Destination Path - - private static string CACHE_GENERATOR_DOTNET_DESTINATION_PATH = string.Empty; - private static bool CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED = false; - - public static async Task GetGeneratorDotnetDestinationPath() - { - // When possible, use the cache: - if (CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED) - return CACHE_GENERATOR_DOTNET_DESTINATION_PATH; - var generatorDotnetDestinationPath = string.Empty; - try - { - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); + public static async Task GetGeneratorDotnetDestinationPath() => await AppSettings.GetSetting(SettingNames.GENERATOR_DOTNET_DESTINATION_PATH, string.Empty); - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_DESTINATION_PATH) is { } existingSetting) - { - generatorDotnetDestinationPath = existingSetting.TextValue; - return generatorDotnetDestinationPath; - } + public static async Task SetGeneratorDotnetDestinationPath(string path) => await AppSettings.SetSetting(SettingNames.GENERATOR_DOTNET_DESTINATION_PATH, path); - // Does not exist, so create it: - var setting = new Setting - { - Code = SettingNames.GENERATOR_DOTNET_DESTINATION_PATH, - TextValue = generatorDotnetDestinationPath, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - return generatorDotnetDestinationPath; - } - finally - { - CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED = true; - CACHE_GENERATOR_DOTNET_DESTINATION_PATH = generatorDotnetDestinationPath; - } - } - - public static async Task SetGeneratorDotnetDestinationPath(string path) - { - // Update the cache: - CACHE_GENERATOR_DOTNET_DESTINATION_PATH = path; - CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED = true; - - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_DESTINATION_PATH) is { } existingSetting) - { - existingSetting.TextValue = path; - await db.SaveChangesAsync(); - } - - // Does not exist, so create it: - else - { - var setting = new Setting - { - Code = SettingNames.GENERATOR_DOTNET_DESTINATION_PATH, - TextValue = path, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - } - } - #endregion #region .NET Generator Namespace - - private static string CACHE_GENERATOR_DOTNET_NAMESPACE = string.Empty; - private static bool CACHE_GENERATOR_DOTNET_NAMESPACE_IS_LOADED = false; - - public static async Task GetGeneratorDotnetNamespace() - { - // When possible, use the cache: - if (CACHE_GENERATOR_DOTNET_NAMESPACE_IS_LOADED) - return CACHE_GENERATOR_DOTNET_NAMESPACE; - var generatorDotnetNamespace = "I18N"; - try - { - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); + public static async Task GetGeneratorDotnetNamespace() => await AppSettings.GetSetting(SettingNames.GENERATOR_DOTNET_NAMESPACE, "I18N"); - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_NAMESPACE) is { } existingSetting) - { - generatorDotnetNamespace = existingSetting.TextValue; - return generatorDotnetNamespace; - } - - // Does not exist, so create it: - var setting = new Setting - { - Code = SettingNames.GENERATOR_DOTNET_NAMESPACE, - TextValue = generatorDotnetNamespace, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - return generatorDotnetNamespace; - } - finally - { - CACHE_GENERATOR_DOTNET_NAMESPACE_IS_LOADED = true; - CACHE_GENERATOR_DOTNET_NAMESPACE = generatorDotnetNamespace; - } - } - - public static async Task SetGeneratorDotnetNamespace(string updatedNamespace) - { - // Update the cache: - CACHE_GENERATOR_DOTNET_NAMESPACE = updatedNamespace; - CACHE_GENERATOR_DOTNET_NAMESPACE_IS_LOADED = true; - - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_NAMESPACE) is { } existingSetting) - { - existingSetting.TextValue = updatedNamespace; - await db.SaveChangesAsync(); - } - - // Does not exist, so create it: - else - { - var setting = new Setting - { - Code = SettingNames.GENERATOR_DOTNET_NAMESPACE, - TextValue = updatedNamespace, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - } - } + public static async Task SetGeneratorDotnetNamespace(string updatedNamespace) => await AppSettings.SetSetting(SettingNames.GENERATOR_DOTNET_NAMESPACE, updatedNamespace); #endregion #region .NET Generator Default Culture - private static int CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE = -1; - private static bool CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE_IS_LOADED = false; - - public static async Task GetGeneratorDotnetDefaultCultureIndex() - { - // When possible, use the cache: - if (CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE_IS_LOADED) - return CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE; + public static async Task GetGeneratorDotnetDefaultCultureIndex() => await AppSettings.GetSetting(SettingNames.GENERATOR_DOTNET_DEFAULT_CULTURE, 0); - var generatorDotnetDefaultCulture = 0; - try - { - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); + public static async Task SetGeneratorDotnetDefaultCultureIndex(int updatedCulture) => await AppSettings.SetSetting(SettingNames.GENERATOR_DOTNET_DEFAULT_CULTURE, updatedCulture); - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_DEFAULT_CULTURE) is { } existingSetting) - { - generatorDotnetDefaultCulture = existingSetting.IntegerValue; - return generatorDotnetDefaultCulture; - } - - // Does not exist, so create it: - var setting = new Setting - { - Code = SettingNames.GENERATOR_DOTNET_DEFAULT_CULTURE, - IntegerValue = generatorDotnetDefaultCulture, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - return generatorDotnetDefaultCulture; - } - finally - { - CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE_IS_LOADED = true; - CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE = generatorDotnetDefaultCulture; - } - } - - public static async Task SetGeneratorDotnetDefaultCultureIndex(int updatedCulture) - { - // Update the cache: - CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE = updatedCulture; - CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE_IS_LOADED = true; - - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_DEFAULT_CULTURE) is { } existingSetting) - { - existingSetting.IntegerValue = updatedCulture; - await db.SaveChangesAsync(); - } - - // Does not exist, so create it: - else - { - var setting = new Setting - { - Code = SettingNames.GENERATOR_DOTNET_DEFAULT_CULTURE, - IntegerValue = updatedCulture, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - } - } - #endregion #region Godot Generator Enabled/Disabled - private static bool CACHE_GENERATOR_GODOT_ENABLED = true; - private static bool CACHE_GENERATOR_GODOT_ENABLED_IS_LOADED = false; - - public static async Task GetGeneratorGodotEnabled() - { - // When possible, use the cache: - if (CACHE_GENERATOR_GODOT_ENABLED_IS_LOADED) - return CACHE_GENERATOR_GODOT_ENABLED; + public static async Task GetGeneratorGodotEnabled() => await AppSettings.GetSetting(SettingNames.GENERATOR_GODOT_ENABLED, false); - var generatorGodotEnabled = false; - try - { - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_GODOT_ENABLED) is { } existingSetting) - { - generatorGodotEnabled = existingSetting.BoolValue; - return generatorGodotEnabled; - } - - // Does not exist, so create it: - var setting = new Setting - { - Code = SettingNames.GENERATOR_GODOT_ENABLED, - BoolValue = generatorGodotEnabled, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - return generatorGodotEnabled; - } - finally - { - CACHE_GENERATOR_GODOT_ENABLED_IS_LOADED = true; - CACHE_GENERATOR_GODOT_ENABLED = generatorGodotEnabled; - } - } - - public static async Task SetGeneratorGodotEnabled(bool enabled) - { - // Update the cache: - CACHE_GENERATOR_GODOT_ENABLED = enabled; - CACHE_GENERATOR_GODOT_ENABLED_IS_LOADED = true; - - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_GODOT_ENABLED) is { } existingSetting) - { - existingSetting.BoolValue = enabled; - await db.SaveChangesAsync(); - } - - // Does not exist, so create it: - else - { - var setting = new Setting - { - Code = SettingNames.GENERATOR_GODOT_ENABLED, - BoolValue = enabled, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - } - } + public static async Task SetGeneratorGodotEnabled(bool enabled) => await AppSettings.SetSetting(SettingNames.GENERATOR_GODOT_ENABLED, enabled); #endregion #region Godot Generator Destination Path - private static string CACHE_GENERATOR_GODOT_DESTINATION_PATH = string.Empty; - private static bool CACHE_GENERATOR_GODOT_DESTINATION_PATH_IS_LOADED = false; - - public static async Task GetGeneratorGodotDestinationPath() - { - // When possible, use the cache: - if (CACHE_GENERATOR_GODOT_DESTINATION_PATH_IS_LOADED) - return CACHE_GENERATOR_GODOT_DESTINATION_PATH; + public static async Task GetGeneratorGodotDestinationPath() => await AppSettings.GetSetting(SettingNames.GENERATOR_GODOT_DESTINATION_PATH, string.Empty); - var generatorGodotDestinationPath = string.Empty; - try - { - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_GODOT_DESTINATION_PATH) is { } existingSetting) - { - generatorGodotDestinationPath = existingSetting.TextValue; - return generatorGodotDestinationPath; - } - - // Does not exist, so create it: - var setting = new Setting - { - Code = SettingNames.GENERATOR_GODOT_DESTINATION_PATH, - TextValue = generatorGodotDestinationPath, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - return generatorGodotDestinationPath; - } - finally - { - CACHE_GENERATOR_GODOT_DESTINATION_PATH_IS_LOADED = true; - CACHE_GENERATOR_GODOT_DESTINATION_PATH = generatorGodotDestinationPath; - } - } - - public static async Task SetGeneratorGodotDestinationPath(string path) - { - // Update the cache: - CACHE_GENERATOR_GODOT_DESTINATION_PATH = path; - CACHE_GENERATOR_GODOT_DESTINATION_PATH_IS_LOADED = true; - - // Get the database: - await using var db = ProcessorMeta.ServiceProvider.GetRequiredService(); - - // Check, if the setting is already set: - if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_GODOT_DESTINATION_PATH) is { } existingSetting) - { - existingSetting.TextValue = path; - await db.SaveChangesAsync(); - } - - // Does not exist, so create it: - else - { - var setting = new Setting - { - Code = SettingNames.GENERATOR_GODOT_DESTINATION_PATH, - TextValue = path, - }; - - await db.Settings.AddAsync(setting); - await db.SaveChangesAsync(); - } - } + public static async Task SetGeneratorGodotDestinationPath(string path) => await AppSettings.SetSetting(SettingNames.GENERATOR_GODOT_DESTINATION_PATH, path); #endregion