I18NCommander/I18N Commander/Processor/AppSettings.cs

using DataModel.Database;
using DataModel.Database.Common;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

namespace Processor;

public static class AppSettings
{
    #region DeepL Mode

    public static async Task SetDeepLMode(SettingDeepLMode mode)
    {
        // Convert the enum to its int value:
        var intValue = (int)mode;
        
        // 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.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<SettingDeepLMode> GetDeepLMode()
    {
        // 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.DEEPL_MODE) is { } existingSetting)
            return (SettingDeepLMode) existingSetting.IntegerValue;

        // Does not exist, so create it:
        var setting = new Setting
        {
            Code = SettingNames.DEEPL_MODE,
            IntegerValue = (int)SettingDeepLMode.DISABLED,
        };
            
        await db.Settings.AddAsync(setting);
        await db.SaveChangesAsync();
        
        return (SettingDeepLMode) setting.IntegerValue;
    }

    #endregion
    
    #region DeepL API Key
    
    public static async Task SetDeepLAPIKey(string apiKey)
    {
        // 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.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<string> GetDeepLAPIKey()
    {
        // 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.DEEPL_API_KEY) is { } existingSetting)
            return existingSetting.TextValue;
        
        // Does not exist, so create it:
        var setting = new Setting
        {
            Code = SettingNames.DEEPL_API_KEY,
            TextValue = string.Empty,
        };
            
        await db.Settings.AddAsync(setting);
        await db.SaveChangesAsync();
        
        return setting.TextValue;
    }
    
    #endregion
    
    #region DeepL Action
    
    public static async Task SetDeepLAction(SettingDeepLAction action)
    {
        // Convert the enum to its int value:
        var intValue = (int)action;
        
        // 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.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<SettingDeepLAction> GetDeepLAction()
    {
        // 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.DEEPL_ACTION) is { } existingSetting)
            return (SettingDeepLAction) existingSetting.IntegerValue;
        
        // Does not exist, so create it:
        var setting = new Setting
        {
            Code = SettingNames.DEEPL_ACTION,
            IntegerValue = (int)SettingDeepLAction.MANUAL,
        };
            
        await db.Settings.AddAsync(setting);
        await db.SaveChangesAsync();
        
        return (SettingDeepLAction) setting.IntegerValue;
    }
    
    #endregion
}