Merge pull request #250 from Moonlight-Panel/ImproveInstallUX

Improved install user experience

.gitattributes

@@ -1,2 +1,10 @@
 # Auto detect text files and perform LF normalization
 * text=auto
+Moonlight/wwwroot/** linguist-vendored
+Moonlight/wwwroot/assets/js/scripts.bundle.js linguist-vendored
+Moonlight/wwwroot/assets/js/widgets.bundle.js linguist-vendored
+Moonlight/wwwroot/assets/js/theme.js linguist-vendored
+Moonlight/wwwroot/assets/css/boxicons.min.css linguist-vendored
+Moonlight/wwwroot/assets/css/style.bundle.css linguist-vendored
+Moonlight/wwwroot/assets/plugins/** linguist-vendored
+Moonlight/wwwroot/assets/fonts/** linguist-vendored

.gitignore

@@ -42,3 +42,4 @@ Desktop.ini
 
 storage/
 Moonlight/publish.ps1
+Moonlight/version

Moonlight/App/ApiClients/Daemon/DaemonApiHelper.cs

@@ -1,5 +1,4 @@
 using Moonlight.App.Database.Entities;
-using Moonlight.App.Exceptions;
 using Newtonsoft.Json;
 using RestSharp;
 
@@ -14,26 +13,13 @@ public class DaemonApiHelper
         Client = new();
     }
     
-    private string GetApiUrl(Node node)
-    {
-        /* SSL not implemented in moonlight daemon
-        if(node.Ssl)
-            return $"https://{node.Fqdn}:{node.MoonlightDaemonPort}/";
-        else
-            return $"http://{node.Fqdn}:{node.MoonlightDaemonPort}/";*/
-        
-        return $"http://{node.Fqdn}:{node.MoonlightDaemonPort}/";
-    }
-    
     public async Task<T> Get<T>(Node node, string resource)
     {
-        RestRequest request = new(GetApiUrl(node) + resource);
+        var request = await CreateRequest(node, resource);
 
-        request.AddHeader("Content-Type", "application/json");
+        request.Method = Method.Get;
-        request.AddHeader("Accept", "application/json");
-        request.AddHeader("Authorization", node.Token);
         
-        var response = await Client.GetAsync(request);
+        var response = await Client.ExecuteAsync(request);
 
         if (!response.IsSuccessful)
         {
@@ -52,4 +38,69 @@ public class DaemonApiHelper
 
         return JsonConvert.DeserializeObject<T>(response.Content!)!;
     }
+    
+    public async Task Post(Node node, string resource, object body)
+    {
+        var request = await CreateRequest(node, resource);
+
+        request.Method = Method.Post;
+
+        request.AddParameter("text/plain", JsonConvert.SerializeObject(body), ParameterType.RequestBody);
+
+        var response = await Client.ExecuteAsync(request);
+
+        if (!response.IsSuccessful)
+        {
+            if (response.StatusCode != 0)
+            {
+                throw new DaemonException(
+                    $"An error occured: ({response.StatusCode}) {response.Content}",
+                    (int)response.StatusCode
+                );
+            }
+            else
+            {
+                throw new Exception($"An internal error occured: {response.ErrorMessage}");
+            }
+        }
+    }
+    
+    public async Task Delete(Node node, string resource, object body)
+    {
+        var request = await CreateRequest(node, resource);
+
+        request.Method = Method.Delete;
+
+        request.AddParameter("text/plain", JsonConvert.SerializeObject(body), ParameterType.RequestBody);
+
+        var response = await Client.ExecuteAsync(request);
+
+        if (!response.IsSuccessful)
+        {
+            if (response.StatusCode != 0)
+            {
+                throw new DaemonException(
+                    $"An error occured: ({response.StatusCode}) {response.Content}",
+                    (int)response.StatusCode
+                );
+            }
+            else
+            {
+                throw new Exception($"An internal error occured: {response.ErrorMessage}");
+            }
+        }
+    }
+
+    private Task<RestRequest> CreateRequest(Node node, string resource)
+    {
+        var url = $"http://{node.Fqdn}:{node.MoonlightDaemonPort}/";
+        
+        RestRequest request = new(url + resource);
+
+        request.AddHeader("Content-Type", "application/json");
+        request.AddHeader("Accept", "application/json");
+        request.AddHeader("Authorization", node.Token);
+        
+        return Task.FromResult(request);
+    }
 }

Moonlight/App/ApiClients/Daemon/Requests/Mount.cs

@@ -0,0 +1,8 @@
+namespace Moonlight.App.ApiClients.Daemon.Requests;
+
+public class Mount
+{
+    public string Server { get; set; } = "";
+    public string ServerPath { get; set; } = "";
+    public string Path { get; set; } = "";
+}

Moonlight/App/ApiClients/Daemon/Requests/Unmount.cs

@@ -0,0 +1,6 @@
+namespace Moonlight.App.ApiClients.Daemon.Requests;
+
+public class Unmount
+{
+    public string Path { get; set; } = "";
+}

Moonlight/App/ApiClients/Daemon/Resources/Container.cs

@@ -0,0 +1,10 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class Container
+{
+    public string Name { get; set; } = "";
+    public long Memory { get; set; }
+    public double Cpu { get; set; }
+    public long NetworkIn { get; set; }
+    public long NetworkOut { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/ContainerStats.cs

@@ -1,15 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class ContainerStats
-{
-    public List<Container> Containers { get; set; } = new();
-    
-    public class Container
-    {
-        public string Name { get; set; }
-        public long Memory { get; set; }
-        public double Cpu { get; set; }
-        public long NetworkIn { get; set; }
-        public long NetworkOut { get; set; }
-    }
-}

Moonlight/App/ApiClients/Daemon/Resources/CpuMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class CpuMetrics
+{
+    public string CpuModel { get; set; } = "";
+    public double CpuUsage { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/CpuStats.cs

@@ -1,8 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class CpuStats
-{
-    public double Usage { get; set; }
-    public int Cores { get; set; }
-    public string Model { get; set; } = "";
-}

Moonlight/App/ApiClients/Daemon/Resources/DiskMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class DiskMetrics
+{
+    public long Used { get; set; }
+    public long Total { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/DiskStats.cs

@@ -1,9 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class DiskStats
-{
-    public long FreeBytes { get; set; }
-    public string DriveFormat { get; set; }
-    public string Name { get; set; }
-    public long TotalSize { get; set; }
-}

Moonlight/App/ApiClients/Daemon/Resources/DockerMetrics.cs

@@ -0,0 +1,6 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class DockerMetrics
+{
+    public Container[] Containers { get; set; } = Array.Empty<Container>();
+}

Moonlight/App/ApiClients/Daemon/Resources/MemoryMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class MemoryMetrics
+{
+    public long Used { get; set; }
+    public long Total { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/MemoryStats.cs

@@ -1,15 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class MemoryStats
-{
-    public List<MemoryStick> Sticks { get; set; } = new();
-    public double Free { get; set; }
-    public double Used { get; set; }
-    public double Total { get; set; }
-    
-    public class MemoryStick
-    {
-        public int Size { get; set; }
-        public string Type { get; set; } = "";
-    }
-}

Moonlight/App/ApiClients/Daemon/Resources/SystemMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class SystemMetrics
+{
+    public string OsName { get; set; } = "";
+    public long Uptime { get; set; }
+}

Moonlight/App/ApiClients/Modrinth/ModrinthApiHelper.cs

@@ -0,0 +1,58 @@
+using Newtonsoft.Json;
+using RestSharp;
+
+namespace Moonlight.App.ApiClients.Modrinth;
+
+public class ModrinthApiHelper
+{
+    private readonly RestClient Client;
+
+    public ModrinthApiHelper()
+    {
+        Client = new();
+        Client.AddDefaultParameter(
+            new HeaderParameter("User-Agent", "Moonlight-Panel/Moonlight (admin@endelon-hosting.de)")
+        );
+    }
+    
+    public async Task<T> Get<T>(string resource)
+    {
+        var request = CreateRequest(resource);
+
+        request.Method = Method.Get;
+
+        var response = await Client.ExecuteAsync(request);
+
+        if (!response.IsSuccessful)
+        {
+            if (response.StatusCode != 0)
+            {
+                throw new ModrinthException(
+                    $"An error occured: ({response.StatusCode}) {response.Content}",
+                    (int)response.StatusCode
+                );
+            }
+            else
+            {
+                throw new Exception($"An internal error occured: {response.ErrorMessage}");
+            }
+        }
+
+        return JsonConvert.DeserializeObject<T>(response.Content!)!;
+    }
+    
+    private RestRequest CreateRequest(string resource)
+    {
+        var url = "https://api.modrinth.com/v2/" + resource;
+
+        var request = new RestRequest(url)
+        {
+            Timeout = 300000
+        };
+
+        request.AddHeader("Content-Type", "application/json");
+        request.AddHeader("Accept", "application/json");
+
+        return request;
+    }
+}

Moonlight/App/ApiClients/Modrinth/ModrinthException.cs

@@ -0,0 +1,19 @@
+namespace Moonlight.App.ApiClients.Modrinth;
+
+public class ModrinthException : Exception
+{
+    public int StatusCode { get; set; }
+    
+    public ModrinthException()
+    {
+    }
+
+    public ModrinthException(string message, int statusCode) : base(message)
+    {
+        StatusCode = statusCode;
+    }
+
+    public ModrinthException(string message, Exception inner) : base(message, inner)
+    {
+    }
+}

Moonlight/App/ApiClients/Modrinth/Resources/Pagination.cs

@@ -0,0 +1,14 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class Pagination
+{
+    [JsonProperty("hits")] public Project[] Hits { get; set; }
+
+    [JsonProperty("offset")] public long Offset { get; set; }
+
+    [JsonProperty("limit")] public long Limit { get; set; }
+
+    [JsonProperty("total_hits")] public long TotalHits { get; set; }
+}

Moonlight/App/ApiClients/Modrinth/Resources/Project.cs

@@ -0,0 +1,48 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class Project
+{
+    [JsonProperty("project_id")] public string ProjectId { get; set; }
+
+    [JsonProperty("project_type")] public string ProjectType { get; set; }
+
+    [JsonProperty("slug")] public string Slug { get; set; }
+
+    [JsonProperty("author")] public string Author { get; set; }
+
+    [JsonProperty("title")] public string Title { get; set; }
+
+    [JsonProperty("description")] public string Description { get; set; }
+
+    [JsonProperty("categories")] public string[] Categories { get; set; }
+
+    [JsonProperty("display_categories")] public string[] DisplayCategories { get; set; }
+
+    [JsonProperty("versions")] public string[] Versions { get; set; }
+
+    [JsonProperty("downloads")] public long Downloads { get; set; }
+
+    [JsonProperty("follows")] public long Follows { get; set; }
+
+    [JsonProperty("icon_url")] public string IconUrl { get; set; }
+
+    [JsonProperty("date_created")] public DateTimeOffset DateCreated { get; set; }
+
+    [JsonProperty("date_modified")] public DateTimeOffset DateModified { get; set; }
+
+    [JsonProperty("latest_version")] public string LatestVersion { get; set; }
+
+    [JsonProperty("license")] public string License { get; set; }
+
+    [JsonProperty("client_side")] public string ClientSide { get; set; }
+
+    [JsonProperty("server_side")] public string ServerSide { get; set; }
+
+    [JsonProperty("gallery")] public Uri[] Gallery { get; set; }
+
+    [JsonProperty("featured_gallery")] public Uri FeaturedGallery { get; set; }
+
+    [JsonProperty("color")] public long? Color { get; set; }
+}

Moonlight/App/ApiClients/Modrinth/Resources/Version.cs

@@ -0,0 +1,57 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class Version
+{
+    [JsonProperty("name")]
+    public string Name { get; set; }
+
+    [JsonProperty("version_number")]
+    public string VersionNumber { get; set; }
+
+    [JsonProperty("changelog")]
+    public string Changelog { get; set; }
+
+    [JsonProperty("dependencies")]
+    public object[] Dependencies { get; set; }
+
+    [JsonProperty("game_versions")]
+    public object[] GameVersions { get; set; }
+
+    [JsonProperty("version_type")]
+    public string VersionType { get; set; }
+
+    [JsonProperty("loaders")]
+    public object[] Loaders { get; set; }
+
+    [JsonProperty("featured")]
+    public bool Featured { get; set; }
+
+    [JsonProperty("status")]
+    public string Status { get; set; }
+
+    [JsonProperty("requested_status")]
+    public string RequestedStatus { get; set; }
+
+    [JsonProperty("id")]
+    public string Id { get; set; }
+
+    [JsonProperty("project_id")]
+    public string ProjectId { get; set; }
+
+    [JsonProperty("author_id")]
+    public string AuthorId { get; set; }
+
+    [JsonProperty("date_published")]
+    public DateTime DatePublished { get; set; }
+
+    [JsonProperty("downloads")]
+    public long Downloads { get; set; }
+
+    [JsonProperty("changelog_url")]
+    public object ChangelogUrl { get; set; }
+
+    [JsonProperty("files")]
+    public VersionFile[] Files { get; set; }
+}

Moonlight/App/ApiClients/Modrinth/Resources/VersionFile.cs

@@ -0,0 +1,21 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class VersionFile
+{
+    [JsonProperty("url")]
+    public Uri Url { get; set; }
+
+    [JsonProperty("filename")]
+    public string Filename { get; set; }
+
+    [JsonProperty("primary")]
+    public bool Primary { get; set; }
+
+    [JsonProperty("size")]
+    public long Size { get; set; }
+
+    [JsonProperty("file_type")]
+    public string FileType { get; set; }
+}

Moonlight/App/ApiClients/Telemetry/Requests/TelemetryData.cs

@@ -0,0 +1,11 @@
+namespace Moonlight.App.ApiClients.Telemetry.Requests;
+
+public class TelemetryData
+{
+    public string AppUrl { get; set; } = "";
+    public int Servers { get; set; }
+    public int Nodes { get; set; }
+    public int Users { get; set; }
+    public int Databases { get; set; }
+    public int Webspaces { get; set; }
+}

Moonlight/App/ApiClients/Telemetry/TelemetryApiHelper.cs

@@ -0,0 +1,52 @@
+using Newtonsoft.Json;
+using RestSharp;
+
+namespace Moonlight.App.ApiClients.Telemetry;
+
+public class TelemetryApiHelper
+{
+    private readonly RestClient Client;
+
+    public TelemetryApiHelper()
+    {
+        Client = new();
+    }
+
+    public async Task Post(string resource, object? body)
+    {
+        var request = CreateRequest(resource);
+
+        request.Method = Method.Post;
+        
+        request.AddParameter("application/json", JsonConvert.SerializeObject(body), ParameterType.RequestBody);
+
+        var response = await Client.ExecuteAsync(request);
+        
+        if (!response.IsSuccessful)
+        {
+            if (response.StatusCode != 0)
+            {
+                throw new TelemetryException(
+                    $"An error occured: ({response.StatusCode}) {response.Content}",
+                    (int)response.StatusCode
+                );
+            }
+            else
+            {
+                throw new Exception($"An internal error occured: {response.ErrorMessage}");
+            }
+        }
+    }
+
+    private RestRequest CreateRequest(string resource)
+    {
+        var url = "https://telemetry.moonlightpanel.xyz/" + resource;
+
+        var request = new RestRequest(url)
+        {
+            Timeout = 3000000
+        };
+
+        return request;
+    }
+}

Moonlight/App/ApiClients/Telemetry/TelemetryException.cs

@@ -0,0 +1,32 @@
+using System.Runtime.Serialization;
+
+namespace Moonlight.App.ApiClients.Telemetry;
+
+[Serializable]
+public class TelemetryException : Exception
+{
+    public int StatusCode { get; set; }
+
+    public TelemetryException()
+    {
+    }
+    
+    public TelemetryException(string message, int statusCode) : base(message)
+    {
+        StatusCode = statusCode;
+    }
+
+    public TelemetryException(string message) : base(message)
+    {
+    }
+
+    public TelemetryException(string message, Exception inner) : base(message, inner)
+    {
+    }
+
+    protected TelemetryException(
+        SerializationInfo info,
+        StreamingContext context) : base(info, context)
+    {
+    }
+}

Moonlight/App/ApiClients/Wings/WingsApiHelper.cs

@@ -209,7 +209,7 @@ public class WingsApiHelper
 
         var request = new RestRequest(url)
         {
-            Timeout = 60 * 15
+            Timeout = 300000
         };
 
         request.AddHeader("Content-Type", "application/json");

Moonlight/App/Configuration/ConfigV1.cs

@@ -0,0 +1,356 @@
+using System.ComponentModel;
+using Moonlight.App.Helpers;
+
+namespace Moonlight.App.Configuration;
+
+using System;
+using Newtonsoft.Json;
+
+public class ConfigV1
+{
+    [JsonProperty("Moonlight")]
+    public MoonlightData Moonlight { get; set; } = new();
+
+    public class MoonlightData
+    {
+        [JsonProperty("AppUrl")]
+        [Description("The url moonlight is accesible with from the internet")]
+        public string AppUrl { get; set; } = "http://your-moonlight-url-without-slash";
+
+        [JsonProperty("EnableLatencyCheck")]
+        [Description(
+            "This will enable a latency check for connections to moonlight. Users with an too high latency will be warned that moonlight might be buggy for them")]
+        public bool EnableLatencyCheck { get; set; } = true;
+
+        [JsonProperty("LatencyCheckThreshold")]
+        [Description("Specify the latency threshold which has to be reached in order to trigger the warning message")]
+        public int LatencyCheckThreshold { get; set; } = 500;
+
+        [JsonProperty("Auth")] public AuthData Auth { get; set; } = new();
+
+        [JsonProperty("Database")] public DatabaseData Database { get; set; } = new();
+
+        [JsonProperty("DiscordBotApi")] public DiscordBotApiData DiscordBotApi { get; set; } = new();
+
+        [JsonProperty("DiscordBot")] public DiscordBotData DiscordBot { get; set; } = new();
+
+        [JsonProperty("Domains")] public DomainsData Domains { get; set; } = new();
+
+        [JsonProperty("Html")] public HtmlData Html { get; set; } = new();
+
+        [JsonProperty("Marketing")] public MarketingData Marketing { get; set; } = new();
+
+        [JsonProperty("OAuth2")] public OAuth2Data OAuth2 { get; set; } = new();
+
+        [JsonProperty("Security")] public SecurityData Security { get; set; } = new();
+
+        [JsonProperty("Mail")] public MailData Mail { get; set; } = new();
+
+        [JsonProperty("Cleanup")] public CleanupData Cleanup { get; set; } = new();
+        
+        [JsonProperty("DiscordNotifications")] public DiscordNotificationsData DiscordNotifications { get; set; } = new();
+
+        [JsonProperty("Statistics")] public StatisticsData Statistics { get; set; } = new();
+
+        [JsonProperty("Rating")] public RatingData Rating { get; set; } = new();
+
+        [JsonProperty("SmartDeploy")] public SmartDeployData SmartDeploy { get; set; } = new();
+
+        [JsonProperty("Sentry")] public SentryData Sentry { get; set; } = new();
+
+        [JsonProperty("Stripe")] public StripeData Stripe { get; set; } = new();
+
+        [JsonProperty("Tickets")] public TicketsData Tickets { get; set; } = new();
+    }
+    
+    public class TicketsData
+    {
+        [JsonProperty("WelcomeMessage")]
+        [Description("The message that will be sent when a user created a ticket")]
+        public string WelcomeMessage { get; set; } = "Welcome to the support";
+    }
+    
+    public class StripeData
+    {
+        [JsonProperty("ApiKey")]
+        [Description("Put here your stripe api key if you add subscriptions. Currently the only billing option is stripe which is enabled by default and cannot be turned off. This feature is still experimental")]
+        public string ApiKey { get; set; } = "";
+    }
+    
+    public class AuthData
+    {
+        [JsonProperty("DenyLogin")]
+        [Description("Prevent every new login")]
+        public bool DenyLogin { get; set; } = false;
+        
+        [JsonProperty("DenyRegister")]
+        [Description("Prevent every new user to register")]
+        public bool DenyRegister { get; set; } = false;
+    }
+
+    public class CleanupData
+    {
+        [JsonProperty("Cpu")]
+        [Description("The maximum amount of cpu usage in percent a node is allowed to use before the cleanup starts")]
+        public long Cpu { get; set; } = 90;
+
+        [JsonProperty("Memory")]
+        [Description("The minumum amount of memory in megabytes avaliable before the cleanup starts")]
+        public long Memory { get; set; } = 8192;
+
+        [JsonProperty("Wait")]
+        [Description("The delay between every cleanup check in minutes")]
+        public long Wait { get; set; } = 15;
+
+        [JsonProperty("Uptime")]
+        [Description("The maximum uptime of any server in hours before it the server restarted by the cleanup system")]
+        public long Uptime { get; set; } = 6;
+
+        [JsonProperty("Enable")]
+        [Description("The cleanup system provides a fair way for stopping unused servers and staying stable even with overallocation. A detailed explanation: docs.endelon-hosting.de/erklaerungen/cleanup")]
+        public bool Enable { get; set; } = false;
+
+        [JsonProperty("MinUptime")]
+        [Description("The minumum uptime of a server in minutes to prevent stopping servers which just started")]
+        public long MinUptime { get; set; } = 10;
+    }
+
+    public class DatabaseData
+    {
+        [JsonProperty("Database")] public string Database { get; set; } = "moonlight_db";
+
+        [JsonProperty("Host")] public string Host { get; set; } = "your.database.host";
+        
+        [JsonProperty("Password")]
+        [Blur]
+        public string Password { get; set; } = "secret";
+
+        [JsonProperty("Port")] public long Port { get; set; } = 3306;
+
+        [JsonProperty("Username")] public string Username { get; set; } = "moonlight_user";
+    }
+
+    public class DiscordBotApiData
+    {
+        [JsonProperty("Enable")]
+        [Description("Enable the discord bot api. Currently only DatBot is using this api")]
+        public bool Enable { get; set; } = false;
+
+        [JsonProperty("Token")]
+        [Description("Specify the token the api client needs to provide")]
+        [Blur]
+        public string Token { get; set; } = Guid.NewGuid().ToString();
+    }
+    public class DiscordBotData
+    {
+        [JsonProperty("Enable")]
+        [Description("The discord bot can be used to allow customers to manage their servers via discord")]
+        public bool Enable { get; set; } = false;
+
+        [JsonProperty("Token")]
+        [Description("Your discord bot token goes here")]
+        [Blur]
+        public string Token { get; set; } = "discord token here";
+
+        [JsonProperty("PowerActions")]
+        [Description("Enable actions like starting and stopping servers")]
+        public bool PowerActions { get; set; } = false;
+        
+        [JsonProperty("SendCommands")]
+        [Description("Allow users to send commands to their servers")]
+        public bool SendCommands { get; set; } = false;
+    }
+
+    public class DiscordNotificationsData
+    {
+        [JsonProperty("Enable")]
+        [Description("The discord notification system sends you a message everytime a event like a new support chat message is triggered with usefull data describing the event")]
+        public bool Enable { get; set; } = false;
+
+        [JsonProperty("WebHook")]
+        [Description("The discord webhook the notifications are being sent to")]
+        [Blur]
+        public string WebHook { get; set; } = "http://your-discord-webhook-url";
+    }
+
+    public class DomainsData
+    {
+        [JsonProperty("Enable")]
+        [Description("This enables the domain system")]
+        public bool Enable { get; set; } = false;
+        
+        [JsonProperty("AccountId")]
+        [Description("This option specifies the cloudflare account id")]
+        public string AccountId { get; set; } = "cloudflare acc id";
+
+        [JsonProperty("Email")]
+        [Description("This specifies the cloudflare email to use for communicating with the cloudflare api")]
+        public string Email { get; set; } = "cloudflare@acc.email";
+
+        [JsonProperty("Key")]
+        [Description("Your cloudflare api key goes here")]
+        [Blur]
+        public string Key { get; set; } = "secret";
+    }
+
+    public class HtmlData
+    {
+        [JsonProperty("Headers")] public HeadersData Headers { get; set; } = new();
+    }
+
+    public class HeadersData
+    {
+        [JsonProperty("Color")]
+        [Description("This specifies the color of the embed generated by platforms like discord when someone posts a link to your moonlight instance")]
+        public string Color { get; set; } = "#4b27e8";
+
+        [JsonProperty("Description")]
+        [Description("This specifies the description text of the embed generated by platforms like discord when someone posts a link to your moonlight instance and can also help google to index your moonlight instance correctly")]
+        public string Description { get; set; } = "the next generation hosting panel";
+
+        [JsonProperty("Keywords")]
+        [Description("To help search engines like google to index your moonlight instance correctly you can specify keywords seperated by a comma here")]
+        public string Keywords { get; set; } = "moonlight";
+
+        [JsonProperty("Title")]
+        [Description("This specifies the title of the embed generated by platforms like discord when someone posts a link to your moonlight instance")]
+        public string Title { get; set; } = "Moonlight - endelon.link";
+    }
+
+    public class MailData
+    {
+        [JsonProperty("Email")] public string Email { get; set; } = "username@your.mail.host";
+
+        [JsonProperty("Server")] public string Server { get; set; } = "your.mail.host";
+
+        [JsonProperty("Password")]
+        [Blur]
+        public string Password { get; set; } = "secret";
+
+        [JsonProperty("Port")] public int Port { get; set; } = 465;
+
+        [JsonProperty("Ssl")] public bool Ssl { get; set; } = true;
+    }
+
+    public class MarketingData
+    {
+        [JsonProperty("BrandName")] public string BrandName { get; set; } = "Endelon Hosting";
+
+        [JsonProperty("Imprint")] public string Imprint { get; set; } = "https://your-site.xyz/imprint";
+
+        [JsonProperty("Privacy")] public string Privacy { get; set; } = "https://your-site.xyz/privacy";
+        [JsonProperty("About")] public string About { get; set; } = "https://your-site.xyz/about";
+        [JsonProperty("Website")] public string Website { get; set; } = "https://your-site.xyz";
+    }
+
+    public class OAuth2Data
+    {
+        [JsonProperty("OverrideUrl")]
+        [Description("This overrides the redirect url which would be typicaly the app url")]
+        public string OverrideUrl { get; set; } = "https://only-for-development.cases";
+
+        [JsonProperty("EnableOverrideUrl")]
+        [Description("This enables the url override")]
+        public bool EnableOverrideUrl { get; set; } = false;
+
+        [JsonProperty("Providers")]
+        public OAuth2ProviderData[] Providers { get; set; } = Array.Empty<OAuth2ProviderData>();
+    }
+
+    public class OAuth2ProviderData
+    {
+        [JsonProperty("Id")] public string Id { get; set; }
+
+        [JsonProperty("ClientId")] public string ClientId { get; set; }
+
+        [JsonProperty("ClientSecret")]
+        [Blur]
+        public string ClientSecret { get; set; }
+    }
+
+    public class RatingData
+    {
+        [JsonProperty("Enabled")]
+        [Description("The rating systems shows a user who is registered longer than the set amout of days a popup to rate this platform if he hasnt rated it before")]
+        public bool Enabled { get; set; } = false;
+
+        [JsonProperty("Url")]
+        [Description("This is the url a user who rated above a set limit is shown to rate you again. Its recommended to put your google or trustpilot rate link here")]
+        public string Url { get; set; } = "https://link-to-google-or-smth";
+
+        [JsonProperty("MinRating")]
+        [Description("The minimum star count on the rating ranging from 1 to 5")]
+        public int MinRating { get; set; } = 4;
+
+        [JsonProperty("DaysSince")]
+        [Description("The days a user has to be registered to even be able to get this popup")]
+        public int DaysSince { get; set; } = 5;
+    }
+
+    public class SecurityData
+    {
+        [JsonProperty("Token")]
+        [Description("This is the moonlight app token. It is used to encrypt and decrypt data and validte tokens and sessions")]
+        [Blur]
+        public string Token { get; set; } = Guid.NewGuid().ToString();
+
+        [JsonProperty("BlockIpDuration")]
+        [Description("The duration in minutes a ip will be blocked by the anti ddos system")]
+        public int BlockIpDuration { get; set; } = 15;
+
+        [JsonProperty("ReCaptcha")] public ReCaptchaData ReCaptcha { get; set; } = new();
+    }
+
+    public class ReCaptchaData
+    {
+        [JsonProperty("Enable")]
+        [Description("Enables repatcha at places like the register page. For information how to get your recaptcha credentails go to google.com/recaptcha/about/")]
+        public bool Enable { get; set; } = false;
+
+        [JsonProperty("SiteKey")]
+        [Blur]
+        public string SiteKey { get; set; } = "recaptcha site key here";
+
+        [JsonProperty("SecretKey")]
+        [Blur]
+        public string SecretKey { get; set; } = "recaptcha secret here";
+    }
+
+    public class SentryData
+    {
+        [JsonProperty("Enable")]
+        [Description("Sentry is a way to monitor application crashes and performance issues in real time. Enable this option only if you set a sentry dsn")]
+        public bool Enable { get; set; } = false;
+
+        [JsonProperty("Dsn")]
+        [Description("The dsn is the key moonlight needs to communicate with your sentry instance")]
+        [Blur]
+        public string Dsn { get; set; } = "http://your-sentry-url-here";
+    }
+
+    public class SmartDeployData
+    {
+        [JsonProperty("Server")] public SmartDeployServerData Server { get; set; } = new();
+    }
+
+    public class SmartDeployServerData
+    {
+        [JsonProperty("EnableOverride")] public bool EnableOverride { get; set; } = false;
+
+        [JsonProperty("OverrideNode")] public long OverrideNode { get; set; } = 1;
+    }
+
+    public class StatisticsData
+    {
+        [JsonProperty("Enabled")] public bool Enabled { get; set; } = false;
+
+        [JsonProperty("Wait")] public long Wait { get; set; } = 15;
+    }
+
+    public class SellPassData
+    {
+        [JsonProperty("Enable")] public bool Enable { get; set; } = false;
+
+        [JsonProperty("Url")] public string Url { get; set; } = "https://not-implemented-yet";
+    }
+}

Moonlight/App/Database/DataContext.cs

@@ -1,9 +1,7 @@
 using Microsoft.EntityFrameworkCore;
 using Moonlight.App.Database.Entities;
-using Moonlight.App.Database.Entities.LogsEntries;
 using Moonlight.App.Database.Entities.Notification;
 using Moonlight.App.Database.Interceptors;
-using Moonlight.App.Models.Misc;
 using Moonlight.App.Services;
 
 namespace Moonlight.App.Database;
@@ -27,10 +25,6 @@ public class DataContext : DbContext
     public DbSet<ServerVariable> ServerVariables { get; set; }
     public DbSet<User> Users { get; set; }
     public DbSet<LoadingMessage> LoadingMessages { get; set; }
-    public DbSet<AuditLogEntry> AuditLog { get; set; }
-    public DbSet<ErrorLogEntry> ErrorLog { get; set; }
-    public DbSet<SecurityLogEntry> SecurityLog { get; set; }
-
     public DbSet<SharedDomain> SharedDomains { get; set; }
     public DbSet<Domain> Domains { get; set; }
     public DbSet<Revoke> Revokes { get; set; }
@@ -46,20 +40,27 @@ public class DataContext : DbContext
     public DbSet<WebSpace> WebSpaces { get; set; }
     public DbSet<SupportChatMessage> SupportChatMessages { get; set; }
     public DbSet<IpBan> IpBans { get; set; }
+    public DbSet<PermissionGroup> PermissionGroups { get; set; }
+    public DbSet<SecurityLog> SecurityLogs { get; set; }
+    public DbSet<BlocklistIp> BlocklistIps { get; set; }
+    public DbSet<WhitelistIp> WhitelistIps { get; set; }
+    
+    public DbSet<Ticket> Tickets { get; set; }
+    public DbSet<TicketMessage> TicketMessages { get; set; }
 
     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
     {
         if (!optionsBuilder.IsConfigured)
         {
             var config = ConfigService
-                .GetSection("Moonlight")
+                .Get()
-                .GetSection("Database");
+                .Moonlight.Database;
 
-            var connectionString = $"host={config.GetValue<string>("Host")};" +
+            var connectionString = $"host={config.Host};" +
-                                   $"port={config.GetValue<int>("Port")};" +
+                                   $"port={config.Port};" +
-                                   $"database={config.GetValue<string>("Database")};" +
+                                   $"database={config.Database};" +
-                                   $"uid={config.GetValue<string>("Username")};" +
+                                   $"uid={config.Username};" +
-                                   $"pwd={config.GetValue<string>("Password")}";
+                                   $"pwd={config.Password}";
             
             optionsBuilder.UseMySql(
                 connectionString,

Moonlight/App/Database/Entities/BlocklistIp.cs

@@ -0,0 +1,10 @@
+namespace Moonlight.App.Database.Entities;
+
+public class BlocklistIp
+{
+    public int Id { get; set; }
+    public string Ip { get; set; } = "";
+    public DateTime ExpiresAt { get; set; }
+    public long Packets { get; set; }
+    public DateTime CreatedAt { get; set; }
+}

Moonlight/App/Database/Entities/Image.cs

@@ -20,4 +20,5 @@ public class Image
     public List<DockerImage> DockerImages { get; set; } = new();
     public List<ImageVariable> Variables { get; set; } = new();
     public string TagsJson { get; set; } = "";
+    public string BackgroundImageUrl { get; set; } = "";
 }

Moonlight/App/Database/Entities/LogsEntries/AuditLogEntry.cs

@@ -1,13 +0,0 @@
-using Moonlight.App.Models.Misc;
-
-namespace Moonlight.App.Database.Entities.LogsEntries;
-
-public class AuditLogEntry
-{
-    public int Id { get; set; }
-    public AuditLogType Type { get; set; }
-    public string JsonData { get; set; } = "";
-    public bool System { get; set; }
-    public string Ip { get; set; } = "";
-    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
-}

Moonlight/App/Database/Entities/LogsEntries/ErrorLogEntry.cs

@@ -1,12 +0,0 @@
-namespace Moonlight.App.Database.Entities.LogsEntries;
-
-public class ErrorLogEntry
-{
-    public int Id { get; set; }
-    public string Stacktrace { get; set; } = "";
-    public bool System { get; set; }
-    public string JsonData { get; set; } = "";
-    public string Ip { get; set; } = "";
-    public string Class { get; set; } = "";
-    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
-}

Moonlight/App/Database/Entities/LogsEntries/SecurityLogEntry.cs

@@ -1,13 +0,0 @@
-using Moonlight.App.Models.Misc;
-
-namespace Moonlight.App.Database.Entities.LogsEntries;
-
-public class SecurityLogEntry
-{
-    public int Id { get; set; }
-    public bool System { get; set; }
-    public string Ip { get; set; } = "";
-    public SecurityLogType Type { get; set; }
-    public string JsonData { get; set; } = "";
-    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
-}

Moonlight/App/Database/Entities/PermissionGroup.cs

@@ -0,0 +1,8 @@
+namespace Moonlight.App.Database.Entities;
+
+public class PermissionGroup
+{
+    public int Id { get; set; }
+    public string Name { get; set; } = "";
+    public byte[] Permissions { get; set; } = Array.Empty<byte>();
+}

Moonlight/App/Database/Entities/SecurityLog.cs

@@ -0,0 +1,8 @@
+namespace Moonlight.App.Database.Entities;
+
+public class SecurityLog
+{
+    public int Id { get; set; }
+    public string Text { get; set; } = "";
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+}

Moonlight/App/Database/Entities/Server.cs

@@ -13,6 +13,8 @@ public class Server
     public string OverrideStartup { get; set; } = "";
     public bool Installing { get; set; } = false;
     public bool Suspended { get; set; } = false;
+    public bool IsArchived { get; set; } = false;
+    public ServerBackup? Archive { get; set; } = null;
 
     public List<ServerVariable> Variables { get; set; } = new();
     public List<ServerBackup> Backups { get; set; } = new();

Moonlight/App/Database/Entities/Subscription.cs

@@ -1,9 +1,16 @@
-namespace Moonlight.App.Database.Entities;
+using Moonlight.App.Models.Misc;
+
+namespace Moonlight.App.Database.Entities;
 
 public class Subscription
 {
     public int Id { get; set; }
     public string Name { get; set; } = "";
     public string Description { get; set; } = "";
+    public Currency Currency { get; set; } = Currency.USD;
+    public double Price { get; set; }
+    public string StripeProductId { get; set; } = "";
+    public string StripePriceId { get; set; } = "";
     public string LimitsJson { get; set; } = "";
+    public int Duration { get; set; } = 30;
 }

Moonlight/App/Database/Entities/Ticket.cs

@@ -0,0 +1,19 @@
+using Moonlight.App.Models.Misc;
+
+namespace Moonlight.App.Database.Entities;
+
+public class Ticket
+{
+    public int Id { get; set; }
+    public string IssueTopic { get; set; } = "";
+    public string IssueDescription { get; set; } = "";
+    public string IssueTries { get; set; } = "";
+    public User CreatedBy { get; set; }
+    public User? AssignedTo { get; set; }
+    public TicketPriority Priority { get; set; }
+    public TicketStatus Status { get; set; }
+    public TicketSubject Subject { get; set; }
+    public int SubjectId { get; set; }
+    public List<TicketMessage> Messages { get; set; } = new();
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+}

Moonlight/App/Database/Entities/TicketMessage.cs

@@ -0,0 +1,14 @@
+namespace Moonlight.App.Database.Entities;
+
+public class TicketMessage
+{
+    public int Id { get; set; }
+    public string Content { get; set; } = "";
+    public string? AttachmentUrl { get; set; }
+    public User? Sender { get; set; }
+    public bool IsSystemMessage { get; set; }
+    public bool IsEdited { get; set; }
+    public bool IsSupportMessage { get; set; }
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
+}

Moonlight/App/Database/Entities/User.cs

@@ -1,4 +1,5 @@
-using Moonlight.App.Models.Misc;
+using System.ComponentModel.DataAnnotations;
+using Moonlight.App.Models.Misc;
 
 namespace Moonlight.App.Database.Entities;
 
@@ -24,6 +25,8 @@ public class User
     
     public string Country { get; set; } = "";
 
+    public string ServerListLayoutJson { get; set; } = "";
+
     // States
     
     public UserStatus Status { get; set; } = UserStatus.Unverified;
@@ -31,11 +34,14 @@ public class User
     public bool SupportPending { get; set; } = false;
     public bool HasRated { get; set; } = false;
     public int Rating { get; set; } = 0;
+    public bool StreamerMode { get; set; } = false;
     
     // Security
     public bool TotpEnabled { get; set; } = false;
     public string TotpSecret { get; set; } = "";
     public DateTime TokenValidTime { get; set; } = DateTime.UtcNow;
+    public byte[] Permissions { get; set; } = Array.Empty<byte>();
+    public PermissionGroup? PermissionGroup { get; set; }
     
     // Discord
     public ulong DiscordId { get; set; }
@@ -43,10 +49,15 @@ public class User
     // Date stuff
     public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
     public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
+    public DateTime LastVisitedAt { get; set; } = DateTime.UtcNow;
     
     // Subscriptions
 
     public Subscription? CurrentSubscription { get; set; } = null;
-    public DateTime SubscriptionSince { get; set; } = DateTime.Now;
+    public DateTime SubscriptionSince { get; set; } = DateTime.UtcNow;
-    public int SubscriptionDuration { get; set; }
+    public DateTime SubscriptionExpires { get; set; } = DateTime.UtcNow;
+    
+    // Ip logs
+    public string RegisterIp { get; set; } = "";
+    public string LastIp { get; set; } = "";
 }

Moonlight/App/Database/Entities/WhitelistIp.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.Database.Entities;
+
+public class WhitelistIp
+{
+    public int Id { get; set; }
+    public string Ip { get; set; } = "";
+}

Moonlight/App/Database/Interceptors/SqlLoggingInterceptor.cs

@@ -1,6 +1,6 @@
 using System.Data.Common;
-using Logging.Net;
 using Microsoft.EntityFrameworkCore.Diagnostics;
+using Moonlight.App.Helpers;
 
 namespace Moonlight.App.Database.Interceptors;
 

Moonlight/App/Database/Migrations/20230609202138_AddBackgroundImageUrlImage.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddBackgroundImageUrlImage : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "BackgroundImageUrl",
+                table: "Images",
+                type: "longtext",
+                nullable: false)
+                .Annotation("MySql:CharSet", "utf8mb4");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "BackgroundImageUrl",
+                table: "Images");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230611152138_AddLastVisitedTimestamp.cs

@@ -0,0 +1,30 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddLastVisitedTimestamp : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTime>(
+                name: "LastVisitedAt",
+                table: "Users",
+                type: "datetime(6)",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "LastVisitedAt",
+                table: "Users");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230614010621_AddedServerAchive.cs

@@ -0,0 +1,59 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedServerAchive : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "ArchiveId",
+                table: "Servers",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsArchived",
+                table: "Servers",
+                type: "tinyint(1)",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Servers_ArchiveId",
+                table: "Servers",
+                column: "ArchiveId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Servers_ServerBackups_ArchiveId",
+                table: "Servers",
+                column: "ArchiveId",
+                principalTable: "ServerBackups",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Servers_ServerBackups_ArchiveId",
+                table: "Servers");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Servers_ArchiveId",
+                table: "Servers");
+
+            migrationBuilder.DropColumn(
+                name: "ArchiveId",
+                table: "Servers");
+
+            migrationBuilder.DropColumn(
+                name: "IsArchived",
+                table: "Servers");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230623235512_AddedServerListLayoutToUser.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedServerListLayoutToUser : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "ServerListLayoutJson",
+                table: "Users",
+                type: "longtext",
+                nullable: false)
+                .Annotation("MySql:CharSet", "utf8mb4");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ServerListLayoutJson",
+                table: "Users");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230625190428_AddedStreamerMode.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedStreamerMode : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "StreamerMode",
+                table: "Users",
+                type: "tinyint(1)",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "StreamerMode",
+                table: "Users");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230703175432_AddedIpLogsForUser.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedIpLogsForUser : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "LastIp",
+                table: "Users",
+                type: "longtext",
+                nullable: false)
+                .Annotation("MySql:CharSet", "utf8mb4");
+
+            migrationBuilder.AddColumn<string>(
+                name: "RegisterIp",
+                table: "Users",
+                type: "longtext",
+                nullable: false)
+                .Annotation("MySql:CharSet", "utf8mb4");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "LastIp",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "RegisterIp",
+                table: "Users");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230705171914_AddedStripeIntegration.cs

@@ -0,0 +1,96 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedStripeIntegration : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "SubscriptionDuration",
+                table: "Users");
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "SubscriptionExpires",
+                table: "Users",
+                type: "datetime(6)",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+
+            migrationBuilder.AddColumn<int>(
+                name: "Currency",
+                table: "Subscriptions",
+                type: "int",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "Duration",
+                table: "Subscriptions",
+                type: "int",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<double>(
+                name: "Price",
+                table: "Subscriptions",
+                type: "double",
+                nullable: false,
+                defaultValue: 0.0);
+
+            migrationBuilder.AddColumn<string>(
+                name: "StripePriceId",
+                table: "Subscriptions",
+                type: "longtext",
+                nullable: false)
+                .Annotation("MySql:CharSet", "utf8mb4");
+
+            migrationBuilder.AddColumn<string>(
+                name: "StripeProductId",
+                table: "Subscriptions",
+                type: "longtext",
+                nullable: false)
+                .Annotation("MySql:CharSet", "utf8mb4");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "SubscriptionExpires",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "Currency",
+                table: "Subscriptions");
+
+            migrationBuilder.DropColumn(
+                name: "Duration",
+                table: "Subscriptions");
+
+            migrationBuilder.DropColumn(
+                name: "Price",
+                table: "Subscriptions");
+
+            migrationBuilder.DropColumn(
+                name: "StripePriceId",
+                table: "Subscriptions");
+
+            migrationBuilder.DropColumn(
+                name: "StripeProductId",
+                table: "Subscriptions");
+
+            migrationBuilder.AddColumn<int>(
+                name: "SubscriptionDuration",
+                table: "Users",
+                type: "int",
+                nullable: false,
+                defaultValue: 0);
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230715095531_AddPermissions.cs

@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPermissions : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<byte[]>(
+                name: "Permissions",
+                table: "Users",
+                type: "longblob",
+                nullable: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Permissions",
+                table: "Users");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230715214550_AddPermissionGroup.cs

@@ -0,0 +1,68 @@
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPermissionGroup : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "PermissionGroupId",
+                table: "Users",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "PermissionGroups",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    Name = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    Permissions = table.Column<byte[]>(type: "longblob", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PermissionGroups", x => x.Id);
+                })
+                .Annotation("MySql:CharSet", "utf8mb4");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Users_PermissionGroupId",
+                table: "Users",
+                column: "PermissionGroupId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Users_PermissionGroups_PermissionGroupId",
+                table: "Users",
+                column: "PermissionGroupId",
+                principalTable: "PermissionGroups",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Users_PermissionGroups_PermissionGroupId",
+                table: "Users");
+
+            migrationBuilder.DropTable(
+                name: "PermissionGroups");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Users_PermissionGroupId",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "PermissionGroupId",
+                table: "Users");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230718123232_RemovedOldLogsAndAddedErrorLog.cs

@@ -0,0 +1,111 @@
+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class RemovedOldLogsAndAddedErrorLog : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "AuditLog");
+
+            migrationBuilder.DropTable(
+                name: "ErrorLog");
+
+            migrationBuilder.DropTable(
+                name: "SecurityLog");
+
+            migrationBuilder.CreateTable(
+                name: "SecurityLogs",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    Text = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_SecurityLogs", x => x.Id);
+                })
+                .Annotation("MySql:CharSet", "utf8mb4");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "SecurityLogs");
+
+            migrationBuilder.CreateTable(
+                name: "AuditLog",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    Ip = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    JsonData = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    System = table.Column<bool>(type: "tinyint(1)", nullable: false),
+                    Type = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AuditLog", x => x.Id);
+                })
+                .Annotation("MySql:CharSet", "utf8mb4");
+
+            migrationBuilder.CreateTable(
+                name: "ErrorLog",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    Class = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    Ip = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    JsonData = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    Stacktrace = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    System = table.Column<bool>(type: "tinyint(1)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ErrorLog", x => x.Id);
+                })
+                .Annotation("MySql:CharSet", "utf8mb4");
+
+            migrationBuilder.CreateTable(
+                name: "SecurityLog",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    Ip = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    JsonData = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    System = table.Column<bool>(type: "tinyint(1)", nullable: false),
+                    Type = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_SecurityLog", x => x.Id);
+                })
+                .Annotation("MySql:CharSet", "utf8mb4");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230721201950_AddIpRules.cs

@@ -0,0 +1,59 @@
+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddIpRules : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "BlocklistIps",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    Ip = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    ExpiresAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    Packets = table.Column<long>(type: "bigint", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_BlocklistIps", x => x.Id);
+                })
+                .Annotation("MySql:CharSet", "utf8mb4");
+
+            migrationBuilder.CreateTable(
+                name: "WhitelistIps",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    Ip = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4")
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_WhitelistIps", x => x.Id);
+                })
+                .Annotation("MySql:CharSet", "utf8mb4");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "BlocklistIps");
+
+            migrationBuilder.DropTable(
+                name: "WhitelistIps");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230803012947_AddNewTicketModels.cs

@@ -0,0 +1,117 @@
+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddNewTicketModels : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Tickets",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    IssueTopic = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    IssueDescription = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    IssueTries = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    CreatedById = table.Column<int>(type: "int", nullable: false),
+                    AssignedToId = table.Column<int>(type: "int", nullable: true),
+                    Priority = table.Column<int>(type: "int", nullable: false),
+                    Status = table.Column<int>(type: "int", nullable: false),
+                    Subject = table.Column<int>(type: "int", nullable: false),
+                    SubjectId = table.Column<int>(type: "int", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Tickets", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Tickets_Users_AssignedToId",
+                        column: x => x.AssignedToId,
+                        principalTable: "Users",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_Tickets_Users_CreatedById",
+                        column: x => x.CreatedById,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                })
+                .Annotation("MySql:CharSet", "utf8mb4");
+
+            migrationBuilder.CreateTable(
+                name: "TicketMessages",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    Content = table.Column<string>(type: "longtext", nullable: false)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    AttachmentUrl = table.Column<string>(type: "longtext", nullable: true)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    SenderId = table.Column<int>(type: "int", nullable: true),
+                    IsSystemMessage = table.Column<bool>(type: "tinyint(1)", nullable: false),
+                    IsEdited = table.Column<bool>(type: "tinyint(1)", nullable: false),
+                    IsSupportMessage = table.Column<bool>(type: "tinyint(1)", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    TicketId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_TicketMessages", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_TicketMessages_Tickets_TicketId",
+                        column: x => x.TicketId,
+                        principalTable: "Tickets",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_TicketMessages_Users_SenderId",
+                        column: x => x.SenderId,
+                        principalTable: "Users",
+                        principalColumn: "Id");
+                })
+                .Annotation("MySql:CharSet", "utf8mb4");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TicketMessages_SenderId",
+                table: "TicketMessages",
+                column: "SenderId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TicketMessages_TicketId",
+                table: "TicketMessages",
+                column: "TicketId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Tickets_AssignedToId",
+                table: "Tickets",
+                column: "AssignedToId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Tickets_CreatedById",
+                table: "Tickets",
+                column: "CreatedById");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "TicketMessages");
+
+            migrationBuilder.DropTable(
+                name: "Tickets");
+        }
+    }
+}

Moonlight/App/Database/Migrations/DataContextModelSnapshot.cs

@@ -19,6 +19,30 @@ namespace Moonlight.App.Database.Migrations
                 .HasAnnotation("ProductVersion", "7.0.3")
                 .HasAnnotation("Relational:MaxIdentifierLength", 64);
 
+            modelBuilder.Entity("Moonlight.App.Database.Entities.BlocklistIp", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Ip")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<long>("Packets")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("BlocklistIps");
+                });
+
             modelBuilder.Entity("Moonlight.App.Database.Entities.CloudPanel", b =>
                 {
                     b.Property<int>("Id")
@@ -132,6 +156,10 @@ namespace Moonlight.App.Database.Migrations
                     b.Property<int>("Allocations")
                         .HasColumnType("int");
 
+                    b.Property<string>("BackgroundImageUrl")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
                     b.Property<string>("ConfigFiles")
                         .IsRequired()
                         .HasColumnType("longtext");
@@ -237,95 +265,6 @@ namespace Moonlight.App.Database.Migrations
                     b.ToTable("LoadingMessages");
                 });
 
-            modelBuilder.Entity("Moonlight.App.Database.Entities.LogsEntries.AuditLogEntry", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("int");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("datetime(6)");
-
-                    b.Property<string>("Ip")
-                        .IsRequired()
-                        .HasColumnType("longtext");
-
-                    b.Property<string>("JsonData")
-                        .IsRequired()
-                        .HasColumnType("longtext");
-
-                    b.Property<bool>("System")
-                        .HasColumnType("tinyint(1)");
-
-                    b.Property<int>("Type")
-                        .HasColumnType("int");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("AuditLog");
-                });
-
-            modelBuilder.Entity("Moonlight.App.Database.Entities.LogsEntries.ErrorLogEntry", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("int");
-
-                    b.Property<string>("Class")
-                        .IsRequired()
-                        .HasColumnType("longtext");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("datetime(6)");
-
-                    b.Property<string>("Ip")
-                        .IsRequired()
-                        .HasColumnType("longtext");
-
-                    b.Property<string>("JsonData")
-                        .IsRequired()
-                        .HasColumnType("longtext");
-
-                    b.Property<string>("Stacktrace")
-                        .IsRequired()
-                        .HasColumnType("longtext");
-
-                    b.Property<bool>("System")
-                        .HasColumnType("tinyint(1)");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("ErrorLog");
-                });
-
-            modelBuilder.Entity("Moonlight.App.Database.Entities.LogsEntries.SecurityLogEntry", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("int");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("datetime(6)");
-
-                    b.Property<string>("Ip")
-                        .IsRequired()
-                        .HasColumnType("longtext");
-
-                    b.Property<string>("JsonData")
-                        .IsRequired()
-                        .HasColumnType("longtext");
-
-                    b.Property<bool>("System")
-                        .HasColumnType("tinyint(1)");
-
-                    b.Property<int>("Type")
-                        .HasColumnType("int");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("SecurityLog");
-                });
-
             modelBuilder.Entity("Moonlight.App.Database.Entities.MySqlDatabase", b =>
                 {
                     b.Property<int>("Id")
@@ -471,6 +410,25 @@ namespace Moonlight.App.Database.Migrations
                     b.ToTable("NotificationClients");
                 });
 
+            modelBuilder.Entity("Moonlight.App.Database.Entities.PermissionGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<byte[]>("Permissions")
+                        .IsRequired()
+                        .HasColumnType("longblob");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PermissionGroups");
+                });
+
             modelBuilder.Entity("Moonlight.App.Database.Entities.Revoke", b =>
                 {
                     b.Property<int>("Id")
@@ -486,12 +444,33 @@ namespace Moonlight.App.Database.Migrations
                     b.ToTable("Revokes");
                 });
 
+            modelBuilder.Entity("Moonlight.App.Database.Entities.SecurityLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SecurityLogs");
+                });
+
             modelBuilder.Entity("Moonlight.App.Database.Entities.Server", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
                         .HasColumnType("int");
 
+                    b.Property<int?>("ArchiveId")
+                        .HasColumnType("int");
+
                     b.Property<int>("Cpu")
                         .HasColumnType("int");
 
@@ -507,6 +486,9 @@ namespace Moonlight.App.Database.Migrations
                     b.Property<bool>("Installing")
                         .HasColumnType("tinyint(1)");
 
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("tinyint(1)");
+
                     b.Property<bool>("IsCleanupException")
                         .HasColumnType("tinyint(1)");
 
@@ -538,6 +520,8 @@ namespace Moonlight.App.Database.Migrations
 
                     b.HasKey("Id");
 
+                    b.HasIndex("ArchiveId");
+
                     b.HasIndex("ImageId");
 
                     b.HasIndex("MainAllocationId");
@@ -651,10 +635,16 @@ namespace Moonlight.App.Database.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("int");
 
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
                     b.Property<string>("Description")
                         .IsRequired()
                         .HasColumnType("longtext");
 
+                    b.Property<int>("Duration")
+                        .HasColumnType("int");
+
                     b.Property<string>("LimitsJson")
                         .IsRequired()
                         .HasColumnType("longtext");
@@ -663,6 +653,17 @@ namespace Moonlight.App.Database.Migrations
                         .IsRequired()
                         .HasColumnType("longtext");
 
+                    b.Property<double>("Price")
+                        .HasColumnType("double");
+
+                    b.Property<string>("StripePriceId")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("StripeProductId")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
                     b.HasKey("Id");
 
                     b.ToTable("Subscriptions");
@@ -713,6 +714,97 @@ namespace Moonlight.App.Database.Migrations
                     b.ToTable("SupportChatMessages");
                 });
 
+            modelBuilder.Entity("Moonlight.App.Database.Entities.Ticket", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("AssignedToId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedById")
+                        .HasColumnType("int");
+
+                    b.Property<string>("IssueDescription")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("IssueTopic")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("IssueTries")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Subject")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SubjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignedToId");
+
+                    b.HasIndex("CreatedById");
+
+                    b.ToTable("Tickets");
+                });
+
+            modelBuilder.Entity("Moonlight.App.Database.Entities.TicketMessage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("AttachmentUrl")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsEdited")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsSupportMessage")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsSystemMessage")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("SenderId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TicketId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SenderId");
+
+                    b.HasIndex("TicketId");
+
+                    b.ToTable("TicketMessages");
+                });
+
             modelBuilder.Entity("Moonlight.App.Database.Entities.User", b =>
                 {
                     b.Property<int>("Id")
@@ -754,17 +846,39 @@ namespace Moonlight.App.Database.Migrations
                     b.Property<bool>("HasRated")
                         .HasColumnType("tinyint(1)");
 
+                    b.Property<string>("LastIp")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
                     b.Property<string>("LastName")
                         .IsRequired()
                         .HasColumnType("longtext");
 
+                    b.Property<DateTime>("LastVisitedAt")
+                        .HasColumnType("datetime(6)");
+
                     b.Property<string>("Password")
                         .IsRequired()
                         .HasColumnType("longtext");
 
+                    b.Property<int?>("PermissionGroupId")
+                        .HasColumnType("int");
+
+                    b.Property<byte[]>("Permissions")
+                        .IsRequired()
+                        .HasColumnType("longblob");
+
                     b.Property<int>("Rating")
                         .HasColumnType("int");
 
+                    b.Property<string>("RegisterIp")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ServerListLayoutJson")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
                     b.Property<string>("State")
                         .IsRequired()
                         .HasColumnType("longtext");
@@ -772,8 +886,11 @@ namespace Moonlight.App.Database.Migrations
                     b.Property<int>("Status")
                         .HasColumnType("int");
 
-                    b.Property<int>("SubscriptionDuration")
+                    b.Property<bool>("StreamerMode")
-                        .HasColumnType("int");
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime>("SubscriptionExpires")
+                        .HasColumnType("datetime(6)");
 
                     b.Property<DateTime>("SubscriptionSince")
                         .HasColumnType("datetime(6)");
@@ -798,6 +915,8 @@ namespace Moonlight.App.Database.Migrations
 
                     b.HasIndex("CurrentSubscriptionId");
 
+                    b.HasIndex("PermissionGroupId");
+
                     b.ToTable("Users");
                 });
 
@@ -838,6 +957,21 @@ namespace Moonlight.App.Database.Migrations
                     b.ToTable("WebSpaces");
                 });
 
+            modelBuilder.Entity("Moonlight.App.Database.Entities.WhitelistIp", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Ip")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WhitelistIps");
+                });
+
             modelBuilder.Entity("Moonlight.App.Database.Entities.DdosAttack", b =>
                 {
                     b.HasOne("Moonlight.App.Database.Entities.Node", "Node")
@@ -928,6 +1062,10 @@ namespace Moonlight.App.Database.Migrations
 
             modelBuilder.Entity("Moonlight.App.Database.Entities.Server", b =>
                 {
+                    b.HasOne("Moonlight.App.Database.Entities.ServerBackup", "Archive")
+                        .WithMany()
+                        .HasForeignKey("ArchiveId");
+
                     b.HasOne("Moonlight.App.Database.Entities.Image", "Image")
                         .WithMany()
                         .HasForeignKey("ImageId")
@@ -950,6 +1088,8 @@ namespace Moonlight.App.Database.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("Archive");
+
                     b.Navigation("Image");
 
                     b.Navigation("MainAllocation");
@@ -990,13 +1130,49 @@ namespace Moonlight.App.Database.Migrations
                     b.Navigation("Sender");
                 });
 
+            modelBuilder.Entity("Moonlight.App.Database.Entities.Ticket", b =>
+                {
+                    b.HasOne("Moonlight.App.Database.Entities.User", "AssignedTo")
+                        .WithMany()
+                        .HasForeignKey("AssignedToId");
+
+                    b.HasOne("Moonlight.App.Database.Entities.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AssignedTo");
+
+                    b.Navigation("CreatedBy");
+                });
+
+            modelBuilder.Entity("Moonlight.App.Database.Entities.TicketMessage", b =>
+                {
+                    b.HasOne("Moonlight.App.Database.Entities.User", "Sender")
+                        .WithMany()
+                        .HasForeignKey("SenderId");
+
+                    b.HasOne("Moonlight.App.Database.Entities.Ticket", null)
+                        .WithMany("Messages")
+                        .HasForeignKey("TicketId");
+
+                    b.Navigation("Sender");
+                });
+
             modelBuilder.Entity("Moonlight.App.Database.Entities.User", b =>
                 {
                     b.HasOne("Moonlight.App.Database.Entities.Subscription", "CurrentSubscription")
                         .WithMany()
                         .HasForeignKey("CurrentSubscriptionId");
 
+                    b.HasOne("Moonlight.App.Database.Entities.PermissionGroup", "PermissionGroup")
+                        .WithMany()
+                        .HasForeignKey("PermissionGroupId");
+
                     b.Navigation("CurrentSubscription");
+
+                    b.Navigation("PermissionGroup");
                 });
 
             modelBuilder.Entity("Moonlight.App.Database.Entities.WebSpace", b =>
@@ -1039,6 +1215,11 @@ namespace Moonlight.App.Database.Migrations
                     b.Navigation("Variables");
                 });
 
+            modelBuilder.Entity("Moonlight.App.Database.Entities.Ticket", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
             modelBuilder.Entity("Moonlight.App.Database.Entities.WebSpace", b =>
                 {
                     b.Navigation("Databases");

Moonlight/App/Diagnostics/HealthChecks/DaemonHealthCheck.cs

@@ -0,0 +1,58 @@
+using System.Diagnostics;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Moonlight.App.Database.Entities;
+using Moonlight.App.Repositories;
+using Moonlight.App.Services;
+
+namespace Moonlight.App.Diagnostics.HealthChecks;
+
+public class DaemonHealthCheck : IHealthCheck
+{
+    private readonly Repository<Node> NodeRepository;
+    private readonly NodeService NodeService;
+
+    public DaemonHealthCheck(Repository<Node> nodeRepository, NodeService nodeService)
+    {
+        NodeRepository = nodeRepository;
+        NodeService = nodeService;
+    }
+
+    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken())
+    {
+        var nodes = NodeRepository.Get().ToArray();
+        
+        var results = new Dictionary<Node, bool>();
+        var healthCheckData = new Dictionary<string, object>();
+        
+        foreach (var node in nodes)
+        {
+            try
+            {
+                await NodeService.GetCpuMetrics(node);
+                
+                results.Add(node, true);
+            }
+            catch (Exception e)
+            {
+                results.Add(node, false);
+                healthCheckData.Add(node.Name, e.ToStringDemystified());
+            }
+        }
+
+        var offlineNodes = results
+            .Where(x => !x.Value)
+            .ToArray();
+
+        if (offlineNodes.Length == nodes.Length)
+        {
+            return HealthCheckResult.Unhealthy("All node daemons are offline", null, healthCheckData);
+        }
+        
+        if (offlineNodes.Length == 0)
+        {
+            return HealthCheckResult.Healthy("All node daemons are online");
+        }
+            
+        return HealthCheckResult.Degraded($"{offlineNodes.Length} node daemons are offline", null, healthCheckData);
+    }
+}

Moonlight/App/Diagnostics/HealthChecks/DatabaseHealthCheck.cs

@@ -0,0 +1,32 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Moonlight.App.Database;
+
+namespace Moonlight.App.Diagnostics.HealthChecks;
+
+public class DatabaseHealthCheck : IHealthCheck
+{
+    private readonly DataContext DataContext;
+
+    public DatabaseHealthCheck(DataContext dataContext)
+    {
+        DataContext = dataContext;
+    }
+
+    public async Task<HealthCheckResult> CheckHealthAsync(
+        HealthCheckContext context,
+        CancellationToken cancellationToken = new CancellationToken())
+    {
+        try
+        {
+            await DataContext.Database.OpenConnectionAsync(cancellationToken);
+            await DataContext.Database.CloseConnectionAsync();
+            
+            return HealthCheckResult.Healthy("Database is online");
+        }
+        catch (Exception e)
+        {
+            return HealthCheckResult.Unhealthy("Database is offline", e);
+        }
+    }
+}

Moonlight/App/Diagnostics/HealthChecks/NodeHealthCheck.cs

@@ -0,0 +1,58 @@
+using System.Diagnostics;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Moonlight.App.Database.Entities;
+using Moonlight.App.Repositories;
+using Moonlight.App.Services;
+
+namespace Moonlight.App.Diagnostics.HealthChecks;
+
+public class NodeHealthCheck : IHealthCheck
+{
+    private readonly Repository<Node> NodeRepository;
+    private readonly NodeService NodeService;
+
+    public NodeHealthCheck(Repository<Node> nodeRepository, NodeService nodeService)
+    {
+        NodeRepository = nodeRepository;
+        NodeService = nodeService;
+    }
+
+    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken())
+    {
+        var nodes = NodeRepository.Get().ToArray();
+        
+        var results = new Dictionary<Node, bool>();
+        var healthCheckData = new Dictionary<string, object>();
+        
+        foreach (var node in nodes)
+        {
+            try
+            {
+                await NodeService.GetStatus(node);
+                
+                results.Add(node, true);
+            }
+            catch (Exception e)
+            {
+                results.Add(node, false);
+                healthCheckData.Add(node.Name, e.ToStringDemystified());
+            }
+        }
+
+        var offlineNodes = results
+            .Where(x => !x.Value)
+            .ToArray();
+
+        if (offlineNodes.Length == nodes.Length)
+        {
+            return HealthCheckResult.Unhealthy("All nodes are offline", null, healthCheckData);
+        }
+        
+        if (offlineNodes.Length == 0)
+        {
+            return HealthCheckResult.Healthy("All nodes are online");
+        }
+            
+        return HealthCheckResult.Degraded($"{offlineNodes.Length} nodes are offline", null, healthCheckData);
+    }
+}

Moonlight/App/Events/EventSystem.cs

@@ -1,11 +1,10 @@
 using System.Diagnostics;
-using Logging.Net;
+using Moonlight.App.Helpers;
 
 namespace Moonlight.App.Events;
 
 public class EventSystem
 {
-    private Dictionary<int, object> Storage = new();
     private List<Subscriber> Subscribers = new();
 
     private readonly bool Debug = false;
@@ -33,16 +32,8 @@ public class EventSystem
         return Task.CompletedTask;
     }
 
-    public Task Emit(string id, object? d = null)
+    public Task Emit(string id, object? data = null)
     {
-        int hashCode = -1;
-
-        if (d != null)
-        {
-            hashCode = d.GetHashCode();
-            Storage.TryAdd(hashCode, d);
-        }
-
         Subscriber[] subscribers;
 
         lock (Subscribers)
@@ -58,23 +49,6 @@ public class EventSystem
         {
             tasks.Add(new Task(() =>
             {
-                int storageId = hashCode + 0; // To create a copy of the hash code
-
-                object? data = null;
-
-                if (storageId != -1)
-                {
-                    if (Storage.TryGetValue(storageId, out var value))
-                    {
-                        data = value;
-                    }
-                    else
-                    {
-                        Logger.Warn($"Object with the hash '{storageId}' was not present in the storage");
-                        return;
-                    }
-                }
-
                 var stopWatch = new Stopwatch();
                 stopWatch.Start();
 
@@ -115,7 +89,6 @@ public class EventSystem
         Task.Run(() =>
         {
             Task.WaitAll(tasks.ToArray());
-            Storage.Remove(hashCode);
 
             if(Debug)
                 Logger.Debug($"Completed all event tasks for '{id}' and removed object from storage");
@@ -139,4 +112,22 @@ public class EventSystem
         
         return Task.CompletedTask;
     }
+    
+    public Task<T> WaitForEvent<T>(string id, object handle, Func<T, bool> filter)
+    {
+        var taskCompletionSource = new TaskCompletionSource<T>();
+    
+        Func<T, Task> action = async data =>
+        {
+            if (filter.Invoke(data))
+            {
+                taskCompletionSource.SetResult(data);
+                await Off(id, handle);
+            }
+        };
+
+        On<T>(id, handle, action);
+
+        return taskCompletionSource.Task;
+    }
 }

Moonlight/App/Exceptions/DisplayException.cs

@@ -5,6 +5,8 @@ namespace Moonlight.App.Exceptions;
 [Serializable]
 public class DisplayException : Exception
 {
+    public bool DoNotTranslate { get; set; } = false;
+    
     //
     // For guidelines regarding the creation of new exception types, see
     //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
@@ -20,6 +22,11 @@ public class DisplayException : Exception
     {
     }
     
+    public DisplayException(string message, bool doNotTranslate) : base(message)
+    {
+        DoNotTranslate = doNotTranslate;
+    }
+
     public DisplayException(string message, Exception inner) : base(message, inner)
     {
     }

Moonlight/App/Extensions/JSRuntimeExtensions.cs

@@ -0,0 +1,30 @@
+using Microsoft.JSInterop;
+
+namespace Moonlight.App.Extensions;
+
+public static class JSRuntimeExtensions
+{
+    public static async Task InvokeVoidSafeAsync(this IJSRuntime jsRuntime, string method, params object[] args)
+    {
+        try
+        {
+            await jsRuntime.InvokeVoidAsync(method, args);
+        }
+        catch (Exception)
+        {
+            // ignored
+        }
+    }
+    
+    public static void InvokeVoidSafe(this IJSRuntime jsRuntime, string method, params object[] args)
+    {
+        try
+        {
+            jsRuntime.InvokeVoidAsync(method, args);
+        }
+        catch (Exception)
+        {
+            // ignored
+        }
+    }
+}

Moonlight/App/Helpers/AvgHelper.cs

@@ -0,0 +1,39 @@
+using Moonlight.App.Database.Entities;
+
+namespace Moonlight.App.Helpers;
+
+public static class AvgHelper
+{
+    public static StatisticsData[] Calculate(StatisticsData[] data, int splitSize = 40)
+    {
+        if (data.Length <= splitSize)
+            return data;
+
+        var result = new List<StatisticsData>();
+
+        var i = data.Length / (float)splitSize;
+        var pc = (int)Math.Round(i);
+
+        foreach (var part in data.Chunk(pc))
+        {
+            double d = 0;
+            var res = new StatisticsData();
+
+            foreach (var entry in part)
+            {
+                d += entry.Value;
+            }
+
+            res.Chart = part.First().Chart;
+            res.Date = part.First().Date;
+
+            if (d == 0)
+                res.Value = 0;
+
+            res.Value = d / part.Length;
+            result.Add(res);
+        }
+
+        return result.ToArray();
+    }
+}

Moonlight/App/Helpers/BackupHelper.cs

@@ -0,0 +1,119 @@
+using System.Diagnostics;
+using System.IO.Compression;
+using Microsoft.EntityFrameworkCore;
+using Moonlight.App.Database;
+using Moonlight.App.Services;
+using MySql.Data.MySqlClient;
+
+namespace Moonlight.App.Helpers;
+
+public class BackupHelper
+{
+    public async Task CreateBackup(string path)
+    {
+        Logger.Info("Started moonlight backup creation");
+        Logger.Info($"This backup will be saved to '{path}'");
+
+        var stopWatch = new Stopwatch();
+        stopWatch.Start();
+        
+        var cachePath = PathBuilder.Dir("storage", "backups", "cache");
+
+        Directory.CreateDirectory(cachePath);
+
+        //
+        // Exporting database
+        //
+        
+        Logger.Info("Exporting database");
+
+        var configService = new ConfigService(new());
+        var dataContext = new DataContext(configService);
+
+        await using MySqlConnection conn = new MySqlConnection(dataContext.Database.GetConnectionString());
+        await using MySqlCommand cmd = new MySqlCommand();
+        using MySqlBackup mb = new MySqlBackup(cmd);
+        
+        cmd.Connection = conn;
+        await conn.OpenAsync();
+        mb.ExportToFile(PathBuilder.File(cachePath, "database.sql"));
+        await conn.CloseAsync();
+        
+        //
+        // Saving config
+        //
+        
+        Logger.Info("Saving configuration");
+        File.Copy(
+            PathBuilder.File("storage", "configs", "config.json"), 
+            PathBuilder.File(cachePath, "config.json"));
+        
+        //
+        // Saving all storage items needed to restore the panel
+        //
+        
+        Logger.Info("Saving resources");
+        CopyDirectory(
+            PathBuilder.Dir("storage", "resources"), 
+            PathBuilder.Dir(cachePath, "resources"));
+
+        Logger.Info("Saving logs");
+        CopyDirectory(
+            PathBuilder.Dir("storage", "logs"), 
+            PathBuilder.Dir(cachePath, "logs"));
+
+        Logger.Info("Saving uploads");
+        CopyDirectory(
+            PathBuilder.Dir("storage", "uploads"), 
+            PathBuilder.Dir(cachePath, "uploads"));
+        
+        //
+        // Compressing the backup to a single file
+        //
+        
+        Logger.Info("Compressing");
+        ZipFile.CreateFromDirectory(cachePath, 
+            path, 
+            CompressionLevel.Fastest, 
+            false);
+        
+        Directory.Delete(cachePath, true);
+        
+        stopWatch.Stop();
+        Logger.Info($"Backup successfully created. Took {stopWatch.Elapsed.TotalSeconds} seconds");
+    }
+    
+    private void CopyDirectory(string sourceDirName, string destDirName, bool copySubDirs = true)
+    {
+        DirectoryInfo dir = new DirectoryInfo(sourceDirName);
+
+        if (!dir.Exists)
+        {
+            throw new DirectoryNotFoundException($"Source directory does not exist or could not be found: {sourceDirName}");
+        }
+
+        if (!Directory.Exists(destDirName))
+        {
+            Directory.CreateDirectory(destDirName);
+        }
+
+        FileInfo[] files = dir.GetFiles();
+
+        foreach (FileInfo file in files)
+        {
+            string tempPath = Path.Combine(destDirName, file.Name);
+            file.CopyTo(tempPath, false);
+        }
+
+        if (copySubDirs)
+        {
+            DirectoryInfo[] dirs = dir.GetDirectories();
+
+            foreach (DirectoryInfo subdir in dirs)
+            {
+                string tempPath = Path.Combine(destDirName, subdir.Name);
+                CopyDirectory(subdir.FullName, tempPath, copySubDirs);
+            }
+        }
+    }
+}

Moonlight/App/Helpers/BitHelper.cs

@@ -0,0 +1,88 @@
+namespace Moonlight.App.Helpers;
+
+public class BitHelper
+{
+    public static bool ReadBit(byte[] byteArray, int bitIndex)
+    {
+        if (bitIndex < 0)
+            throw new ArgumentOutOfRangeException("bitIndex");
+
+        int byteIndex = bitIndex / 8;
+        if (byteIndex >= byteArray.Length)
+            throw new ArgumentOutOfRangeException("bitIndex");
+
+        int bitNumber = bitIndex % 8;
+        byte mask = (byte)(1 << bitNumber);
+
+        return (byteArray[byteIndex] & mask) != 0;
+    }
+    
+    public static byte[] WriteBit(byte[] byteArray, int bitIndex, bool value)
+    {
+        if (bitIndex < 0)
+            throw new ArgumentOutOfRangeException("bitIndex");
+
+        int byteIndex = bitIndex / 8;
+        byte[] resultArray;
+
+        if (byteIndex >= byteArray.Length)
+        {
+            // Create a new array with increased size and copy elements from old array
+            resultArray = new byte[byteIndex + 1];
+            Array.Copy(byteArray, resultArray, byteArray.Length);
+        }
+        else
+        {
+            // Create a new array and copy elements from old array
+            resultArray = new byte[byteArray.Length];
+            Array.Copy(byteArray, resultArray, byteArray.Length);
+        }
+
+        int bitNumber = bitIndex % 8;
+        byte mask = (byte)(1 << bitNumber);
+
+        if (value)
+            resultArray[byteIndex] |= mask; // Set the bit to 1
+        else
+            resultArray[byteIndex] &= (byte)~mask; // Set the bit to 0
+
+        return resultArray;
+    }
+    
+    public static byte[] OverwriteByteArrays(byte[] targetArray, byte[] overwriteArray)
+    {
+        int targetLength = targetArray.Length;
+        int overwriteLength = overwriteArray.Length;
+
+        int maxLength = Math.Max(targetLength, overwriteLength);
+
+        byte[] resultArray = new byte[maxLength];
+
+        for (int i = 0; i < maxLength; i++)
+        {
+            byte targetByte = i < targetLength ? targetArray[i] : (byte)0;
+            byte overwriteByte = i < overwriteLength ? overwriteArray[i] : (byte)0;
+
+            for (int j = 0; j < 8; j++)
+            {
+                bool overwriteBit = (overwriteByte & (1 << j)) != 0;
+                if (i < targetLength)
+                {
+                    bool targetBit = (targetByte & (1 << j)) != 0;
+                    if (overwriteBit)
+                    {
+                        targetByte = targetBit ? (byte)(targetByte | (1 << j)) : (byte)(targetByte & ~(1 << j));
+                    }
+                }
+                else if (overwriteBit)
+                {
+                    targetByte |= (byte)(1 << j);
+                }
+            }
+
+            resultArray[i] = targetByte;
+        }
+
+        return resultArray;
+    }
+}

Moonlight/App/Helpers/BlurAttribute.cs

@@ -0,0 +1,6 @@
+namespace Moonlight.App.Helpers;
+
+public class BlurAttribute : Attribute
+{
+    
+}

Moonlight/App/Helpers/ByteSizeValue.cs

@@ -0,0 +1,56 @@
+namespace Moonlight.App.Helpers;
+
+public class ByteSizeValue
+{
+    public long Bytes { get; set; }
+
+    public long KiloBytes
+    {
+        get => Bytes / 1024;
+        set => Bytes = value * 1024;
+    }
+    
+    public long MegaBytes
+    {
+        get => KiloBytes / 1024;
+        set => KiloBytes = value * 1024;
+    }
+    
+    public long GigaBytes
+    {
+        get => MegaBytes / 1024;
+        set => MegaBytes = value * 1024;
+    }
+
+    public static ByteSizeValue FromBytes(long bytes)
+    {
+        return new()
+        {
+            Bytes = bytes
+        };
+    }
+    
+    public static ByteSizeValue FromKiloBytes(long kiloBytes)
+    {
+        return new()
+        {
+            KiloBytes = kiloBytes
+        };
+    }
+    
+    public static ByteSizeValue FromMegaBytes(long megaBytes)
+    {
+        return new()
+        {
+            MegaBytes = megaBytes
+        };
+    }
+    
+    public static ByteSizeValue FromGigaBytes(long gigaBytes)
+    {
+        return new()
+        {
+            GigaBytes = gigaBytes
+        };
+    }
+}

Moonlight/App/Helpers/CacheLogger.cs

@@ -1,252 +0,0 @@
-using System.Diagnostics;
-using Logging.Net;
-using Logging.Net.Loggers.SB;
-using Moonlight.App.Models.Misc;
-using ILogger = Logging.Net.ILogger;
-
-namespace Moonlight.App.Helpers;
-
-public class CacheLogger : ILogger
-{
-    private SBLogger SbLogger = new();
-    private List<LogEntry> Messages = new();
-
-    public LogEntry[] GetMessages()
-    {
-        lock (Messages)
-        {
-            var result = new LogEntry[Messages.Count];
-            Messages.CopyTo(result);
-            return result;
-        }
-    }
-
-    public void Clear(int messages)
-    {
-        lock (Messages)
-        {
-            Messages.RemoveRange(0, Math.Min(messages, Messages.Count));
-        }
-    }
-
-    public void Info(string? s)
-    {
-        if (s == null)
-            return;
-
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "info",
-                Message = s
-            });
-        }
-
-        SbLogger.Info(s);
-    }
-
-    public void Debug(string? s)
-    {
-        if (s == null)
-            return;
-
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "debug",
-                Message = s
-            });
-        }
-
-        SbLogger.Debug(s);
-    }
-
-    public void Warn(string? s)
-    {
-        if (s == null)
-            return;
-
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "warn",
-                Message = s
-            });
-        }
-
-        SbLogger.Warn(s);
-    }
-
-    public void Error(string? s)
-    {
-        if (s == null)
-            return;
-
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "error",
-                Message = s
-            });
-        }
-
-        SbLogger.Error(s);
-    }
-
-    public void Fatal(string? s)
-    {
-        if (s == null)
-            return;
-
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "fatal",
-                Message = s
-            });
-        }
-
-        SbLogger.Fatal(s);
-    }
-
-    public void InfoEx(Exception ex)
-    {
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "info",
-                Message = ex.ToStringDemystified()
-            });
-        }
-
-        SbLogger.InfoEx(ex);
-    }
-
-    public void DebugEx(Exception ex)
-    {
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "debug",
-                Message = ex.ToStringDemystified()
-            });
-        }
-
-        SbLogger.DebugEx(ex);
-    }
-
-    public void WarnEx(Exception ex)
-    {
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "warn",
-                Message = ex.ToStringDemystified()
-            });
-        }
-
-        SbLogger.WarnEx(ex);
-    }
-
-    public void ErrorEx(Exception ex)
-    {
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "error",
-                Message = ex.ToStringDemystified()
-            });
-        }
-
-        SbLogger.ErrorEx(ex);
-    }
-
-    public void FatalEx(Exception ex)
-    {
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "fatal",
-                Message = ex.ToStringDemystified()
-            });
-        }
-
-        SbLogger.FatalEx(ex);
-    }
-
-    public LoggingConfiguration GetErrorConfiguration()
-    {
-        return SbLogger.GetErrorConfiguration();
-    }
-
-    public void SetErrorConfiguration(LoggingConfiguration configuration)
-    {
-        SbLogger.SetErrorConfiguration(configuration);
-    }
-
-    public LoggingConfiguration GetFatalConfiguration()
-    {
-        return SbLogger.GetFatalConfiguration();
-    }
-
-    public void SetFatalConfiguration(LoggingConfiguration configuration)
-    {
-        SbLogger.SetFatalConfiguration(configuration);
-    }
-
-    public LoggingConfiguration GetWarnConfiguration()
-    {
-        return SbLogger.GetWarnConfiguration();
-    }
-
-    public void SetWarnConfiguration(LoggingConfiguration configuration)
-    {
-        SbLogger.SetWarnConfiguration(configuration);
-    }
-
-    public LoggingConfiguration GetInfoConfiguration()
-    {
-        return SbLogger.GetInfoConfiguration();
-    }
-
-    public void SetInfoConfiguration(LoggingConfiguration configuration)
-    {
-        SbLogger.SetInfoConfiguration(configuration);
-    }
-
-    public LoggingConfiguration GetDebugConfiguration()
-    {
-        return SbLogger.GetDebugConfiguration();
-    }
-
-    public void SetDebugConfiguration(LoggingConfiguration configuration)
-    {
-        SbLogger.SetDebugConfiguration(configuration);
-    }
-
-    public ILoggingAddition GetAddition()
-    {
-        return SbLogger.GetAddition();
-    }
-
-    public void SetAddition(ILoggingAddition addition)
-    {
-        SbLogger.SetAddition(addition);
-    }
-
-    public bool LogCallingClass
-    {
-        get => SbLogger.LogCallingClass;
-        set => SbLogger.LogCallingClass = value;
-    }
-}

Moonlight/App/Helpers/ComponentHelper.cs

@@ -0,0 +1,12 @@
+using Microsoft.AspNetCore.Components;
+
+namespace Moonlight.App.Helpers;
+
+public class ComponentHelper
+{
+    public static RenderFragment FromType(Type type) => builder =>
+    {
+        builder.OpenComponent(0, type);
+        builder.CloseComponent();
+    };
+}

Moonlight/App/Helpers/DatabaseCheckupService.cs

@@ -1,5 +1,4 @@
 using System.Diagnostics;
-using Logging.Net;
 using Microsoft.EntityFrameworkCore;
 using Moonlight.App.Database;
 using Moonlight.App.Services;
@@ -46,7 +45,9 @@ public class DatabaseCheckupService
         {
             Logger.Info($"{migrations.Length} migrations pending. Updating now");
 
-            await BackupDatabase();
+            var backupHelper = new BackupHelper();
+            await backupHelper.CreateBackup(
+                PathBuilder.File("storage", "backups", $"{new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds()}.zip"));
             
             Logger.Info("Applying migrations");
             
@@ -59,42 +60,4 @@ public class DatabaseCheckupService
             Logger.Info("Database is up-to-date. No migrations have been performed");
         }
     }
-
-    public async Task BackupDatabase()
-    {
-        Logger.Info("Creating backup from database");
-        
-        var configService = new ConfigService(new StorageService());
-        var dateTimeService = new DateTimeService();
-        
-        var config = configService
-            .GetSection("Moonlight")
-            .GetSection("Database");
-
-        var connectionString = $"host={config.GetValue<string>("Host")};" +
-                               $"port={config.GetValue<int>("Port")};" +
-                               $"database={config.GetValue<string>("Database")};" +
-                               $"uid={config.GetValue<string>("Username")};" +
-                               $"pwd={config.GetValue<string>("Password")}";
-        
-        string file = PathBuilder.File("storage", "backups", $"{dateTimeService.GetCurrentUnix()}-mysql.sql");
-        
-        Logger.Info($"Saving it to: {file}");
-        Logger.Info("Starting backup...");
-
-        var sw = new Stopwatch();
-        sw.Start();
-
-        await using MySqlConnection conn = new MySqlConnection(connectionString);
-        await using MySqlCommand cmd = new MySqlCommand();
-        using MySqlBackup mb = new MySqlBackup(cmd);
-        
-        cmd.Connection = conn;
-        await conn.OpenAsync();
-        mb.ExportToFile(file);
-        await conn.CloseAsync();
-
-        sw.Stop();
-        Logger.Info($"Done. {sw.Elapsed.TotalSeconds}s");
-    }
 }

Moonlight/App/Helpers/EggConverter.cs

@@ -0,0 +1,71 @@
+using System.Text;
+using Moonlight.App.Database.Entities;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Moonlight.App.Helpers;
+
+public static class EggConverter
+{
+    public static Image Convert(string json)
+    {
+        var result = new Image();
+
+        var data = new ConfigurationBuilder().AddJsonStream(
+            new MemoryStream(Encoding.ASCII.GetBytes(json))
+        ).Build();
+
+        result.Allocations = 1;
+        result.Description = data.GetValue<string>("description") ?? "";
+        result.Uuid = Guid.NewGuid();
+        result.Startup = data.GetValue<string>("startup") ?? "";
+        result.Name = data.GetValue<string>("name") ?? "Ptero Egg";
+
+        foreach (var variable in data.GetSection("variables").GetChildren())
+        {
+            result.Variables.Add(new()
+            {
+                Key = variable.GetValue<string>("env_variable") ?? "",
+                DefaultValue = variable.GetValue<string>("default_value") ?? ""
+            });
+        }
+        
+        var configData = data.GetSection("config");
+
+        result.ConfigFiles = configData.GetValue<string>("files") ?? "{}";
+
+        var dImagesData = JObject.Parse(json);
+        var dImages = (JObject)dImagesData["docker_images"]!;
+        
+        foreach (var dockerImage in dImages)
+        {
+            var di = new DockerImage()
+            {
+                Default = dockerImage.Key == dImages.Properties().Last().Name,
+                Name = dockerImage.Value!.ToString()
+            };
+
+            result.DockerImages.Add(di);
+        }
+
+        var installSection = data.GetSection("scripts").GetSection("installation");
+
+        result.InstallEntrypoint = installSection.GetValue<string>("entrypoint") ?? "bash";
+        result.InstallScript = installSection.GetValue<string>("script") ?? "";
+        result.InstallDockerImage = installSection.GetValue<string>("container") ?? "";
+
+        var rawJson = configData.GetValue<string>("startup");
+        
+        var startupData = new ConfigurationBuilder().AddJsonStream(
+            new MemoryStream(Encoding.ASCII.GetBytes(rawJson!))
+        ).Build();
+
+        result.StartupDetection = startupData.GetValue<string>("done", "") ?? "";
+        result.StopCommand = configData.GetValue<string>("stop") ?? "";
+
+        result.TagsJson = "[]";
+        result.BackgroundImageUrl = "";
+
+        return result;
+    }
+}

Moonlight/App/Helpers/Files/SftpFileAccess.cs

@@ -1,5 +1,4 @@
-using Logging.Net;
+using Renci.SshNet;
-using Renci.SshNet;
 using ConnectionInfo = Renci.SshNet.ConnectionInfo;
 
 namespace Moonlight.App.Helpers.Files;

Moonlight/App/Helpers/Files/WingsFileAccess.cs

@@ -3,6 +3,7 @@ using Moonlight.App.ApiClients.Wings;
 using Moonlight.App.ApiClients.Wings.Requests;
 using Moonlight.App.ApiClients.Wings.Resources;
 using Moonlight.App.Database.Entities;
+using Moonlight.App.Helpers.Wings;
 using Moonlight.App.Services;
 using RestSharp;
 
@@ -42,19 +43,22 @@ public class WingsFileAccess : FileAccess
             $"api/servers/{Server.Uuid}/files/list-directory?directory={CurrentPath}"
         );
 
-        var x = new List<FileData>();
+        var result = new List<FileData>();
 
-        foreach (var response in res)
+        foreach (var resGrouped in res.GroupBy(x => x.Directory))
         {
-            x.Add(new()
+            foreach (var resItem in resGrouped.OrderBy(x => x.Name))
             {
-                Name = response.Name,
+                result.Add(new()
-                Size = response.File ? response.Size : 0,
+                {
-                IsFile = response.File,
+                    Name = resItem.Name,
-            });
+                    Size = resItem.File ? resItem.Size : 0,
+                    IsFile = resItem.File,
+                });
+            }
         }
 
-        return x.ToArray();
+        return result.ToArray();
     }
 
     public override Task Cd(string dir)
@@ -110,7 +114,7 @@ public class WingsFileAccess : FileAccess
         request.AddParameter("name", "files");
         request.AddParameter("filename", name);
         request.AddHeader("Content-Type", "multipart/form-data");
-        request.AddHeader("Origin", ConfigService.GetSection("Moonlight").GetValue<string>("AppUrl"));
+        request.AddHeader("Origin", ConfigService.Get().Moonlight.AppUrl);
         request.AddFile("files", () =>
         {
             return new StreamProgressHelper(dataStream)
@@ -211,13 +215,27 @@ public class WingsFileAccess : FileAccess
 
     public override async Task Decompress(FileData fileData)
     {
-        var req = new DecompressFile()
+        try
         {
-            Root = CurrentPath,
+            var req = new DecompressFile()
-            File = fileData.Name
+            {
-        };
+                Root = CurrentPath,
+                File = fileData.Name
+            };
 
-        await WingsApiHelper.Post(Server.Node, $"api/servers/{Server.Uuid}/files/decompress", req);
+            await WingsApiHelper.Post(Server.Node, $"api/servers/{Server.Uuid}/files/decompress", req);
+        }
+        catch (Exception e)
+        {
+            if (e.Message.ToLower().Contains("canceled"))
+            {
+                // ignore, maybe do smth better here, like showing a waiting thing or so
+            }
+            else
+            {
+                throw;
+            }
+        }
     }
 
     public override Task<string> GetLaunchUrl()

Moonlight/App/Helpers/Formatter.cs

@@ -1,14 +1,60 @@
-using Moonlight.App.Services;
+using System.Text;
+using Moonlight.App.Services;
 
 namespace Moonlight.App.Helpers;
 
 public static class Formatter
 {
+    public static string ReplaceEnd(string input, string substringToReplace, string newSubstring)
+    {
+        int lastIndexOfSubstring = input.LastIndexOf(substringToReplace);
+        if (lastIndexOfSubstring >= 0)
+        {
+            input = input.Remove(lastIndexOfSubstring, substringToReplace.Length).Insert(lastIndexOfSubstring, newSubstring);
+        }
+
+        return input;
+    }
+    public static string ConvertCamelCaseToSpaces(string input)
+    {
+        StringBuilder output = new StringBuilder();
+
+        foreach (char c in input)
+        {
+            if (char.IsUpper(c))
+            {
+                output.Append(' ');
+            }
+
+            output.Append(c);
+        }
+
+        return output.ToString().Trim();
+    }
     public static string FormatUptime(double uptime)
     {
         TimeSpan t = TimeSpan.FromMilliseconds(uptime);
 
-        return $"{t.Hours}h {t.Minutes}m {t.Seconds}s";
+        if (t.Days > 0)
+        {
+            return $"{t.Days}d  {t.Hours}h {t.Minutes}m {t.Seconds}s";
+        }
+        else
+        {
+            return $"{t.Hours}h {t.Minutes}m {t.Seconds}s";
+        }
+    }
+    
+    public static string FormatUptime(TimeSpan t)
+    {
+        if (t.Days > 0)
+        {
+            return $"{t.Days}d  {t.Hours}h {t.Minutes}m {t.Seconds}s";
+        }
+        else
+        {
+            return $"{t.Hours}h {t.Minutes}m {t.Seconds}s";
+        }
     }
 
     private static double Round(this double d, int decimals)
@@ -109,4 +155,12 @@ public static class Formatter
             return (i / (1024D * 1024D)).Round(2) + " GB";
         }
     }
+    
+    public static double BytesToGb(long bytes)
+    {
+        const double gbMultiplier = 1024 * 1024 * 1024; // 1 GB = 1024 MB * 1024 KB * 1024 B
+
+        double gigabytes = (double)bytes / gbMultiplier;
+        return gigabytes;
+    }
 }

Moonlight/App/Helpers/HostSystemHelper.cs

@@ -1,6 +1,5 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
-using Logging.Net;
 
 namespace Moonlight.App.Helpers;
 

Moonlight/App/Helpers/Logger.cs

@@ -0,0 +1,171 @@
+using System.Diagnostics;
+using System.Reflection;
+using Moonlight.App.Database;
+using Moonlight.App.Services;
+using Moonlight.App.Services.Files;
+using Serilog;
+
+namespace Moonlight.App.Helpers;
+
+public static class Logger
+{
+    // The private static instance of the config service, because we have no di here
+    private static ConfigService ConfigService = new(new StorageService());
+    
+    #region String method calls
+    public static void Verbose(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Verbose("{Message}", message);
+        
+        if(channel == "security")
+            LogSecurityInDb(message);
+    }
+    
+    public static void Info(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Information("{Message}", message);
+        
+        if(channel == "security")
+            LogSecurityInDb(message);
+    }
+    
+    public static void Debug(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Debug("{Message}", message);
+        
+        if(channel == "security")
+            LogSecurityInDb(message);
+    }
+    
+    public static void Error(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Error("{Message}", message);
+        
+        if(channel == "security")
+            LogSecurityInDb(message);
+    }
+    
+    public static void Warn(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Warning("{Message}", message);
+        
+        if(channel == "security")
+            LogSecurityInDb(message);
+    }
+    
+    public static void Fatal(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Fatal("{Message}", message);
+        
+        if(channel == "security")
+            LogSecurityInDb(message);
+    }
+    #endregion
+    
+    #region Exception method calls
+    public static void Verbose(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Verbose(exception, "");
+        
+        if(channel == "security")
+            LogSecurityInDb(exception);
+    }
+    
+    public static void Info(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Information(exception, "");
+        
+        if(channel == "security")
+            LogSecurityInDb(exception);
+    }
+    
+    public static void Debug(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Debug(exception, "");
+        
+        if(channel == "security")
+            LogSecurityInDb(exception);
+    }
+    
+    public static void Error(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Error(exception, "");
+        
+        if(channel == "security")
+            LogSecurityInDb(exception);
+    }
+    
+    public static void Warn(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Warning(exception, "");
+        
+        if(channel == "security")
+            LogSecurityInDb(exception);
+    }
+    
+    public static void Fatal(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Fatal(exception, "");
+        
+        if(channel == "security")
+            LogSecurityInDb(exception);
+    }
+    #endregion
+    
+    private static string GetNameOfCallingClass(int skipFrames = 4)
+    {
+        string fullName;
+        Type declaringType;
+            
+        do
+        {
+            MethodBase method = new StackFrame(skipFrames, false).GetMethod();
+            declaringType = method.DeclaringType;
+            if (declaringType == null)
+            {
+                return method.Name;
+            }
+            skipFrames++;
+            if (declaringType.Name.Contains("<"))
+                fullName = declaringType.ReflectedType.Name;
+            else
+                fullName = declaringType.Name;
+        }
+        while (declaringType.Module.Name.Equals("mscorlib.dll", StringComparison.OrdinalIgnoreCase) | fullName.Contains("Logger"));
+
+        return fullName;
+    }
+
+
+    private static void LogSecurityInDb(Exception exception)
+    {
+        LogSecurityInDb(exception.ToStringDemystified());
+    }
+    private static void LogSecurityInDb(string text)
+    {
+        Task.Run(() =>
+        {
+            var dataContext = new DataContext(ConfigService);
+            
+            dataContext.SecurityLogs.Add(new()
+            {
+                Text = text
+            });
+
+            dataContext.SaveChanges();
+            dataContext.Dispose();
+        });
+    }
+}

Moonlight/App/Helpers/MustBeTrueAttribute.cs

@@ -1,5 +1,4 @@
 using System.ComponentModel.DataAnnotations;
-using Logging.Net;
 
 namespace Moonlight.App.Helpers;
 

Moonlight/App/Helpers/ParseHelper.cs

@@ -1,6 +1,4 @@
-using Logging.Net;
+namespace Moonlight.App.Helpers;
-
-namespace Moonlight.App.Helpers;
 
 public static class ParseHelper
 {

Moonlight/App/Helpers/PropBinder.cs

@@ -0,0 +1,51 @@
+using System.Reflection;
+
+namespace Moonlight.App.Helpers;
+
+public class PropBinder
+{
+    private PropertyInfo PropertyInfo;
+    private object DataObject;
+
+    public PropBinder(PropertyInfo propertyInfo, object dataObject)
+    {
+        PropertyInfo = propertyInfo;
+        DataObject = dataObject;
+    }
+
+    public string StringValue
+    {
+        get => (string)PropertyInfo.GetValue(DataObject)!;
+        set => PropertyInfo.SetValue(DataObject, value);
+    }
+
+    public int IntValue
+    {
+        get => (int)PropertyInfo.GetValue(DataObject)!;
+        set => PropertyInfo.SetValue(DataObject, value);
+    }
+    
+    public long LongValue
+    {
+        get => (long)PropertyInfo.GetValue(DataObject)!;
+        set => PropertyInfo.SetValue(DataObject, value);
+    }
+    
+    public bool BoolValue
+    {
+        get => (bool)PropertyInfo.GetValue(DataObject)!;
+        set => PropertyInfo.SetValue(DataObject, value);
+    }
+
+    public DateTime DateTimeValue
+    {
+        get => (DateTime)PropertyInfo.GetValue(DataObject)!;
+        set => PropertyInfo.SetValue(DataObject, value);
+    }
+    
+    public double DoubleValue
+    {
+        get => (double)PropertyInfo.GetValue(DataObject)!;
+        set => PropertyInfo.SetValue(DataObject, value);
+    }
+}

Moonlight/App/Helpers/Retry.cs

@@ -0,0 +1,66 @@
+namespace Moonlight.App.Helpers;
+
+public class Retry
+{
+    private List<Type> RetryExceptionTypes;
+    private List<Func<Exception, bool>> RetryFilters;
+    private int RetryTimes = 1;
+
+    public Retry()
+    {
+        RetryExceptionTypes = new();
+        RetryFilters = new();
+    }
+
+    public Retry Times(int times)
+    {
+        RetryTimes = times;
+        return this;
+    }
+
+    public Retry At(Func<Exception, bool> filter)
+    {
+        RetryFilters.Add(filter);
+        return this;
+    }
+
+    public Retry At<T>()
+    {
+        RetryExceptionTypes.Add(typeof(T));
+        return this;
+    }
+
+    public async Task Call(Func<Task> method)
+    {
+        int triesLeft = RetryTimes;
+        
+        do
+        {
+            try
+            {
+                await method.Invoke();
+                return;
+            }
+            catch (Exception e)
+            {
+                if(triesLeft < 1) // Throw if no tries left
+                    throw;
+                
+                if (RetryExceptionTypes.Any(x => x.FullName == e.GetType().FullName))
+                {
+                    triesLeft--;
+                    continue;
+                }
+
+                if (RetryFilters.Any(x => x.Invoke(e)))
+                {
+                    triesLeft--;
+                    continue;
+                }
+
+                // Throw if not filtered -> unknown/unhandled
+                throw;
+            }
+        } while (triesLeft >= 0);
+    }
+}

Moonlight/App/Helpers/Wings/Data/ConsoleMessage.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.Helpers.Wings.Data;
+
+public class ConsoleMessage
+{
+    public string Content { get; set; } = "";
+    public bool IsInternal { get; set; } = false;
+}

Moonlight/App/Helpers/Wings/Data/ServerResource.cs

@@ -0,0 +1,36 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.Helpers.Wings.Data;
+
+public class ServerResource
+{
+    [JsonProperty("memory_bytes")]
+    public long MemoryBytes { get; set; }
+
+    [JsonProperty("memory_limit_bytes")]
+    public long MemoryLimitBytes { get; set; }
+
+    [JsonProperty("cpu_absolute")]
+    public float CpuAbsolute { get; set; }
+
+    [JsonProperty("network")]
+    public NetworkData Network { get; set; }
+
+    [JsonProperty("uptime")]
+    public double Uptime { get; set; }
+
+    [JsonProperty("state")]
+    public string State { get; set; }
+
+    [JsonProperty("disk_bytes")]
+    public long DiskBytes { get; set; }
+
+    public class NetworkData
+    {
+        [JsonProperty("rx_bytes")]
+        public long RxBytes { get; set; }
+
+        [JsonProperty("tx_bytes")]
+        public long TxBytes { get; set; }
+    }
+}

Moonlight/App/Helpers/Wings/Enums/ConsoleState.cs

@@ -0,0 +1,8 @@
+namespace Moonlight.App.Helpers.Wings.Enums;
+
+public enum ConsoleState
+{
+    Disconnected,
+    Connecting,
+    Connected
+}

Moonlight/App/Helpers/Wings/Enums/ServerState.cs

@@ -0,0 +1,10 @@
+namespace Moonlight.App.Helpers.Wings.Enums;
+
+public enum ServerState
+{
+    Starting,
+    Running,
+    Stopping,
+    Offline,
+    Installing
+}

Moonlight/App/Helpers/Wings/Events/BaseEvent.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.Helpers.Wings.Events;
+
+public class BaseEvent
+{
+    public string Event { get; set; } = "";
+    public string[] Args { get; set; } = Array.Empty<string>();
+}

Moonlight/App/Helpers/Wings/Events/SendTokenEvent.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.Helpers.Wings.Events;
+
+public class SendTokenEvent
+{
+    public string Event { get; set; } = "auth";
+    public List<string> Args = new();
+}

Moonlight/App/Helpers/Wings/WingsConsole.cs

@@ -0,0 +1,390 @@
+using System.Net.WebSockets;
+using System.Text;
+using Moonlight.App.Helpers.Wings.Data;
+using Moonlight.App.Helpers.Wings.Enums;
+using Moonlight.App.Helpers.Wings.Events;
+using Newtonsoft.Json;
+using ConsoleMessage = Moonlight.App.Helpers.Wings.Data.ConsoleMessage;
+
+namespace Moonlight.App.Helpers.Wings;
+
+public class WingsConsole : IDisposable
+{
+    private ClientWebSocket WebSocket;
+    public List<ConsoleMessage> Messages;
+    private Task? ConsoleTask;
+
+    private string Socket = "";
+    private string Origin = "";
+    private string Token = "";
+    
+    private bool Disconnecting;
+
+    public ConsoleState ConsoleState { get; private set; }
+    public ServerState ServerState { get; private set; }
+    public ServerResource Resource { get; private set; }
+
+    public EventHandler<ConsoleState> OnConsoleStateUpdated { get; set; }
+    public EventHandler<ServerState> OnServerStateUpdated { get; set; }
+    public EventHandler<ServerResource> OnResourceUpdated { get; set; }
+    public EventHandler<ConsoleMessage> OnMessage { get; set; }
+    public Func<WingsConsole, Task<string>> OnRequestNewToken { get; set; }
+
+    public WingsConsole()
+    {
+        ConsoleState = ConsoleState.Disconnected;
+        ServerState = ServerState.Offline;
+        Messages = new();
+        
+        Resource = new()
+        {
+            Network = new()
+            {
+                RxBytes = 0,
+                TxBytes = 0
+            },
+            State = "offline",
+            Uptime = 0,
+            CpuAbsolute = 0,
+            DiskBytes = 0,
+            MemoryBytes = 0,
+            MemoryLimitBytes = 0
+        };
+    }
+
+    public Task Connect(string origin, string socket, string token)
+    {
+        Disconnecting = false;
+        WebSocket = new();
+        ConsoleState = ConsoleState.Disconnected;
+        ServerState = ServerState.Offline;
+        Messages = new();
+        
+        Resource = new()
+        {
+            Network = new()
+            {
+                RxBytes = 0,
+                TxBytes = 0
+            },
+            State = "offline",
+            Uptime = 0,
+            CpuAbsolute = 0,
+            DiskBytes = 0,
+            MemoryBytes = 0,
+            MemoryLimitBytes = 0
+        };
+        
+        Socket = socket;
+        Origin = origin;
+        Token = token;
+
+        WebSocket.Options.SetRequestHeader("Origin", Origin);
+        WebSocket.Options.SetRequestHeader("Authorization", "Bearer " + Token);
+
+        ConsoleTask = Task.Run(async () =>
+        {
+            try
+            {
+                await Work();
+            }
+            catch (Exception e)
+            {
+                Logger.Warn("Error connecting to wings console");
+                Logger.Warn(e);
+            }
+        });
+
+        return Task.CompletedTask;
+    }
+
+    private async Task Work()
+    {
+        await UpdateConsoleState(ConsoleState.Connecting);
+
+        await WebSocket.ConnectAsync(
+            new Uri(Socket),
+            CancellationToken.None
+        );
+
+        if (WebSocket.State != WebSocketState.Connecting && WebSocket.State != WebSocketState.Open)
+        {
+            await SaveMessage("Unable to connect to websocket", true);
+            await UpdateConsoleState(ConsoleState.Disconnected);
+            return;
+        }
+
+        await UpdateConsoleState(ConsoleState.Connected);
+
+        await Send(new SendTokenEvent()
+        {
+            Args = { Token }
+        });
+
+        while (WebSocket.State == WebSocketState.Open)
+        {
+            try
+            {
+                var raw = await ReceiveRaw();
+                
+                if(string.IsNullOrEmpty(raw))
+                    continue;
+                
+                var eventData = JsonConvert.DeserializeObject<BaseEvent>(raw);
+
+                if (eventData == null)
+                {
+                    await SaveMessage("Unable to parse event", true);
+                    continue;
+                }
+
+                switch (eventData.Event)
+                {
+                    case "jwt error":
+                        if (WebSocket != null)
+                        {
+                            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                                await WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None);
+            
+                            WebSocket.Dispose();
+                        }
+                        
+                        await UpdateServerState(ServerState.Offline);
+                        await UpdateConsoleState(ConsoleState.Disconnected);
+
+                        await SaveMessage("Received a jwt error. Disconnected", true);
+                        break;
+
+                    case "token expired":
+                        if (WebSocket != null)
+                        {
+                            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                                await WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None);
+            
+                            WebSocket.Dispose();
+                        }
+                        
+                        await UpdateServerState(ServerState.Offline);
+                        await UpdateConsoleState(ConsoleState.Disconnected);
+
+                        await SaveMessage("Token expired", true);
+                        
+                        break;
+
+                    case "token expiring":
+                        await SaveMessage("Token will expire soon. Generating a new one", true);
+
+                        Token = await OnRequestNewToken.Invoke(this);
+
+                        await Send(new SendTokenEvent()
+                        {
+                            Args = { Token }
+                        });
+                        break;
+
+                    case "auth success":
+                        // Send intents
+                        await SendRaw("{\"event\":\"send logs\",\"args\":[null]}");
+                        await SendRaw("{\"event\":\"send stats\",\"args\":[null]}");
+                        break;
+
+                    case "stats":
+                        var stats = JsonConvert.DeserializeObject<ServerResource>(eventData.Args[0]);
+
+                        if (stats == null)
+                            break;
+
+                        var serverState = ParseServerState(stats.State);
+
+                        if (ServerState != serverState)
+                            await UpdateServerState(serverState);
+
+                        await UpdateResource(stats);
+                        break;
+
+                    case "status":
+                        var serverStateParsed = ParseServerState(eventData.Args[0]);
+
+                        if (ServerState != serverStateParsed)
+                            await UpdateServerState(serverStateParsed);
+                        break;
+
+                    case "console output":
+                        foreach (var line in eventData.Args)
+                        {
+                            await SaveMessage(line);
+                        }
+
+                        break;
+
+                    case "install output":
+                        foreach (var line in eventData.Args)
+                        {
+                            await SaveMessage(line);
+                        }
+
+                        break;
+
+                    case "daemon message":
+                        foreach (var line in eventData.Args)
+                        {
+                            await SaveMessage(line);
+                        }
+
+                        break;
+
+                    case "install started":
+                        await UpdateServerState(ServerState.Installing);
+                        break;
+
+                    case "install completed":
+                        await UpdateServerState(ServerState.Offline);
+                        break;
+                }
+            }
+            catch(JsonReaderException){}
+            catch(JsonSerializationException){}
+            catch (Exception e)
+            {
+                if (!Disconnecting)
+                {
+                    Logger.Warn("Error while performing websocket actions");
+                    Logger.Warn(e);
+
+                    await SaveMessage("A unknown error occured while processing websocket", true);
+                }
+            }
+        }
+    }
+
+    private Task UpdateConsoleState(ConsoleState consoleState)
+    {
+        ConsoleState = consoleState;
+        OnConsoleStateUpdated?.Invoke(this, consoleState);
+
+        return Task.CompletedTask;
+    }
+    private Task UpdateServerState(ServerState serverState)
+    {
+        ServerState = serverState;
+        OnServerStateUpdated?.Invoke(this, serverState);
+
+        return Task.CompletedTask;
+    }
+    private Task UpdateResource(ServerResource resource)
+    {
+        Resource = resource;
+        OnResourceUpdated?.Invoke(this, Resource);
+
+        return Task.CompletedTask;
+    }
+
+    private Task SaveMessage(string content, bool internalMessage = false)
+    {
+        var msg = new ConsoleMessage()
+        {
+            Content = content,
+            IsInternal = internalMessage
+        };
+
+        lock (Messages)
+        {
+            Messages.Add(msg);
+        }
+
+        OnMessage?.Invoke(this, msg);
+
+        return Task.CompletedTask;
+    }
+    
+    private ServerState ParseServerState(string raw)
+    {
+        switch (raw)
+        {
+            case "offline":
+                return ServerState.Offline;
+            case "starting":
+                return ServerState.Starting;
+            case "running":
+                return ServerState.Running;
+            case "stopping":
+                return ServerState.Stopping;
+            case "installing":
+                return ServerState.Installing;
+            default:
+                return ServerState.Offline;
+        }
+    }
+    
+    public async Task EnterCommand(string content)
+    {
+        if (ConsoleState == ConsoleState.Connected)
+        {
+            await SendRaw("{\"event\":\"send command\",\"args\":[\"" + content + "\"]}");
+        }
+    }
+
+    public async Task SetPowerState(string state)
+    {
+        if (ConsoleState == ConsoleState.Connected)
+        {
+            await SendRaw("{\"event\":\"set state\",\"args\":[\"" + state + "\"]}");
+        }
+    }
+
+    private async Task Send(object data)
+    {
+        await SendRaw(JsonConvert.SerializeObject(data));
+    }
+    
+    private async Task SendRaw(string data)
+    {
+        if (WebSocket.State == WebSocketState.Open)
+        {
+            byte[] byteContentBuffer = Encoding.UTF8.GetBytes(data);
+            await WebSocket.SendAsync(new ArraySegment<byte>(byteContentBuffer), WebSocketMessageType.Text, true,
+                CancellationToken.None);
+        }
+    }
+
+    private async Task<string> ReceiveRaw()
+    {
+        ArraySegment<byte> receivedBytes = new ArraySegment<byte>(new byte[1024]);
+        WebSocketReceiveResult result = await WebSocket.ReceiveAsync(receivedBytes, CancellationToken.None);
+        return Encoding.UTF8.GetString(receivedBytes.Array!, 0, result.Count);
+    }
+
+    public async Task Disconnect()
+    {
+        Disconnecting = true;
+        Messages.Clear();
+
+        if (WebSocket != null)
+        {
+            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                await WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None);
+            
+            WebSocket.Dispose();
+        }
+
+        if(ConsoleTask != null && ConsoleTask.IsCompleted)
+            ConsoleTask.Dispose();
+    }
+
+    public void Dispose()
+    {
+        Disconnecting = true;
+        Messages.Clear();
+
+        if (WebSocket != null)
+        {
+            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None).Wait();
+            
+            WebSocket.Dispose();
+        }
+        
+        if(ConsoleTask != null && ConsoleTask.IsCompleted)
+            ConsoleTask.Dispose();
+    }
+}

Moonlight/App/Helpers/Wings/WingsConsoleHelper.cs

@@ -7,37 +7,34 @@ using Moonlight.App.Database.Entities;
 using Moonlight.App.Repositories.Servers;
 using Moonlight.App.Services;
 
-namespace Moonlight.App.Helpers;
+namespace Moonlight.App.Helpers.Wings;
 
 public class WingsConsoleHelper
 {
     private readonly ServerRepository ServerRepository;
-    private readonly WingsJwtHelper WingsJwtHelper;
     private readonly string AppUrl;
 
     public WingsConsoleHelper(
         ServerRepository serverRepository,
-        ConfigService configService,
+        ConfigService configService)
-        WingsJwtHelper wingsJwtHelper)
     {
         ServerRepository = serverRepository;
-        WingsJwtHelper = wingsJwtHelper;
 
-        AppUrl = configService.GetSection("Moonlight").GetValue<string>("AppUrl");
+        AppUrl = configService.Get().Moonlight.AppUrl;
     }
 
-    public async Task ConnectWings(PteroConsole.NET.PteroConsole pteroConsole, Server server)
+    public async Task ConnectWings(WingsConsole console, Server server)
     {
         var serverData = ServerRepository
             .Get()
             .Include(x => x.Node)
             .First(x => x.Id == server.Id);
         
-        var token = GenerateToken(serverData);
+        var token = await GenerateToken(serverData);
 
         if (serverData.Node.Ssl)
         {
-            await pteroConsole.Connect(
+            await console.Connect(
                 AppUrl,
                 $"wss://{serverData.Node.Fqdn}:{serverData.Node.HttpPort}/api/servers/{serverData.Uuid}/ws",
                 token
@@ -45,7 +42,7 @@ public class WingsConsoleHelper
         }
         else
         {
-            await pteroConsole.Connect(
+            await console.Connect(
                 AppUrl,
                 $"ws://{serverData.Node.Fqdn}:{serverData.Node.HttpPort}/api/servers/{serverData.Uuid}/ws",
                 token
@@ -53,7 +50,7 @@ public class WingsConsoleHelper
         }
     }
 
-    public string GenerateToken(Server server)
+    public async Task<string> GenerateToken(Server server)
     {
         var serverData = ServerRepository
             .Get()
@@ -66,7 +63,7 @@ public class WingsConsoleHelper
 
         using (MD5 md5 = MD5.Create())
         {
-            var inputBytes = Encoding.ASCII.GetBytes(userid + serverData.Uuid.ToString());
+            var inputBytes = Encoding.ASCII.GetBytes(userid + server.Uuid.ToString());
             var outputBytes = md5.ComputeHash(inputBytes);
 
             var identifier = Convert.ToHexString(outputBytes).ToLower();
@@ -77,7 +74,7 @@ public class WingsConsoleHelper
                 .WithAlgorithm(new HMACSHA256Algorithm())
                 .WithSecret(secret)
                 .AddClaim("user_id", userid)
-                .AddClaim("server_uuid", serverData.Uuid.ToString())
+                .AddClaim("server_uuid", server.Uuid.ToString())
                 .AddClaim("permissions", new[]
                 {
                     "*",

Moonlight/App/Helpers/Wings/WingsJwtHelper.cs

@@ -4,7 +4,7 @@ using JWT.Algorithms;
 using JWT.Builder;
 using Moonlight.App.Services;
 
-namespace Moonlight.App.Helpers;
+namespace Moonlight.App.Helpers.Wings;
 
 public class WingsJwtHelper
 {
@@ -15,7 +15,7 @@ public class WingsJwtHelper
     {
         ConfigService = configService;
 
-        AppUrl = ConfigService.GetSection("Moonlight").GetValue<string>("AppUrl");
+        AppUrl = ConfigService.Get().Moonlight.AppUrl;
     }
 
     public string Generate(string secret, Action<Dictionary<string, string>> claimsAction)

Moonlight/App/Helpers/Wings/WingsServerConverter.cs

@@ -5,7 +5,7 @@ using Moonlight.App.Http.Resources.Wings;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Servers;
 
-namespace Moonlight.App.Helpers;
+namespace Moonlight.App.Helpers.Wings;
 
 public class WingsServerConverter
 {