Implement automatic configuration of client (#39)

* Implement initial remote configurability

Code quality is not in mind as of yet - this is merely a test to see if remote configuration works at all.

* Cleanup and reorganization of remote configuration components

* Ordering visual nitpick in LighthouseClient constructor

* Remove mixed JSON lib and attributes

JsonObjectAttribute isn't required

* Move LighthouseApiImpl into Types.Interfaces

* Update README to reflect remote configurability

* Temporarily deprecate local configurability

* Disable config unit test and address code scan warnings

* Use SerializableAttribute instead of UsedImplicitlyAttribute

* Remove nullable annotation from PartyIdPrefix

* Remove default value locking from GUI

* Move entity and config enums to Types.Enums

This is to help with organization mostly - and the fact that these enums could be used elsewhere and you may not want to reference the entire Slot entity for example to access that enum.

* Nitpick remote config failure log message

* Move log enricher to a subclass in Logger

* Add nullable asset warning and change most fail logs to errors

* MainForm class doesn't really need to be sealed

* Reflect changes in LBPUnion/ProjectLighthouse@1003d59

* Implement Refresh integration testing

* Finalize changes from testing and add missing JsonPropertyName attribs

* Add success log for remote configuration retrieval

PLRPC.CLI/Program.cs

@@ -1,7 +1,6 @@
 using CommandLine;
 using JetBrains.Annotations;
 using LBPUnion.PLRPC.Helpers;
-using LBPUnion.PLRPC.Types.Configuration;
 using LBPUnion.PLRPC.Types.Logging;
 
 namespace LBPUnion.PLRPC.CLI;
@@ -13,86 +12,45 @@ public static class Program
 
     private static ParserResult<CommandLineArguments> parserResult;
 
-    private static PlrpcConfiguration config;
-
     private static string serverUrl;
     private static string username;
-    private static string applicationId;
 
     public static async Task Main(string[] args)
     {
         parserResult = Parser.Default.ParseArguments<CommandLineArguments>(args);
 
         await parserResult.MapResult(async arguments =>
-        {
-            switch (arguments)
-            {
-                case { UseConfig: true}: await RunConfigurationMode(); break;
-                case { UseConfig: false }: await RunFlagMode(); break;
-            }
-        }, _ => Task.CompletedTask);
-    }
-
-    private static async Task RunConfigurationMode()
-    {
-        config = await new Configuration(logger).LoadFromConfiguration();
-
-        if (config == null)
-        {
-            logger.Fatal("Failed to load configuration file, please check your entries.", LogArea.Configuration);
-            return;
-        }
-
-        serverUrl = config.ServerUrl;
-        username = config.Username;
-        applicationId = config.ApplicationId;
-
-        await new Initializer(logger, updater).InitializeLighthouseClient(serverUrl, username, applicationId);
-    }
-
-    private static async Task RunFlagMode()
-    {
-        parserResult.WithParsed(arguments =>
         {
             serverUrl = arguments.ServerUrl;
             username = arguments.Username;
-            applicationId = arguments.ApplicationId;
-        });
-
-        bool isValidUsername = username != null && ValidationHelper.IsValidUsername(username);
-        bool isValidServerUrl = serverUrl != null && ValidationHelper.IsValidUrl(serverUrl);
+
+            bool isValidUsername = username != null && ValidationHelper.IsValidUsername(username);
+            bool isValidServerUrl = serverUrl != null && ValidationHelper.IsValidUrl(serverUrl);
 
-        if (!isValidUsername || !isValidServerUrl)
-        {
-            logger.Fatal("Server URL and/or username are invalid or were not specified.", LogArea.Configuration);
-            return;
-        }
+            if (!isValidUsername || !isValidServerUrl)
+            {
+                logger.Fatal("Server URL and/or username are invalid or were not specified.", LogArea.Configuration);
+                return;
+            }
 
-        await new Initializer(logger, updater).InitializeLighthouseClient(serverUrl, username, applicationId);
+            await new Initializer(logger, updater).InitializeLighthouseClient(serverUrl, username);
+        }, _ => Task.CompletedTask);
     }
 
     [UsedImplicitly]
     #nullable enable
     public class CommandLineArguments
     {
-        public CommandLineArguments(bool useConfig, string? serverUrl, string? username, string? applicationId)
+        public CommandLineArguments(string? serverUrl, string? username)
         {
-            this.UseConfig = useConfig;
             this.ServerUrl = serverUrl;
             this.Username = username;
-            this.ApplicationId = applicationId ?? "1060973475151495288"; // default to ProjectLighthouse app ID
         }
 
-        [Option('c', "config", Required = false, HelpText = "Use a configuration file.")]
-        public bool UseConfig { get; }
-
-        [Option('s', "server", Required = false, HelpText = "The URL of the server to connect to.")]
+        [Option('s', "server", Required = true, HelpText = "The URL of the server to connect to.")]
         public string? ServerUrl { get; }
 
-        [Option('u', "username", Required = false, HelpText = "Your username on the server.")]
+        [Option('u', "username", Required = true, HelpText = "Your username on the server.")]
         public string? Username { get; }
-
-        [Option('a', "applicationid", Required = false, HelpText = "The Discord application ID to use.")]
-        public string? ApplicationId { get; }
     }
 }

PLRPC.GUI/Forms/MainForm.cs

@@ -12,7 +12,6 @@ public class MainForm : Form
 
     private static readonly TextBox username;
     private static readonly TextBox serverUrl;
-    private static readonly TextBox applicationId;
 
     public MainForm()
     {
@@ -49,35 +48,17 @@ public MainForm()
                     new(serverUrl = new TextBox
                     {
                         Text = "https://lighthouse.lbpunion.com/",
-                        Enabled = false,
-                    }),
-                }),
-                new TableRow(new List<TableCell>
-                {
-                    new(new Label
-                    {
-                        Text = Strings.MainForm.ApplicationId,
-                    }),
-                    new(applicationId = new TextBox
-                    {
-                        Text = "1060973475151495288",
-                        Enabled = false,
                     }),
                 }),
             },
         },
     };
 
-    private static readonly Button connectButton = new(InitializeClientHandler)
+    private static readonly Button connectButton = new(InitializationHandler)
     {
         Text = Strings.MainForm.Connect,
     };
 
-    private static readonly Button unlockDefaultsButton = new(UnlockDefaultsHandler)
-    {
-        Text = Strings.MainForm.UnlockDefaults,
-    };
-
     private readonly TableLayout tableLayout = new()
     {
         Padding = new Padding(10, 10, 10, 10),
@@ -86,17 +67,15 @@ public MainForm()
         {
             new TableRow(configurationEntries),
             new TableRow(connectButton),
-            new TableRow(unlockDefaultsButton),
         },
     };
 
-    private static async void InitializeClientHandler(object sender, EventArgs eventArgs)
+    private static async void InitializationHandler(object sender, EventArgs eventArgs)
     {
         List<TextBox> arguments = new()
         {
             serverUrl,
             username,
-            applicationId,
         };
 
         switch (arguments)
@@ -118,21 +97,19 @@ private static async void InitializeClientHandler(object sender, EventArgs event
             }
         }
 
-        try
-        {
-            // Text changes
-            connectButton.Text = Strings.MainForm.Connected;
+        // Text changes
+        connectButton.Text = Strings.MainForm.Connected;
 
-            // Button states
-            connectButton.Enabled = false;
-            unlockDefaultsButton.Enabled = false;
+        // Button states
+        connectButton.Enabled = false;
 
-            // Field states
-            serverUrl.Enabled = false;
-            username.Enabled = false;
-            applicationId.Enabled = false;
+        // Field states
+        serverUrl.Enabled = false;
+        username.Enabled = false;
 
-            await new Initializer(logger, updater).InitializeLighthouseClient(serverUrl.Text.Trim('/'), username.Text, applicationId.Text);
+        try
+        {
+            await new Initializer(logger, updater).InitializeLighthouseClient(serverUrl.Text.Trim('/'), username.Text);
         }
         catch (Exception exception)
         {
@@ -145,19 +122,4 @@ private static async void InitializeClientHandler(object sender, EventArgs event
             MessageBox.Show(exceptionBuilder.ToString(), MessageBoxButtons.OK, MessageBoxType.Error);
         }
     }
-
-    private static void UnlockDefaultsHandler(object sender, EventArgs eventArgs)
-    {
-        // Text changes
-        unlockDefaultsButton.Text = Strings.MainForm.UnlockedDefaults;
-
-        // Button states
-        unlockDefaultsButton.Enabled = false;
-
-        // Field states
-        serverUrl.Enabled = true;
-        applicationId.Enabled = true;
-
-        MessageBox.Show(Strings.MainForm.UnlockedDefaultsWarning, "Warning", MessageBoxButtons.OK, MessageBoxType.Warning);
-    }
 }

PLRPC.GUI/Strings/MainForm.cs

@@ -5,15 +5,10 @@ public static class MainForm
     public const string Configuration = "Configuration";
     public const string Username = "Username";
     public const string ServerUrl = "Server URL";
-    public const string ApplicationId = "Application ID";
     public const string Connect = "Connect";
     public const string Connected = "Connected";
-    public const string UnlockDefaults = "Unlock Defaults";
-    public const string UnlockedDefaults = "Unlocked Defaults";
     public const string BlankFieldsError = "Please fill in all fields and try again.";
     public const string InitializationError = "An error occurred while initializing the PLRPC client.";
     public const string InvalidUrlError = "The URL specified is in an invalid format. Please try again.";
     public const string InvalidUsernameError = "The username specified is invalid. Please try again.";
-    public const string UnlockedDefaultsWarning =
-        "You have just unlocked defaults. Support will not be provided whilst using modified defaults. Continue at your own risk.";
 }

PLRPC.Tests/Integration/ConfigurationTests.cs

@@ -0,0 +1,56 @@
+using LBPUnion.PLRPC.Types.Configuration;
+using LBPUnion.PLRPC.Types.Enums;
+using Xunit;
+
+namespace LBPUnion.PLRPC.Tests.Integration;
+
+[Trait("Category", "Integration")]
+public class ConfigurationTests
+{
+    private static readonly Logger unitTestLogger = new();
+
+    private static readonly HttpClient lighthouseUnitTestClient = new()
+    {
+        BaseAddress = new Uri("https://lighthouse.lbpunion.com/api/v1/"),
+        DefaultRequestHeaders = { { "User-Agent", "LBPUnion/1.0 (PLRPC; unit-test) ApiClient/2.0" } },
+    };
+
+    private static readonly HttpClient refreshUnitTestClient = new()
+    {
+        BaseAddress = new Uri("https://refresh.jvyden.xyz/api/v1/"),
+        DefaultRequestHeaders = { { "User-Agent", "LBPUnion/1.0 (PLRPC; unit-test) ApiClient/2.0" } },
+    };
+
+    private static readonly Configuration lighthouseConfig = new(lighthouseUnitTestClient, unitTestLogger);
+    private static readonly Configuration refreshConfig = new(refreshUnitTestClient, unitTestLogger);
+
+    [Fact]
+    public async void CanRetrieveAndParseLighthouseConfiguration()
+    {
+        RemoteConfiguration? remoteConfiguration = await lighthouseConfig.GetRemoteConfiguration();
+
+        if (remoteConfiguration == null)
+        {
+            Assert.Fail("Failed to retrieve remote configuration");
+        }
+
+        Assert.Equal("1060973475151495288", remoteConfiguration.ApplicationId);
+        Assert.Equal("beacon", remoteConfiguration.PartyIdPrefix);
+        Assert.Equal(UsernameType.Integer, remoteConfiguration.UsernameType);
+    }
+
+    [Fact]
+    public async void CanRetrieveAndParseRefreshConfiguration()
+    {
+        RemoteConfiguration? remoteConfiguration = await refreshConfig.GetRemoteConfiguration();
+
+        if (remoteConfiguration == null)
+        {
+            Assert.Fail("Failed to retrieve remote configuration");
+        }
+
+        Assert.Equal("1138956002037866648", remoteConfiguration.ApplicationId);
+        Assert.Equal("LittleBigRefresh", remoteConfiguration.PartyIdPrefix);
+        Assert.Equal(UsernameType.Username, remoteConfiguration.UsernameType);
+    }
+}

PLRPC.Tests/Integration/ApiTests.cs → PLRPC.Tests/Integration/LighthouseApiTests.cs

@@ -1,12 +1,14 @@
 using LBPUnion.PLRPC.Types.Entities;
+using LBPUnion.PLRPC.Types.Enums;
+using LBPUnion.PLRPC.Types.Interfaces;
 using Xunit;
 
 namespace LBPUnion.PLRPC.Tests.Integration;
 
 [Trait("Category", "Integration")]
-public class ApiTests
+public class LighthouseApiTests
 {
-    private static readonly HttpClient apiClient = new()
+    private static readonly HttpClient unitTestClient = new()
     {
         BaseAddress = new Uri("https://lighthouse.lbpunion.com/api/v1/"),
         DefaultRequestHeaders =
@@ -18,12 +20,12 @@ public class ApiTests
     };
 
     private static readonly TimeSpan cacheExpirationTime = TimeSpan.FromHours(1);
-    private static readonly ApiRepositoryImpl apiRepository = new(apiClient, cacheExpirationTime);
+    private static readonly LighthouseApiImpl lighthouseApi = new(unitTestClient, cacheExpirationTime);
 
     [Fact]
     public async void CanGetUser()
     {
-        User? user = await apiRepository.GetUser("littlebigmolly");
+        User? user = await lighthouseApi.GetUser("littlebigmolly");
 
         Assert.NotNull(user);
 
@@ -35,7 +37,7 @@ public async void CanGetUser()
     [Fact]
     public async void CanGetSlot()
     {
-        Slot? slot = await apiRepository.GetSlot(8443);
+        Slot? slot = await lighthouseApi.GetSlot(8443);
 
         Assert.NotNull(slot);