Implemented .NET generator settings

I18N Commander/Processor/AppSettings.cs

@@ -537,5 +537,153 @@ public static class AppSettings
     
     #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<bool> GetGeneratorDotnetEnabled()
+    {
+        // When possible, use the cache:
+        if (CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED)
+            return CACHE_GENERATOR_DOTNET_ENABLED;
+
+        var generatorDotnetEnabled = false;
+        try
+        {
+            // Get the database:
+            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
+
+            // 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<DataContext>();
+        
+        // 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();
+        }
+    }
+
+    #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<string> 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<DataContext>();
+
+            // 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;
+            }
+
+            // 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<DataContext>();
+        
+        // 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
+
     #endregion
 }