Removed hangfire. Added TickerQ

.github/workflows/publish-dev-packages.yml

@@ -3,9 +3,6 @@ name: Build and Publish NuGet Package
 on:
   push:
     branches: [ v2_ChangeArchitecture,v2.1 ]
-    paths:
-      - '**.csproj'
-  
   workflow_dispatch:
 
 jobs:

Moonlight.ApiServer.Runtime/Moonlight.ApiServer.Runtime.csproj

@@ -13,12 +13,9 @@
     </ItemGroup>
     
     <ItemGroup>
-        <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Server" Version="9.0.8" />
-        <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.8">
-          <PrivateAssets>all</PrivateAssets>
-          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-        </PackageReference>
-        <PackageReference Include="MoonCore.PluginFramework" Version="1.0.9" />
+        <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Server" Version="9.0.7" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.7" />
+        <PackageReference Include="MoonCore.PluginFramework" Version="1.0.8" />
     </ItemGroup>
     
     <Import Project="Plugins.props" />

Moonlight.ApiServer.Runtime/Program.cs

@@ -1,25 +1,28 @@
-using Moonlight.ApiServer.Configuration;
-using Moonlight.ApiServer.Runtime;
+using Moonlight.ApiServer.Runtime;
 using Moonlight.ApiServer.Startup;
 
 var pluginLoader = new PluginLoader();
 pluginLoader.Initialize();
+/*
+await startup.Run(args, pluginLoader.Instances);
+
+*/
+
+var cs = new Startup();
+
+await cs.Initialize(args, pluginLoader.Instances);
 
 var builder = WebApplication.CreateBuilder(args);
 
-builder.AddMoonlight(pluginLoader.Instances);
+await cs.AddMoonlight(builder);
 
 var app = builder.Build();
 
-app.UseMoonlight(pluginLoader.Instances);
-
-// Add frontend
-var configuration = AppConfiguration.CreateEmpty();
-builder.Configuration.Bind(configuration);
+await cs.AddMoonlight(app);
 
 // Handle setup of wasm app hosting in the runtime
 // so the Moonlight.ApiServer doesn't need the wasm package
-if (configuration.Frontend.EnableHosting)
+if (cs.Configuration.Frontend.EnableHosting)
 {
     if (app.Environment.IsDevelopment())
         app.UseWebAssemblyDebugging();
@@ -28,7 +31,5 @@ if (configuration.Frontend.EnableHosting)
     app.UseStaticFiles();
 }
 
-app.MapMoonlight(pluginLoader.Instances);
-
 
 await app.RunAsync();

Moonlight.ApiServer/Configuration/AppConfiguration.cs

@@ -1,37 +1,24 @@
 using MoonCore.Helpers;
-using Moonlight.ApiServer.Implementations.LocalAuth;
 using YamlDotNet.Serialization;
 
 namespace Moonlight.ApiServer.Configuration;
 
 public record AppConfiguration
 {
-    [YamlMember(Description = "Moonlight configuration\n\n\nThe public url your instance should be accessible through")]
+    [YamlMember(Description = "The public url your instance should be accessible through")]
     public string PublicUrl { get; set; } = "http://localhost:5165";
     
-    [YamlMember(Description = "\nThe credentials of the postgres which moonlight should use")]
+    [YamlMember(Description = "The credentials of the postgres which moonlight should use")]
     public DatabaseConfig Database { get; set; } = new();
     
-    [YamlMember(Description = "\nSettings regarding authentication")]
+    [YamlMember(Description = "Settings regarding authentication")]
     public AuthenticationConfig Authentication { get; set; } = new();
     
-    [YamlMember(Description = "\nThese options are only meant for development purposes")]
+    [YamlMember(Description = "These options are only meant for development purposes")]
     public DevelopmentConfig Development { get; set; } = new();
-    
-    [YamlMember(Description = "\nSettings for hosting the frontend")]
     public FrontendData Frontend { get; set; } = new();
-    
-    [YamlMember(Description = "\nSettings for the internal web server moonlight is running in")]
     public KestrelConfig Kestrel { get; set; } = new();
-
-    [YamlMember(Description = "\nSettings for the internal file manager for moonlights storage access")]
-    public FilesData Files { get; set; } = new();
-    
-    [YamlMember(Description = "\nSettings for open telemetry")]
-    public OpenTelemetryData OpenTelemetry { get; set; } = new();
-
-    [YamlMember(Description = "\nConfiguration for the realtime communication solution SignalR")]
-    public SignalRData SignalR { get; set; } = new();
+    public MetricsData Metrics { get; set; } = new();
 
     public static AppConfiguration CreateEmpty()
     {
@@ -42,29 +29,10 @@ public record AppConfiguration
             Kestrel = new()
             {
                 AllowedOrigins = []
-            },
-            Authentication = new()
-            {
-                EnabledSchemes = []
             }
         };
     }
 
-    public record SignalRData
-    {
-        [YamlMember(Description =
-            "\nWhether to use redis (or any other redis compatible solution) to scale out SignalR hubs. This is required when using multiple api server replicas")]
-        public bool UseRedis { get; set; } = false;
-
-        public string RedisConnectionString { get; set; } = "";
-    }
-
-    public record FilesData
-    {
-        [YamlMember(Description = "The maximum file size limit a combine operation is allowed to process")]
-        public double CombineLimit { get; set; } = ByteConverter.FromGigaBytes(5).MegaBytes;
-    }
-
     public record FrontendData
     {
         [YamlMember(Description = "Enable the hosting of the frontend. Disable this if you only want to run the api server")]
@@ -87,20 +55,25 @@ public record AppConfiguration
         [YamlMember(Description = "The secret token to use for creating jwts and encrypting things. This needs to be at least 32 characters long")]
         public string Secret { get; set; } = Formatter.GenerateString(32);
         
-        [YamlMember(Description = "Settings for the user sessions")]
-        public SessionsConfig Sessions { get; set; } = new();
+        [YamlMember(Description = "The lifespan of generated user tokens in hours")]
+        public int TokenDuration { get; set; } = 24 * 10;
 
-        [YamlMember(Description = "This specifies if the first registered/synced user will become an admin automatically")]
-        public bool FirstUserAdmin { get; set; } = true;
+        [YamlMember(Description = "This enables the use of the local oauth2 provider, so moonlight will use itself as an oauth2 provider")]
+        public bool EnableLocalOAuth2 { get; set; } = true;
+        public OAuth2Data OAuth2 { get; set; } = new();
         
-        [YamlMember(Description = "This specifies the authentication schemes the frontend should be able to challenge")]
-        public string[] EnabledSchemes { get; set; } = [LocalAuthConstants.AuthenticationScheme];
-    }
+        public record OAuth2Data
+        {
+            public string Secret { get; set; } = Formatter.GenerateString(32);
+            public string ClientId { get; set; } = Formatter.GenerateString(8);
+            public string ClientSecret { get; set; } = Formatter.GenerateString(32);
+            public string? AuthorizationEndpoint { get; set; }
+            public string? AccessEndpoint { get; set; }
+            public string? AuthorizationRedirect { get; set; }
 
-    public record SessionsConfig
-    {
-        public string CookieName { get; set; } = "session";
-        public int ExpiresIn { get; set; } = 10;
+            [YamlMember(Description = "This specifies if the first registered user will become an admin automatically. This only works when using local oauth2")]
+            public bool FirstUserAdmin { get; set; } = true;
+        }
     }
     
     public record DevelopmentConfig
@@ -118,37 +91,12 @@ public record AppConfiguration
         public string[] AllowedOrigins { get; set; } = ["*"];
     }
     
-    public record OpenTelemetryData
+    public record MetricsData
     {
-        [YamlMember(Description = "This enables open telemetry for moonlight")]
+        [YamlMember(Description = "This enables the collecting of metrics and allows access to the /metrics endpoint")]
         public bool Enable { get; set; } = false;
         
-        public OpenTelemetryMetricsData Metrics { get; set; } = new();
-        public OpenTelemetryTracesData Traces { get; set; } = new();
-        public OpenTelemetryLogsData Logs { get; set; } = new();
-    }
-
-    public record OpenTelemetryMetricsData
-    {
-        [YamlMember(Description = "This enables the exporting of metrics")]
-        public bool Enable { get; set; } = true;
-
-        [YamlMember(Description = "Enables the /metrics exporter for prometheus")]
-        public bool EnablePrometheus { get; set; } = false;
-        
         [YamlMember(Description = "The interval in which metrics are created, specified in seconds")]
         public int Interval { get; set; } = 15;
     }
-    
-    public record OpenTelemetryTracesData
-    {
-        [YamlMember(Description = "This enables the exporting of traces")]
-        public bool Enable { get; set; } = true;
-    }
-    
-    public record OpenTelemetryLogsData
-    {
-        [YamlMember(Description = "This enables the exporting of logs")]
-        public bool Enable { get; set; } = true;
-    }
 }

Moonlight.ApiServer/Database/CoreDataContext.cs

@@ -1,14 +1,14 @@
-using Hangfire.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
+using MoonCore.Extended.SingleDb;
 using Moonlight.ApiServer.Configuration;
 using Moonlight.ApiServer.Database.Entities;
 using Moonlight.ApiServer.Models;
 
 namespace Moonlight.ApiServer.Database;
 
-public class CoreDataContext : DbContext
+public class CoreDataContext : DatabaseContext
 {
-    private readonly AppConfiguration Configuration;
+    public override string Prefix { get; } = "Core";
 
     public DbSet<User> Users { get; set; }
     public DbSet<ApiKey> ApiKeys { get; set; }
@@ -16,34 +16,19 @@ public class CoreDataContext : DbContext
 
     public CoreDataContext(AppConfiguration configuration)
     {
-        Configuration = configuration;
-    }
-
-    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
-    {
-        if(optionsBuilder.IsConfigured)
-            return;
-
-        var database = Configuration.Database;
-        
-        var connectionString = $"Host={database.Host};" +
-                               $"Port={database.Port};" +
-                               $"Database={database.Database};" +
-                               $"Username={database.Username};" +
-                               $"Password={database.Password}";
-
-        optionsBuilder.UseNpgsql(connectionString, builder =>
+        Options = new()
         {
-            builder.MigrationsHistoryTable("MigrationsHistory", "core");
-        });
+            Host = configuration.Database.Host,
+            Port = configuration.Database.Port,
+            Username = configuration.Database.Username,
+            Password = configuration.Database.Password,
+            Database = configuration.Database.Database
+        };
     }
 
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
-        modelBuilder.Model.SetDefaultSchema("core");
-        
         base.OnModelCreating(modelBuilder);
-        modelBuilder.OnHangfireModelCreating();
 
         modelBuilder.Ignore<ApplicationTheme>();
         modelBuilder.Entity<Theme>()

Moonlight.ApiServer/Database/Migrations/20250226080942_AddedUsersAndApiKey.Designer.cs

@@ -0,0 +1,90 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Moonlight.ApiServer.Database;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    [DbContext(typeof(CoreDataContext))]
+    [Migration("20250226080942_AddedUsersAndApiKey")]
+    partial class AddedUsersAndApiKey
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.ApiKey", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PermissionsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Secret")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Core_ApiKeys", (string)null);
+                });
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PermissionsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("TokenValidTimestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Core_Users", (string)null);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/20250226080942_AddedUsersAndApiKey.cs

@@ -0,0 +1,59 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedUsersAndApiKey : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Core_ApiKeys",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Secret = table.Column<string>(type: "text", nullable: false),
+                    Description = table.Column<string>(type: "text", nullable: false),
+                    PermissionsJson = table.Column<string>(type: "jsonb", nullable: false),
+                    ExpiresAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Core_ApiKeys", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Core_Users",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Username = table.Column<string>(type: "text", nullable: false),
+                    Email = table.Column<string>(type: "text", nullable: false),
+                    Password = table.Column<string>(type: "text", nullable: false),
+                    TokenValidTimestamp = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    PermissionsJson = table.Column<string>(type: "jsonb", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Core_Users", x => x.Id);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Core_ApiKeys");
+
+            migrationBuilder.DropTable(
+                name: "Core_Users");
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/20250314095412_ModifiedApiKeyEntity.Designer.cs

@@ -0,0 +1,89 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Moonlight.ApiServer.Database;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    [DbContext(typeof(CoreDataContext))]
+    [Migration("20250314095412_ModifiedApiKeyEntity")]
+    partial class ModifiedApiKeyEntity
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.ApiKey", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PermissionsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Core_ApiKeys", (string)null);
+                });
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PermissionsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("TokenValidTimestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Core_Users", (string)null);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/20250314095412_ModifiedApiKeyEntity.cs

@@ -0,0 +1,41 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class ModifiedApiKeyEntity : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Secret",
+                table: "Core_ApiKeys");
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedAt",
+                table: "Core_ApiKeys",
+                type: "timestamp with time zone",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "CreatedAt",
+                table: "Core_ApiKeys");
+
+            migrationBuilder.AddColumn<string>(
+                name: "Secret",
+                table: "Core_ApiKeys",
+                type: "text",
+                nullable: false,
+                defaultValue: "");
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/20250405172522_AddedHangfireTables.Designer.cs

@@ -0,0 +1,393 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Moonlight.ApiServer.Database;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    [DbContext(typeof(CoreDataContext))]
+    [Migration("20250405172522_AddedHangfireTables")]
+    partial class AddedHangfireTables
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireCounter", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("ExpireAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Value")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExpireAt");
+
+                    b.HasIndex("Key", "Value");
+
+                    b.ToTable("HangfireCounter");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireHash", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Field")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("ExpireAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Key", "Field");
+
+                    b.HasIndex("ExpireAt");
+
+                    b.ToTable("HangfireHash");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJob", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("ExpireAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InvocationData")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long?>("StateId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("StateName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExpireAt");
+
+                    b.HasIndex("StateId");
+
+                    b.HasIndex("StateName");
+
+                    b.ToTable("HangfireJob");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJobParameter", b =>
+                {
+                    b.Property<long>("JobId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("JobId", "Name");
+
+                    b.ToTable("HangfireJobParameter");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireList", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Position")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("ExpireAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Key", "Position");
+
+                    b.HasIndex("ExpireAt");
+
+                    b.ToTable("HangfireList");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireLock", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime>("AcquiredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("HangfireLock");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireQueuedJob", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("FetchedAt")
+                        .IsConcurrencyToken()
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("JobId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Queue")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobId");
+
+                    b.HasIndex("Queue", "FetchedAt");
+
+                    b.ToTable("HangfireQueuedJob");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireServer", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime>("Heartbeat")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Queues")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("WorkerCount")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Heartbeat");
+
+                    b.ToTable("HangfireServer");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireSet", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Value")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("ExpireAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double>("Score")
+                        .HasColumnType("double precision");
+
+                    b.HasKey("Key", "Value");
+
+                    b.HasIndex("ExpireAt");
+
+                    b.HasIndex("Key", "Score");
+
+                    b.ToTable("HangfireSet");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireState", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Data")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("JobId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Reason")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("HangfireState");
+                });
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.ApiKey", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PermissionsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Core_ApiKeys", (string)null);
+                });
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PermissionsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("TokenValidTimestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Core_Users", (string)null);
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJob", b =>
+                {
+                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireState", "State")
+                        .WithMany()
+                        .HasForeignKey("StateId");
+
+                    b.Navigation("State");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJobParameter", b =>
+                {
+                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireJob", "Job")
+                        .WithMany("Parameters")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireQueuedJob", b =>
+                {
+                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireJob", "Job")
+                        .WithMany("QueuedJobs")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireState", b =>
+                {
+                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireJob", "Job")
+                        .WithMany("States")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJob", b =>
+                {
+                    b.Navigation("Parameters");
+
+                    b.Navigation("QueuedJobs");
+
+                    b.Navigation("States");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/20250405172522_AddedHangfireTables.cs

@@ -7,34 +7,13 @@ using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 namespace Moonlight.ApiServer.Database.Migrations
 {
     /// <inheritdoc />
-    public partial class RecreatedMigrationsForChangeOfSchema : Migration
+    public partial class AddedHangfireTables : Migration
     {
         /// <inheritdoc />
         protected override void Up(MigrationBuilder migrationBuilder)
         {
-            migrationBuilder.EnsureSchema(
-                name: "core");
-
-            migrationBuilder.CreateTable(
-                name: "ApiKeys",
-                schema: "core",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Description = table.Column<string>(type: "text", nullable: false),
-                    Permissions = table.Column<string[]>(type: "text[]", nullable: false),
-                    ExpiresAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
-                    CreatedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_ApiKeys", x => x.Id);
-                });
-
             migrationBuilder.CreateTable(
                 name: "HangfireCounter",
-                schema: "core",
                 columns: table => new
                 {
                     Id = table.Column<long>(type: "bigint", nullable: false)
@@ -50,7 +29,6 @@ namespace Moonlight.ApiServer.Database.Migrations
 
             migrationBuilder.CreateTable(
                 name: "HangfireHash",
-                schema: "core",
                 columns: table => new
                 {
                     Key = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
@@ -65,7 +43,6 @@ namespace Moonlight.ApiServer.Database.Migrations
 
             migrationBuilder.CreateTable(
                 name: "HangfireList",
-                schema: "core",
                 columns: table => new
                 {
                     Key = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
@@ -80,7 +57,6 @@ namespace Moonlight.ApiServer.Database.Migrations
 
             migrationBuilder.CreateTable(
                 name: "HangfireLock",
-                schema: "core",
                 columns: table => new
                 {
                     Id = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
@@ -93,7 +69,6 @@ namespace Moonlight.ApiServer.Database.Migrations
 
             migrationBuilder.CreateTable(
                 name: "HangfireServer",
-                schema: "core",
                 columns: table => new
                 {
                     Id = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
@@ -109,7 +84,6 @@ namespace Moonlight.ApiServer.Database.Migrations
 
             migrationBuilder.CreateTable(
                 name: "HangfireSet",
-                schema: "core",
                 columns: table => new
                 {
                     Key = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
@@ -122,47 +96,8 @@ namespace Moonlight.ApiServer.Database.Migrations
                     table.PrimaryKey("PK_HangfireSet", x => new { x.Key, x.Value });
                 });
 
-            migrationBuilder.CreateTable(
-                name: "Themes",
-                schema: "core",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    IsEnabled = table.Column<bool>(type: "boolean", nullable: false),
-                    Name = table.Column<string>(type: "text", nullable: false),
-                    Author = table.Column<string>(type: "text", nullable: false),
-                    Version = table.Column<string>(type: "text", nullable: false),
-                    UpdateUrl = table.Column<string>(type: "text", nullable: true),
-                    DonateUrl = table.Column<string>(type: "text", nullable: true),
-                    Content = table.Column<string>(type: "jsonb", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Themes", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Users",
-                schema: "core",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Username = table.Column<string>(type: "text", nullable: false),
-                    Email = table.Column<string>(type: "text", nullable: false),
-                    Password = table.Column<string>(type: "text", nullable: false),
-                    TokenValidTimestamp = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
-                    Permissions = table.Column<string[]>(type: "text[]", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Users", x => x.Id);
-                });
-
             migrationBuilder.CreateTable(
                 name: "HangfireJob",
-                schema: "core",
                 columns: table => new
                 {
                     Id = table.Column<long>(type: "bigint", nullable: false)
@@ -180,7 +115,6 @@ namespace Moonlight.ApiServer.Database.Migrations
 
             migrationBuilder.CreateTable(
                 name: "HangfireJobParameter",
-                schema: "core",
                 columns: table => new
                 {
                     JobId = table.Column<long>(type: "bigint", nullable: false),
@@ -193,7 +127,6 @@ namespace Moonlight.ApiServer.Database.Migrations
                     table.ForeignKey(
                         name: "FK_HangfireJobParameter_HangfireJob_JobId",
                         column: x => x.JobId,
-                        principalSchema: "core",
                         principalTable: "HangfireJob",
                         principalColumn: "Id",
                         onDelete: ReferentialAction.Cascade);
@@ -201,7 +134,6 @@ namespace Moonlight.ApiServer.Database.Migrations
 
             migrationBuilder.CreateTable(
                 name: "HangfireQueuedJob",
-                schema: "core",
                 columns: table => new
                 {
                     Id = table.Column<long>(type: "bigint", nullable: false)
@@ -216,7 +148,6 @@ namespace Moonlight.ApiServer.Database.Migrations
                     table.ForeignKey(
                         name: "FK_HangfireQueuedJob_HangfireJob_JobId",
                         column: x => x.JobId,
-                        principalSchema: "core",
                         principalTable: "HangfireJob",
                         principalColumn: "Id",
                         onDelete: ReferentialAction.Cascade);
@@ -224,7 +155,6 @@ namespace Moonlight.ApiServer.Database.Migrations
 
             migrationBuilder.CreateTable(
                 name: "HangfireState",
-                schema: "core",
                 columns: table => new
                 {
                     Id = table.Column<long>(type: "bigint", nullable: false)
@@ -241,7 +171,6 @@ namespace Moonlight.ApiServer.Database.Migrations
                     table.ForeignKey(
                         name: "FK_HangfireState_HangfireJob_JobId",
                         column: x => x.JobId,
-                        principalSchema: "core",
                         principalTable: "HangfireJob",
                         principalColumn: "Id",
                         onDelete: ReferentialAction.Cascade);
@@ -249,88 +178,73 @@ namespace Moonlight.ApiServer.Database.Migrations
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireCounter_ExpireAt",
-                schema: "core",
                 table: "HangfireCounter",
                 column: "ExpireAt");
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireCounter_Key_Value",
-                schema: "core",
                 table: "HangfireCounter",
                 columns: new[] { "Key", "Value" });
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireHash_ExpireAt",
-                schema: "core",
                 table: "HangfireHash",
                 column: "ExpireAt");
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireJob_ExpireAt",
-                schema: "core",
                 table: "HangfireJob",
                 column: "ExpireAt");
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireJob_StateId",
-                schema: "core",
                 table: "HangfireJob",
                 column: "StateId");
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireJob_StateName",
-                schema: "core",
                 table: "HangfireJob",
                 column: "StateName");
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireList_ExpireAt",
-                schema: "core",
                 table: "HangfireList",
                 column: "ExpireAt");
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireQueuedJob_JobId",
-                schema: "core",
                 table: "HangfireQueuedJob",
                 column: "JobId");
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireQueuedJob_Queue_FetchedAt",
-                schema: "core",
                 table: "HangfireQueuedJob",
                 columns: new[] { "Queue", "FetchedAt" });
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireServer_Heartbeat",
-                schema: "core",
                 table: "HangfireServer",
                 column: "Heartbeat");
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireSet_ExpireAt",
-                schema: "core",
                 table: "HangfireSet",
                 column: "ExpireAt");
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireSet_Key_Score",
-                schema: "core",
                 table: "HangfireSet",
                 columns: new[] { "Key", "Score" });
 
             migrationBuilder.CreateIndex(
                 name: "IX_HangfireState_JobId",
-                schema: "core",
                 table: "HangfireState",
                 column: "JobId");
 
             migrationBuilder.AddForeignKey(
                 name: "FK_HangfireJob_HangfireState_StateId",
-                schema: "core",
                 table: "HangfireJob",
                 column: "StateId",
-                principalSchema: "core",
                 principalTable: "HangfireState",
                 principalColumn: "Id");
         }
@@ -340,60 +254,37 @@ namespace Moonlight.ApiServer.Database.Migrations
         {
             migrationBuilder.DropForeignKey(
                 name: "FK_HangfireJob_HangfireState_StateId",
-                schema: "core",
                 table: "HangfireJob");
 
             migrationBuilder.DropTable(
-                name: "ApiKeys",
-                schema: "core");
+                name: "HangfireCounter");
 
             migrationBuilder.DropTable(
-                name: "HangfireCounter",
-                schema: "core");
+                name: "HangfireHash");
 
             migrationBuilder.DropTable(
-                name: "HangfireHash",
-                schema: "core");
+                name: "HangfireJobParameter");
 
             migrationBuilder.DropTable(
-                name: "HangfireJobParameter",
-                schema: "core");
+                name: "HangfireList");
 
             migrationBuilder.DropTable(
-                name: "HangfireList",
-                schema: "core");
+                name: "HangfireLock");
 
             migrationBuilder.DropTable(
-                name: "HangfireLock",
-                schema: "core");
+                name: "HangfireQueuedJob");
 
             migrationBuilder.DropTable(
-                name: "HangfireQueuedJob",
-                schema: "core");
+                name: "HangfireServer");
 
             migrationBuilder.DropTable(
-                name: "HangfireServer",
-                schema: "core");
+                name: "HangfireSet");
 
             migrationBuilder.DropTable(
-                name: "HangfireSet",
-                schema: "core");
+                name: "HangfireState");
 
             migrationBuilder.DropTable(
-                name: "Themes",
-                schema: "core");
-
-            migrationBuilder.DropTable(
-                name: "Users",
-                schema: "core");
-
-            migrationBuilder.DropTable(
-                name: "HangfireState",
-                schema: "core");
-
-            migrationBuilder.DropTable(
-                name: "HangfireJob",
-                schema: "core");
+                name: "HangfireJob");
         }
     }
 }

Moonlight.ApiServer/Database/Migrations/20250712202608_SwitchedToPgArraysForPermissions.Designer.cs

@@ -0,0 +1,393 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Moonlight.ApiServer.Database;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    [DbContext(typeof(CoreDataContext))]
+    [Migration("20250712202608_SwitchedToPgArraysForPermissions")]
+    partial class SwitchedToPgArraysForPermissions
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireCounter", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("ExpireAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Value")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExpireAt");
+
+                    b.HasIndex("Key", "Value");
+
+                    b.ToTable("HangfireCounter");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireHash", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Field")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("ExpireAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Key", "Field");
+
+                    b.HasIndex("ExpireAt");
+
+                    b.ToTable("HangfireHash");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJob", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("ExpireAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InvocationData")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long?>("StateId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("StateName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExpireAt");
+
+                    b.HasIndex("StateId");
+
+                    b.HasIndex("StateName");
+
+                    b.ToTable("HangfireJob");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJobParameter", b =>
+                {
+                    b.Property<long>("JobId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("JobId", "Name");
+
+                    b.ToTable("HangfireJobParameter");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireList", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Position")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("ExpireAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Key", "Position");
+
+                    b.HasIndex("ExpireAt");
+
+                    b.ToTable("HangfireList");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireLock", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime>("AcquiredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("HangfireLock");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireQueuedJob", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("FetchedAt")
+                        .IsConcurrencyToken()
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("JobId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Queue")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobId");
+
+                    b.HasIndex("Queue", "FetchedAt");
+
+                    b.ToTable("HangfireQueuedJob");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireServer", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime>("Heartbeat")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Queues")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("WorkerCount")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Heartbeat");
+
+                    b.ToTable("HangfireServer");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireSet", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Value")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("ExpireAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double>("Score")
+                        .HasColumnType("double precision");
+
+                    b.HasKey("Key", "Value");
+
+                    b.HasIndex("ExpireAt");
+
+                    b.HasIndex("Key", "Score");
+
+                    b.ToTable("HangfireSet");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireState", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Data")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("JobId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Reason")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("HangfireState");
+                });
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.ApiKey", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.PrimitiveCollection<string[]>("Permissions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Core_ApiKeys", (string)null);
+                });
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.PrimitiveCollection<string[]>("Permissions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("TokenValidTimestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Core_Users", (string)null);
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJob", b =>
+                {
+                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireState", "State")
+                        .WithMany()
+                        .HasForeignKey("StateId");
+
+                    b.Navigation("State");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJobParameter", b =>
+                {
+                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireJob", "Job")
+                        .WithMany("Parameters")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireQueuedJob", b =>
+                {
+                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireJob", "Job")
+                        .WithMany("QueuedJobs")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireState", b =>
+                {
+                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireJob", "Job")
+                        .WithMany("States")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJob", b =>
+                {
+                    b.Navigation("Parameters");
+
+                    b.Navigation("QueuedJobs");
+
+                    b.Navigation("States");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/20250712202608_SwitchedToPgArraysForPermissions.cs

@@ -0,0 +1,62 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class SwitchedToPgArraysForPermissions : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "PermissionsJson",
+                table: "Core_Users");
+
+            migrationBuilder.DropColumn(
+                name: "PermissionsJson",
+                table: "Core_ApiKeys");
+
+            migrationBuilder.AddColumn<string[]>(
+                name: "Permissions",
+                table: "Core_Users",
+                type: "text[]",
+                nullable: false,
+                defaultValue: new string[0]);
+
+            migrationBuilder.AddColumn<string[]>(
+                name: "Permissions",
+                table: "Core_ApiKeys",
+                type: "text[]",
+                nullable: false,
+                defaultValue: new string[0]);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Permissions",
+                table: "Core_Users");
+
+            migrationBuilder.DropColumn(
+                name: "Permissions",
+                table: "Core_ApiKeys");
+
+            migrationBuilder.AddColumn<string>(
+                name: "PermissionsJson",
+                table: "Core_Users",
+                type: "jsonb",
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AddColumn<string>(
+                name: "PermissionsJson",
+                table: "Core_ApiKeys",
+                type: "jsonb",
+                nullable: false,
+                defaultValue: "");
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/20250720203346_AddedThemes.Designer.cs

@@ -12,16 +12,15 @@ using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 namespace Moonlight.ApiServer.Database.Migrations
 {
     [DbContext(typeof(CoreDataContext))]
-    [Migration("20250919201409_RecreatedMigrationsForChangeOfSchema")]
-    partial class RecreatedMigrationsForChangeOfSchema
+    [Migration("20250720203346_AddedThemes")]
+    partial class AddedThemes
     {
         /// <inheritdoc />
         protected override void BuildTargetModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasDefaultSchema("core")
-                .HasAnnotation("ProductVersion", "9.0.8")
+                .HasAnnotation("ProductVersion", "9.0.7")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
@@ -51,7 +50,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasIndex("Key", "Value");
 
-                    b.ToTable("HangfireCounter", "core");
+                    b.ToTable("HangfireCounter");
                 });
 
             modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireHash", b =>
@@ -74,7 +73,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasIndex("ExpireAt");
 
-                    b.ToTable("HangfireHash", "core");
+                    b.ToTable("HangfireHash");
                 });
 
             modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJob", b =>
@@ -110,7 +109,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasIndex("StateName");
 
-                    b.ToTable("HangfireJob", "core");
+                    b.ToTable("HangfireJob");
                 });
 
             modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJobParameter", b =>
@@ -127,7 +126,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasKey("JobId", "Name");
 
-                    b.ToTable("HangfireJobParameter", "core");
+                    b.ToTable("HangfireJobParameter");
                 });
 
             modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireList", b =>
@@ -149,7 +148,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasIndex("ExpireAt");
 
-                    b.ToTable("HangfireList", "core");
+                    b.ToTable("HangfireList");
                 });
 
             modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireLock", b =>
@@ -163,7 +162,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("HangfireLock", "core");
+                    b.ToTable("HangfireLock");
                 });
 
             modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireQueuedJob", b =>
@@ -192,7 +191,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasIndex("Queue", "FetchedAt");
 
-                    b.ToTable("HangfireQueuedJob", "core");
+                    b.ToTable("HangfireQueuedJob");
                 });
 
             modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireServer", b =>
@@ -218,7 +217,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasIndex("Heartbeat");
 
-                    b.ToTable("HangfireServer", "core");
+                    b.ToTable("HangfireServer");
                 });
 
             modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireSet", b =>
@@ -243,7 +242,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasIndex("Key", "Score");
 
-                    b.ToTable("HangfireSet", "core");
+                    b.ToTable("HangfireSet");
                 });
 
             modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireState", b =>
@@ -276,7 +275,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasIndex("JobId");
 
-                    b.ToTable("HangfireState", "core");
+                    b.ToTable("HangfireState");
                 });
 
             modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.ApiKey", b =>
@@ -303,7 +302,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("ApiKeys", "core");
+                    b.ToTable("Core_ApiKeys", (string)null);
                 });
 
             modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.Theme", b =>
@@ -337,7 +336,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("Themes", "core");
+                    b.ToTable("Core_Themes", (string)null);
                 });
 
             modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.User", b =>
@@ -369,7 +368,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("Users", "core");
+                    b.ToTable("Core_Users", (string)null);
                 });
 
             modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJob", b =>
@@ -516,11 +515,11 @@ namespace Moonlight.ApiServer.Database.Migrations
                                 .IsRequired()
                                 .HasColumnType("text");
 
-                            b1.Property<int>("Depth")
-                                .HasColumnType("integer");
+                            b1.Property<float>("Depth")
+                                .HasColumnType("real");
 
-                            b1.Property<int>("Noise")
-                                .HasColumnType("integer");
+                            b1.Property<float>("Noise")
+                                .HasColumnType("real");
 
                             b1.Property<float>("RadiusBox")
                                 .HasColumnType("real");
@@ -539,7 +538,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                             b1.HasKey("ThemeId");
 
-                            b1.ToTable("Themes", "core");
+                            b1.ToTable("Core_Themes");
 
                             b1.ToJson("Content");
 

Moonlight.ApiServer/Database/Migrations/20250720203346_AddedThemes.cs

@@ -0,0 +1,41 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedThemes : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Core_Themes",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    IsEnabled = table.Column<bool>(type: "boolean", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false),
+                    Author = table.Column<string>(type: "text", nullable: false),
+                    Version = table.Column<string>(type: "text", nullable: false),
+                    UpdateUrl = table.Column<string>(type: "text", nullable: true),
+                    DonateUrl = table.Column<string>(type: "text", nullable: true),
+                    Content = table.Column<string>(type: "jsonb", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Core_Themes", x => x.Id);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Core_Themes");
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/20250819195904_RemovedHangfire.Designer.cs

@@ -0,0 +1,260 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Moonlight.ApiServer.Database;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    [DbContext(typeof(CoreDataContext))]
+    [Migration("20250819195904_RemovedHangfire")]
+    partial class RemovedHangfire
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.ApiKey", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.PrimitiveCollection<string[]>("Permissions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Core_ApiKeys", (string)null);
+                });
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.Theme", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Author")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DonateUrl")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("UpdateUrl")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Version")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Core_Themes", (string)null);
+                });
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.PrimitiveCollection<string[]>("Permissions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("TokenValidTimestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Core_Users", (string)null);
+                });
+
+            modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.Theme", b =>
+                {
+                    b.OwnsOne("Moonlight.ApiServer.Models.ApplicationTheme", "Content", b1 =>
+                        {
+                            b1.Property<int>("ThemeId")
+                                .HasColumnType("integer");
+
+                            b1.Property<float>("Border")
+                                .HasColumnType("real");
+
+                            b1.Property<string>("ColorAccent")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorAccentContent")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorBackground")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorBase100")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorBase150")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorBase200")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorBase250")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorBase300")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorBaseContent")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorError")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorErrorContent")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorInfo")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorInfoContent")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorNeutral")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorNeutralContent")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorPrimary")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorPrimaryContent")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorSecondary")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorSecondaryContent")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorSuccess")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorSuccessContent")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorWarning")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<string>("ColorWarningContent")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.Property<int>("Depth")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("Noise")
+                                .HasColumnType("integer");
+
+                            b1.Property<float>("RadiusBox")
+                                .HasColumnType("real");
+
+                            b1.Property<float>("RadiusField")
+                                .HasColumnType("real");
+
+                            b1.Property<float>("RadiusSelector")
+                                .HasColumnType("real");
+
+                            b1.Property<float>("SizeField")
+                                .HasColumnType("real");
+
+                            b1.Property<float>("SizeSelector")
+                                .HasColumnType("real");
+
+                            b1.HasKey("ThemeId");
+
+                            b1.ToTable("Core_Themes");
+
+                            b1.ToJson("Content");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ThemeId");
+                        });
+
+                    b.Navigation("Content")
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/20250819195904_RemovedHangfire.cs

@@ -0,0 +1,290 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class RemovedHangfire : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_HangfireJob_HangfireState_StateId",
+                table: "HangfireJob");
+
+            migrationBuilder.DropTable(
+                name: "HangfireCounter");
+
+            migrationBuilder.DropTable(
+                name: "HangfireHash");
+
+            migrationBuilder.DropTable(
+                name: "HangfireJobParameter");
+
+            migrationBuilder.DropTable(
+                name: "HangfireList");
+
+            migrationBuilder.DropTable(
+                name: "HangfireLock");
+
+            migrationBuilder.DropTable(
+                name: "HangfireQueuedJob");
+
+            migrationBuilder.DropTable(
+                name: "HangfireServer");
+
+            migrationBuilder.DropTable(
+                name: "HangfireSet");
+
+            migrationBuilder.DropTable(
+                name: "HangfireState");
+
+            migrationBuilder.DropTable(
+                name: "HangfireJob");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "HangfireCounter",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    ExpireAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    Key = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Value = table.Column<long>(type: "bigint", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_HangfireCounter", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "HangfireHash",
+                columns: table => new
+                {
+                    Key = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Field = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    ExpireAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    Value = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_HangfireHash", x => new { x.Key, x.Field });
+                });
+
+            migrationBuilder.CreateTable(
+                name: "HangfireList",
+                columns: table => new
+                {
+                    Key = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Position = table.Column<int>(type: "integer", nullable: false),
+                    ExpireAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    Value = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_HangfireList", x => new { x.Key, x.Position });
+                });
+
+            migrationBuilder.CreateTable(
+                name: "HangfireLock",
+                columns: table => new
+                {
+                    Id = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    AcquiredAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_HangfireLock", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "HangfireServer",
+                columns: table => new
+                {
+                    Id = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Heartbeat = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    Queues = table.Column<string>(type: "text", nullable: false),
+                    StartedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    WorkerCount = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_HangfireServer", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "HangfireSet",
+                columns: table => new
+                {
+                    Key = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
+                    Value = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    ExpireAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    Score = table.Column<double>(type: "double precision", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_HangfireSet", x => new { x.Key, x.Value });
+                });
+
+            migrationBuilder.CreateTable(
+                name: "HangfireJob",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    StateId = table.Column<long>(type: "bigint", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    ExpireAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    InvocationData = table.Column<string>(type: "text", nullable: false),
+                    StateName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_HangfireJob", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "HangfireJobParameter",
+                columns: table => new
+                {
+                    JobId = table.Column<long>(type: "bigint", nullable: false),
+                    Name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Value = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_HangfireJobParameter", x => new { x.JobId, x.Name });
+                    table.ForeignKey(
+                        name: "FK_HangfireJobParameter_HangfireJob_JobId",
+                        column: x => x.JobId,
+                        principalTable: "HangfireJob",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "HangfireQueuedJob",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    JobId = table.Column<long>(type: "bigint", nullable: false),
+                    FetchedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    Queue = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_HangfireQueuedJob", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_HangfireQueuedJob_HangfireJob_JobId",
+                        column: x => x.JobId,
+                        principalTable: "HangfireJob",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "HangfireState",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    JobId = table.Column<long>(type: "bigint", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    Data = table.Column<string>(type: "text", nullable: false),
+                    Name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Reason = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_HangfireState", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_HangfireState_HangfireJob_JobId",
+                        column: x => x.JobId,
+                        principalTable: "HangfireJob",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireCounter_ExpireAt",
+                table: "HangfireCounter",
+                column: "ExpireAt");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireCounter_Key_Value",
+                table: "HangfireCounter",
+                columns: new[] { "Key", "Value" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireHash_ExpireAt",
+                table: "HangfireHash",
+                column: "ExpireAt");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireJob_ExpireAt",
+                table: "HangfireJob",
+                column: "ExpireAt");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireJob_StateId",
+                table: "HangfireJob",
+                column: "StateId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireJob_StateName",
+                table: "HangfireJob",
+                column: "StateName");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireList_ExpireAt",
+                table: "HangfireList",
+                column: "ExpireAt");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireQueuedJob_JobId",
+                table: "HangfireQueuedJob",
+                column: "JobId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireQueuedJob_Queue_FetchedAt",
+                table: "HangfireQueuedJob",
+                columns: new[] { "Queue", "FetchedAt" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireServer_Heartbeat",
+                table: "HangfireServer",
+                column: "Heartbeat");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireSet_ExpireAt",
+                table: "HangfireSet",
+                column: "ExpireAt");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireSet_Key_Score",
+                table: "HangfireSet",
+                columns: new[] { "Key", "Score" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_HangfireState_JobId",
+                table: "HangfireState",
+                column: "JobId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_HangfireJob_HangfireState_StateId",
+                table: "HangfireJob",
+                column: "StateId",
+                principalTable: "HangfireState",
+                principalColumn: "Id");
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/20250819200221_AddedTickerQ.Designer.cs

@@ -0,0 +1,222 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Moonlight.ApiServer.Database;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    [DbContext(typeof(TickerDataContext))]
+    [Migration("20250819200221_AddedTickerQ")]
+    partial class AddedTickerQ
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.CronTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Expression")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("bytea");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("integer");
+
+                    b.PrimitiveCollection<int[]>("RetryIntervals")
+                        .HasColumnType("integer[]");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Expression")
+                        .HasDatabaseName("IX_CronTickers_Expression");
+
+                    b.ToTable("CronTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.CronTickerOccurrenceEntity<TickerQ.EntityFrameworkCore.Entities.CronTickerEntity>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CronTickerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Exception")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("ExecutionTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LockHolder")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CronTickerId")
+                        .HasDatabaseName("IX_CronTickerOccurrence_CronTickerId");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_ExecutionTime");
+
+                    b.HasIndex("CronTickerId", "ExecutionTime")
+                        .IsUnique()
+                        .HasDatabaseName("UQ_CronTickerId_ExecutionTime");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_Status_ExecutionTime");
+
+                    b.ToTable("CronTickerOccurrences", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.TimeTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("BatchParent")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("BatchRunCondition")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Exception")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("ExecutionTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LockHolder")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("bytea");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.PrimitiveCollection<int[]>("RetryIntervals")
+                        .HasColumnType("integer[]");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BatchParent");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_ExecutionTime");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_Status_ExecutionTime");
+
+                    b.ToTable("TimeTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.CronTickerOccurrenceEntity<TickerQ.EntityFrameworkCore.Entities.CronTickerEntity>", b =>
+                {
+                    b.HasOne("TickerQ.EntityFrameworkCore.Entities.CronTickerEntity", "CronTicker")
+                        .WithMany()
+                        .HasForeignKey("CronTickerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CronTicker");
+                });
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.TimeTickerEntity", b =>
+                {
+                    b.HasOne("TickerQ.EntityFrameworkCore.Entities.TimeTickerEntity", "ParentJob")
+                        .WithMany("ChildJobs")
+                        .HasForeignKey("BatchParent")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.TimeTickerEntity", b =>
+                {
+                    b.Navigation("ChildJobs");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/20250819200221_AddedTickerQ.cs

@@ -0,0 +1,169 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedTickerQ : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "ticker");
+
+            migrationBuilder.CreateTable(
+                name: "CronTickers",
+                schema: "ticker",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    Expression = table.Column<string>(type: "text", nullable: true),
+                    Request = table.Column<byte[]>(type: "bytea", nullable: true),
+                    Retries = table.Column<int>(type: "integer", nullable: false),
+                    RetryIntervals = table.Column<int[]>(type: "integer[]", nullable: true),
+                    Function = table.Column<string>(type: "text", nullable: true),
+                    Description = table.Column<string>(type: "text", nullable: true),
+                    InitIdentifier = table.Column<string>(type: "text", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_CronTickers", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "TimeTickers",
+                schema: "ticker",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    Status = table.Column<int>(type: "integer", nullable: false),
+                    LockHolder = table.Column<string>(type: "text", nullable: true),
+                    Request = table.Column<byte[]>(type: "bytea", nullable: true),
+                    ExecutionTime = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    LockedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    ExecutedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    Exception = table.Column<string>(type: "text", nullable: true),
+                    ElapsedTime = table.Column<long>(type: "bigint", nullable: false),
+                    Retries = table.Column<int>(type: "integer", nullable: false),
+                    RetryCount = table.Column<int>(type: "integer", nullable: false),
+                    RetryIntervals = table.Column<int[]>(type: "integer[]", nullable: true),
+                    BatchParent = table.Column<Guid>(type: "uuid", nullable: true),
+                    BatchRunCondition = table.Column<int>(type: "integer", nullable: true),
+                    Function = table.Column<string>(type: "text", nullable: true),
+                    Description = table.Column<string>(type: "text", nullable: true),
+                    InitIdentifier = table.Column<string>(type: "text", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_TimeTickers", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_TimeTickers_TimeTickers_BatchParent",
+                        column: x => x.BatchParent,
+                        principalSchema: "ticker",
+                        principalTable: "TimeTickers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "CronTickerOccurrences",
+                schema: "ticker",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    Status = table.Column<int>(type: "integer", nullable: false),
+                    LockHolder = table.Column<string>(type: "text", nullable: true),
+                    ExecutionTime = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    CronTickerId = table.Column<Guid>(type: "uuid", nullable: false),
+                    LockedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    ExecutedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    Exception = table.Column<string>(type: "text", nullable: true),
+                    ElapsedTime = table.Column<long>(type: "bigint", nullable: false),
+                    RetryCount = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_CronTickerOccurrences", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_CronTickerOccurrences_CronTickers_CronTickerId",
+                        column: x => x.CronTickerId,
+                        principalSchema: "ticker",
+                        principalTable: "CronTickers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickerOccurrence_CronTickerId",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                column: "CronTickerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickerOccurrence_ExecutionTime",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                column: "ExecutionTime");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickerOccurrence_Status_ExecutionTime",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                columns: new[] { "Status", "ExecutionTime" });
+
+            migrationBuilder.CreateIndex(
+                name: "UQ_CronTickerId_ExecutionTime",
+                schema: "ticker",
+                table: "CronTickerOccurrences",
+                columns: new[] { "CronTickerId", "ExecutionTime" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CronTickers_Expression",
+                schema: "ticker",
+                table: "CronTickers",
+                column: "Expression");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimeTicker_ExecutionTime",
+                schema: "ticker",
+                table: "TimeTickers",
+                column: "ExecutionTime");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimeTicker_Status_ExecutionTime",
+                schema: "ticker",
+                table: "TimeTickers",
+                columns: new[] { "Status", "ExecutionTime" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimeTickers_BatchParent",
+                schema: "ticker",
+                table: "TimeTickers",
+                column: "BatchParent");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "CronTickerOccurrences",
+                schema: "ticker");
+
+            migrationBuilder.DropTable(
+                name: "TimeTickers",
+                schema: "ticker");
+
+            migrationBuilder.DropTable(
+                name: "CronTickers",
+                schema: "ticker");
+        }
+    }
+}

Moonlight.ApiServer/Database/Migrations/CoreDataContextModelSnapshot.cs

@@ -17,265 +17,11 @@ namespace Moonlight.ApiServer.Database.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasDefaultSchema("core")
-                .HasAnnotation("ProductVersion", "9.0.8")
+                .HasAnnotation("ProductVersion", "9.0.7")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
 
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireCounter", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("bigint");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
-
-                    b.Property<DateTime?>("ExpireAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("Key")
-                        .IsRequired()
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<long>("Value")
-                        .HasColumnType("bigint");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ExpireAt");
-
-                    b.HasIndex("Key", "Value");
-
-                    b.ToTable("HangfireCounter", "core");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireHash", b =>
-                {
-                    b.Property<string>("Key")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("Field")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<DateTime?>("ExpireAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("Value")
-                        .HasColumnType("text");
-
-                    b.HasKey("Key", "Field");
-
-                    b.HasIndex("ExpireAt");
-
-                    b.ToTable("HangfireHash", "core");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJob", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("bigint");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<DateTime?>("ExpireAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("InvocationData")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long?>("StateId")
-                        .HasColumnType("bigint");
-
-                    b.Property<string>("StateName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ExpireAt");
-
-                    b.HasIndex("StateId");
-
-                    b.HasIndex("StateName");
-
-                    b.ToTable("HangfireJob", "core");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJobParameter", b =>
-                {
-                    b.Property<long>("JobId")
-                        .HasColumnType("bigint");
-
-                    b.Property<string>("Name")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("Value")
-                        .HasColumnType("text");
-
-                    b.HasKey("JobId", "Name");
-
-                    b.ToTable("HangfireJobParameter", "core");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireList", b =>
-                {
-                    b.Property<string>("Key")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<int>("Position")
-                        .HasColumnType("integer");
-
-                    b.Property<DateTime?>("ExpireAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("Value")
-                        .HasColumnType("text");
-
-                    b.HasKey("Key", "Position");
-
-                    b.HasIndex("ExpireAt");
-
-                    b.ToTable("HangfireList", "core");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireLock", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<DateTime>("AcquiredAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("HangfireLock", "core");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireQueuedJob", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("bigint");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
-
-                    b.Property<DateTime?>("FetchedAt")
-                        .IsConcurrencyToken()
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<long>("JobId")
-                        .HasColumnType("bigint");
-
-                    b.Property<string>("Queue")
-                        .IsRequired()
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("JobId");
-
-                    b.HasIndex("Queue", "FetchedAt");
-
-                    b.ToTable("HangfireQueuedJob", "core");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireServer", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<DateTime>("Heartbeat")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("Queues")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("StartedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<int>("WorkerCount")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Heartbeat");
-
-                    b.ToTable("HangfireServer", "core");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireSet", b =>
-                {
-                    b.Property<string>("Key")
-                        .HasMaxLength(100)
-                        .HasColumnType("character varying(100)");
-
-                    b.Property<string>("Value")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<DateTime?>("ExpireAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<double>("Score")
-                        .HasColumnType("double precision");
-
-                    b.HasKey("Key", "Value");
-
-                    b.HasIndex("ExpireAt");
-
-                    b.HasIndex("Key", "Score");
-
-                    b.ToTable("HangfireSet", "core");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireState", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("bigint");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("Data")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("JobId")
-                        .HasColumnType("bigint");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("Reason")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("JobId");
-
-                    b.ToTable("HangfireState", "core");
-                });
-
             modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.ApiKey", b =>
                 {
                     b.Property<int>("Id")
@@ -300,7 +46,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("ApiKeys", "core");
+                    b.ToTable("Core_ApiKeys", (string)null);
                 });
 
             modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.Theme", b =>
@@ -334,7 +80,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("Themes", "core");
+                    b.ToTable("Core_Themes", (string)null);
                 });
 
             modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.User", b =>
@@ -366,49 +112,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("Users", "core");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJob", b =>
-                {
-                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireState", "State")
-                        .WithMany()
-                        .HasForeignKey("StateId");
-
-                    b.Navigation("State");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJobParameter", b =>
-                {
-                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireJob", "Job")
-                        .WithMany("Parameters")
-                        .HasForeignKey("JobId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Job");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireQueuedJob", b =>
-                {
-                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireJob", "Job")
-                        .WithMany("QueuedJobs")
-                        .HasForeignKey("JobId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Job");
-                });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireState", b =>
-                {
-                    b.HasOne("Hangfire.EntityFrameworkCore.HangfireJob", "Job")
-                        .WithMany("States")
-                        .HasForeignKey("JobId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Job");
+                    b.ToTable("Core_Users", (string)null);
                 });
 
             modelBuilder.Entity("Moonlight.ApiServer.Database.Entities.Theme", b =>
@@ -536,7 +240,7 @@ namespace Moonlight.ApiServer.Database.Migrations
 
                             b1.HasKey("ThemeId");
 
-                            b1.ToTable("Themes", "core");
+                            b1.ToTable("Core_Themes");
 
                             b1.ToJson("Content");
 
@@ -547,15 +251,6 @@ namespace Moonlight.ApiServer.Database.Migrations
                     b.Navigation("Content")
                         .IsRequired();
                 });
-
-            modelBuilder.Entity("Hangfire.EntityFrameworkCore.HangfireJob", b =>
-                {
-                    b.Navigation("Parameters");
-
-                    b.Navigation("QueuedJobs");
-
-                    b.Navigation("States");
-                });
 #pragma warning restore 612, 618
         }
     }

Moonlight.ApiServer/Database/Migrations/TickerDataContextModelSnapshot.cs

@@ -0,0 +1,219 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Moonlight.ApiServer.Database;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Moonlight.ApiServer.Database.Migrations
+{
+    [DbContext(typeof(TickerDataContext))]
+    partial class TickerDataContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.CronTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Expression")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("bytea");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("integer");
+
+                    b.PrimitiveCollection<int[]>("RetryIntervals")
+                        .HasColumnType("integer[]");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Expression")
+                        .HasDatabaseName("IX_CronTickers_Expression");
+
+                    b.ToTable("CronTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.CronTickerOccurrenceEntity<TickerQ.EntityFrameworkCore.Entities.CronTickerEntity>", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CronTickerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Exception")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("ExecutionTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LockHolder")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CronTickerId")
+                        .HasDatabaseName("IX_CronTickerOccurrence_CronTickerId");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_ExecutionTime");
+
+                    b.HasIndex("CronTickerId", "ExecutionTime")
+                        .IsUnique()
+                        .HasDatabaseName("UQ_CronTickerId_ExecutionTime");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_CronTickerOccurrence_Status_ExecutionTime");
+
+                    b.ToTable("CronTickerOccurrences", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.TimeTickerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("BatchParent")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("BatchRunCondition")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<long>("ElapsedTime")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Exception")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ExecutedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("ExecutionTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Function")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitIdentifier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LockHolder")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<byte[]>("Request")
+                        .HasColumnType("bytea");
+
+                    b.Property<int>("Retries")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.PrimitiveCollection<int[]>("RetryIntervals")
+                        .HasColumnType("integer[]");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BatchParent");
+
+                    b.HasIndex("ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_ExecutionTime");
+
+                    b.HasIndex("Status", "ExecutionTime")
+                        .HasDatabaseName("IX_TimeTicker_Status_ExecutionTime");
+
+                    b.ToTable("TimeTickers", "ticker");
+                });
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.CronTickerOccurrenceEntity<TickerQ.EntityFrameworkCore.Entities.CronTickerEntity>", b =>
+                {
+                    b.HasOne("TickerQ.EntityFrameworkCore.Entities.CronTickerEntity", "CronTicker")
+                        .WithMany()
+                        .HasForeignKey("CronTickerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CronTicker");
+                });
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.TimeTickerEntity", b =>
+                {
+                    b.HasOne("TickerQ.EntityFrameworkCore.Entities.TimeTickerEntity", "ParentJob")
+                        .WithMany("ChildJobs")
+                        .HasForeignKey("BatchParent")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("TickerQ.EntityFrameworkCore.Entities.TimeTickerEntity", b =>
+                {
+                    b.Navigation("ChildJobs");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Moonlight.ApiServer/Database/TickerDataContext.cs

@@ -0,0 +1,31 @@
+using Microsoft.EntityFrameworkCore;
+using MoonCore.Extended.SingleDb;
+using Moonlight.ApiServer.Configuration;
+using TickerQ.EntityFrameworkCore.Configurations;
+
+namespace Moonlight.ApiServer.Database;
+
+public class TickerDataContext : DatabaseContext
+{
+    public override string Prefix => "Ticker";
+    
+    public TickerDataContext(AppConfiguration configuration)
+    {
+        Options = new()
+        {
+            Host = configuration.Database.Host,
+            Port = configuration.Database.Port,
+            Username = configuration.Database.Username,
+            Password = configuration.Database.Password,
+            Database = configuration.Database.Database
+        };
+    }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        // Apply TickerQ entity configurations explicitly
+        modelBuilder.ApplyConfiguration(new TimeTickerConfigurations()); 
+        modelBuilder.ApplyConfiguration(new CronTickerConfigurations()); 
+        modelBuilder.ApplyConfiguration(new CronTickerOccurrenceConfigurations()); 
+    }
+}

Moonlight.ApiServer/Extensions/ZipArchiveExtensions.cs

@@ -5,7 +5,7 @@ namespace Moonlight.ApiServer.Extensions;
 
 public static class ZipArchiveExtensions
 {
-    public static async Task AddBinaryAsync(this ZipArchive archive, string name, byte[] bytes)
+    public static async Task AddBinary(this ZipArchive archive, string name, byte[] bytes)
     {
         var entry = archive.CreateEntry(name);
         await using var dataStream = entry.Open();
@@ -14,13 +14,13 @@ public static class ZipArchiveExtensions
         await dataStream.FlushAsync();
     }
 
-    public static async Task AddTextAsync(this ZipArchive archive, string name, string content)
+    public static async Task AddText(this ZipArchive archive, string name, string content)
     {
         var data = Encoding.UTF8.GetBytes(content);
-        await archive.AddBinaryAsync(name, data);
+        await archive.AddBinary(name, data);
     }
 
-    public static async Task AddFileAsync(this ZipArchive archive, string name, string path)
+    public static async Task AddFile(this ZipArchive archive, string name, string path)
     {
         var fs = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
         

Moonlight.ApiServer/Helpers/FilePathHelper.cs

@@ -1,25 +0,0 @@
-namespace Moonlight.ApiServer.Helpers;
-
-public class FilePathHelper
-{
-    public static string SanitizePath(string path)
-    {
-        if (string.IsNullOrWhiteSpace(path))
-            return string.Empty;
-
-        // Normalize separators
-        path = path.Replace('\\', '/');
-
-        // Remove ".." and "."
-        var parts = path.Split('/', StringSplitOptions.RemoveEmptyEntries)
-            .Where(part => part != ".." && part != ".");
-
-        var sanitized = string.Join("/", parts);
-
-        // Ensure it does not start with a slash
-        if (sanitized.StartsWith('/'))
-            sanitized = sanitized.TrimStart('/');
-
-        return sanitized;
-    }
-}

Moonlight.ApiServer/Http/Controllers/Admin/ApiKeys/ApiKeysController.cs

@@ -1,10 +1,11 @@
-using Microsoft.AspNetCore.Authorization;
+using System.ComponentModel.DataAnnotations;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
-using MoonCore.Common;
+using MoonCore.Exceptions;
 using MoonCore.Extended.Abstractions;
+using MoonCore.Models;
 using Moonlight.ApiServer.Database.Entities;
-using Moonlight.ApiServer.Mappers;
 using Moonlight.ApiServer.Services;
 using Moonlight.Shared.Http.Requests.Admin.ApiKeys;
 using Moonlight.Shared.Http.Responses.Admin.ApiKeys;
@@ -26,82 +27,72 @@ public class ApiKeysController : Controller
 
     [HttpGet]
     [Authorize(Policy = "permissions:admin.apikeys.get")]
-    public async Task<ActionResult<CountedData<ApiKeyResponse>>> GetAsync(
-        [FromQuery] int startIndex,
-        [FromQuery] int count,
-        [FromQuery] string? orderBy,
-        [FromQuery] string? filter,
-        [FromQuery] string orderByDir = "asc"
+    public async Task<IPagedData<ApiKeyResponse>> Get(
+        [FromQuery] [Range(0, int.MaxValue)] int page,
+        [FromQuery] [Range(1, 100)] int pageSize
     )
     {
-        if (count > 100)
-            return Problem("You cannot fetch more items than 100 at a time", statusCode: 400);
+        var count = await ApiKeyRepository.Get().CountAsync();
 
-        IQueryable<ApiKey> query = ApiKeyRepository.Get();
-
-        query = orderBy switch
-        {
-            nameof(ApiKey.Id) => orderByDir == "desc"
-                ? query.OrderByDescending(x => x.Id)
-                : query.OrderBy(x => x.Id),
-                
-            nameof(ApiKey.ExpiresAt) => orderByDir == "desc"
-                ? query.OrderByDescending(x => x.ExpiresAt)
-                : query.OrderBy(x => x.ExpiresAt),
-            
-            nameof(ApiKey.CreatedAt) => orderByDir == "desc"
-                ? query.OrderByDescending(x => x.CreatedAt)
-                : query.OrderBy(x => x.CreatedAt),
-            
-            _ => query.OrderBy(x => x.Id)
-        };
-
-        if (!string.IsNullOrEmpty(filter))
-        {
-            query = query.Where(x =>
-                EF.Functions.ILike(x.Description, $"%{filter}%")
-            );
-        }
-
-        var totalCount = await query.CountAsync();
-
-        var items = await query
-            .Skip(startIndex)
-            .Take(count)
-            .AsNoTracking()
-            .ProjectToResponse()
+        var apiKeys = await ApiKeyRepository
+            .Get()
+            .OrderBy(x => x.Id)
+            .Skip(page * pageSize)
+            .Take(pageSize)
             .ToArrayAsync();
 
-        return new CountedData<ApiKeyResponse>()
+        var mappedApiKey = apiKeys
+            .Select(x => new ApiKeyResponse()
+            {
+                Id = x.Id,
+                Permissions = x.Permissions,
+                Description = x.Description,
+                ExpiresAt = x.ExpiresAt
+            })
+            .ToArray();
+
+        return new PagedData<ApiKeyResponse>()
         {
-            Items = items,
-            TotalCount = totalCount
+            CurrentPage = page,
+            Items = mappedApiKey,
+            PageSize = pageSize,
+            TotalItems = count,
+            TotalPages = count == 0 ? 0 : (count - 1) / pageSize
         };
     }
 
-    [HttpGet("{id:int}")]
+    [HttpGet("{id}")]
     [Authorize(Policy = "permissions:admin.apikeys.get")]
-    public async Task<ActionResult<ApiKeyResponse>> GetSingleAsync(int id)
+    public async Task<ApiKeyResponse> GetSingle(int id)
     {
         var apiKey = await ApiKeyRepository
             .Get()
-            .AsNoTracking()
-            .ProjectToResponse()
             .FirstOrDefaultAsync(x => x.Id == id);
 
         if (apiKey == null)
-            return Problem("No api key with that id found", statusCode: 404);
+            throw new HttpApiException("No api key with that id found", 404);
 
-        return apiKey;
+        return new ApiKeyResponse()
+        {
+            Id = apiKey.Id,
+            Permissions = apiKey.Permissions,
+            Description = apiKey.Description,
+            ExpiresAt = apiKey.ExpiresAt
+        };
     }
 
     [HttpPost]
     [Authorize(Policy = "permissions:admin.apikeys.create")]
-    public async Task<CreateApiKeyResponse> CreateAsync([FromBody] CreateApiKeyRequest request)
+    public async Task<CreateApiKeyResponse> Create([FromBody] CreateApiKeyRequest request)
     {
-        var apiKey = ApiKeyMapper.ToApiKey(request);
+        var apiKey = new ApiKey()
+        {
+            Description = request.Description,
+            Permissions = request.Permissions,
+            ExpiresAt = request.ExpiresAt
+        };
 
-        var finalApiKey = await ApiKeyRepository.AddAsync(apiKey);
+        var finalApiKey = await ApiKeyRepository.Add(apiKey);
 
         var response = new CreateApiKeyResponse
         {
@@ -115,36 +106,41 @@ public class ApiKeysController : Controller
         return response;
     }
 
-    [HttpPatch("{id:int}")]
+    [HttpPatch("{id}")]
     [Authorize(Policy = "permissions:admin.apikeys.update")]
-    public async Task<ActionResult<ApiKeyResponse>> UpdateAsync([FromRoute] int id, [FromBody] UpdateApiKeyRequest request)
+    public async Task<ApiKeyResponse> Update([FromRoute] int id, [FromBody] UpdateApiKeyRequest request)
     {
         var apiKey = await ApiKeyRepository
             .Get()
             .FirstOrDefaultAsync(x => x.Id == id);
 
         if (apiKey == null)
-            return Problem("No api key with that id found", statusCode: 404);
+            throw new HttpApiException("No api key with that id found", 404);
 
-        ApiKeyMapper.Merge(apiKey, request);
+        apiKey.Description = request.Description;
 
-        await ApiKeyRepository.UpdateAsync(apiKey);
+        await ApiKeyRepository.Update(apiKey);
 
-        return ApiKeyMapper.ToResponse(apiKey);
+        return new ApiKeyResponse()
+        {
+            Id = apiKey.Id,
+            Description = apiKey.Description,
+            Permissions = apiKey.Permissions,
+            ExpiresAt = apiKey.ExpiresAt
+        };
     }
 
-    [HttpDelete("{id:int}")]
+    [HttpDelete("{id}")]
     [Authorize(Policy = "permissions:admin.apikeys.delete")]
-    public async Task<ActionResult> DeleteAsync([FromRoute] int id)
+    public async Task Delete([FromRoute] int id)
     {
         var apiKey = await ApiKeyRepository
             .Get()
             .FirstOrDefaultAsync(x => x.Id == id);
 
         if (apiKey == null)
-            return Problem("No api key with that id found", statusCode: 404);
+            throw new HttpApiException("No api key with that id found", 404);
 
-        await ApiKeyRepository.RemoveAsync(apiKey);
-        return NoContent();
+        await ApiKeyRepository.Remove(apiKey);
     }
 }

Moonlight.ApiServer/Http/Controllers/Admin/Sys/AdvancedController.cs

@@ -19,9 +19,9 @@ public class AdvancedController : Controller
 
     [HttpGet("frontend")]
     [Authorize(Policy = "permissions:admin.system.advanced.frontend")]
-    public async Task FrontendAsync()
+    public async Task Frontend()
     {
-        var stream = await FrontendService.GenerateZipAsync();
+        var stream = await FrontendService.GenerateZip();
         await Results.File(stream, fileDownloadName: "frontend.zip").ExecuteAsync(HttpContext);
     }
 }

Moonlight.ApiServer/Http/Controllers/Admin/Sys/Customisation/ThemesController.cs

@@ -1,8 +1,10 @@
-using Microsoft.AspNetCore.Authorization;
+using System.ComponentModel.DataAnnotations;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
-using MoonCore.Common;
+using MoonCore.Exceptions;
 using MoonCore.Extended.Abstractions;
+using MoonCore.Models;
 using Moonlight.ApiServer.Database.Entities;
 using Moonlight.ApiServer.Mappers;
 using Moonlight.Shared.Http.Requests.Admin.Sys.Theme;
@@ -23,96 +25,68 @@ public class ThemesController : Controller
 
     [HttpGet]
     [Authorize(Policy = "permissions:admin.system.customisation.themes.read")]
-    public async Task<ActionResult<CountedData<ThemeResponse>>> GetAsync(
-        [FromQuery] int startIndex,
-        [FromQuery] int count,
-        [FromQuery] string? orderBy,
-        [FromQuery] string? filter,
-        [FromQuery] string orderByDir = "asc"
+    public async Task<PagedData<ThemeResponse>> Get(
+        [FromQuery] [Range(0, int.MaxValue)] int page,
+        [FromQuery] [Range(1, 100)] int pageSize
     )
     {
-        if (count > 100)
-            return Problem("You cannot fetch more items than 100 at a time", statusCode: 400);
+        var count = await ThemeRepository.Get().CountAsync();
         
-        IQueryable<Theme> query = ThemeRepository.Get();
-
-        query = orderBy switch
-        {
-            nameof(Theme.Id) => orderByDir == "desc"
-                ? query.OrderByDescending(x => x.Id)
-                : query.OrderBy(x => x.Id),
-                
-            nameof(Theme.Name) => orderByDir == "desc"
-                ? query.OrderByDescending(x => x.Name)
-                : query.OrderBy(x => x.Name),
-            
-            nameof(Theme.Version) => orderByDir == "desc"
-                ? query.OrderByDescending(x => x.Version)
-                : query.OrderBy(x => x.Version),
-            
-            _ => query.OrderBy(x => x.Id)
-        };
-
-        if (!string.IsNullOrEmpty(filter))
-        {
-            query = query.Where(x =>
-                EF.Functions.ILike(x.Name, $"%{filter}%")
-            );
-        }
-
-        var totalCount = await query.CountAsync();
-
-        var items = await query
-            .Skip(startIndex)
-            .Take(count)
-            .AsNoTracking()
-            .ProjectToResponse()
+        var items = await ThemeRepository
+            .Get()
+            .Skip(page * pageSize)
+            .Take(pageSize)
             .ToArrayAsync();
         
-        return new CountedData<ThemeResponse>()
+        var mappedItems = items
+            .Select(ThemeMapper.ToResponse)
+            .ToArray();
+        
+        return new PagedData<ThemeResponse>()
         {
-            Items = items,
-            TotalCount = totalCount
+            CurrentPage = page,
+            Items = mappedItems,
+            PageSize = pageSize,
+            TotalItems = count,
+            TotalPages = count == 0 ? 0 : (count - 1) / pageSize
         };
     }
 
     [HttpGet("{id:int}")]
     [Authorize(Policy = "permissions:admin.system.customisation.themes.read")]
-    public async Task<ActionResult<ThemeResponse>> GetSingleAsync([FromRoute] int id)
+    public async Task<ThemeResponse> GetSingle([FromRoute] int id)
     {
         var theme = await ThemeRepository
             .Get()
-            .AsNoTracking()
-            .ProjectToResponse()
             .FirstOrDefaultAsync(t => t.Id == id);
 
         if (theme == null)
-            return Problem("Theme with this id not found", statusCode: 404);
+            throw new HttpApiException("Theme with this id not found", 404);
         
-        return theme;
+        return ThemeMapper.ToResponse(theme);
     }
 
     [HttpPost]
     [Authorize(Policy = "permissions:admin.system.customisation.themes.write")]
-    public async Task<ActionResult<ThemeResponse>> CreateAsync([FromBody] CreateThemeRequest request)
+    public async Task<ThemeResponse> Create([FromBody] CreateThemeRequest request)
     {
         var theme = ThemeMapper.ToTheme(request);
         
-        var finalTheme = await ThemeRepository.AddAsync(theme);
+        var finalTheme = await ThemeRepository.Add(theme);
         
         return ThemeMapper.ToResponse(finalTheme);
     }
 
     [HttpPatch("{id:int}")]
     [Authorize(Policy = "permissions:admin.system.customisation.themes.write")]
-    public async Task<ActionResult<ThemeResponse>> UpdateAsync([FromRoute] int id, [FromBody] UpdateThemeRequest request)
+    public async Task<ThemeResponse> Update([FromRoute] int id, [FromBody] UpdateThemeRequest request)
     {
         var theme = await ThemeRepository
             .Get()
             .FirstOrDefaultAsync(t => t.Id == id);
         
         if (theme == null)
-            return Problem("Theme with this id not found", statusCode: 404);
+            throw new HttpApiException("Theme with this id not found", 404);
 
         // Disable all other enabled themes if we are enabling the current theme.
         // This ensures only one theme is enabled at the time
@@ -126,28 +100,29 @@ public class ThemesController : Controller
             foreach (var otherTheme in otherThemes)
                 otherTheme.IsEnabled = false;
 
-            await ThemeRepository.RunTransactionAsync(set => { set.UpdateRange(otherThemes); });
+            await ThemeRepository.RunTransaction(set =>
+            {
+                set.UpdateRange(otherThemes);
+            });
         }
         
         ThemeMapper.Merge(theme, request);
-        
-        await ThemeRepository.UpdateAsync(theme);
+        await ThemeRepository.Update(theme);
         
         return ThemeMapper.ToResponse(theme);
     }
 
     [HttpDelete("{id:int}")]
     [Authorize(Policy = "permissions:admin.system.customisation.themes.write")]
-    public async Task<ActionResult> DeleteAsync([FromRoute] int id)
+    public async Task Delete([FromRoute] int id)
     {
         var theme = await ThemeRepository
             .Get()
             .FirstOrDefaultAsync(x => x.Id == id);
         
         if (theme == null)
-            return Problem("Theme with this id not found", statusCode: 404);
+            throw new HttpApiException("Theme with this id not found", 404);
         
-        await ThemeRepository.RemoveAsync(theme);
-        return NoContent();
+        await ThemeRepository.Remove(theme);
     }
 }

Moonlight.ApiServer/Http/Controllers/Admin/Sys/DiagnoseController.cs

@@ -1,4 +1,5 @@
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Moonlight.ApiServer.Services;
 using Moonlight.Shared.Http.Requests.Admin.Sys;
@@ -20,16 +21,21 @@ public class DiagnoseController : Controller
     }
 
     [HttpPost]
-    public async Task<ActionResult> DiagnoseAsync([FromBody] GenerateDiagnoseRequest request)
+    public async Task Diagnose([FromBody] GenerateDiagnoseRequest request)
     {
-        var stream = await DiagnoseService.GenerateDiagnoseAsync(request.Providers);
+        var stream = await DiagnoseService.GenerateDiagnose(request.Providers);
         
-        return File(stream, "application/zip", "diagnose.zip");
+        await Results.Stream(
+                stream,
+                contentType: "application/zip",
+                fileDownloadName: "diagnose.zip"
+            )
+            .ExecuteAsync(HttpContext);
     }
 
     [HttpGet("providers")]
-    public async Task<ActionResult<DiagnoseProvideResponse[]>> GetProvidersAsync()
+    public async Task<DiagnoseProvideResponse[]> GetProviders()
     {
-        return await DiagnoseService.GetProvidersAsync();
+        return await DiagnoseService.GetProviders();
     }
 }

Moonlight.ApiServer/Http/Controllers/Admin/Sys/Files/CombineController.cs

@@ -1,81 +0,0 @@
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
-using MoonCore.Helpers;
-using Moonlight.ApiServer.Configuration;
-using Moonlight.ApiServer.Helpers;
-using Moonlight.Shared.Http.Requests.Admin.Sys.Files;
-
-namespace Moonlight.ApiServer.Http.Controllers.Admin.Sys.Files;
-
-[ApiController]
-[Route("api/admin/system/files")]
-[Authorize(Policy = "permissions:admin.system.files")]
-public class CombineController : Controller
-{
-    private readonly AppConfiguration Configuration;
-
-    private const string BaseDirectory = "storage";
-
-    public CombineController(AppConfiguration configuration)
-    {
-        Configuration = configuration;
-    }
-
-    [HttpPost("combine")]
-    public async Task<IResult> CombineAsync([FromBody] CombineRequest request)
-    {
-        // Validate file lenght
-        if (request.Files.Length < 2)
-            return Results.Problem("At least two files are required", statusCode: 400);
-
-        // Resolve the physical paths
-        var destination = Path.Combine(BaseDirectory, FilePathHelper.SanitizePath(request.Destination));
-
-        var files = request.Files
-            .Select(path => Path.Combine(BaseDirectory, FilePathHelper.SanitizePath(path)))
-            .ToArray();
-
-        // Validate max file size
-        long combinedSize = 0;
-
-        foreach (var file in files)
-        {
-            var fi = new FileInfo(file);
-            combinedSize += fi.Length;
-        }
-
-        if (ByteConverter.FromBytes(combinedSize).MegaBytes > Configuration.Files.CombineLimit)
-        {
-            return Results.Problem("The combine operation exceeds the maximum file size", statusCode: 400);
-        }
-
-        // Combine files
-
-        await using var destinationFs = System.IO.File.Open(
-            destination,
-            FileMode.Create,
-            FileAccess.ReadWrite,
-            FileShare.Read
-        );
-
-        foreach (var file in files)
-        {
-            await using var fs = System.IO.File.Open(
-                file,
-                FileMode.Open,
-                FileAccess.ReadWrite
-            );
-
-            await fs.CopyToAsync(destinationFs);
-            await destinationFs.FlushAsync();
-
-            fs.Close();
-        }
-
-        await destinationFs.FlushAsync();
-        destinationFs.Close();
-
-        return Results.Ok();
-    }
-}

Moonlight.ApiServer/Http/Controllers/Admin/Sys/Files/CompressController.cs

@@ -1,183 +0,0 @@
-using System.Text;
-using ICSharpCode.SharpZipLib.GZip;
-using ICSharpCode.SharpZipLib.Tar;
-using ICSharpCode.SharpZipLib.Zip;
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
-using MoonCore.Helpers;
-using Moonlight.ApiServer.Helpers;
-using Moonlight.Shared.Http.Requests.Admin.Sys.Files;
-
-namespace Moonlight.ApiServer.Http.Controllers.Admin.Sys.Files;
-
-[ApiController]
-[Route("api/admin/system/files")]
-[Authorize(Policy = "permissions:admin.system.files")]
-public class CompressController : Controller
-{
-    private const string BaseDirectory = "storage";
-
-    [HttpPost("compress")]
-    public async Task<IResult> CompressAsync([FromBody] CompressRequest request)
-    {
-        // Validate item length
-        if (request.Items.Length == 0)
-        {
-            return Results.Problem(
-                "At least one item is required",
-                statusCode: 400
-            );
-        }
-
-        // Build paths
-        var destinationPath = Path.Combine(BaseDirectory, FilePathHelper.SanitizePath(request.Destination));
-        var rootPath = Path.Combine(BaseDirectory, FilePathHelper.SanitizePath(request.Root));
-
-        // Resolve the relative to the root item paths to absolute paths
-        var itemsPaths = request.Items.Select(item =>
-            Path.Combine(
-                BaseDirectory,
-                FilePathHelper.SanitizePath(
-                    UnixPath.Combine(request.Root, item)
-                )
-            )
-        );
-
-        // Execute request
-        switch (request.Format)
-        {
-            case "tar.gz":
-                await CompressTarGzAsync(destinationPath, itemsPaths, rootPath);
-                break;
-
-            case "zip":
-                await CompressZipAsync(destinationPath, itemsPaths, rootPath);
-                break;
-
-            default:
-                return Results.Problem("Unsupported archive format specified", statusCode: 400);
-        }
-
-        return Results.Ok();
-    }
-
-    
-
-    #region Tar Gz
-
-    private async Task CompressTarGzAsync(string destination, IEnumerable<string> items, string root)
-    {
-        await using var outStream = System.IO.File.Create(destination);
-        await using var gzoStream = new GZipOutputStream(outStream);
-        await using var tarStream = new TarOutputStream(gzoStream, Encoding.UTF8);
-
-        foreach (var item in items)
-            await CompressItemToTarGzAsync(tarStream, item, root);
-
-        await tarStream.FlushAsync();
-        await gzoStream.FlushAsync();
-        await outStream.FlushAsync();
-
-        tarStream.Close();
-        gzoStream.Close();
-        outStream.Close();
-    }
-
-    private async Task CompressItemToTarGzAsync(TarOutputStream tarOutputStream, string item, string root)
-    {
-        if (System.IO.File.Exists(item))
-        {
-            // Open file stream
-            var fs = System.IO.File.Open(item, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-
-            // Meta 
-            var entry = TarEntry.CreateTarEntry(
-                Formatter
-                    .ReplaceStart(item, root, "")
-                    .TrimStart('/')
-            );
-
-            // Set size
-            entry.Size = fs.Length;
-
-            // Write entry
-            await tarOutputStream.PutNextEntryAsync(entry, CancellationToken.None);
-
-            // Copy file content to tar stream
-            await fs.CopyToAsync(tarOutputStream);
-            fs.Close();
-
-            // Close the entry
-            tarOutputStream.CloseEntry();
-
-            return;
-        }
-
-        if (Directory.Exists(item))
-        {
-            foreach (var fsEntry in Directory.EnumerateFileSystemEntries(item))
-                await CompressItemToTarGzAsync(tarOutputStream, fsEntry, root);
-        }
-    }
-
-    #endregion
-
-    #region ZIP
-
-    private async Task CompressZipAsync(string destination, IEnumerable<string> items, string root)
-    {
-        await using var outStream = System.IO.File.Create(destination);
-        await using var zipOutputStream = new ZipOutputStream(outStream);
-
-        foreach (var item in items)
-            await AddItemToZipAsync(zipOutputStream, item, root);
-
-        await zipOutputStream.FlushAsync();
-        await outStream.FlushAsync();
-
-        zipOutputStream.Close();
-        outStream.Close();
-    }
-
-    private async Task AddItemToZipAsync(ZipOutputStream outputStream, string item, string root)
-    {
-        if (System.IO.File.Exists(item))
-        {
-            // Open file stream
-            var fs = System.IO.File.Open(item, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-
-            // Meta 
-            var entry = new ZipEntry(
-                Formatter
-                    .ReplaceStart(item, root, "")
-                    .TrimStart('/')
-            );
-
-            entry.Size = fs.Length;
-
-            // Write entry
-            await outputStream.PutNextEntryAsync(entry, CancellationToken.None);
-
-            // Copy file content to tar stream
-            await fs.CopyToAsync(outputStream);
-            fs.Close();
-
-            // Close the entry
-            outputStream.CloseEntry();
-
-            // Flush caches
-            await outputStream.FlushAsync();
-
-            return;
-        }
-
-        if (Directory.Exists(item))
-        {
-            foreach (var subItem in Directory.EnumerateFileSystemEntries(item))
-                await AddItemToZipAsync(outputStream, subItem, root);
-        }
-    }
-
-    #endregion
-}

Moonlight.ApiServer/Http/Controllers/Admin/Sys/Files/DecompressController.cs

@@ -1,113 +0,0 @@
-using System.Text;
-using ICSharpCode.SharpZipLib.GZip;
-using ICSharpCode.SharpZipLib.Tar;
-using ICSharpCode.SharpZipLib.Zip;
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Mvc;
-using Moonlight.ApiServer.Helpers;
-using Moonlight.Shared.Http.Requests.Admin.Sys.Files;
-
-namespace Moonlight.ApiServer.Http.Controllers.Admin.Sys.Files;
-
-[ApiController]
-[Route("api/admin/system/files")]
-[Authorize(Policy = "permissions:admin.system.files")]
-public class DecompressController : Controller
-{
-    private const string BaseDirectory = "storage";
-    
-    [HttpPost("decompress")]
-    public async Task DecompressAsync([FromBody] DecompressRequest request)
-    {
-        var path = Path.Combine(BaseDirectory, FilePathHelper.SanitizePath(request.Path));
-        var destination = Path.Combine(BaseDirectory, FilePathHelper.SanitizePath(request.Destination));
-        
-        switch (request.Format)
-        {
-            case "tar.gz":
-                await DecompressTarGzAsync(path, destination);
-                break;
-            
-            case "zip":
-                await DecompressZipAsync(path, destination);
-                break;
-        }
-    }
-    
-     #region Tar Gz
-
-    private async Task DecompressTarGzAsync(string path, string destination)
-    {
-        await using var fs = System.IO.File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-        await using var gzipInputStream = new GZipInputStream(fs);
-        await using var tarInputStream = new TarInputStream(gzipInputStream, Encoding.UTF8);
-
-        while (true)
-        {
-            var entry = await tarInputStream.GetNextEntryAsync(CancellationToken.None);
-
-            if (entry == null)
-                break;
-
-            var safeFilePath = FilePathHelper.SanitizePath(entry.Name);
-            var fileDestination = Path.Combine(destination, safeFilePath);
-            var parentFolder = Path.GetDirectoryName(fileDestination);
-
-            // Ensure parent directory exists, if it's not the base directory
-            if (parentFolder != null && parentFolder != BaseDirectory)
-                Directory.CreateDirectory(parentFolder);
-
-            await using var fileDestinationFs =
-                System.IO.File.Open(fileDestination, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
-            await tarInputStream.CopyToAsync(fileDestinationFs, CancellationToken.None);
-
-            await fileDestinationFs.FlushAsync();
-            fileDestinationFs.Close();
-        }
-
-        tarInputStream.Close();
-        gzipInputStream.Close();
-        fs.Close();
-    }
-
-    #endregion
-
-    #region Zip
-
-    private async Task DecompressZipAsync(string path, string destination)
-    {
-        await using var fs = System.IO.File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-        await using var zipInputStream = new ZipInputStream(fs);
-
-        while (true)
-        {
-            var entry = zipInputStream.GetNextEntry();
-
-            if (entry == null)
-                break;
-
-            if (entry.IsDirectory)
-                continue;
-
-            var safeFilePath = FilePathHelper.SanitizePath(entry.Name);
-            var fileDestination = Path.Combine(destination, safeFilePath);
-            var parentFolder = Path.GetDirectoryName(fileDestination);
-
-            // Ensure parent directory exists, if it's not the base directory
-            if (parentFolder != null && parentFolder != BaseDirectory)
-                Directory.CreateDirectory(parentFolder);
-
-            await using var fileDestinationFs =
-                System.IO.File.Open(fileDestination, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
-            await zipInputStream.CopyToAsync(fileDestinationFs, CancellationToken.None);
-
-            await fileDestinationFs.FlushAsync();
-            fileDestinationFs.Close();
-        }
-
-        zipInputStream.Close();
-        fs.Close();
-    }
-
-    #endregion
-}

Moonlight.ApiServer/Http/Controllers/Admin/Sys/Files/DownloadUrlController.cs

@@ -1,128 +0,0 @@
-using ICSharpCode.SharpZipLib.Zip;
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
-using MoonCore.Exceptions;
-using MoonCore.Helpers;
-using Moonlight.ApiServer.Configuration;
-using Moonlight.ApiServer.Helpers;
-using Moonlight.Shared.Http.Responses.Admin.Sys;
-
-namespace Moonlight.ApiServer.Http.Controllers.Admin.Sys.Files;
-
-[ApiController]
-[Route("api/admin/system/files/downloadUrl")]
-[Authorize(Policy = "permissions:admin.system.files")]
-public class DownloadUrlController : Controller
-{
-    private readonly AppConfiguration Configuration;
-
-    private const string BaseDirectory = "storage";
-
-    public DownloadUrlController(AppConfiguration configuration)
-    {
-        Configuration = configuration;
-    }
-
-    [HttpGet]
-    public async Task GetAsync([FromQuery] string path)
-    {
-        var physicalPath = Path.Combine(BaseDirectory, FilePathHelper.SanitizePath(path));
-        var name = Path.GetFileName(physicalPath);
-
-        if (System.IO.File.Exists(physicalPath))
-        {
-            await using var fs = System.IO.File.Open(physicalPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-
-            await Results.File(fs, fileDownloadName: name).ExecuteAsync(HttpContext);
-        }
-        else if(Directory.Exists(physicalPath))
-        {
-            // Without the base directory we would have the full path to the target folder
-            // inside the zip
-            
-            var baseDirectory = Path.Combine(
-                BaseDirectory,
-                FilePathHelper.SanitizePath(Path.GetDirectoryName(path) ?? "")
-            );
-            
-            Response.StatusCode = 200;
-            Response.ContentType = "application/zip";
-            Response.Headers["Content-Disposition"] = $"attachment; filename=\"{name}.zip\"";
-
-            try
-            {
-                await using var zipStream = new ZipOutputStream(Response.Body);
-                zipStream.IsStreamOwner = false;
-
-                await StreamFolderAsZipAsync(zipStream, physicalPath, baseDirectory, HttpContext.RequestAborted);
-            }
-            catch (ZipException)
-            {
-                // Ignored
-            }
-            catch (TaskCanceledException)
-            {
-                // Ignored
-            }
-        }
-    }
-
-    private async Task StreamFolderAsZipAsync(
-        ZipOutputStream zipStream,
-        string path, string rootPath,
-        CancellationToken cancellationToken
-    )
-    {
-        foreach (var file in Directory.EnumerateFiles(path))
-        {
-            if (HttpContext.RequestAborted.IsCancellationRequested)
-                return;
-
-            var fi = new FileInfo(file);
-
-            var filePath = Formatter.ReplaceStart(file, rootPath, "");
-
-            await zipStream.PutNextEntryAsync(new ZipEntry(filePath)
-            {
-                Size = fi.Length,
-            }, cancellationToken);
-
-            await using var fs = System.IO.File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            await fs.CopyToAsync(zipStream, cancellationToken);
-            await fs.FlushAsync(cancellationToken);
-
-            fs.Close();
-
-            await zipStream.FlushAsync(cancellationToken);
-        }
-
-        foreach (var directory in Directory.EnumerateDirectories(path))
-        {
-            if (HttpContext.RequestAborted.IsCancellationRequested)
-                return;
-
-            await StreamFolderAsZipAsync(zipStream, directory, rootPath, cancellationToken);
-        }
-    }
-
-
-    // Yes I know we can just create that url on the client as the exist validation is done on both endpoints,
-    // but we leave it here for future modifications. E.g. using a distributed file provider or smth like that
-    [HttpPost]
-    public Task<DownloadUrlResponse> PostAsync([FromQuery] string path)
-    {
-        var safePath = FilePathHelper.SanitizePath(path);
-        var physicalPath = Path.Combine(BaseDirectory, safePath);
-
-        if (System.IO.File.Exists(physicalPath) || Directory.Exists(physicalPath))
-        {
-            return Task.FromResult(new DownloadUrlResponse()
-            {
-                Url = $"{Configuration.PublicUrl}/api/admin/system/files/downloadUrl?path={path}"
-            });
-        }
-
-        throw new HttpApiException("No such file or directory found", 404);
-    }
-}

Moonlight.ApiServer/Http/Controllers/Admin/Sys/Files/FilesController.cs

@@ -1,192 +0,0 @@
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
-using MoonCore.Exceptions;
-using Moonlight.ApiServer.Helpers;
-using Moonlight.Shared.Http.Responses.Admin.Sys;
-
-namespace Moonlight.ApiServer.Http.Controllers.Admin.Sys.Files;
-
-[ApiController]
-[Route("api/admin/system/files")]
-[Authorize(Policy = "permissions:admin.system.files")]
-public class FilesController : Controller
-{
-    private const string BaseDirectory = "storage";
-
-    [HttpPost("touch")]
-    public async Task CreateFileAsync([FromQuery] string path)
-    {
-        var safePath = FilePathHelper.SanitizePath(path);
-        var physicalPath = Path.Combine(BaseDirectory, safePath);
-
-        if (System.IO.File.Exists(physicalPath))
-            throw new HttpApiException("A file already exists at that path", 400);
-
-        if (Directory.Exists(path))
-            throw new HttpApiException("A folder already exists at that path", 400);
-
-        await using var fs = System.IO.File.Create(physicalPath);
-        fs.Close();
-    }
-    
-    [HttpPost("mkdir")]
-    public Task CreateFolderAsync([FromQuery] string path)
-    {
-        var safePath = FilePathHelper.SanitizePath(path);
-        var physicalPath = Path.Combine(BaseDirectory, safePath);
-
-        if (Directory.Exists(path))
-            throw new HttpApiException("A folder already exists at that path", 400);
-        
-        if (System.IO.File.Exists(physicalPath))
-            throw new HttpApiException("A file already exists at that path", 400);
-
-        Directory.CreateDirectory(physicalPath);
-        return Task.CompletedTask;
-    }
-    
-    [HttpGet("list")]
-    public Task<FileSystemEntryResponse[]> ListAsync([FromQuery] string path)
-    {
-        var safePath = FilePathHelper.SanitizePath(path);
-        var physicalPath = Path.Combine(BaseDirectory, safePath);
-
-        var entries = new List<FileSystemEntryResponse>();
-
-        var files = Directory.GetFiles(physicalPath);
-
-        foreach (var file in files)
-        {
-            var fi = new FileInfo(file);
-
-            entries.Add(new FileSystemEntryResponse()
-            {
-                Name = fi.Name,
-                Size = fi.Length,
-                CreatedAt = fi.CreationTimeUtc,
-                IsFolder = false,
-                UpdatedAt = fi.LastWriteTimeUtc
-            });
-        }
-
-        var directories = Directory.GetDirectories(physicalPath);
-
-        foreach (var directory in directories)
-        {
-            var di = new DirectoryInfo(directory);
-
-            entries.Add(new FileSystemEntryResponse()
-            {
-                Name = di.Name,
-                Size = 0,
-                CreatedAt = di.CreationTimeUtc,
-                UpdatedAt = di.LastWriteTimeUtc,
-                IsFolder = true
-            });
-        }
-
-        return Task.FromResult(
-            entries.ToArray()
-        );
-    }
-
-    [HttpPost("move")]
-    public Task MoveAsync([FromQuery] string oldPath, [FromQuery] string newPath)
-    {
-        var oldSafePath = FilePathHelper.SanitizePath(oldPath);
-        var newSafePath = FilePathHelper.SanitizePath(newPath);
-
-        var oldPhysicalDirPath = Path.Combine(BaseDirectory, oldSafePath);
-
-        if (Directory.Exists(oldPhysicalDirPath))
-        {
-            var newPhysicalDirPath = Path.Combine(BaseDirectory, newSafePath);
-
-            Directory.Move(
-                oldPhysicalDirPath,
-                newPhysicalDirPath
-            );
-        }
-        else
-        {
-            var oldPhysicalFilePath = Path.Combine(BaseDirectory, oldSafePath);
-            var newPhysicalFilePath = Path.Combine(BaseDirectory, newSafePath);
-
-            System.IO.File.Move(
-                oldPhysicalFilePath,
-                newPhysicalFilePath
-            );
-        }
-
-        return Task.CompletedTask;
-    }
-
-    [HttpDelete("delete")]
-    public Task DeleteAsync([FromQuery] string path)
-    {
-        var safePath = FilePathHelper.SanitizePath(path);
-        var physicalDirPath = Path.Combine(BaseDirectory, safePath);
-
-        if (Directory.Exists(physicalDirPath))
-            Directory.Delete(physicalDirPath, true);
-        else
-        {
-            var physicalFilePath = Path.Combine(BaseDirectory, safePath);
-
-            System.IO.File.Delete(physicalFilePath);
-        }
-
-        return Task.CompletedTask;
-    }
-
-    [HttpPost("upload")]
-    public async Task<IResult> UploadAsync([FromQuery] string path)
-    {
-        if (Request.Form.Files.Count != 1)
-            return Results.Problem("Only one file is allowed in the request", statusCode: 400);
-
-        var file = Request.Form.Files[0];
-        
-        var safePath = FilePathHelper.SanitizePath(path);
-        var physicalPath = Path.Combine(BaseDirectory, safePath);
-
-        // Create directory which the new file should be put into
-        var baseDirectory = Path.GetDirectoryName(physicalPath);
-        
-        if(!string.IsNullOrEmpty(baseDirectory))
-            Directory.CreateDirectory(baseDirectory);
-
-        // Create file from provided form
-        await using var dataStream = file.OpenReadStream();
-
-        await using var targetStream = System.IO.File.Open(
-            physicalPath,
-            FileMode.Create,
-            FileAccess.ReadWrite,
-            FileShare.Read
-        );
-
-        // Copy the content to the newly created file
-        await dataStream.CopyToAsync(targetStream);
-        await targetStream.FlushAsync();
-        
-        // Close both streams
-        targetStream.Close();
-        dataStream.Close();
-
-        return Results.Ok();
-    }
-
-    [HttpGet("download")]
-    public async Task DownloadAsync([FromQuery] string path)
-    {
-        var safePath = FilePathHelper.SanitizePath(path);
-        var physicalPath = Path.Combine(BaseDirectory, safePath);
-
-        await using var fs = System.IO.File.Open(physicalPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-        await fs.CopyToAsync(Response.Body);
-        
-        fs.Close();
-    }
-}

Moonlight.ApiServer/Http/Controllers/Admin/Sys/FilesController.cs

@@ -0,0 +1,475 @@
+using System.Text;
+using ICSharpCode.SharpZipLib.GZip;
+using ICSharpCode.SharpZipLib.Tar;
+using ICSharpCode.SharpZipLib.Zip;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using MoonCore.Exceptions;
+using MoonCore.Helpers;
+using Moonlight.Shared.Http.Requests.Admin.Sys.Files;
+using Moonlight.Shared.Http.Responses.Admin.Sys;
+
+namespace Moonlight.ApiServer.Http.Controllers.Admin.Sys;
+
+[ApiController]
+[Route("api/admin/system/files")]
+[Authorize(Policy = "permissions:admin.system.files")]
+public class FilesController : Controller
+{
+    private readonly string BaseDirectory = "storage";
+    private readonly long MaxChunkSize = ByteConverter.FromMegaBytes(20).Bytes;
+
+    [HttpPost("touch")]
+    public async Task CreateFile([FromQuery] string path)
+    {
+        var safePath = SanitizePath(path);
+        var physicalPath = Path.Combine(BaseDirectory, safePath);
+
+        if (System.IO.File.Exists(physicalPath))
+            throw new HttpApiException("A file already exists at that path", 400);
+
+        if (Directory.Exists(path))
+            throw new HttpApiException("A folder already exists at that path", 400);
+
+        await using var fs = System.IO.File.Create(physicalPath);
+        fs.Close();
+    }
+    
+    [HttpPost("mkdir")]
+    public Task CreateFolder([FromQuery] string path)
+    {
+        var safePath = SanitizePath(path);
+        var physicalPath = Path.Combine(BaseDirectory, safePath);
+
+        if (Directory.Exists(path))
+            throw new HttpApiException("A folder already exists at that path", 400);
+        
+        if (System.IO.File.Exists(physicalPath))
+            throw new HttpApiException("A file already exists at that path", 400);
+
+        Directory.CreateDirectory(physicalPath);
+        return Task.CompletedTask;
+    }
+    
+    [HttpGet("list")]
+    public Task<FileSystemEntryResponse[]> List([FromQuery] string path)
+    {
+        var safePath = SanitizePath(path);
+        var physicalPath = Path.Combine(BaseDirectory, safePath);
+
+        var entries = new List<FileSystemEntryResponse>();
+
+        var files = Directory.GetFiles(physicalPath);
+
+        foreach (var file in files)
+        {
+            var fi = new FileInfo(file);
+
+            entries.Add(new FileSystemEntryResponse()
+            {
+                Name = fi.Name,
+                Size = fi.Length,
+                CreatedAt = fi.CreationTimeUtc,
+                IsFolder = false,
+                UpdatedAt = fi.LastWriteTimeUtc
+            });
+        }
+
+        var directories = Directory.GetDirectories(physicalPath);
+
+        foreach (var directory in directories)
+        {
+            var di = new DirectoryInfo(directory);
+
+            entries.Add(new FileSystemEntryResponse()
+            {
+                Name = di.Name,
+                Size = 0,
+                CreatedAt = di.CreationTimeUtc,
+                UpdatedAt = di.LastWriteTimeUtc,
+                IsFolder = true
+            });
+        }
+
+        return Task.FromResult(
+            entries.ToArray()
+        );
+    }
+
+    [HttpPost("upload")]
+    public async Task Upload([FromQuery] string path, [FromQuery] long chunkSize, [FromQuery] long totalSize, [FromQuery] int chunkId)
+    {
+        if (Request.Form.Files.Count != 1)
+            throw new HttpApiException("You need to provide exactly one file", 400);
+
+        var file = Request.Form.Files[0];
+        
+        if (file.Length > chunkSize)
+            throw new HttpApiException("The provided data exceeds the chunk size limit", 400);
+        
+        var chunks = totalSize / chunkSize;
+        chunks += totalSize % chunkSize > 0 ? 1 : 0;
+
+        if (chunkId > chunks)
+            throw new HttpApiException("Invalid chunk id: Out of bounds", 400);
+        
+        var positionToSkipTo = chunkSize * chunkId;
+
+        var safePath = SanitizePath(path);
+        var physicalPath = Path.Combine(BaseDirectory, safePath);
+        var baseDir = Path.GetDirectoryName(physicalPath);
+
+        if (!string.IsNullOrEmpty(baseDir))
+            Directory.CreateDirectory(baseDir);
+
+        await using var fs = System.IO.File.Open(physicalPath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
+
+        // This resizes the file to the correct size so we can handle the chunk if it didnt exist
+        
+        if (fs.Length != totalSize)
+            fs.SetLength(totalSize);
+        
+        fs.Position = positionToSkipTo;
+
+        var dataStream = file.OpenReadStream();
+
+        await dataStream.CopyToAsync(fs);
+        await fs.FlushAsync();
+
+        fs.Close();
+    }
+
+    [HttpPost("move")]
+    public Task Move([FromQuery] string oldPath, [FromQuery] string newPath)
+    {
+        var oldSafePath = SanitizePath(oldPath);
+        var newSafePath = SanitizePath(newPath);
+
+        var oldPhysicalDirPath = Path.Combine(BaseDirectory, oldSafePath);
+
+        if (Directory.Exists(oldPhysicalDirPath))
+        {
+            var newPhysicalDirPath = Path.Combine(BaseDirectory, newSafePath);
+
+            Directory.Move(
+                oldPhysicalDirPath,
+                newPhysicalDirPath
+            );
+        }
+        else
+        {
+            var oldPhysicalFilePath = Path.Combine(BaseDirectory, oldSafePath);
+            var newPhysicalFilePath = Path.Combine(BaseDirectory, newSafePath);
+
+            System.IO.File.Move(
+                oldPhysicalFilePath,
+                newPhysicalFilePath
+            );
+        }
+
+        return Task.CompletedTask;
+    }
+
+    [HttpDelete("delete")]
+    public Task Delete([FromQuery] string path)
+    {
+        var safePath = SanitizePath(path);
+        var physicalDirPath = Path.Combine(BaseDirectory, safePath);
+
+        if (Directory.Exists(physicalDirPath))
+            Directory.Delete(physicalDirPath, true);
+        else
+        {
+            var physicalFilePath = Path.Combine(BaseDirectory, safePath);
+
+            System.IO.File.Delete(physicalFilePath);
+        }
+
+        return Task.CompletedTask;
+    }
+
+    [HttpGet("download")]
+    public async Task Download([FromQuery] string path)
+    {
+        var safePath = SanitizePath(path);
+        var physicalPath = Path.Combine(BaseDirectory, safePath);
+
+        await using var fs = System.IO.File.Open(physicalPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+        await fs.CopyToAsync(Response.Body);
+        
+        fs.Close();
+    }
+
+    [HttpPost("compress")]
+    public async Task Compress([FromBody] CompressRequest request)
+    {
+        if (request.Type == "tar.gz")
+            await CompressTarGz(request.Path, request.ItemsToCompress);
+        else if (request.Type == "zip")
+            await CompressZip(request.Path, request.ItemsToCompress);
+    }
+
+    #region Tar Gz
+
+    private async Task CompressTarGz(string path, string[] itemsToCompress)
+    {
+        var safePath = SanitizePath(path);
+        var destination = Path.Combine(BaseDirectory, safePath);
+
+        await using var outStream = System.IO.File.Create(destination);
+        await using var gzoStream = new GZipOutputStream(outStream);
+        await using var tarStream = new TarOutputStream(gzoStream, Encoding.UTF8);
+
+        foreach (var itemName in itemsToCompress)
+        {
+            var safeFilePath = SanitizePath(itemName);
+            var filePath = Path.Combine(BaseDirectory, safeFilePath);
+
+            var fi = new FileInfo(filePath);
+
+            if (fi.Exists)
+                await AddFileToTarGz(tarStream, filePath);
+            else
+            {
+                var safeDirePath = SanitizePath(itemName);
+                var dirPath = Path.Combine(BaseDirectory, safeDirePath);
+
+                await AddDirectoryToTarGz(tarStream, dirPath);
+            }
+        }
+
+        await tarStream.FlushAsync();
+        await gzoStream.FlushAsync();
+        await outStream.FlushAsync();
+
+        tarStream.Close();
+        gzoStream.Close();
+        outStream.Close();
+    }
+
+    private async Task AddDirectoryToTarGz(TarOutputStream tarOutputStream, string root)
+    {
+        foreach (var file in Directory.GetFiles(root))
+            await AddFileToTarGz(tarOutputStream, file);
+
+        foreach (var directory in Directory.GetDirectories(root))
+            await AddDirectoryToTarGz(tarOutputStream, directory);
+    }
+
+    private async Task AddFileToTarGz(TarOutputStream tarOutputStream, string file)
+    {
+        // Open file stream
+        var fs = System.IO.File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+
+        // Meta 
+        var entry = TarEntry.CreateTarEntry(file);
+
+        // Fix path
+        entry.Name = Formatter
+            .ReplaceStart(entry.Name, BaseDirectory, "")
+            .TrimStart('/');
+
+        entry.Size = fs.Length;
+
+        // Write entry
+        await tarOutputStream.PutNextEntryAsync(entry, CancellationToken.None);
+
+        // Copy file content to tar stream
+        await fs.CopyToAsync(tarOutputStream);
+        fs.Close();
+
+        // Close the entry
+        tarOutputStream.CloseEntry();
+    }
+
+    #endregion
+
+    #region ZIP
+
+    private async Task CompressZip(string path, string[] itemsToCompress)
+    {
+        var safePath = SanitizePath(path);
+        var destination = Path.Combine(BaseDirectory, safePath);
+
+        await using var outStream = System.IO.File.Create(destination);
+        await using var zipOutputStream = new ZipOutputStream(outStream);
+
+        foreach (var itemName in itemsToCompress)
+        {
+            var safeFilePath = SanitizePath(itemName);
+            var filePath = Path.Combine(BaseDirectory, safeFilePath);
+
+            var fi = new FileInfo(filePath);
+
+            if (fi.Exists)
+                await AddFileToZip(zipOutputStream, filePath);
+            else
+            {
+                var safeDirePath = SanitizePath(itemName);
+                var dirPath = Path.Combine(BaseDirectory, safeDirePath);
+
+                await AddDirectoryToZip(zipOutputStream, dirPath);
+            }
+        }
+
+        await zipOutputStream.FlushAsync();
+        await outStream.FlushAsync();
+
+        zipOutputStream.Close();
+        outStream.Close();
+    }
+
+    private async Task AddFileToZip(ZipOutputStream zipOutputStream, string path)
+    {
+        // Open file stream
+        var fs = System.IO.File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+
+        // Fix path
+        var name = Formatter
+            .ReplaceStart(path, BaseDirectory, "")
+            .TrimStart('/');
+
+        // Meta 
+        var entry = new ZipEntry(name);
+
+        entry.Size = fs.Length;
+
+        // Write entry
+        await zipOutputStream.PutNextEntryAsync(entry, CancellationToken.None);
+
+        // Copy file content to tar stream
+        await fs.CopyToAsync(zipOutputStream);
+        fs.Close();
+
+        // Close the entry
+        zipOutputStream.CloseEntry();
+    }
+
+    private async Task AddDirectoryToZip(ZipOutputStream zipOutputStream, string root)
+    {
+        foreach (var file in Directory.GetFiles(root))
+            await AddFileToZip(zipOutputStream, file);
+
+        foreach (var directory in Directory.GetDirectories(root))
+            await AddDirectoryToZip(zipOutputStream, directory);
+    }
+
+    #endregion
+
+    [HttpPost("decompress")]
+    public async Task Decompress([FromBody] DecompressRequest request)
+    {
+        if (request.Type == "tar.gz")
+            await DecompressTarGz(request.Path, request.Destination);
+        else if (request.Type == "zip")
+            await DecompressZip(request.Path, request.Destination);
+    }
+
+    #region Tar Gz
+
+    private async Task DecompressTarGz(string path, string destination)
+    {
+        var safeDestination = SanitizePath(destination);
+
+        var safeArchivePath = SanitizePath(path);
+        var archivePath = Path.Combine(BaseDirectory, safeArchivePath);
+
+        await using var fs = System.IO.File.Open(archivePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+        await using var gzipInputStream = new GZipInputStream(fs);
+        await using var tarInputStream = new TarInputStream(gzipInputStream, Encoding.UTF8);
+
+        while (true)
+        {
+            var entry = await tarInputStream.GetNextEntryAsync(CancellationToken.None);
+
+            if (entry == null)
+                break;
+
+            var safeFilePath = SanitizePath(entry.Name);
+            var fileDestination = Path.Combine(BaseDirectory, safeDestination, safeFilePath);
+            var parentFolder = Path.GetDirectoryName(fileDestination);
+
+            // Ensure parent directory exists, if it's not the base directory
+            if (parentFolder != null && parentFolder != BaseDirectory)
+                Directory.CreateDirectory(parentFolder);
+
+            await using var fileDestinationFs =
+                System.IO.File.Open(fileDestination, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
+            await tarInputStream.CopyToAsync(fileDestinationFs, CancellationToken.None);
+
+            await fileDestinationFs.FlushAsync();
+            fileDestinationFs.Close();
+        }
+
+        tarInputStream.Close();
+        gzipInputStream.Close();
+        fs.Close();
+    }
+
+    #endregion
+
+    #region Zip
+
+    private async Task DecompressZip(string path, string destination)
+    {
+        var safeDestination = SanitizePath(destination);
+
+        var safeArchivePath = SanitizePath(path);
+        var archivePath = Path.Combine(BaseDirectory, safeArchivePath);
+
+        await using var fs = System.IO.File.Open(archivePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+        await using var zipInputStream = new ZipInputStream(fs);
+
+        while (true)
+        {
+            var entry = zipInputStream.GetNextEntry();
+
+            if (entry == null)
+                break;
+
+            if (entry.IsDirectory)
+                continue;
+
+            var safeFilePath = SanitizePath(entry.Name);
+            var fileDestination = Path.Combine(BaseDirectory, safeDestination, safeFilePath);
+            var parentFolder = Path.GetDirectoryName(fileDestination);
+
+            // Ensure parent directory exists, if it's not the base directory
+            if (parentFolder != null && parentFolder != BaseDirectory)
+                Directory.CreateDirectory(parentFolder);
+
+            await using var fileDestinationFs =
+                System.IO.File.Open(fileDestination, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
+            await zipInputStream.CopyToAsync(fileDestinationFs, CancellationToken.None);
+
+            await fileDestinationFs.FlushAsync();
+            fileDestinationFs.Close();
+        }
+
+        zipInputStream.Close();
+        fs.Close();
+    }
+
+    #endregion
+
+    private string SanitizePath(string path)
+    {
+        if (string.IsNullOrWhiteSpace(path))
+            return string.Empty;
+
+        // Normalize separators
+        path = path.Replace('\\', '/');
+
+        // Remove ".." and "."
+        var parts = path.Split('/', StringSplitOptions.RemoveEmptyEntries)
+            .Where(part => part != ".." && part != ".");
+
+        var sanitized = string.Join("/", parts);
+
+        // Ensure it does not start with a slash
+        if (sanitized.StartsWith('/'))
+            sanitized = sanitized.TrimStart('/');
+
+        return sanitized;
+    }
+}

Moonlight.ApiServer/Http/Controllers/Admin/Sys/HangfireController.cs

@@ -1,40 +0,0 @@
-using Hangfire;
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Mvc;
-using Moonlight.Shared.Http.Responses.Admin.Hangfire;
-
-namespace Moonlight.ApiServer.Http.Controllers.Admin.Sys;
-
-[ApiController]
-[Route("api/admin/system/hangfire")]
-[Authorize(Policy = "permissions:admin.system.hangfire")]
-public class HangfireController : Controller
-{
-    private readonly JobStorage JobStorage;
-
-    public HangfireController(JobStorage jobStorage)
-    {
-        JobStorage = jobStorage;
-    }
-
-    [HttpGet("stats")]
-    public Task<HangfireStatsResponse> GetStatsAsync()
-    {
-        var statistics = JobStorage.GetMonitoringApi().GetStatistics();
-
-        return Task.FromResult(new HangfireStatsResponse()
-        {
-            Awaiting = statistics.Awaiting,
-            Deleted = statistics.Deleted,
-            Enqueued = statistics.Enqueued,
-            Failed = statistics.Failed,
-            Processing = statistics.Processing,
-            Queues = statistics.Queues,
-            Recurring = statistics.Recurring,
-            Retries = statistics.Retries,
-            Scheduled = statistics.Scheduled,
-            Servers = statistics.Servers,
-            Succeeded = statistics.Succeeded
-        });
-    }
-}

Moonlight.ApiServer/Http/Controllers/Admin/Sys/SystemController.cs

@@ -18,21 +18,21 @@ public class SystemController : Controller
 
     [HttpGet]
     [Authorize(Policy = "permissions:admin.system.overview")]
-    public async Task<SystemOverviewResponse> GetOverviewAsync()
+    public async Task<SystemOverviewResponse> GetOverview()
     {
         return new()
         {
-            Uptime = await ApplicationService.GetUptimeAsync(),
-            CpuUsage = await ApplicationService.GetCpuUsageAsync(),
-            MemoryUsage = await ApplicationService.GetMemoryUsageAsync(),
-            OperatingSystem = await ApplicationService.GetOsNameAsync()
+            Uptime = await ApplicationService.GetUptime(),
+            CpuUsage = await ApplicationService.GetCpuUsage(),
+            MemoryUsage = await ApplicationService.GetMemoryUsage(),
+            OperatingSystem = await ApplicationService.GetOsName()
         };
     }
 
     [HttpPost("shutdown")]
     [Authorize(Policy = "permissions:admin.system.shutdown")]
-    public async Task ShutdownAsync()
+    public async Task Shutdown()
     {
-        await ApplicationService.ShutdownAsync();
+        await ApplicationService.Shutdown();
     }
 }

Moonlight.ApiServer/Http/Controllers/Admin/Users/UsersController.cs

@@ -1,13 +1,14 @@
+using System.ComponentModel.DataAnnotations;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
-using MoonCore.Common;
+using MoonCore.Exceptions;
 using MoonCore.Extended.Abstractions;
 using MoonCore.Extended.Helpers;
+using MoonCore.Models;
 using Moonlight.ApiServer.Database.Entities;
 using Moonlight.ApiServer.Services;
-using Moonlight.ApiServer.Mappers;
 using Moonlight.Shared.Http.Requests.Admin.Users;
 using Moonlight.Shared.Http.Responses.Admin.Users;
 
@@ -26,78 +27,63 @@ public class UsersController : Controller
 
     [HttpGet]
     [Authorize(Policy = "permissions:admin.users.get")]
-    public async Task<ActionResult<CountedData<UserResponse>>> GetAsync(
-        [FromQuery] int startIndex,
-        [FromQuery] int count,
-        [FromQuery] string? orderBy,
-        [FromQuery] string? filter,
-        [FromQuery] string orderByDir = "asc"
+    public async Task<IPagedData<UserResponse>> Get(
+        [FromQuery] [Range(0, int.MaxValue)] int page,
+        [FromQuery] [Range(1, 100)] int pageSize
     )
     {
-        if (count > 100)
-            return Problem("You cannot fetch more items than 100 at a time", statusCode: 400);
+        var count = await UserRepository.Get().CountAsync();
 
-        IQueryable<User> query = UserRepository.Get();
-
-        query = orderBy switch
-        {
-            nameof(Database.Entities.User.Id) => orderByDir == "desc"
-                ? query.OrderByDescending(x => x.Id)
-                : query.OrderBy(x => x.Id),
-                
-            nameof(Database.Entities.User.Username) => orderByDir == "desc"
-                ? query.OrderByDescending(x => x.Username)
-                : query.OrderBy(x => x.Username),
-            
-            nameof(Database.Entities.User.Email) => orderByDir == "desc"
-                ? query.OrderByDescending(x => x.Email)
-                : query.OrderBy(x => x.Email),
-            
-            _ => query.OrderBy(x => x.Id)
-        };
-
-        if (!string.IsNullOrEmpty(filter))
-        {
-            query = query.Where(x =>
-                EF.Functions.ILike(x.Username, $"%{filter}%") ||
-                EF.Functions.ILike(x.Email, $"%{filter}%")
-            );
-        }
-
-        var totalCount = await query.CountAsync();
-
-        var items = await query
-            .Skip(startIndex)
-            .Take(count)
-            .AsNoTracking()
-            .ProjectToResponse()
+        var users = await UserRepository
+            .Get()
+            .OrderBy(x => x.Id)
+            .Skip(page * pageSize)
+            .Take(pageSize)
             .ToArrayAsync();
 
-        return new CountedData<UserResponse>()
+        var mappedUsers = users
+            .Select(x => new UserResponse()
+            {
+                Id = x.Id,
+                Email = x.Email,
+                Username = x.Username,
+                Permissions = x.Permissions
+            })
+            .ToArray();
+
+        return new PagedData<UserResponse>()
         {
-            Items = items,
-            TotalCount = totalCount
+            CurrentPage = page,
+            Items = mappedUsers,
+            PageSize = pageSize,
+            TotalItems = count,
+            TotalPages = count == 0 ? 0 : (count - 1) / pageSize
         };
     }
 
     [HttpGet("{id}")]
     [Authorize(Policy = "permissions:admin.users.get")]
-    public async Task<ActionResult<UserResponse>> GetSingleAsync(int id)
+    public async Task<UserResponse> GetSingle(int id)
     {
         var user = await UserRepository
             .Get()
-            .ProjectToResponse()
             .FirstOrDefaultAsync(x => x.Id == id);
 
         if (user == null)
-            return Problem("No user with that id found", statusCode: 404);
+            throw new HttpApiException("No user with that id found", 404);
 
-        return user;
+        return new UserResponse()
+        {
+            Id = user.Id,
+            Email = user.Email,
+            Username = user.Username,
+            Permissions = user.Permissions
+        };
     }
 
     [HttpPost]
     [Authorize(Policy = "permissions:admin.users.create")]
-    public async Task<ActionResult<UserResponse>> CreateAsync([FromBody] CreateUserRequest request)
+    public async Task<UserResponse> Create([FromBody] CreateUserRequest request)
     {
         // Reformat values
         request.Username = request.Username.ToLower().Trim();
@@ -105,10 +91,10 @@ public class UsersController : Controller
 
         // Check for users with the same values
         if (UserRepository.Get().Any(x => x.Username == request.Username))
-            return Problem("A user with that username already exists", statusCode: 400);
+            throw new HttpApiException("A user with that username already exists", 400);
 
         if (UserRepository.Get().Any(x => x.Email == request.Email))
-            return Problem("A user with that email address already exists", statusCode: 400);
+            throw new HttpApiException("A user with that email address already exists", 400);
 
         var hashedPassword = HashHelper.Hash(request.Password);
 
@@ -120,21 +106,27 @@ public class UsersController : Controller
             Permissions = request.Permissions
         };
 
-        var finalUser = await UserRepository.AddAsync(user);
+        var finalUser = await UserRepository.Add(user);
 
-        return UserMapper.ToResponse(finalUser);
+        return new UserResponse()
+        {
+            Id = finalUser.Id,
+            Email = finalUser.Email,
+            Username = finalUser.Username,
+            Permissions = finalUser.Permissions
+        };
     }
 
     [HttpPatch("{id}")]
     [Authorize(Policy = "permissions:admin.users.update")]
-    public async Task<ActionResult<UserResponse>> UpdateAsync([FromRoute] int id, [FromBody] UpdateUserRequest request)
+    public async Task<UserResponse> Update([FromRoute] int id, [FromBody] UpdateUserRequest request)
     {
         var user = await UserRepository
             .Get()
             .FirstOrDefaultAsync(x => x.Id == id);
 
         if (user == null)
-            return Problem("No user with that id found", statusCode: 404);
+            throw new HttpApiException("No user with that id found", 404);
 
         // Reformat values
         request.Username = request.Username.ToLower().Trim();
@@ -142,10 +134,10 @@ public class UsersController : Controller
 
         // Check for users with the same values
         if (UserRepository.Get().Any(x => x.Username == request.Username && x.Id != user.Id))
-            return Problem("Another user with that username already exists", statusCode: 400);
+            throw new HttpApiException("A user with that username already exists", 400);
 
         if (UserRepository.Get().Any(x => x.Email == request.Email && x.Id != user.Id))
-            return Problem("Another user with that email address already exists", statusCode: 400);
+            throw new HttpApiException("A user with that email address already exists", 400);
 
         // Perform hashing the password if required
         if (!string.IsNullOrEmpty(request.Password))
@@ -163,33 +155,38 @@ public class UsersController : Controller
         user.Email = request.Email;
         user.Username = request.Username;
 
-        await UserRepository.UpdateAsync(user);
+        await UserRepository.Update(user);
 
-        return UserMapper.ToResponse(user);
+        return new UserResponse()
+        {
+            Id = user.Id,
+            Email = user.Email,
+            Username = user.Username,
+            Permissions = user.Permissions
+        };
     }
 
     [HttpDelete("{id}")]
     [Authorize(Policy = "permissions:admin.users.delete")]
-    public async Task<ActionResult> DeleteAsync([FromRoute] int id, [FromQuery] bool force = false)
+    public async Task Delete([FromRoute] int id, [FromQuery] bool force = false)
     {
         var user = await UserRepository
             .Get()
             .FirstOrDefaultAsync(x => x.Id == id);
 
         if (user == null)
-            return Problem("No user with that id found", statusCode: 404);
+            throw new HttpApiException("No user with that id found", 404);
 
         var deletionService = HttpContext.RequestServices.GetRequiredService<UserDeletionService>();
 
         if (!force)
         {
-            var validationResult = await deletionService.ValidateAsync(user);
+            var validationResult = await deletionService.Validate(user);
 
             if (!validationResult.IsAllowed)
-                return Problem("Unable to delete user", statusCode: 400, title: validationResult.Reason);
+                throw new HttpApiException($"Unable to delete user", 400, validationResult.Reason);
         }
 
-        await deletionService.DeleteAsync(user, force);
-        return NoContent();
+        await deletionService.Delete(user, force);
     }
 }

Moonlight.ApiServer/Http/Controllers/Auth/AuthController.cs

@@ -1,10 +1,16 @@
-using System.Security.Claims;
-using Microsoft.AspNetCore.Authentication;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
 using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.IdentityModel.Tokens;
+using MoonCore.Exceptions;
+using MoonCore.Extended.Abstractions;
 using Moonlight.ApiServer.Configuration;
+using Moonlight.ApiServer.Database.Entities;
 using Moonlight.ApiServer.Interfaces;
+using Moonlight.Shared.Http.Requests.Auth;
 using Moonlight.Shared.Http.Responses.Auth;
 
 namespace Moonlight.ApiServer.Http.Controllers.Auth;
@@ -13,116 +19,93 @@ namespace Moonlight.ApiServer.Http.Controllers.Auth;
 [Route("api/auth")]
 public class AuthController : Controller
 {
-    private readonly IAuthenticationSchemeProvider SchemeProvider;
-    private readonly IEnumerable<IAuthCheckExtension> Extensions;
     private readonly AppConfiguration Configuration;
+    private readonly DatabaseRepository<User> UserRepository;
+    private readonly IOAuth2Provider OAuth2Provider;
 
     public AuthController(
-        IAuthenticationSchemeProvider schemeProvider,
-        IEnumerable<IAuthCheckExtension> extensions,
-        AppConfiguration configuration
+        AppConfiguration configuration,
+        DatabaseRepository<User> userRepository,
+        IOAuth2Provider oAuth2Provider
     )
     {
-        SchemeProvider = schemeProvider;
-        Extensions = extensions;
+        UserRepository = userRepository;
+        OAuth2Provider = oAuth2Provider;
         Configuration = configuration;
     }
 
-    [HttpGet]
-    public async Task<AuthSchemeResponse[]> GetSchemesAsync()
+    [AllowAnonymous]
+    [HttpGet("start")]
+    public async Task<LoginStartResponse> Start()
     {
-        var schemes = await SchemeProvider.GetAllSchemesAsync();
+        var url = await OAuth2Provider.Start();
 
-        var allowedSchemes = Configuration.Authentication.EnabledSchemes;
-
-        return schemes
-            .Where(x => allowedSchemes.Contains(x.Name))
-            .Select(scheme => new AuthSchemeResponse()
-            {
-                DisplayName = scheme.DisplayName ?? scheme.Name,
-                Identifier = scheme.Name
-            })
-            .ToArray();
+        return new LoginStartResponse()
+        {
+            Url = url
+        };
     }
 
-    [HttpGet("{identifier:alpha}")]
-    public async Task StartSchemeAsync([FromRoute] string identifier)
+    [AllowAnonymous]
+    [HttpPost("complete")]
+    public async Task<LoginCompleteResponse> Complete([FromBody] LoginCompleteRequest request)
     {
-        // Validate identifier against our enable list
-        var allowedSchemes = Configuration.Authentication.EnabledSchemes;
+        var user = await OAuth2Provider.Complete(request.Code);
 
-        if (!allowedSchemes.Contains(identifier))
+        if (user == null)
+            throw new HttpApiException("Unable to load user data", 500);
+
+        // Generate token
+        var securityTokenDescriptor = new SecurityTokenDescriptor()
         {
-            await Results
-                .Problem(
-                    "Invalid scheme identifier provided",
-                    statusCode: 404
-                )
-                .ExecuteAsync(HttpContext);
-
-            return;
-        }
-
-        // Now we can check if it even exists
-        var scheme = await SchemeProvider.GetSchemeAsync(identifier);
-
-        if (scheme == null)
-        {
-            await Results
-                .Problem(
-                    "Invalid scheme identifier provided",
-                    statusCode: 404
-                )
-                .ExecuteAsync(HttpContext);
-
-            return;
-        }
-
-        // Everything fine, challenge the frontend
-        await HttpContext.ChallengeAsync(
-            scheme.Name,
-            new AuthenticationProperties()
+            Expires = DateTime.Now.AddHours(Configuration.Authentication.TokenDuration),
+            IssuedAt = DateTime.Now,
+            NotBefore = DateTime.Now.AddMinutes(-1),
+            Claims = new Dictionary<string, object>()
             {
-                RedirectUri = "/"
-            }
-        );
+                {
+                    "userId",
+                    user.Id
+                },
+                {
+                    "permissions",
+                    string.Join(";", user.Permissions)
+                }
+            },
+            SigningCredentials = new SigningCredentials(
+                new SymmetricSecurityKey(
+                    Encoding.UTF8.GetBytes(Configuration.Authentication.Secret)
+                ),
+                SecurityAlgorithms.HmacSha256
+            ),
+            Issuer = Configuration.PublicUrl,
+            Audience = Configuration.PublicUrl
+        };
+
+        var jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
+        var securityToken = jwtSecurityTokenHandler.CreateToken(securityTokenDescriptor);
+
+        var jwt = jwtSecurityTokenHandler.WriteToken(securityToken);
+
+        return new()
+        {
+            AccessToken = jwt
+        };
     }
 
     [Authorize]
     [HttpGet("check")]
-    public async Task<AuthClaimResponse[]> CheckAsync()
+    public async Task<CheckResponse> Check()
     {
-        var username = User.FindFirstValue(ClaimTypes.Name)!;
-        var id = User.FindFirstValue(ClaimTypes.NameIdentifier)!;
-        var email = User.FindFirstValue(ClaimTypes.Email)!;
-        var userId = User.FindFirstValue("UserId")!;
-        var permissions = User.FindFirstValue("Permissions")!;
+        var userIdStr = User.FindFirstValue("userId")!;
+        var userId = int.Parse(userIdStr);
+        var user = await UserRepository.Get().FirstAsync(x => x.Id == userId);
 
-        // Create basic set of claims used by the frontend
-        var claims = new List<AuthClaimResponse>()
+        return new()
         {
-            new(ClaimTypes.Name, username),
-            new(ClaimTypes.NameIdentifier, id),
-            new(ClaimTypes.Email, email),
-            new("UserId", userId),
-            new("Permissions", permissions)
+            Email = user.Email,
+            Username = user.Username,
+            Permissions = user.Permissions
         };
-
-        // Enrich the frontend claims by extensions (used by plugins)
-        foreach (var extension in Extensions)
-        {
-            claims.AddRange(
-                await extension.GetFrontendClaimsAsync(User)
-            );
-        }
-
-        return claims.ToArray();
-    }
-
-    [HttpGet("logout")]
-    public async Task LogoutAsync()
-    {
-        await HttpContext.SignOutAsync();
-        await Results.Redirect("/").ExecuteAsync(HttpContext);
     }
 }

Moonlight.ApiServer/Http/Controllers/Frontend/FrontendController.cs

@@ -18,13 +18,13 @@ public class FrontendController : Controller
     }
 
     [HttpGet("frontend.json")]
-    public async Task<FrontendConfiguration> GetConfigurationAsync()
-        => await FrontendService.GetConfigurationAsync();
+    public async Task<FrontendConfiguration> GetConfiguration()
+        => await FrontendService.GetConfiguration();
 
     [HttpGet]
-    public async Task<IResult> IndexAsync()
+    public async Task<IResult> Index()
     {
-        var content = await FrontendService.GenerateIndexHtmlAsync();
+        var content = await FrontendService.GenerateIndexHtml();
 
         return Results.Text(content, "text/html", Encoding.UTF8);
     }

Moonlight.ApiServer/Http/Controllers/Frontend/FrontendPage.razor

@@ -1,7 +1,8 @@
 @using Moonlight.ApiServer.Database.Entities
+@using Moonlight.Shared.Misc
 
 <!DOCTYPE html>
-<html lang="en" class="bg-base-200 text-base-content font-inter">
+<html lang="en" class="bg-background text-base-content font-inter">
 
 <head>
     <meta charset="utf-8"/>
@@ -22,45 +23,48 @@
     {
         <style>
             :root {
-                --color-base-100: @(Theme.Content.ColorBase100);
-                --color-base-200: @(Theme.Content.ColorBase200);
-                --color-base-300: @(Theme.Content.ColorBase300);
-                --color-base-content: @(Theme.Content.ColorBaseContent);
+                --mooncore-color-background: @(Theme.Content.ColorBackground);
+                --mooncore-color-base-100: @(Theme.Content.ColorBase100);
+                --mooncore-color-base-150: @(Theme.Content.ColorBase150);
+                --mooncore-color-base-200: @(Theme.Content.ColorBase200);
+                --mooncore-color-base-250: @(Theme.Content.ColorBase250);
+                --mooncore-color-base-300: @(Theme.Content.ColorBase300);
+                --mooncore-color-base-content: @(Theme.Content.ColorBaseContent);
 
-                --color-primary: @(Theme.Content.ColorPrimary);
-                --color-primary-content: @(Theme.Content.ColorPrimaryContent);
+                --mooncore-color-primary: @(Theme.Content.ColorPrimary);
+                --mooncore-color-primary-content: @(Theme.Content.ColorPrimaryContent);
 
-                --color-secondary: @(Theme.Content.ColorSecondary);
-                --color-secondary-content: @(Theme.Content.ColorSecondaryContent);
+                --mooncore-color-secondary: @(Theme.Content.ColorSecondary);
+                --mooncore-color-secondary-content: @(Theme.Content.ColorSecondaryContent);
 
-                --color-accent: @(Theme.Content.ColorAccent);
-                --color-accent-content: @(Theme.Content.ColorAccentContent);
+                --mooncore-color-accent: @(Theme.Content.ColorAccent);
+                --mooncore-color-accent-content: @(Theme.Content.ColorAccentContent);
 
-                --color-neutral: @(Theme.Content.ColorNeutral);
-                --color-neutral-content: @(Theme.Content.ColorNeutralContent);
+                --mooncore-color-neutral: @(Theme.Content.ColorNeutral);
+                --mooncore-color-neutral-content: @(Theme.Content.ColorNeutralContent);
 
-                --color-info: @(Theme.Content.ColorInfo);
-                --color-info-content: @(Theme.Content.ColorInfoContent);
+                --mooncore-color-info: @(Theme.Content.ColorInfo);
+                --mooncore-color-info-content: @(Theme.Content.ColorInfoContent);
 
-                --color-success: @(Theme.Content.ColorSuccess);
-                --color-success-content: @(Theme.Content.ColorSuccessContent);
+                --mooncore-color-success: @(Theme.Content.ColorSuccess);
+                --mooncore-color-success-content: @(Theme.Content.ColorSuccessContent);
 
-                --color-warning: @(Theme.Content.ColorWarning);
-                --color-warning-content: @(Theme.Content.ColorWarningContent);
+                --mooncore-color-warning: @(Theme.Content.ColorWarning);
+                --mooncore-color-warning-content: @(Theme.Content.ColorWarningContent);
 
-                --color-error: @(Theme.Content.ColorError);
-                --color-error-content: @(Theme.Content.ColorErrorContent);
+                --mooncore-color-error: @(Theme.Content.ColorError);
+                --mooncore-color-error-content: @(Theme.Content.ColorErrorContent);
 
-                --radius-selector: @(Theme.Content.RadiusSelector)rem;
-                --radius-field: @(Theme.Content.RadiusField)rem;
-                --radius-box: @(Theme.Content.RadiusBox)rem;
+                --mooncore-radius-selector: @(Theme.Content.RadiusSelector)rem;
+                --mooncore-radius-field: @(Theme.Content.RadiusField)rem;
+                --mooncore-radius-box: @(Theme.Content.RadiusBox)rem;
 
-                --size-selector: @(Theme.Content.SizeSelector)rem;
-                --size-field: @(Theme.Content.SizeField)rem;
+                --mooncore-size-selector: @(Theme.Content.SizeSelector)rem;
+                --mooncore-size-field: @(Theme.Content.SizeField)rem;
 
-                --border: @(Theme.Content.Border)px;
-                --depth: @(Theme.Content.Depth);
-                --noise: @(Theme.Content.Noise);
+                --mooncore-border: @(Theme.Content.Border)px;
+                --mooncore-depth: @(Theme.Content.Depth);
+                --mooncore-noise: @(Theme.Content.Noise);
             }
         </style>
     }

Moonlight.ApiServer/Http/Controllers/LocalAuth/LocalAuthController.cs

@@ -1,202 +0,0 @@
-using System.Security.Claims;
-using Microsoft.AspNetCore.Authentication;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using MoonCore.Extended.Abstractions;
-using MoonCore.Extended.Helpers;
-using MoonCore.Helpers;
-using Moonlight.ApiServer.Configuration;
-using Moonlight.ApiServer.Database.Entities;
-using Moonlight.ApiServer.Implementations.LocalAuth;
-
-namespace Moonlight.ApiServer.Http.Controllers.LocalAuth;
-
-[ApiController]
-[Route("api/localAuth")]
-public class LocalAuthController : Controller
-{
-    private readonly DatabaseRepository<User> UserRepository;
-    private readonly IServiceProvider ServiceProvider;
-    private readonly IAuthenticationService AuthenticationService;
-    private readonly IOptionsMonitor<LocalAuthOptions> Options;
-    private readonly ILogger<LocalAuthController> Logger;
-    private readonly AppConfiguration Configuration;
-
-    public LocalAuthController(
-        DatabaseRepository<User> userRepository,
-        IServiceProvider serviceProvider,
-        IAuthenticationService authenticationService,
-        IOptionsMonitor<LocalAuthOptions> options,
-        ILogger<LocalAuthController> logger,
-        AppConfiguration configuration
-    )
-    {
-        UserRepository = userRepository;
-        ServiceProvider = serviceProvider;
-        AuthenticationService = authenticationService;
-        Options = options;
-        Logger = logger;
-        Configuration = configuration;
-    }
-
-    [HttpGet]
-    [HttpGet("login")]
-    public async Task<ActionResult> LoginAsync()
-    {
-        var html = await ComponentHelper.RenderToHtmlAsync<Login>(ServiceProvider);
-
-        return Content(html, "text/html");
-    }
-
-    [HttpGet("register")]
-    public async Task<ActionResult> RegisterAsync()
-    {
-        var html = await ComponentHelper.RenderToHtmlAsync<Register>(ServiceProvider);
-
-        return Content(html, "text/html");
-    }
-
-    [HttpPost]
-    [HttpPost("login")]
-    public async Task<ActionResult> LoginAsync([FromForm] string email, [FromForm] string password)
-    {
-        try
-        {
-            // Perform login
-            var user = await InternalLoginAsync(email, password);
-
-            // Login user
-            var options = Options.Get(LocalAuthConstants.AuthenticationScheme);
-
-            await AuthenticationService.SignInAsync(HttpContext, options.SignInScheme, new ClaimsPrincipal(
-                new ClaimsIdentity(
-                    [
-                        new Claim(ClaimTypes.Email, user.Email),
-                        new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
-                        new Claim(ClaimTypes.Name, user.Username)
-                    ],
-                    LocalAuthConstants.AuthenticationScheme
-                )
-            ), new AuthenticationProperties());
-
-            // Redirect back to wasm app
-            return Redirect("/");
-        }
-        catch (Exception e)
-        {
-            string errorMessage;
-
-            if (e is AggregateException aggregateException)
-                errorMessage = aggregateException.Message;
-            else
-            {
-                errorMessage = "An internal error occured";
-                Logger.LogError(e, "An unhandled error occured while logging in user");
-            }
-
-            var html = await ComponentHelper.RenderToHtmlAsync<Login>(ServiceProvider,
-                parameters => { parameters["ErrorMessage"] = errorMessage; });
-
-            return Content(html, "text/html");
-        }
-    }
-
-    [HttpPost("register")]
-    public async Task<ActionResult> RegisterAsync([FromForm] string email, [FromForm] string password, [FromForm] string username)
-    {
-        try
-        {
-            // Perform register
-            var user = await InternalRegisterAsync(username, email, password);
-
-            // Login user
-            var options = Options.Get(LocalAuthConstants.AuthenticationScheme);
-
-            await AuthenticationService.SignInAsync(HttpContext, options.SignInScheme, new ClaimsPrincipal(
-                new ClaimsIdentity(
-                    [
-                        new Claim(ClaimTypes.Email, user.Email),
-                        new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
-                        new Claim(ClaimTypes.Name, user.Username)
-                    ],
-                    LocalAuthConstants.AuthenticationScheme
-                )
-            ), new AuthenticationProperties());
-
-            // Redirect back to wasm app
-            return Redirect("/");
-        }
-        catch (Exception e)
-        {
-            string errorMessage;
-
-            if (e is AggregateException aggregateException)
-                errorMessage = aggregateException.Message;
-            else
-            {
-                errorMessage = "An internal error occured";
-                Logger.LogError(e, "An unhandled error occured while logging in user");
-            }
-
-            var html = await ComponentHelper.RenderToHtmlAsync<Register>(ServiceProvider,
-                parameters => { parameters["ErrorMessage"] = errorMessage; });
-
-            return Content(html, "text/html");
-        }
-    }
-
-    private async Task<User> InternalRegisterAsync(string username, string email, string password)
-    {
-        email = email.ToLower();
-        username = username.ToLower();
-
-        if (await UserRepository.Get().AnyAsync(x => x.Username == username))
-            throw new AggregateException("A account with that username already exists");
-
-        if (await UserRepository.Get().AnyAsync(x => x.Email == email))
-            throw new AggregateException("A account with that email already exists");
-
-        string[] permissions = [];
-
-        if (Configuration.Authentication.FirstUserAdmin)
-        {
-            var count = await UserRepository
-                .Get()
-                .CountAsync();
-
-            if (count == 0)
-                permissions = ["*"];
-        }
-
-        var user = new User()
-        {
-            Username = username,
-            Email = email,
-            Password = HashHelper.Hash(password),
-            Permissions = permissions
-        };
-
-        var finalUser = await UserRepository.AddAsync(user);
-
-        return finalUser;
-    }
-
-    private async Task<User> InternalLoginAsync(string email, string password)
-    {
-        email = email.ToLower();
-
-        var user = await UserRepository
-            .Get()
-            .FirstOrDefaultAsync(x => x.Email == email);
-
-        if (user == null)
-            throw new AggregateException("Invalid combination of email and password");
-
-        if (!HashHelper.Verify(password, user.Password))
-            throw new AggregateException("Invalid combination of email and password");
-
-        return user;
-    }
-}

Moonlight.ApiServer/Http/Controllers/OAuth2/Login.razor

@@ -1,4 +1,4 @@
-<html lang="en" class="h-full bg-base-200">
+<html lang="en" class="h-full bg-background">
 <head>
     <title>Login into your account</title>
     <meta charset="UTF-8"/>
@@ -9,7 +9,8 @@
 
 <div class="flex h-auto min-h-screen items-center justify-center overflow-x-hidden py-10">
     <div class="relative flex items-center justify-center px-4 sm:px-6 lg:px-8">
-        <div class="bg-base-100 shadow-base-300/20 z-1 w-full space-y-6 rounded-xl p-6 shadow-md sm:min-w-md lg:p-8">
+        <div
+            class="bg-base-100 shadow-base-300/20 z-1 w-full space-y-6 rounded-xl p-6 shadow-md sm:min-w-md lg:p-8">
             <div class="flex justify-center items-center gap-3">
                 <img src="/_content/Moonlight.Client/svg/logo.svg" class="size-12" alt="brand-logo"/>
             </div>
@@ -41,7 +42,8 @@
                 </form>
                 <p class="text-base-content/80 mb-4 text-center">
                     No account?
-                    <a href="/api/localAuth/register" class="link link-animated link-primary font-normal">Create an account</a>
+                    <a href="?client_id=@(ClientId)&redirect_uri=@(RedirectUri)&response_type=@(ResponseType)&view=register"
+                       class="link link-animated link-primary font-normal">Create an account</a>
                 </p>
             </div>
         </div>
@@ -53,5 +55,8 @@
 
 @code
 {
+    [Parameter] public string ClientId { get; set; }
+    [Parameter] public string RedirectUri { get; set; }
+    [Parameter] public string ResponseType { get; set; }
     [Parameter] public string? ErrorMessage { get; set; }
 }

Moonlight.ApiServer/Http/Controllers/OAuth2/OAuth2Controller.cs

@@ -0,0 +1,317 @@
+using System.ComponentModel.DataAnnotations;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+using System.Text.RegularExpressions;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.IdentityModel.Tokens;
+using MoonCore.Exceptions;
+using MoonCore.Extended.Abstractions;
+using MoonCore.Extended.Helpers;
+using MoonCore.Helpers;
+using Moonlight.ApiServer.Configuration;
+using Moonlight.ApiServer.Database.Entities;
+using Moonlight.Shared.Http.Responses.OAuth2;
+
+namespace Moonlight.ApiServer.Http.Controllers.OAuth2;
+
+[ApiController]
+[Route("oauth2")]
+public partial class OAuth2Controller : Controller
+{
+    private readonly AppConfiguration Configuration;
+    private readonly DatabaseRepository<User> UserRepository;
+
+    private readonly string ExpectedRedirectUri;
+
+    public OAuth2Controller(AppConfiguration configuration, DatabaseRepository<User> userRepository)
+    {
+        Configuration = configuration;
+        UserRepository = userRepository;
+
+        ExpectedRedirectUri = string.IsNullOrEmpty(Configuration.Authentication.OAuth2.AuthorizationRedirect)
+            ? Configuration.PublicUrl
+            : Configuration.Authentication.OAuth2.AuthorizationRedirect;
+    }
+
+    [AllowAnonymous]
+    [HttpGet("authorize")]
+    public async Task Authorize(
+        [FromQuery(Name = "client_id")] string clientId,
+        [FromQuery(Name = "redirect_uri")] string redirectUri,
+        [FromQuery(Name = "response_type")] string responseType,
+        [FromQuery(Name = "view")] string view = "login"
+    )
+    {
+        if (!Configuration.Authentication.EnableLocalOAuth2)
+            throw new HttpApiException("Local OAuth2 has been disabled", 403);
+
+        if (Configuration.Authentication.OAuth2.ClientId != clientId ||
+            redirectUri != ExpectedRedirectUri ||
+            responseType != "code")
+        {
+            throw new HttpApiException("Invalid oauth2 request", 400);
+        }
+
+        string html;
+
+        if (view == "register")
+        {
+            html = await ComponentHelper.RenderComponent<Register>(HttpContext.RequestServices, parameters =>
+            {
+                parameters.Add("ClientId", clientId);
+                parameters.Add("RedirectUri", redirectUri);
+                parameters.Add("ResponseType", responseType);
+            });
+        }
+        else
+        {
+            html = await ComponentHelper.RenderComponent<Login>(HttpContext.RequestServices, parameters =>
+            {
+                parameters.Add("ClientId", clientId);
+                parameters.Add("RedirectUri", redirectUri);
+                parameters.Add("ResponseType", responseType);
+            });
+        }
+        
+        await Results
+            .Text(html, "text/html", Encoding.UTF8)
+            .ExecuteAsync(HttpContext);
+    }
+
+    [AllowAnonymous]
+    [HttpPost("authorize")]
+    public async Task AuthorizePost(
+        [FromQuery(Name = "client_id")] string clientId,
+        [FromQuery(Name = "redirect_uri")] string redirectUri,
+        [FromQuery(Name = "response_type")] string responseType,
+        [FromForm(Name = "email")] [EmailAddress(ErrorMessage = "You need to provide a valid email address")] string email,
+        [FromForm(Name = "password")] string password,
+        [FromForm(Name = "username")] string username = "",
+        [FromQuery(Name = "view")] string view = "login"
+    )
+    {
+        if (!Configuration.Authentication.EnableLocalOAuth2)
+            throw new HttpApiException("Local OAuth2 has been disabled", 403);
+
+        if (Configuration.Authentication.OAuth2.ClientId != clientId ||
+            redirectUri != ExpectedRedirectUri ||
+            responseType != "code")
+        {
+            throw new HttpApiException("Invalid oauth2 request", 400);
+        }
+
+        if (view == "register" && string.IsNullOrEmpty(username))
+            throw new HttpApiException("You need to provide a username", 400);
+
+        string? errorMessage = null;
+
+        try
+        {
+            if (view == "register")
+            {
+                var user = await Register(username, email, password);
+                var code = await GenerateCode(user);
+
+                Response.Redirect($"{redirectUri}?code={code}");
+            }
+            else
+            {
+                var user = await Login(email, password);
+                var code = await GenerateCode(user);
+
+                Response.Redirect($"{redirectUri}?code={code}");
+            }
+        }
+        catch (HttpApiException e)
+        {
+            errorMessage = e.Title;
+            
+            string html;
+        
+            if (view == "register")
+            {
+                html = await ComponentHelper.RenderComponent<Register>(HttpContext.RequestServices, parameters =>
+                {
+                    parameters.Add("ClientId", clientId);
+                    parameters.Add("RedirectUri", redirectUri);
+                    parameters.Add("ResponseType", responseType);
+                    parameters.Add("ErrorMessage", errorMessage!);
+                });
+            }
+            else
+            {
+                html = await ComponentHelper.RenderComponent<Login>(HttpContext.RequestServices, parameters =>
+                {
+                    parameters.Add("ClientId", clientId);
+                    parameters.Add("RedirectUri", redirectUri);
+                    parameters.Add("ResponseType", responseType);
+                    parameters.Add("ErrorMessage", errorMessage!);
+                });
+            }
+
+            await Results
+                .Text(html, "text/html", Encoding.UTF8)
+                .ExecuteAsync(HttpContext);
+        }
+    }
+
+    [AllowAnonymous]
+    [HttpPost("handle")]
+    public async Task<OAuth2HandleResponse> Handle(
+        [FromForm(Name = "grant_type")] string grantType,
+        [FromForm(Name = "code")] string code,
+        [FromForm(Name = "redirect_uri")] string redirectUri,
+        [FromForm(Name = "client_id")] string clientId
+    )
+    {
+        if (!Configuration.Authentication.EnableLocalOAuth2)
+            throw new HttpApiException("Local OAuth2 has been disabled", 403);
+
+        // Check header
+        if (!Request.Headers.ContainsKey("Authorization"))
+            throw new HttpApiException("You are missing the Authorization header", 400);
+
+        var authorizationHeaderValue = Request.Headers["Authorization"].FirstOrDefault() ?? "";
+
+        if (authorizationHeaderValue != $"Basic {Configuration.Authentication.OAuth2.ClientSecret}")
+            throw new HttpApiException("Invalid Authorization header value", 400);
+
+        // Check form
+        if (grantType != "authorization_code")
+            throw new HttpApiException("Invalid grant type provided", 400);
+
+        if (clientId != Configuration.Authentication.OAuth2.ClientId)
+            throw new HttpApiException("Invalid client id provided", 400);
+
+        if (redirectUri != ExpectedRedirectUri)
+            throw new HttpApiException("Invalid redirect uri provided", 400);
+
+        var jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
+
+        ClaimsPrincipal? codeData;
+
+        try
+        {
+            codeData = jwtSecurityTokenHandler.ValidateToken(code, new TokenValidationParameters()
+            {
+                IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(
+                    Configuration.Authentication.OAuth2.Secret
+                )),
+                ValidateIssuerSigningKey = true,
+                ValidateLifetime = true,
+                ClockSkew = TimeSpan.Zero,
+                ValidateAudience = false,
+                ValidateIssuer = false
+            }, out _);
+        }
+        catch (SecurityTokenException)
+        {
+            throw new HttpApiException("Invalid code provided", 400);
+        }
+
+        if (codeData == null)
+            throw new HttpApiException("Invalid code provided", 400);
+
+        var userIdClaim = codeData.Claims.FirstOrDefault(x => x.Type == "id");
+
+        if (userIdClaim == null)
+            throw new HttpApiException("Malformed code provided", 400);
+
+        if (!int.TryParse(userIdClaim.Value, out var userId))
+            throw new HttpApiException("Malformed code provided", 400);
+
+        var user = UserRepository
+            .Get()
+            .FirstOrDefault(x => x.Id == userId);
+
+        if (user == null)
+            throw new HttpApiException("Malformed code provided", 400);
+
+        return new()
+        {
+            UserId = user.Id
+        };
+    }
+
+    private Task<string> GenerateCode(User user)
+    {
+        var securityTokenDescriptor = new SecurityTokenDescriptor()
+        {
+            Expires = DateTime.Now.AddMinutes(1),
+            IssuedAt = DateTime.Now,
+            NotBefore = DateTime.Now.AddMinutes(-1),
+            Claims = new Dictionary<string, object>()
+            {
+                {
+                    "id",
+                    user.Id
+                }
+            },
+            SigningCredentials = new SigningCredentials(
+                new SymmetricSecurityKey(
+                    Encoding.UTF8.GetBytes(Configuration.Authentication.OAuth2.Secret)
+                ),
+                SecurityAlgorithms.HmacSha256
+            )
+        };
+
+        var jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
+        var securityToken = jwtSecurityTokenHandler.CreateToken(securityTokenDescriptor);
+
+        return Task.FromResult(
+            jwtSecurityTokenHandler.WriteToken(securityToken)
+        );
+    }
+
+    private async Task<User> Register(string username, string email, string password)
+    {
+        if (await UserRepository.Get().AnyAsync(x => x.Username == username))
+            throw new HttpApiException("A account with that username already exists", 400);
+
+        if (await UserRepository.Get().AnyAsync(x => x.Email == email))
+            throw new HttpApiException("A account with that email already exists", 400);
+
+        if (!UsernameRegex().IsMatch(username))
+            throw new HttpApiException("The username is only allowed to be contained out of small characters and numbers", 400);
+        
+        var user = new User()
+        {
+            Username = username,
+            Email = email,
+            Password = HashHelper.Hash(password),
+        };
+        
+        if (Configuration.Authentication.OAuth2.FirstUserAdmin)
+        {
+            var userCount = await UserRepository.Get().CountAsync();
+            
+            if (userCount == 0)
+                user.Permissions = ["*"];
+            
+        }
+
+        return await UserRepository.Add(user);
+    }
+
+    private async Task<User> Login(string email, string password)
+    {
+        var user = await UserRepository
+            .Get()
+            .FirstOrDefaultAsync(x => x.Email == email);
+
+        if (user == null)
+            throw new HttpApiException("Invalid combination of email and password", 400);
+
+        if (!HashHelper.Verify(password, user.Password))
+            throw new HttpApiException("Invalid combination of email and password", 400);
+
+        return user;
+    }
+
+    [GeneratedRegex("^[a-z][a-z0-9]*$")]
+    private static partial Regex UsernameRegex();
+}

Moonlight.ApiServer/Http/Controllers/OAuth2/Register.razor

@@ -1,4 +1,4 @@
-<html lang="en" class="h-full bg-base-200">
+<html lang="en" class="h-full bg-background">
 <head>
     <title>Register a new account</title>
     <meta charset="UTF-8"/>
@@ -9,7 +9,8 @@
 
 <div class="flex h-auto min-h-screen items-center justify-center overflow-x-hidden py-10">
     <div class="relative flex items-center justify-center px-4 sm:px-6 lg:px-8">
-        <div class="bg-base-100 shadow-base-300/20 z-1 w-full space-y-6 rounded-xl p-6 shadow-md sm:min-w-md lg:p-8">
+        <div
+            class="bg-base-100 shadow-base-300/20 z-1 w-full space-y-6 rounded-xl p-6 shadow-md sm:min-w-md lg:p-8">
             <div class="flex justify-center items-center gap-3">
                 <img src="/_content/Moonlight.Client/svg/logo.svg" class="size-12" alt="brand-logo"/>
             </div>
@@ -46,7 +47,8 @@
                 </form>
                 <p class="text-base-content/80 mb-4 text-center">
                     Already registered?
-                    <a href="/api/localAuth/login" class="link link-animated link-primary font-normal">Login into your account</a>
+                    <a href="?client_id=@(ClientId)&redirect_uri=@(RedirectUri)&response_type=@(ResponseType)&view=login"
+                       class="link link-animated link-primary font-normal">Login into your account</a>
                 </p>
             </div>
         </div>
@@ -57,5 +59,8 @@
 
 @code
 {
+    [Parameter] public string ClientId { get; set; }
+    [Parameter] public string RedirectUri { get; set; }
+    [Parameter] public string ResponseType { get; set; }
     [Parameter] public string? ErrorMessage { get; set; }
 }

Moonlight.ApiServer/Http/Controllers/Swagger/SwaggerController.cs

@@ -24,7 +24,7 @@ public class SwaggerController : Controller
 
     [HttpGet]
     [Authorize]
-    public async Task<ActionResult> GetAsync()
+    public async Task<ActionResult> Get()
     {
         if (!Configuration.Development.EnableApiDocs)
             return BadRequest("Api docs are disabled");
@@ -32,7 +32,7 @@ public class SwaggerController : Controller
         var options = new ApiDocsOptions();
         var optionsJson = JsonSerializer.Serialize(options);
 
-        var html = await ComponentHelper.RenderToHtmlAsync<SwaggerPage>(
+        var html = await ComponentHelper.RenderComponent<SwaggerPage>(
             ServiceProvider,
             parameters =>
             {

Moonlight.ApiServer/Http/Hubs/DiagnoseHub.cs

@@ -1,14 +0,0 @@
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.SignalR;
-
-namespace Moonlight.ApiServer.Http.Hubs;
-
-[Authorize(Policy = "permissions:admin.system.diagnose")]
-public class DiagnoseHub : Hub
-{
-    [HubMethodName("Ping")]
-    public async Task PingAsync()
-    {
-        await Clients.All.SendAsync("Pong");
-    }
-}

Moonlight.ApiServer/IAssemblyMarker.cs

@@ -1,3 +0,0 @@
-namespace Moonlight.ApiServer;
-
-public interface IAssemblyMarker;

Moonlight.ApiServer/Implementations/Diagnose/CoreConfigDiagnoseProvider.cs

@@ -1,6 +1,5 @@
-using System.Diagnostics;
 using System.IO.Compression;
-using MoonCore.Yaml;
+using System.Text.Json;
 using Moonlight.ApiServer.Configuration;
 using Moonlight.ApiServer.Extensions;
 using Moonlight.ApiServer.Interfaces;
@@ -9,11 +8,11 @@ namespace Moonlight.ApiServer.Implementations.Diagnose;
 
 public class CoreConfigDiagnoseProvider : IDiagnoseProvider
 {
-    private readonly AppConfiguration Configuration;
+    private readonly AppConfiguration Config;
 
-    public CoreConfigDiagnoseProvider(AppConfiguration configuration)
+    public CoreConfigDiagnoseProvider(AppConfiguration config)
     {
-        Configuration = configuration;
+        Config = config;
     }
 
     private string CheckForNullOrEmpty(string? content)
@@ -23,25 +22,36 @@ public class CoreConfigDiagnoseProvider : IDiagnoseProvider
             : "ISNOTEMPTY";
     }
 
-    public async Task ModifyZipArchiveAsync(ZipArchive archive)
+    public async Task ModifyZipArchive(ZipArchive archive)
     {
-        try
-        {
-            var configString = YamlSerializer.Serialize(Configuration);
-            var configuration = YamlSerializer.Deserialize<AppConfiguration>(configString);
+        var json = JsonSerializer.Serialize(Config);
+        var config = JsonSerializer.Deserialize<AppConfiguration>(json);
 
-            configuration.Database.Password = CheckForNullOrEmpty(configuration.Database.Password);
-            configuration.Authentication.Secret = CheckForNullOrEmpty(configuration.Authentication.Secret);
-            configuration.SignalR.RedisConnectionString = CheckForNullOrEmpty(configuration.SignalR.RedisConnectionString);
-
-            await archive.AddTextAsync(
-                "core/config.txt",
-                YamlSerializer.Serialize(configuration)
-            );
-        }
-        catch (Exception e)
+        if (config == null)
         {
-            await archive.AddTextAsync("core/config.txt", $"Unable to load config: {e.ToStringDemystified()}");
+            await archive.AddText("core/config.txt", "Could not fetch config.");
+            return;
         }
+
+        config.Database.Password = CheckForNullOrEmpty(config.Database.Password);
+
+        config.Authentication.OAuth2.ClientSecret = CheckForNullOrEmpty(config.Authentication.OAuth2.ClientSecret);
+
+        config.Authentication.OAuth2.Secret = CheckForNullOrEmpty(config.Authentication.OAuth2.Secret);
+
+        config.Authentication.Secret = CheckForNullOrEmpty(config.Authentication.Secret);
+
+        config.Authentication.OAuth2.ClientId = CheckForNullOrEmpty(config.Authentication.OAuth2.ClientId);
+
+        await archive.AddText(
+            "core/config.txt",
+            JsonSerializer.Serialize(
+                config,
+                new JsonSerializerOptions()
+                {
+                    WriteIndented = true
+                }
+            )
+        );
     }
 }

Moonlight.ApiServer/Implementations/Diagnose/LogsDiagnoseProvider.cs

@@ -6,16 +6,17 @@ namespace Moonlight.ApiServer.Implementations.Diagnose;
 
 public class LogsDiagnoseProvider : IDiagnoseProvider
 {
-    public async Task ModifyZipArchiveAsync(ZipArchive archive)
+    public async Task ModifyZipArchive(ZipArchive archive)
     {
-        var path = Path.Combine("storage", "logs", "moonlight.log");
+        var path = Path.Combine("storage", "logs", "latest.log");
 
-        if (File.Exists(path))
+        if (!File.Exists(path))
         {
-            var logsContent = await File.ReadAllTextAsync(path);
-            await archive.AddTextAsync("logs.txt", logsContent);
+            await archive.AddText("logs.txt", "Logs file latest.log has not been found");
+            return;
         }
-        else
-            await archive.AddTextAsync("logs.txt", "Logs file moonlight.log has not been found");
+        
+        var logsContent = await File.ReadAllTextAsync(path);
+        await archive.AddText("logs.txt", logsContent);
     }
 }

Moonlight.ApiServer/Implementations/LocalAuth/LocalAuthConstants.cs

@@ -1,6 +0,0 @@
-namespace Moonlight.ApiServer.Implementations.LocalAuth;
-
-public static class LocalAuthConstants
-{
-    public const string AuthenticationScheme = "LocalAuth";
-}

Moonlight.ApiServer/Implementations/LocalAuth/LocalAuthHandler.cs

@@ -1,32 +0,0 @@
-using System.Text.Encodings.Web;
-using Microsoft.AspNetCore.Authentication;
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-
-namespace Moonlight.ApiServer.Implementations.LocalAuth;
-
-public class LocalAuthHandler : AuthenticationHandler<LocalAuthOptions>
-{
-    public LocalAuthHandler(
-        IOptionsMonitor<LocalAuthOptions> options,
-        ILoggerFactory logger,
-        UrlEncoder encoder
-    ) : base(options, logger, encoder)
-    {
-    }
-
-    protected override Task<AuthenticateResult> HandleAuthenticateAsync()
-    {
-        return Task.FromResult(
-            AuthenticateResult.Fail("Local authentication does not directly support AuthenticateAsync")
-        );
-    }
-
-    protected override async Task HandleChallengeAsync(AuthenticationProperties properties)
-    {
-        await Results
-            .Redirect("/api/localAuth")
-            .ExecuteAsync(Context);
-    }
-}

Moonlight.ApiServer/Implementations/LocalAuth/LocalAuthOptions.cs

@@ -1,8 +0,0 @@
-using Microsoft.AspNetCore.Authentication;
-
-namespace Moonlight.ApiServer.Implementations.LocalAuth;
-
-public class LocalAuthOptions : AuthenticationSchemeOptions
-{
-    public string? SignInScheme { get; set; }
-}

Moonlight.ApiServer/Implementations/LocalOAuth2Provider.cs

@@ -0,0 +1,106 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using MoonCore.Exceptions;
+using MoonCore.Extended.Abstractions;
+using MoonCore.Helpers;
+using Moonlight.ApiServer.Configuration;
+using Moonlight.ApiServer.Database.Entities;
+using Moonlight.ApiServer.Interfaces;
+using Moonlight.Shared.Http.Responses.OAuth2;
+
+namespace Moonlight.ApiServer.Implementations;
+
+public class LocalOAuth2Provider : IOAuth2Provider
+{
+    private readonly AppConfiguration Configuration;
+    private readonly ILogger<LocalOAuth2Provider> Logger;
+    private readonly DatabaseRepository<User> UserRepository;
+
+    public LocalOAuth2Provider(
+        AppConfiguration configuration,
+        ILogger<LocalOAuth2Provider> logger,
+        DatabaseRepository<User> userRepository
+    )
+    {
+        UserRepository = userRepository;
+        Configuration = configuration;
+        Logger = logger;
+    }
+
+    public Task<string> Start()
+    {
+        var redirectUri = string.IsNullOrEmpty(Configuration.Authentication.OAuth2.AuthorizationRedirect)
+            ? Configuration.PublicUrl
+            : Configuration.Authentication.OAuth2.AuthorizationRedirect;
+
+        var endpoint = string.IsNullOrEmpty(Configuration.Authentication.OAuth2.AuthorizationEndpoint)
+            ? Configuration.PublicUrl + "/oauth2/authorize"
+            : Configuration.Authentication.OAuth2.AuthorizationEndpoint;
+
+        var clientId = Configuration.Authentication.OAuth2.ClientId;
+        
+        var url = $"{endpoint}" +
+                  $"?client_id={clientId}" +
+                  $"&redirect_uri={redirectUri}" +
+                  $"&response_type=code";
+
+        return Task.FromResult(url);
+    }
+
+    public async Task<User?> Complete(string code)
+    {
+        // Create http client to call the auth provider
+        var httpClient = new HttpClient();
+        using var httpApiClient = new HttpApiClient(httpClient);
+
+        httpClient.DefaultRequestHeaders.Add("Authorization",
+            $"Basic {Configuration.Authentication.OAuth2.ClientSecret}");
+
+        // Build access endpoint
+        var accessEndpoint = string.IsNullOrEmpty(Configuration.Authentication.OAuth2.AccessEndpoint)
+            ? $"{Configuration.PublicUrl}/oauth2/handle"
+            : Configuration.Authentication.OAuth2.AccessEndpoint;
+
+        // Build redirect uri
+        var redirectUri = string.IsNullOrEmpty(Configuration.Authentication.OAuth2.AuthorizationRedirect)
+            ? Configuration.PublicUrl
+            : Configuration.Authentication.OAuth2.AuthorizationRedirect;
+
+        // Call the auth provider
+        OAuth2HandleResponse handleData;
+
+        try
+        {
+            handleData = await httpApiClient.PostJson<OAuth2HandleResponse>(accessEndpoint, new FormUrlEncodedContent(
+                [
+                    new KeyValuePair<string, string>("grant_type", "authorization_code"),
+                    new KeyValuePair<string, string>("code", code),
+                    new KeyValuePair<string, string>("redirect_uri", redirectUri),
+                    new KeyValuePair<string, string>("client_id", Configuration.Authentication.OAuth2.ClientId)
+                ]
+            ));
+        }
+        catch (HttpApiException e)
+        {
+            if (e.Status == 400)
+                Logger.LogTrace("The auth server returned an error: {e}", e);
+            else
+                Logger.LogCritical("The auth server returned an error: {e}", e);
+
+            throw new HttpApiException("Unable to request user data", 500);
+        }
+
+        // Notice: We just look up the user id here
+        // which works as our oauth2 provider is using the same db.
+        // a real oauth2 provider would create a user here
+        
+        // Handle the returned data
+        var userId = handleData.UserId;
+
+        var user = await UserRepository
+            .Get()
+            .FirstOrDefaultAsync(x => x.Id == userId);
+
+        return user;
+    }
+}

Moonlight.ApiServer/Implementations/Metrics/ApplicationMetric.cs

@@ -11,7 +11,7 @@ public class ApplicationMetric : IMetric
     private Gauge<int> CpuUsage;
     private Gauge<double> Uptime;
     
-    public Task InitializeAsync(Meter meter)
+    public Task Initialize(Meter meter)
     {
         MemoryUsage = meter.CreateGauge<long>("moonlight_memory_usage");
         CpuUsage = meter.CreateGauge<int>("moonlight_cpu_usage");
@@ -20,17 +20,17 @@ public class ApplicationMetric : IMetric
         return Task.CompletedTask;
     }
 
-    public async Task RunAsync(IServiceProvider provider, CancellationToken cancellationToken)
+    public async Task Run(IServiceProvider provider, CancellationToken cancellationToken)
     {
         var applicationService = provider.GetRequiredService<ApplicationService>();
 
-        var memory = await applicationService.GetMemoryUsageAsync();
+        var memory = await applicationService.GetMemoryUsage();
         MemoryUsage.Record(memory);
 
-        var uptime = await applicationService.GetUptimeAsync();
+        var uptime = await applicationService.GetUptime();
         Uptime.Record(uptime.TotalSeconds);
 
-        var cpu = await applicationService.GetCpuUsageAsync();
+        var cpu = await applicationService.GetCpuUsage();
         CpuUsage.Record(cpu);
     }
 }

Moonlight.ApiServer/Implementations/Metrics/UsersMetric.cs

@@ -11,14 +11,14 @@ public class UsersMetric : IMetric
 {
     private Gauge<int> Users;
     
-    public Task InitializeAsync(Meter meter)
+    public Task Initialize(Meter meter)
     {
         Users = meter.CreateGauge<int>("moonlight_users");
         
         return Task.CompletedTask;
     }
 
-    public async Task RunAsync(IServiceProvider provider, CancellationToken cancellationToken)
+    public async Task Run(IServiceProvider provider, CancellationToken cancellationToken)
     {
         var usersRepo = provider.GetRequiredService<DatabaseRepository<User>>();
         var count = await usersRepo.Get().CountAsync(cancellationToken: cancellationToken);

Moonlight.ApiServer/Implementations/Startup/CoreStartup.cs

@@ -1,7 +1,7 @@
 using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.Configuration;
+using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Hosting;
 using Microsoft.OpenApi.Models;
 using Moonlight.ApiServer.Configuration;
 using Moonlight.ApiServer.Database;
@@ -11,21 +11,17 @@ using Moonlight.ApiServer.Interfaces;
 using Moonlight.ApiServer.Models;
 using Moonlight.ApiServer.Plugins;
 using Moonlight.ApiServer.Services;
-using OpenTelemetry.Logs;
 using OpenTelemetry.Metrics;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
 
 namespace Moonlight.ApiServer.Implementations.Startup;
 
 public class CoreStartup : IPluginStartup
 {
-    public void AddPlugin(WebApplicationBuilder builder)
+    public Task BuildApplication(IServiceProvider serviceProvider, IHostApplicationBuilder builder)
     {
-        var configuration = AppConfiguration.CreateEmpty();
-        builder.Configuration.Bind(configuration);
+        var configuration = serviceProvider.GetRequiredService<AppConfiguration>();
 
-         #region Api Docs
+        #region Api Docs
 
         if (configuration.Development.EnableApiDocs)
         {
@@ -68,56 +64,22 @@ public class CoreStartup : IPluginStartup
 
         #region Prometheus
 
-        if (configuration.OpenTelemetry.Enable)
+        if (configuration.Metrics.Enable)
         {
-            var openTel = builder.Services.AddOpenTelemetry();
-            var openTelConfig = configuration.OpenTelemetry;
+            builder.Services.AddSingleton<MetricsBackgroundService>();
+            builder.Services.AddHostedService(sp => sp.GetRequiredService<MetricsBackgroundService>());
 
-            var resourceBuilder = ResourceBuilder.CreateDefault();
-            resourceBuilder.AddService(serviceName: "moonlight");
+            builder.Services.AddSingleton<IMetric, ApplicationMetric>();
+            builder.Services.AddSingleton<IMetric, UsersMetric>();
 
-            openTel.ConfigureResource(x => x.AddService(serviceName: "moonlight"));
-
-            if (openTelConfig.Metrics.Enable)
-            {
-                builder.Services.AddSingleton<MetricsBackgroundService>();
-                builder.Services.AddHostedService(sp => sp.GetRequiredService<MetricsBackgroundService>());
-
-                builder.Services.AddSingleton<IMetric, ApplicationMetric>();
-                builder.Services.AddSingleton<IMetric, UsersMetric>();
-
-                openTel.WithMetrics(providerBuilder =>
+            builder.Services.AddOpenTelemetry()
+                .WithMetrics(providerBuilder =>
                 {
+                    providerBuilder.AddPrometheusExporter();
                     providerBuilder.AddAspNetCoreInstrumentation();
-                    providerBuilder.AddOtlpExporter();
-
-                    if (openTelConfig.Metrics.EnablePrometheus)
-                        providerBuilder.AddPrometheusExporter();
 
                     providerBuilder.AddMeter("moonlight");
                 });
-            }
-
-            if (openTelConfig.Logs.Enable)
-            {
-                openTel.WithLogging();
-
-                builder.Logging.AddOpenTelemetry(options =>
-                {
-                    options.SetResourceBuilder(resourceBuilder);
-                    options.AddOtlpExporter();
-                });
-            }
-
-            if (openTelConfig.Traces.Enable)
-            {
-                openTel.WithTracing(providerBuilder =>
-                {
-                    providerBuilder.AddAspNetCoreInstrumentation();
-
-                    providerBuilder.AddOtlpExporter();
-                });
-            }
         }
 
         #endregion
@@ -138,27 +100,31 @@ public class CoreStartup : IPluginStartup
         }
 
         #endregion
+
+        return Task.CompletedTask;
     }
 
-    public void UsePlugin(WebApplication app)
+    public Task ConfigureApplication(IServiceProvider serviceProvider, IApplicationBuilder app)
     {
-        var configuration = AppConfiguration.CreateEmpty();
-        app.Configuration.Bind(configuration);
+        var configuration = serviceProvider.GetRequiredService<AppConfiguration>();
 
         #region Prometheus
 
-        if (configuration.OpenTelemetry is { Enable: true, Metrics.EnablePrometheus: true })
+        if (configuration.Metrics.Enable)
             app.UseOpenTelemetryPrometheusScrapingEndpoint();
 
         #endregion
+
+        return Task.CompletedTask;
     }
 
-    public void MapPlugin(WebApplication app)
+    public Task ConfigureEndpoints(IServiceProvider serviceProvider, IEndpointRouteBuilder routeBuilder)
     {
-        var configuration = AppConfiguration.CreateEmpty();
-        app.Configuration.Bind(configuration);
+        var configuration = serviceProvider.GetRequiredService<AppConfiguration>();
 
         if (configuration.Development.EnableApiDocs)
-            app.MapSwagger("/api/swagger/{documentName}");
+            routeBuilder.MapSwagger("/api/swagger/{documentName}");
+
+        return Task.CompletedTask;
     }
 }

Moonlight.ApiServer/Implementations/TickerExceptionHandler.cs

@@ -0,0 +1,29 @@
+using Microsoft.Extensions.Logging;
+using TickerQ.Utilities.Enums;
+using TickerQ.Utilities.Interfaces;
+
+namespace Moonlight.ApiServer.Implementations;
+
+public class TickerExceptionHandler : ITickerExceptionHandler
+{
+    private readonly ILogger<TickerExceptionHandler> Logger;
+
+    public TickerExceptionHandler(ILogger<TickerExceptionHandler> logger)
+    {
+        Logger = logger;
+    }
+
+    public Task HandleExceptionAsync(Exception exception, Guid tickerId, TickerType tickerType)
+    {
+        Logger.LogError(exception, "An unhandled error occured while running ticker {id} ({type})", tickerId, tickerType);
+        
+        return Task.CompletedTask;
+    }
+
+    public Task HandleCanceledExceptionAsync(Exception exception, Guid tickerId, TickerType tickerType)
+    {
+        Logger.LogError(exception, "An unhandled error occured while handling canceled ticker {id} ({type})", tickerId, tickerType);
+        
+        return Task.CompletedTask;
+    }
+}

Moonlight.ApiServer/Implementations/UserAuthInvalidation.cs

@@ -0,0 +1,62 @@
+using System.Security.Claims;
+using Microsoft.EntityFrameworkCore;
+using MoonCore.Extended.Abstractions;
+using MoonCore.Extended.JwtInvalidation;
+using Moonlight.ApiServer.Database.Entities;
+
+namespace Moonlight.ApiServer.Implementations;
+
+public class UserAuthInvalidation : IJwtInvalidateHandler
+{
+    private readonly DatabaseRepository<User> UserRepository;
+    private readonly DatabaseRepository<ApiKey> ApiKeyRepository;
+
+    public UserAuthInvalidation(
+        DatabaseRepository<User> userRepository,
+        DatabaseRepository<ApiKey> apiKeyRepository
+    )
+    {
+        UserRepository = userRepository;
+        ApiKeyRepository = apiKeyRepository;
+    }
+
+    public async Task<bool> Handle(ClaimsPrincipal principal)
+    {
+        var userIdClaim = principal.FindFirstValue("userId");
+
+        if (!string.IsNullOrEmpty(userIdClaim))
+        {
+            var userId = int.Parse(userIdClaim);
+
+            var user = await UserRepository
+                .Get()
+                .FirstOrDefaultAsync(x => x.Id == userId);
+
+            if (user == null)
+                return true; // User is deleted, invalidate session
+            
+            var iatStr = principal.FindFirstValue("iat")!;
+            var iat = DateTimeOffset.FromUnixTimeSeconds(long.Parse(iatStr));
+
+            // If the token has been issued before the token valid time, its expired, and we want to invalidate it
+            return user.TokenValidTimestamp > iat;
+        }
+
+        var apiKeyIdClaim = principal.FindFirstValue("apiKeyId");
+
+        if (!string.IsNullOrEmpty(apiKeyIdClaim))
+        {
+            var apiKeyId = int.Parse(apiKeyIdClaim);
+
+            var apiKey = await ApiKeyRepository
+                .Get()
+                .FirstOrDefaultAsync(x => x.Id == apiKeyId);
+
+            // If the api key exists, we don't want to invalidate the request.
+            // If it doesn't exist we want to invalidate the request
+            return apiKey == null;
+        }
+
+        return true;
+    }
+}

Moonlight.ApiServer/Interfaces/IAuthCheckExtension.cs

@@ -1,16 +0,0 @@
-using System.Security.Claims;
-using Moonlight.Shared.Http.Responses.Auth;
-
-namespace Moonlight.ApiServer.Interfaces;
-
-public interface IAuthCheckExtension
-{
-    /// <summary>
-    /// This function will be called by the frontend reaching out to the api server for claim information.
-    /// You can use this function to give your frontend plugins access to user specific data which is
-    /// static for the session. E.g. the avatar url of a user
-    /// </summary>
-    /// <param name="principal">The principal of the current signed-in user</param>
-    /// <returns>An array of claim responses which gets added to the list of claims to send to the frontend</returns>
-    public Task<AuthClaimResponse[]> GetFrontendClaimsAsync(ClaimsPrincipal principal);
-}

Moonlight.ApiServer/Interfaces/IDiagnoseProvider.cs

@@ -4,5 +4,5 @@ namespace Moonlight.ApiServer.Interfaces;
 
 public interface IDiagnoseProvider
 {
-    public Task ModifyZipArchiveAsync(ZipArchive archive);
+    public Task ModifyZipArchive(ZipArchive archive);
 }

Moonlight.ApiServer/Interfaces/IMetric.cs

@@ -4,6 +4,6 @@ namespace Moonlight.ApiServer.Interfaces;
 
 public interface IMetric
 {
-    public Task InitializeAsync(Meter meter);
-    public Task RunAsync(IServiceProvider provider, CancellationToken cancellationToken);
+    public Task Initialize(Meter meter);
+    public Task Run(IServiceProvider provider, CancellationToken cancellationToken);
 }

Moonlight.ApiServer/Interfaces/IOAuth2Provider.cs

@@ -0,0 +1,10 @@
+using Moonlight.ApiServer.Database.Entities;
+
+namespace Moonlight.ApiServer.Interfaces;
+
+public interface IOAuth2Provider
+{
+    public Task<string> Start();
+    
+    public Task<User?> Complete(string code);
+}

Moonlight.ApiServer/Interfaces/IUserAuthExtension.cs

@@ -1,25 +0,0 @@
-using System.Security.Claims;
-using Moonlight.ApiServer.Database.Entities;
-
-namespace Moonlight.ApiServer.Interfaces;
-
-public interface IUserAuthExtension
-{
-    /// <summary>
-    /// This function is called on every sign-in. It should be used to synchronize additional user data from the principal
-    /// or extend the claims saved in the user session
-    /// </summary>
-    /// <param name="user">The current user this method is called for</param>
-    /// <param name="principal">The principal after being processed by moonlight itself</param>
-    /// <returns>The result of the synchronisation. Returning false will immediately invalidate the sign-in and no other extensions will be called</returns>
-    public Task<bool> SyncAsync(User user, ClaimsPrincipal principal);
-
-    /// <summary>
-    /// IMPORTANT: Please note that heavy operations should not occur in this method as it will be called for every request
-    /// of every user
-    /// </summary>
-    /// <param name="user">The current user this method is called for</param>
-    /// <param name="principal">The principal after being processed by moonlight itself</param>
-    /// <returns>The result of the validation. Returning false will immediately invalidate the users session and no other extensions will be called</returns>
-    public Task<bool> ValidateAsync(User user, ClaimsPrincipal principal);
-}

Moonlight.ApiServer/Interfaces/IUserDeleteHandler.cs

@@ -5,6 +5,6 @@ namespace Moonlight.ApiServer.Interfaces;
 
 public interface IUserDeleteHandler
 {
-    public Task<UserDeleteValidationResult> ValidateAsync(User user);
-    public Task DeleteAsync(User user, bool force);
+    public Task<UserDeleteValidationResult> Validate(User user);
+    public Task Delete(User user, bool force);
 }

Moonlight.ApiServer/Mappers/ApiKeyMapper.cs

@@ -1,19 +0,0 @@
-using Moonlight.ApiServer.Database.Entities;
-using Moonlight.Shared.Http.Requests.Admin.ApiKeys;
-using Moonlight.Shared.Http.Responses.Admin.ApiKeys;
-using Riok.Mapperly.Abstractions;
-
-namespace Moonlight.ApiServer.Mappers;
-
-[Mapper]
-public static partial class ApiKeyMapper
-{
-    // Mappers
-    public static partial ApiKeyResponse ToResponse(ApiKey apiKey);
-    public static partial ApiKey ToApiKey(CreateApiKeyRequest request);
-    public static partial void Merge([MappingTarget] ApiKey apiKey, UpdateApiKeyRequest request);
-    
-    // EF Relations
-
-    public static partial IQueryable<ApiKeyResponse> ProjectToResponse(this IQueryable<ApiKey> apiKeys);
-}

Moonlight.ApiServer/Mappers/ThemeMapper.cs

@@ -8,12 +8,7 @@ namespace Moonlight.ApiServer.Mappers;
 [Mapper]
 public static partial class ThemeMapper
 {
-    // Mappers
     public static partial ThemeResponse ToResponse(Theme theme);
     public static partial Theme ToTheme(CreateThemeRequest request);
     public static partial void Merge([MappingTarget] Theme theme, UpdateThemeRequest request);
-    
-    // EF Relations
-
-    public static partial IQueryable<ThemeResponse> ProjectToResponse(this IQueryable<Theme> themes);
 }

Moonlight.ApiServer/Mappers/UserMapper.cs

@@ -1,15 +0,0 @@
-using Moonlight.ApiServer.Database.Entities;
-using Moonlight.Shared.Http.Responses.Admin.Users;
-using Riok.Mapperly.Abstractions;
-
-namespace Moonlight.ApiServer.Mappers;
-
-[Mapper]
-public static partial class UserMapper
-{
-    // Mappers
-    public static partial UserResponse ToResponse(User user);
-    
-    // EF Relations
-    public static partial IQueryable<UserResponse> ProjectToResponse(this IQueryable<User> users);
-}

Moonlight.ApiServer/Moonlight.ApiServer.csproj

@@ -1,43 +1,46 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk.Razor">
-    <PropertyGroup>
-        <TargetFramework>net9.0</TargetFramework>
-        <Nullable>enable</Nullable>
-        <ImplicitUsings>enable</ImplicitUsings>
-    </PropertyGroup>
-    <ItemGroup>
-        <ProjectReference Include="..\Moonlight.Shared\Moonlight.Shared.csproj"/>
-    </ItemGroup>
-    <ItemGroup>
-        <Folder Include="Database\Migrations\"/>
-    </ItemGroup>
-    <PropertyGroup>
-        <PackageId>Moonlight.ApiServer</PackageId>
-        <Version>2.1.15</Version>
-        <Authors>Moonlight Panel</Authors>
-        <Description>A build of the api server for moonlight development</Description>
-        <PackageProjectUrl>https://github.com/Moonlight-Panel/Moonlight</PackageProjectUrl>
-        <DevelopmentDependency>true</DevelopmentDependency>
-        <PackageTags>apiserver</PackageTags>
-        <IsPackable>true</IsPackable>
-    </PropertyGroup>
-    <ItemGroup>
-        <PackageReference Include="Hangfire.AspNetCore" Version="1.8.20"/>
-        <PackageReference Include="Hangfire.Core" Version="1.8.20"/>
-        <PackageReference Include="Hangfire.EntityFrameworkCore" Version="0.7.0"/>
-        <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="9.0.9" />
-        <PackageReference Include="Microsoft.AspNetCore.SignalR.StackExchangeRedis" Version="9.0.9" />
-        <PackageReference Include="MoonCore" Version="2.0.6" />
-        <PackageReference Include="MoonCore.Extended" Version="1.4.2" />
-        <PackageReference Include="MoonCore.PluginFramework.Generator" Version="1.0.3" />
-        <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" />
-        <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.12.0" />
-        <PackageReference Include="OpenTelemetry.Exporter.Prometheus.AspNetCore" Version="1.12.0-beta.1"/>
-        <PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.12.0"/>
-        <PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.12.0"/>
-        <PackageReference Include="Riok.Mapperly" Version="4.3.0-next.3" />
-        <PackageReference Include="SharpZipLib" Version="1.4.2"/>
-        <PackageReference Include="Swashbuckle.AspNetCore" Version="9.0.4" />
-        <PackageReference Include="Ben.Demystifier" Version="0.4.1"/>
-    </ItemGroup>
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Moonlight.Shared\Moonlight.Shared.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Database\Migrations\" />
+    <Folder Include="Helpers\" />
+  </ItemGroup>
+  <PropertyGroup>
+    <PackageId>Moonlight.ApiServer</PackageId>
+    <Version>2.1.7</Version>
+    <Authors>Moonlight Panel</Authors>
+    <Description>A build of the api server for moonlight development</Description>
+    <PackageProjectUrl>https://github.com/Moonlight-Panel/Moonlight</PackageProjectUrl>
+    <DevelopmentDependency>true</DevelopmentDependency>
+    <PackageTags>apiserver</PackageTags>
+    <IsPackable>true</IsPackable>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.7" />
+    <PackageReference Include="MoonCore" Version="1.9.2" />
+    <PackageReference Include="MoonCore.Extended" Version="1.3.5" />
+    <PackageReference Include="MoonCore.PluginFramework.Generator" Version="1.0.2" />
+    <PackageReference Include="OpenTelemetry.Exporter.Prometheus.AspNetCore" Version="1.12.0-beta.1" />
+    <PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.12.0" />
+    <PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.12.0" />
+    <PackageReference Include="Riok.Mapperly" Version="4.3.0-next.2" />
+    <PackageReference Include="SharpZipLib" Version="1.4.2" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="8.1.2" />
+    <PackageReference Include="Ben.Demystifier" Version="0.4.1" />
+    <PackageReference Include="TickerQ" Version="2.4.4" />
+    <PackageReference Include="TickerQ.EntityFrameworkCore" Version="2.4.4" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Remove="storage\**\*" />
+    <Content Remove="storage\**\*" />
+    <None Remove="storage\**\*" />
+    <None Remove="Properties\launchSettings.json" />
+  </ItemGroup>
 </Project>

Moonlight.ApiServer/Plugins/IPluginStartup.cs

@@ -1,10 +1,12 @@
 using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.Hosting;
 
 namespace Moonlight.ApiServer.Plugins;
 
 public interface IPluginStartup
 {
-    public void AddPlugin(WebApplicationBuilder builder);
-    public void UsePlugin(WebApplication app);
-    public void MapPlugin(WebApplication app);
+    public Task BuildApplication(IServiceProvider serviceProvider, IHostApplicationBuilder builder);
+    public Task ConfigureApplication(IServiceProvider serviceProvider, IApplicationBuilder app);
+    public Task ConfigureEndpoints(IServiceProvider serviceProvider, IEndpointRouteBuilder routeBuilder);
 }

Moonlight.ApiServer/Services/ApiKeyAuthService.cs

@@ -1,32 +0,0 @@
-using System.Security.Claims;
-using Microsoft.EntityFrameworkCore;
-using MoonCore.Extended.Abstractions;
-using Moonlight.ApiServer.Database.Entities;
-
-namespace Moonlight.ApiServer.Services;
-
-public class ApiKeyAuthService
-{
-    private readonly DatabaseRepository<ApiKey> ApiKeyRepository;
-
-    public ApiKeyAuthService(DatabaseRepository<ApiKey> apiKeyRepository)
-    {
-        ApiKeyRepository = apiKeyRepository;
-    }
-
-    public async Task<bool> ValidateAsync(ClaimsPrincipal? principal)
-    {
-        // Ignore malformed claims principal
-        if (principal is not { Identity.IsAuthenticated: true })
-            return false;
-
-        var apiKeyIdStr = principal.FindFirstValue("ApiKeyId");
-
-        if (!int.TryParse(apiKeyIdStr, out var apiKeyId))
-            return false;
-
-        return await ApiKeyRepository
-            .Get()
-            .AnyAsync(x => x.Id == apiKeyId);
-    }
-}

Moonlight.ApiServer/Services/ApiKeyService.cs

@@ -29,11 +29,11 @@ public class ApiKeyService
             Claims = new Dictionary<string, object>()
             {
                 {
-                    "ApiKeyId",
+                    "apiKeyId",
                     apiKey.Id
                 },
                 {
-                    "Permissions",
+                    "permissions",
                     string.Join(";", apiKey.Permissions)
                 }
             },

Moonlight.ApiServer/Services/ApplicationService.cs

@@ -19,7 +19,7 @@ public class ApplicationService
         Host = host;
     }
 
-    public Task<string> GetOsNameAsync()
+    public Task<string> GetOsName()
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
         {
@@ -58,7 +58,7 @@ public class ApplicationService
         return Task.FromResult("N/A");
     }
     
-    public async Task<long> GetMemoryUsageAsync()
+    public async Task<long> GetMemoryUsage()
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
         {
@@ -87,14 +87,14 @@ public class ApplicationService
         }
     }
     
-    public Task<TimeSpan> GetUptimeAsync()
+    public Task<TimeSpan> GetUptime()
     {
         var process = Process.GetCurrentProcess();
         var uptime = DateTime.Now - process.StartTime;
         return Task.FromResult(uptime);
     }
 
-    public Task<int> GetCpuUsageAsync()
+    public Task<int> GetCpuUsage()
     {
         var process = Process.GetCurrentProcess();
         var cpuTime = process.TotalProcessorTime;
@@ -105,7 +105,7 @@ public class ApplicationService
         return Task.FromResult(cpuUsage);
     }
 
-    public Task ShutdownAsync()
+    public Task Shutdown()
     {
         Logger.LogCritical("Restart of api server has been requested");
 

Moonlight.ApiServer/Services/DiagnoseService.cs

@@ -22,7 +22,7 @@ public class DiagnoseService
         Logger = logger;
     }
 
-    public Task<DiagnoseProvideResponse[]> GetProvidersAsync()
+    public Task<DiagnoseProvideResponse[]> GetProviders()
     {
         var availableProviders = new List<DiagnoseProvideResponse>();
 
@@ -48,7 +48,7 @@ public class DiagnoseService
         );
     }
 
-    public async Task<MemoryStream> GenerateDiagnoseAsync(string[] requestedProviders)
+    public async Task<MemoryStream> GenerateDiagnose(string[] requestedProviders)
     {
         IDiagnoseProvider[] providers;
 
@@ -78,7 +78,7 @@ public class DiagnoseService
 
             foreach (var provider in providers)
             {
-                await provider.ModifyZipArchiveAsync(zipArchive);
+                await provider.ModifyZipArchive(zipArchive);
             }
             
             zipArchive.Dispose();

Moonlight.ApiServer/Services/FrontendService.cs

@@ -40,7 +40,7 @@ public class FrontendService
         ThemeRepository = themeRepository;
     }
 
-    public Task<FrontendConfiguration> GetConfigurationAsync()
+    public Task<FrontendConfiguration> GetConfiguration()
     {
         var configuration = new FrontendConfiguration()
         {
@@ -51,7 +51,7 @@ public class FrontendService
         return Task.FromResult(configuration);
     }
 
-    public async Task<string> GenerateIndexHtmlAsync() // TODO: Cache
+    public async Task<string> GenerateIndexHtml() // TODO: Cache
     {
         // Load requested theme
         var theme = await ThemeRepository
@@ -70,7 +70,7 @@ public class FrontendService
             .Distinct()
             .ToArray();
 
-        return await ComponentHelper.RenderToHtmlAsync<FrontendPage>(
+        return await ComponentHelper.RenderComponent<FrontendPage>(
             ServiceProvider,
             parameters =>
             {
@@ -82,7 +82,7 @@ public class FrontendService
         );
     }
 
-    public async Task<Stream> GenerateZipAsync() // TODO: Rework to be able to extract everything successfully
+    public async Task<Stream> GenerateZip() // TODO: Rework to be able to extract everything successfully
     {
         // We only allow the access to this function when we are actually hosting the frontend
         if (!Configuration.Frontend.EnableHosting)
@@ -109,16 +109,16 @@ public class FrontendService
         var zipArchive = new ZipArchive(memoryStream, ZipArchiveMode.Create, true);
 
         // Add wasm application
-        await ArchiveFsItemAsync(zipArchive, wasmPath, wasmPath);
+        await ArchiveFsItem(zipArchive, wasmPath, wasmPath);
 
         // Add blazor files
-        await ArchiveFsItemAsync(zipArchive, blazorPath, blazorPath, "_framework/");
+        await ArchiveFsItem(zipArchive, blazorPath, blazorPath, "_framework/");
 
         // Add frontend.json
-        var frontendConfig = await GetConfigurationAsync();
+        var frontendConfig = await GetConfiguration();
         frontendConfig.HostEnvironment = "Static";
         var frontendJson = JsonSerializer.Serialize(frontendConfig);
-        await ArchiveTextAsync(zipArchive, "frontend.json", frontendJson);
+        await ArchiveText(zipArchive, "frontend.json", frontendJson);
 
         // Finish zip archive and reset stream so the code calling this function can process it
         zipArchive.Dispose();
@@ -128,7 +128,7 @@ public class FrontendService
         return memoryStream;
     }
 
-    private async Task ArchiveFsItemAsync(ZipArchive archive, string path, string prefixToRemove, string prefixToAdd = "")
+    private async Task ArchiveFsItem(ZipArchive archive, string path, string prefixToRemove, string prefixToAdd = "")
     {
         if (File.Exists(path))
         {
@@ -147,17 +147,17 @@ public class FrontendService
         else
         {
             foreach (var directoryItem in Directory.EnumerateFileSystemEntries(path))
-                await ArchiveFsItemAsync(archive, directoryItem, prefixToRemove, prefixToAdd);
+                await ArchiveFsItem(archive, directoryItem, prefixToRemove, prefixToAdd);
         }
     }
 
-    private async Task ArchiveTextAsync(ZipArchive archive, string path, string content)
+    private async Task ArchiveText(ZipArchive archive, string path, string content)
     {
         var data = Encoding.UTF8.GetBytes(content);
-        await ArchiveBytesAsync(archive, path, data);
+        await ArchiveBytes(archive, path, data);
     }
 
-    private async Task ArchiveBytesAsync(ZipArchive archive, string path, byte[] bytes)
+    private async Task ArchiveBytes(ZipArchive archive, string path, byte[] bytes)
     {
         var entry = archive.CreateEntry(path);
         await using var dataStream = entry.Open();

Moonlight.ApiServer/Services/MetricsBackgroundService.cs

@@ -33,7 +33,7 @@ public class MetricsBackgroundService : BackgroundService
         Metrics = metrics.ToArray();
     }
 
-    private async Task InitializeAsync()
+    private async Task Initialize()
     {
         Logger.LogDebug(
             "Initializing metrics: {names}",
@@ -41,12 +41,12 @@ public class MetricsBackgroundService : BackgroundService
         );
 
         foreach (var metric in Metrics)
-            await metric.InitializeAsync(Meter);
+            await metric.Initialize(Meter);
     }
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
-        await InitializeAsync();
+        await Initialize();
 
         while (!stoppingToken.IsCancellationRequested)
         {
@@ -56,7 +56,7 @@ public class MetricsBackgroundService : BackgroundService
             {
                 try
                 {
-                    await metric.RunAsync(scope.ServiceProvider, stoppingToken);
+                    await metric.Run(scope.ServiceProvider, stoppingToken);
                 }
                 catch (TaskCanceledException)
                 {
@@ -73,7 +73,7 @@ public class MetricsBackgroundService : BackgroundService
             }
 
             await Task.Delay(
-                TimeSpan.FromSeconds(Configuration.OpenTelemetry.Metrics.Interval),
+                TimeSpan.FromSeconds(Configuration.Metrics.Interval),
                 stoppingToken
             );
         }

Moonlight.ApiServer/Services/UserAuthService.cs

@@ -1,168 +0,0 @@
-using System.Security.Claims;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using MoonCore.Extended.Abstractions;
-using MoonCore.Extended.Helpers;
-using MoonCore.Helpers;
-using Moonlight.ApiServer.Configuration;
-using Moonlight.ApiServer.Database.Entities;
-using Moonlight.ApiServer.Interfaces;
-
-namespace Moonlight.ApiServer.Services;
-
-public class UserAuthService
-{
-    private readonly ILogger<UserAuthService> Logger;
-    private readonly DatabaseRepository<User> UserRepository;
-    private readonly AppConfiguration Configuration;
-    private readonly IEnumerable<IUserAuthExtension> Extensions;
-
-    private const string UserIdClaim = "UserId";
-    private const string IssuedAtClaim = "IssuedAt";
-
-    public UserAuthService(
-        ILogger<UserAuthService> logger,
-        DatabaseRepository<User> userRepository,
-        AppConfiguration configuration,
-        IEnumerable<IUserAuthExtension> extensions
-    )
-    {
-        Logger = logger;
-        UserRepository = userRepository;
-        Configuration = configuration;
-        Extensions = extensions;
-    }
-
-    public async Task<bool> SyncAsync(ClaimsPrincipal? principal)
-    {
-        // Ignore malformed claims principal
-        if (principal is not { Identity.IsAuthenticated: true })
-            return false;
-
-        // Search for email and username. We need both to create the user model if required.
-        // We do a ToLower here because external authentication provider might provide case-sensitive data
-
-        var email = principal.FindFirstValue(ClaimTypes.Email)?.ToLower();
-        var username = principal.FindFirstValue(ClaimTypes.Name)?.ToLower();
-
-        if (string.IsNullOrEmpty(email) || string.IsNullOrEmpty(username))
-        {
-            Logger.LogWarning(
-                "The authentication scheme {scheme} did not provide claim types: email, name. These are required to sync to user to the database",
-                principal.Identity.AuthenticationType
-            );
-
-            return false;
-        }
-
-        // If you plan to use multiple auth providers it can be a good idea
-        // to use an identifier in the user model which consists of the provider and the NameIdentifier
-        // instead of the email address. For simplicity, we just use the email as the identifier so multiple auth providers
-        // can lead to the same account when the email matches
-        var user = await UserRepository
-            .Get()
-            .FirstOrDefaultAsync(u => u.Email == email);
-
-        if (user == null)
-        {
-            string[] permissions = [];
-
-            // Yes I know we handle the first user admin thing in the LocalAuth too,
-            // but this only works fo the local auth. So if a user uses an external auth scheme
-            // like oauth2 discord, the first user admin toggle would do nothing
-            if (Configuration.Authentication.FirstUserAdmin)
-            {
-                var count = await UserRepository
-                    .Get()
-                    .CountAsync();
-
-                if (count == 0)
-                    permissions = ["*"];
-            }
-
-            user = await UserRepository.AddAsync(new User()
-            {
-                Email = email,
-                TokenValidTimestamp = DateTimeOffset.UtcNow.AddMinutes(-1),
-                Username = username,
-                Password = HashHelper.Hash(Formatter.GenerateString(64)),
-                Permissions = permissions
-            });
-        }
-
-        // You can sync other properties here
-        if (user.Username != username)
-        {
-            user.Username = username;
-            await UserRepository.UpdateAsync(user);
-        }
-
-        // Enrich claims with required metadata
-        principal.Identities.First().AddClaims([
-            new Claim(UserIdClaim, user.Id.ToString()),
-            new Claim(IssuedAtClaim, DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString()),
-            new Claim("Permissions", string.Join(';', user.Permissions))
-        ]);
-        
-        // Call extensions
-        foreach (var extension in Extensions)
-        {
-            var result = await extension.SyncAsync(user, principal);
-
-            if (!result) // Exit immediately if result is false
-                return false;
-        }
-
-        return true;
-    }
-
-    public async Task<bool> ValidateAsync(ClaimsPrincipal? principal)
-    {
-        // Ignore malformed claims principal
-        if (principal is not { Identity.IsAuthenticated: true })
-            return false;
-
-        // Validate if the user still exists, and then we want to validate the token issue time
-        // against the invalidation time
-
-        var userIdStr = principal.FindFirstValue(UserIdClaim);
-
-        if (!int.TryParse(userIdStr, out var userId))
-            return false;
-
-        var user = await UserRepository
-            .Get()
-            .FirstOrDefaultAsync(u => u.Id == userId);
-
-        if (user == null)
-            return false;
-
-        // Token time validation
-        var issuedAtStr = principal.FindFirstValue(IssuedAtClaim);
-
-        if (!long.TryParse(issuedAtStr, out var issuedAtUnix))
-            return false;
-
-        var issuedAt = DateTimeOffset
-            .FromUnixTimeSeconds(issuedAtUnix)
-            .ToUniversalTime();
-
-        // If the issued at timestamp is greater than the token validation timestamp
-        // everything is fine. If not it means that the token should be invalidated
-        // as it is too old
-
-        if (issuedAt < user.TokenValidTimestamp)
-            return false;
-        
-        // Call extensions
-        foreach (var extension in Extensions)
-        {
-            var result = await extension.ValidateAsync(user, principal);
-
-            if (!result) // Exit immediately if result is false
-                return false;
-        }
-
-        return true;
-    }
-}

Moonlight.ApiServer/Services/UserService.cs

@@ -19,11 +19,11 @@ public class UserDeletionService
         Handlers = handlers.ToArray();
     }
 
-    public async Task<UserDeleteValidationResult> ValidateAsync(User user)
+    public async Task<UserDeleteValidationResult> Validate(User user)
     {
         foreach (var handler in Handlers)
         {
-            var result = await handler.ValidateAsync(user);
+            var result = await handler.Validate(user);
 
             if (!result.IsAllowed)
                 return result;
@@ -32,11 +32,11 @@ public class UserDeletionService
         return UserDeleteValidationResult.Allow();
     }
 
-    public async Task DeleteAsync(User user, bool force)
+    public async Task Delete(User user, bool force)
     {
         foreach (var handler in Handlers)
-            await handler.DeleteAsync(user, force);
+            await Delete(user, force);
 
-        await UserRepository.RemoveAsync(user);
+        await UserRepository.Remove(user);
     }
 }

Moonlight.ApiServer/Startup/Startup.Auth.cs

@@ -1,189 +1,64 @@
 using System.Text;
-using Microsoft.AspNetCore.Authentication.JwtBearer;
 using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.DataProtection;
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.IdentityModel.Tokens;
+using MoonCore.Extended.JwtInvalidation;
 using MoonCore.Permissions;
-using Moonlight.ApiServer.Configuration;
-using Moonlight.ApiServer.Implementations.LocalAuth;
+using Moonlight.ApiServer.Implementations;
+using Moonlight.ApiServer.Interfaces;
 using Moonlight.ApiServer.Services;
 
 namespace Moonlight.ApiServer.Startup;
 
-public static partial class Startup
+public partial class Startup
 {
-    private static void AddAuth(this WebApplicationBuilder builder)
+    private Task RegisterAuth()
     {
-        var configuration = AppConfiguration.CreateEmpty();
-        builder.Configuration.Bind(configuration);
-        
-        builder.Services
-            .AddAuthentication(options => { options.DefaultScheme = "MainScheme"; })
-            .AddPolicyScheme("MainScheme", null, options =>
-            {
-                // If an api key is specified via the bearer auth header
-                // we want to use the ApiKey scheme for authenticating the request
-                options.ForwardDefaultSelector = context =>
-                {
-                    var headers = context.Request.Headers;
-       
-                    // For regular api calls
-                    if (headers.ContainsKey("Authorization"))
-                        return "ApiKey";
- 
-                    // For websocket requests which cannot use the Authorization header
-                    if (headers.Upgrade == "websocket" && headers.Connection == "Upgrade" && context.Request.Query.ContainsKey("access_token"))
-                        return "ApiKey";
-
-                    // Regular user traffic/auth
-                    return "Session";
-                };
-            })
-            .AddJwtBearer("ApiKey", null, options =>
+        WebApplicationBuilder.Services
+            .AddAuthentication("coreAuthentication")
+            .AddJwtBearer("coreAuthentication", options =>
             {
                 options.TokenValidationParameters = new()
                 {
                     IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(
-                        configuration.Authentication.Secret
+                        Configuration.Authentication.Secret
                     )),
                     ValidateIssuerSigningKey = true,
                     ValidateLifetime = true,
                     ClockSkew = TimeSpan.Zero,
                     ValidateAudience = true,
-                    ValidAudience = configuration.PublicUrl,
+                    ValidAudience = Configuration.PublicUrl,
                     ValidateIssuer = true,
-                    ValidIssuer = configuration.PublicUrl
+                    ValidIssuer = Configuration.PublicUrl
                 };
-
-                options.Events = new JwtBearerEvents()
-                {
-                    OnTokenValidated = async context =>
-                    {
-                        var apiKeyAuthService = context
-                            .HttpContext
-                            .RequestServices
-                            .GetRequiredService<ApiKeyAuthService>();
-
-                        var result = await apiKeyAuthService.ValidateAsync(context.Principal);
-
-                        if (!result)
-                            context.Fail("API key has been deleted");
-                    },
-                    
-                    OnMessageReceived = context =>
-                    {
-                        var accessToken = context.Request.Query["access_token"];
-
-                        if (!string.IsNullOrEmpty(accessToken))
-                            context.Token = accessToken;
-                        
-                        return Task.CompletedTask;
-                    }
-                };
-            })
-            .AddCookie("Session", null, options =>
-            {
-                options.ExpireTimeSpan = TimeSpan.FromDays(configuration.Authentication.Sessions.ExpiresIn);
-
-                options.Cookie = new CookieBuilder()
-                {
-                    Name = configuration.Authentication.Sessions.CookieName,
-                    Path = "/",
-                    IsEssential = true,
-                    SecurePolicy = CookieSecurePolicy.SameAsRequest
-                };
-
-                // As redirects won't work in our spa which uses API calls
-                // we need to customize the responses when certain actions happen
-                options.Events.OnRedirectToLogin = async context =>
-                {
-                    await Results.Problem(
-                            title: "Unauthenticated",
-                            detail: "You need to authenticate yourself to use this endpoint",
-                            statusCode: 401
-                        )
-                        .ExecuteAsync(context.HttpContext);
-                };
-
-                options.Events.OnRedirectToAccessDenied = async context =>
-                {
-                    await Results.Problem(
-                            title: "Permission denied",
-                            detail: "You are missing the required permissions to access this endpoint",
-                            statusCode: 403
-                        )
-                        .ExecuteAsync(context.HttpContext);
-                };
-
-                options.Events.OnSigningIn = async context =>
-                {
-                    var userSyncService = context
-                        .HttpContext
-                        .RequestServices
-                        .GetRequiredService<UserAuthService>();
-
-                    var result = await userSyncService.SyncAsync(context.Principal);
-
-                    if (!result)
-                        context.Principal = new();
-                    else
-                        context.Properties.IsPersistent = true;
-                };
-
-                options.Events.OnValidatePrincipal = async context =>
-                {
-                    var userSyncService = context
-                        .HttpContext
-                        .RequestServices
-                        .GetRequiredService<UserAuthService>();
-
-                    var result = await userSyncService.ValidateAsync(context.Principal);
-
-                    if (!result)
-                        context.RejectPrincipal();
-                };
-            })
-            .AddScheme<LocalAuthOptions, LocalAuthHandler>(LocalAuthConstants.AuthenticationScheme, "Local Auth", options =>
-            {
-                options.ForwardAuthenticate = "Session";
-                options.ForwardSignIn = "Session";
-                options.ForwardSignOut = "Session";
-
-                options.SignInScheme = "Session";
             });
         
-        builder.Services.AddAuthorization();
+        WebApplicationBuilder.Services.AddJwtBearerInvalidation("coreAuthentication");
+        WebApplicationBuilder.Services.AddScoped<IJwtInvalidateHandler, UserAuthInvalidation>();
 
-        builder.Services.AddAuthorizationPermissions(options =>
+        WebApplicationBuilder.Services.AddAuthorization();
+        
+        WebApplicationBuilder.Services.AddAuthorizationPermissions(options =>
         {
-            options.ClaimName = "Permissions";
+            options.ClaimName = "permissions";
             options.Prefix = "permissions:";
         });
 
-        builder.Services.AddScoped<UserAuthService>();
-        builder.Services.AddScoped<ApiKeyAuthService>();
+        // Add local oauth2 provider if enabled
+        if (Configuration.Authentication.EnableLocalOAuth2)
+            WebApplicationBuilder.Services.AddScoped<IOAuth2Provider, LocalOAuth2Provider>();
 
-        // Setup data protection storage within storage folder
-        // so its persists in containers
-        var dpKeyPath = Path.Combine("storage", "dataProtectionKeys");
+        WebApplicationBuilder.Services.AddScoped<UserDeletionService>();
 
-        Directory.CreateDirectory(dpKeyPath);
-
-        builder.Services
-            .AddDataProtection()
-            .PersistKeysToFileSystem(
-                new DirectoryInfo(dpKeyPath)
-            );
-
-        builder.Services.AddScoped<UserDeletionService>();
+        return Task.CompletedTask;
     }
 
-    private static void UseAuth(this WebApplication application)
+    private Task UseAuth()
     {
-        application.UseAuthentication();
-        application.UseAuthorization();
+        WebApplication.UseAuthentication();
+
+        WebApplication.UseAuthorization();
+
+        return Task.CompletedTask;
     }
 }

Moonlight.ApiServer/Startup/Startup.Base.cs

@@ -1,62 +1,63 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using MoonCore.Extended.Extensions;
 using MoonCore.Extensions;
 using MoonCore.Helpers;
-using Moonlight.ApiServer.Configuration;
-using Moonlight.ApiServer.Plugins;
 
 namespace Moonlight.ApiServer.Startup;
 
-public static partial class Startup
+public partial class Startup
 {
-    private static void AddBase(this WebApplicationBuilder builder, IPluginStartup[] startups)
+    private Task RegisterBase()
     {
-        builder.Services.AutoAddServices<IAssemblyMarker>();
-        builder.Services.AddHttpClient();
+        WebApplicationBuilder.Services.AutoAddServices<Startup>();
+        WebApplicationBuilder.Services.AddHttpClient();
 
-        builder.Services.AddApiExceptionHandler();
+        WebApplicationBuilder.Services.AddApiExceptionHandler();
+
+        // Add pre-existing services
+        WebApplicationBuilder.Services.AddSingleton(Configuration);
 
         // Configure controllers
-        var mvcBuilder = builder.Services.AddControllers();
+        var mvcBuilder = WebApplicationBuilder.Services.AddControllers();
 
         // Add plugin assemblies as application parts
-        foreach (var pluginStartup in startups.Select(x => x.GetType().Assembly).Distinct())
+        foreach (var pluginStartup in PluginStartups.Select(x => x.GetType().Assembly).Distinct())
             mvcBuilder.AddApplicationPart(pluginStartup.GetType().Assembly);
+
+        return Task.CompletedTask;
     }
 
-    private static void UseBase(this WebApplication application)
+    private Task UseBase()
     {
-        application.UseRouting();
-        application.UseExceptionHandler();
+        WebApplication.UseRouting();
+        WebApplication.UseExceptionHandler();
+
+        return Task.CompletedTask;
     }
 
-    private static void MapBase(this WebApplication application)
+    private Task MapBase()
     {
-        application.MapControllers();
+        WebApplication.MapControllers();
 
-        // Frontend
-        var configuration = AppConfiguration.CreateEmpty();
-        application.Configuration.Bind(configuration);
+        if (Configuration.Frontend.EnableHosting)
+            WebApplication.MapFallbackToController("Index", "Frontend");
 
-        if (configuration.Frontend.EnableHosting)
-            application.MapFallbackToController("Index", "Frontend");
+        return Task.CompletedTask;
     }
 
-    private static void ConfigureKestrel(this WebApplicationBuilder builder)
+    private Task ConfigureKestrel()
     {
-        var configuration = AppConfiguration.CreateEmpty();
-        builder.Configuration.Bind(configuration);
-        
-        builder.WebHost.ConfigureKestrel(kestrelOptions =>
+        WebApplicationBuilder.WebHost.ConfigureKestrel(kestrelOptions =>
         {
             var maxUploadInBytes = ByteConverter
-                .FromMegaBytes(configuration.Kestrel.UploadLimit)
+                .FromMegaBytes(Configuration.Kestrel.UploadLimit)
                 .Bytes;
 
             kestrelOptions.Limits.MaxRequestBodySize = maxUploadInBytes;
         });
+
+        return Task.CompletedTask;
     }
 }

Moonlight.ApiServer/Startup/Startup.Config.cs

@@ -1,4 +1,3 @@
-using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using MoonCore.EnvConfiguration;
@@ -7,23 +6,30 @@ using Moonlight.ApiServer.Configuration;
 
 namespace Moonlight.ApiServer.Startup;
 
-public static partial class Startup
+public partial class Startup
 {
-    private static void AddConfiguration(this WebApplicationBuilder builder)
+    private async Task SetupAppConfiguration()
     {
-        // Yaml
-        var yamlPath = Path.Combine("storage", "config.yml");
+        var configPath = Path.Combine("storage", "config.yml");
 
-        YamlDefaultGenerator.GenerateAsync<AppConfiguration>(yamlPath).Wait();
+        await YamlDefaultGenerator.Generate<AppConfiguration>(configPath);
 
-        builder.Configuration.AddYamlFile(yamlPath);
+        // Configure configuration (wow)
+        var configurationBuilder = new ConfigurationBuilder();
 
-        // Env
-        builder.Configuration.AddEnvironmentVariables(prefix: "MOONLIGHT_", separator: "_");
+        configurationBuilder.AddYamlFile(configPath);
+        configurationBuilder.AddEnvironmentVariables(prefix: "MOONLIGHT_", separator: "_");
 
-        var configuration = AppConfiguration.CreateEmpty();
-        builder.Configuration.Bind(configuration);
+        var configurationRoot = configurationBuilder.Build();
         
-        builder.Services.AddSingleton(configuration);
+        // Retrieve configuration
+        Configuration = AppConfiguration.CreateEmpty();
+        configurationRoot.Bind(Configuration);
+    }
+
+    private Task RegisterAppConfiguration()
+    {
+        WebApplicationBuilder.Services.AddSingleton(Configuration);
+        return Task.CompletedTask;
     }
 }

Moonlight.ApiServer/Startup/Startup.Database.cs

@@ -1,17 +1,25 @@
-using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
 using MoonCore.Extended.Abstractions;
 using MoonCore.Extended.Extensions;
 
 namespace Moonlight.ApiServer.Startup;
 
-public static partial class Startup
+public partial class Startup
 {
-    private static void AddDatabase(this WebApplicationBuilder builder)
+    private Task RegisterDatabase()
     {
-        builder.Services.AddDbAutoMigrations();
-        builder.Services.AddDatabaseMappings();
+        WebApplicationBuilder.Services.AddDatabaseMappings();
+        WebApplicationBuilder.Services.AddServiceCollectionAccessor();
 
-        builder.Services.AddScoped(typeof(DatabaseRepository<>));
+        WebApplicationBuilder.Services.AddScoped(typeof(DatabaseRepository<>));
+
+        return Task.CompletedTask;
+    }
+
+    private async Task PrepareDatabase()
+    {
+        await WebApplication.Services.EnsureDatabaseMigrated();
+
+        WebApplication.Services.GenerateDatabaseMappings();
     }
 }

Moonlight.ApiServer/Startup/Startup.Hangfire.cs

@@ -1,45 +0,0 @@
-using Hangfire;
-using Hangfire.EntityFrameworkCore;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Moonlight.ApiServer.Database;
-
-namespace Moonlight.ApiServer.Startup;
-
-public static partial class Startup
-{
-    private static void AddMoonlightHangfire(this WebApplicationBuilder builder)
-    {
-        builder.Services.AddHangfire((provider, configuration) =>
-        {
-            configuration.SetDataCompatibilityLevel(CompatibilityLevel.Version_180);
-            configuration.UseSimpleAssemblyNameTypeSerializer();
-            configuration.UseRecommendedSerializerSettings();
-            configuration.UseEFCoreStorage(() =>
-            {
-                var scope = provider.CreateScope();
-                return scope.ServiceProvider.GetRequiredService<CoreDataContext>();
-            }, new EFCoreStorageOptions());
-        });
-
-        builder.Services.AddHangfireServer();
-
-        builder.Logging.AddFilter(
-            "Hangfire.Server.BackgroundServerProcess",
-            LogLevel.Warning
-        );
-
-        builder.Logging.AddFilter(
-            "Hangfire.BackgroundJobServer",
-            LogLevel.Warning
-        );
-    }
-
-    private static void UseMoonlightHangfire(this WebApplication application)
-    {
-        if (application.Environment.IsDevelopment())
-            application.UseHangfireDashboard();
-    }
-}

Moonlight.ApiServer/Startup/Startup.Logging.cs

@@ -1,55 +1,61 @@
 using System.Text.Json;
-using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.Logging;
 using MoonCore.Logging;
 
 namespace Moonlight.ApiServer.Startup;
 
-public static partial class Startup
+public partial class Startup
 {
-    private static void AddLogging(this WebApplicationBuilder builder)
+    private Task SetupLogging()
     {
-        // Logging providers
-        builder.Logging.ClearProviders();
+        var loggerFactory = new LoggerFactory();
+        loggerFactory.AddAnsiConsole();
 
-        builder.Logging.AddAnsiConsole();
-        builder.Logging.AddFile(Path.Combine("storage", "logs", "moonlight.log"));
+        Logger = loggerFactory.CreateLogger<Startup>();
+
+        return Task.CompletedTask;
+    }
+
+    private async Task RegisterLogging()
+    {
+        // Configure application logging
+        WebApplicationBuilder.Logging.ClearProviders();
+        WebApplicationBuilder.Logging.AddAnsiConsole();
+        WebApplicationBuilder.Logging.AddFile(Path.Combine("storage", "logs", "moonlight.log"));
 
         // Logging levels
         var logConfigPath = Path.Combine("storage", "logConfig.json");
 
-        // Ensure default log levels exist
+        // Ensure logging config, add a default one is missing
         if (!File.Exists(logConfigPath))
         {
             var defaultLogLevels = new Dictionary<string, string>
             {
                 { "Default", "Information" },
                 { "Microsoft.AspNetCore", "Warning" },
-                { "System.Net.Http.HttpClient", "Warning" },
-                { "Moonlight.ApiServer.Implementations.LocalAuth.LocalAuthHandler", "Warning" }
+                { "System.Net.Http.HttpClient", "Warning" }
             };
 
             var logLevelsJson = JsonSerializer.Serialize(defaultLogLevels);
-            File.WriteAllText(logConfigPath, logLevelsJson);
+            await File.WriteAllTextAsync(logConfigPath, logLevelsJson);
         }
 
-        // Read log levels
+        // Add logging configuration
         var logLevels = JsonSerializer.Deserialize<Dictionary<string, string>>(
-            File.ReadAllText(logConfigPath)
+            await File.ReadAllTextAsync(logConfigPath)
         )!;
 
-        // Apply configured log levels
         foreach (var level in logLevels)
-            builder.Logging.AddFilter(level.Key, Enum.Parse<LogLevel>(level.Value));
+            WebApplicationBuilder.Logging.AddFilter(level.Key, Enum.Parse<LogLevel>(level.Value));
 
         // Mute exception handler middleware
         // https://github.com/dotnet/aspnetcore/issues/19740
-        builder.Logging.AddFilter(
+        WebApplicationBuilder.Logging.AddFilter(
             "Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware",
             LogLevel.Critical
         );
 
-        builder.Logging.AddFilter(
+        WebApplicationBuilder.Logging.AddFilter(
             "Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware",
             LogLevel.Critical
         );

Moonlight.ApiServer/Startup/Startup.Misc.cs

@@ -1,14 +1,12 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Cors.Infrastructure;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
-using Moonlight.ApiServer.Configuration;
 
 namespace Moonlight.ApiServer.Startup;
 
-public static partial class Startup
+public partial class Startup
 {
-    private static void PrintVersionAsync()
+    private Task PrintVersion()
     {
         // Fancy start console output... yes very fancy :>
         var rainbow = new Crayon.Rainbow(0.5);
@@ -23,22 +21,23 @@ public static partial class Startup
         }
 
         Console.WriteLine();
+
+        return Task.CompletedTask;
     }
 
-    private static void CreateStorageAsync()
+    private Task CreateStorage()
     {
         Directory.CreateDirectory("storage");
         Directory.CreateDirectory(Path.Combine("storage", "logs"));
+
+        return Task.CompletedTask;
     }
     
-    private static void AddMoonlightCors(this WebApplicationBuilder builder)
+    private Task RegisterCors()
     {
-        var configuration = AppConfiguration.CreateEmpty();
-        builder.Configuration.Bind(configuration);
+        var allowedOrigins = Configuration.Kestrel.AllowedOrigins;
 
-        var allowedOrigins = configuration.Kestrel.AllowedOrigins;
-
-        builder.Services.AddCors(options =>
+        WebApplicationBuilder.Services.AddCors(options =>
         {
             var cors = new CorsPolicyBuilder();
 
@@ -61,10 +60,14 @@ public static partial class Startup
                 cors.Build()
             );
         });
+
+        return Task.CompletedTask;
     }
 
-    private static void UseMoonlightCors(this WebApplication application)
+    private Task UseCors()
     {
-        application.UseCors();
+        WebApplication.UseCors();
+
+        return Task.CompletedTask;
     }
 }

Moonlight.ApiServer/Startup/Startup.Plugins.cs

@@ -1,25 +1,87 @@
-using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using MoonCore.Logging;
 using Moonlight.ApiServer.Plugins;
 
 namespace Moonlight.ApiServer.Startup;
 
-public static partial class Startup
+public partial class Startup
 {
-    private static void AddPlugins(this WebApplicationBuilder builder, IPluginStartup[] startups)
+    private IServiceProvider PluginLoadServiceProvider;
+    private IPluginStartup[] PluginStartups;
+    
+    private Task InitializePlugins()
     {
-        foreach (var startup in startups)
-            startup.AddPlugin(builder);
+        // Create service provider for starting up
+        var serviceCollection = new ServiceCollection();
+
+        serviceCollection.AddSingleton(Configuration);
+
+        serviceCollection.AddLogging(builder =>
+        {
+            builder.ClearProviders();
+            builder.AddAnsiConsole();
+        });
+
+        PluginLoadServiceProvider = serviceCollection.BuildServiceProvider();
+        
+        return Task.CompletedTask;
     }
 
-    private static void UsePlugins(this WebApplication application, IPluginStartup[] startups)
+    private async Task HookPluginBuild()
     {
-        foreach (var startup in startups)
-            startup.UsePlugin(application);
+        foreach (var pluginAppStartup in PluginStartups)
+        {
+            try
+            {
+                await pluginAppStartup.BuildApplication(PluginLoadServiceProvider, WebApplicationBuilder);
+            }
+            catch (Exception e)
+            {
+                Logger.LogError(
+                    "An error occured while processing 'BuildApp' for '{name}': {e}",
+                    pluginAppStartup.GetType().FullName,
+                    e
+                );
+            }
+        }
     }
 
-    private static void MapPlugins(this WebApplication application, IPluginStartup[] startups)
+    private async Task HookPluginConfigure()
     {
-        foreach (var startup in startups)
-            startup.MapPlugin(application);
+        foreach (var pluginAppStartup in PluginStartups)
+        {
+            try
+            {
+                await pluginAppStartup.ConfigureApplication(PluginLoadServiceProvider, WebApplication);
+            }
+            catch (Exception e)
+            {
+                Logger.LogError(
+                    "An error occured while processing 'ConfigureApp' for '{name}': {e}",
+                    pluginAppStartup.GetType().FullName,
+                    e
+                );
+            }
+        }
+    }
+
+    private async Task HookPluginEndpoints()
+    {
+        foreach (var pluginEndpointStartup in PluginStartups)
+        {
+            try
+            {
+                await pluginEndpointStartup.ConfigureEndpoints(PluginLoadServiceProvider, WebApplication);
+            }
+            catch (Exception e)
+            {
+                Logger.LogError(
+                    "An error occured while processing 'ConfigureEndpoints' for '{name}': {e}",
+                    pluginEndpointStartup.GetType().FullName,
+                    e
+                );
+            }
+        }
     }
 }

Moonlight.ApiServer/Startup/Startup.SignalR.cs

@@ -1,26 +0,0 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using Moonlight.ApiServer.Configuration;
-using Moonlight.ApiServer.Http.Hubs;
-
-namespace Moonlight.ApiServer.Startup;
-
-public static partial class Startup
-{
-    private static void AddMoonlightSignalR(this WebApplicationBuilder builder)
-    {
-        var configuration = AppConfiguration.CreateEmpty();
-        builder.Configuration.Bind(configuration);
-        
-        var signalRBuilder = builder.Services.AddSignalR();
-
-        if (configuration.SignalR.UseRedis)
-            signalRBuilder.AddStackExchangeRedis(configuration.SignalR.RedisConnectionString);
-    }
-
-    private static void MapMoonlightSignalR(this WebApplication application)
-    {
-        application.MapHub<DiagnoseHub>("/api/admin/system/diagnose/ws");
-    }
-}

Moonlight.ApiServer/Startup/Startup.TickerQ.cs

@@ -0,0 +1,34 @@
+using Microsoft.Extensions.DependencyInjection;
+using Moonlight.ApiServer.Database;
+using Moonlight.ApiServer.Implementations;
+using TickerQ.DependencyInjection;
+using TickerQ.EntityFrameworkCore.DependencyInjection;
+
+namespace Moonlight.ApiServer.Startup;
+
+public partial class Startup
+{
+    private Task RegisterTickerQ()
+    {
+        WebApplicationBuilder.Services.AddTickerQ(builder =>
+        {
+            builder.SetExceptionHandler<TickerExceptionHandler>();
+
+            builder.AddOperationalStore<TickerDataContext>(optionBuilder =>
+            {
+                optionBuilder.CancelMissedTickersOnApplicationRestart();
+            });
+        });
+
+        WebApplicationBuilder.Services.AddDbContext<TickerDataContext>();
+        
+        return Task.CompletedTask;
+    }
+
+    private Task UseTickerQ()
+    {
+        WebApplication.UseTickerQ();
+        
+        return Task.CompletedTask;
+    }
+}

Moonlight.ApiServer/Startup/Startup.cs

@@ -1,42 +1,67 @@
 using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Logging;
+using Moonlight.ApiServer.Configuration;
 using Moonlight.ApiServer.Plugins;
 
 namespace Moonlight.ApiServer.Startup;
 
-public static partial class Startup
+public partial class Startup
 {
-    public static void AddMoonlight(this WebApplicationBuilder builder, IPluginStartup[] startups)
+    private string[] Args;
+
+    // Logger
+    public ILogger<Startup> Logger { get; private set; }
+
+    // Configuration
+    public AppConfiguration Configuration { get; private set; }
+
+    // WebApplication Stuff
+    public WebApplication WebApplication { get; private set; }
+    public WebApplicationBuilder WebApplicationBuilder { get; private set; }
+
+    public Task Initialize(string[] args, IPluginStartup[]? plugins = null)
     {
-        PrintVersionAsync();
-        CreateStorageAsync();
+        Args = args;
+        PluginStartups = plugins ?? [];
         
-        builder.AddConfiguration();
-        builder.AddLogging();
-        
-        builder.ConfigureKestrel();
-        builder.AddBase(startups);
-        builder.AddDatabase();
-        builder.AddAuth();
-        builder.AddMoonlightCors();
-        builder.AddMoonlightHangfire();
-        builder.AddMoonlightSignalR();
-        
-        builder.AddPlugins(startups);
+        return Task.CompletedTask;
     }
 
-    public static void UseMoonlight(this WebApplication application, IPluginStartup[] startups)
+    public async Task AddMoonlight(WebApplicationBuilder builder)
     {
-        application.UseBase();
-        application.UseMoonlightCors();
-        application.UseAuth();
-        application.UseMoonlightHangfire();
-        application.UsePlugins(startups);
+        WebApplicationBuilder = builder;
+
+        await PrintVersion();
+
+        await CreateStorage();
+        await SetupAppConfiguration();
+        await SetupLogging();
+        await InitializePlugins();
+
+        await ConfigureKestrel();
+        await RegisterAppConfiguration();
+        await RegisterLogging();
+        await RegisterBase();
+        await RegisterDatabase();
+        await RegisterAuth();
+        await RegisterCors();
+        await RegisterTickerQ();
+        await HookPluginBuild();
     }
 
-    public static void MapMoonlight(this WebApplication application, IPluginStartup[] startups)
+    public async Task AddMoonlight(WebApplication application)
     {
-        application.MapBase();
-        application.MapMoonlightSignalR();
-        application.MapPlugins(startups);
+        WebApplication = application;
+
+        await PrepareDatabase();
+
+        await UseCors();
+        await UseBase();
+        await UseAuth();
+        await UseTickerQ();
+        await HookPluginConfigure();
+
+        await MapBase();
+        await HookPluginEndpoints();
     }
 }

Moonlight.Client.Runtime/Moonlight.Client.Runtime.csproj

@@ -12,15 +12,11 @@
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="MoonCore.PluginFramework" Version="1.0.9" />
-        <PackageReference Include="MoonCore.PluginFramework.Generator" Version="1.0.3" />
+        <PackageReference Include="MoonCore.PluginFramework" Version="1.0.8" />
+        <PackageReference Include="MoonCore.PluginFramework.Generator" Version="1.0.2" />
 
-        <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="9.0.9" />
-        <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="9.0.9" PrivateAssets="all" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <Folder Include="wwwroot\css\" />
+        <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="9.0.5"/>
+        <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="9.0.5" PrivateAssets="all"/>
     </ItemGroup>
 
     <Import Project="Plugins.props" />

Moonlight.Client.Runtime/Program.cs

@@ -5,12 +5,16 @@ using Moonlight.Client.Startup;
 var pluginLoader = new PluginLoader();
 pluginLoader.Initialize();
 
-var builder = WebAssemblyHostBuilder.CreateDefault(args);
+var startup = new Startup();
 
-builder.AddMoonlight(pluginLoader.Instances);
+await startup.Initialize(pluginLoader.Instances);
 
-var app = builder.Build();
+var wasmHostBuilder = WebAssemblyHostBuilder.CreateDefault(args);
 
-app.ConfigureMoonlight(pluginLoader.Instances);
+await startup.AddMoonlight(wasmHostBuilder);
 
-await app.RunAsync();
+var wasmApp = wasmHostBuilder.Build();
+
+await startup.AddMoonlight(wasmApp);
+
+await wasmApp.RunAsync();

Moonlight.Client.Runtime/Styles/styles.css

@@ -9,10 +9,14 @@
 @theme {
     --font-inter: "Inter", var(--font-sans);
     --font-scp: "Source Code Pro", var(--font-mono);
+    
+    --color-background: var(--mooncore-color-background);
+    --color-base-150: var(--mooncore-color-base-150);
+    --color-base-250: var(--mooncore-color-base-250);
 }
 
 @plugin "flyonui" {
-    themes: moonlight --default;
+    themes: mooncore --default;
 }
 
 @source "./node_modules/flyonui/dist/index.js";
@@ -41,6 +45,41 @@
     width: var(--blazor-load-percentage, 0%);
 }
 
+@plugin "flyonui/theme" {
+    name: "mooncore";
+    default: true;
+    prefersdark: true;
+    color-scheme: "dark";
+    --color-base-100: var(--mooncore-color-base-100);
+    --color-base-200: var(--mooncore-color-base-200);
+    --color-base-300: var(--mooncore-color-base-300);
+    --color-base-content: var(--mooncore-color-base-content);
+    --color-primary: var(--mooncore-color-primary);
+    --color-primary-content: var(--mooncore-color-primary-content);
+    --color-secondary: var(--mooncore-color-secondary);
+    --color-secondary-content: var(--mooncore-color-secondary-content);
+    --color-accent: var(--mooncore-color-accent);
+    --color-accent-content: var(--mooncore-color-accent-content);
+    --color-neutral: var(--mooncore-color-neutral);
+    --color-neutral-content: var(--mooncore-color-neutral-content);
+    --color-info: var(--mooncore-color-info);
+    --color-info-content: var(--mooncore-color-info-content);
+    --color-success: var(--mooncore-color-success);
+    --color-success-content: var(--mooncore-color-success-content);
+    --color-warning: var(--mooncore-color-warning);
+    --color-warning-content: var(--mooncore-color-warning-content);
+    --color-error: var(--mooncore-color-error);
+    --color-error-content: var(--mooncore-color-error-content);
+    --radius-selector: var(--mooncore-radius-selector);
+    --radius-field: var(--mooncore-radius-field);
+    --radius-box: var(--mooncore-radius-box);
+    --size-selector: var(--mooncore-size-selector);
+    --size-field: var(--mooncore-size-field);
+    --border: var(--mooncore-border);
+    --depth: var(--mooncore-depth);
+    --noise: var(--mooncore-noise);
+}
+
 @layer utilities {
     .btn {
         @apply text-sm font-medium inline-flex items-center justify-center;
@@ -51,11 +90,15 @@
     }
     
     .input {
-        @apply !border-base-content/20 border-2 ring-0! outline-0! focus:border-primary! focus-within:border-primary! bg-base-100/50;
+        @apply !border-base-content/20 border-2 ring-0! outline-0! focus:border-primary! focus-within:border-primary! bg-base-200/50;
+    }
+    
+    .advance-select-toggle {
+        @apply !border-base-content/20 border-2 ring-0! outline-0! focus:border-primary! focus-within:border-primary! bg-base-200/50;
     }
 
     .select {
-        @apply !border-base-content/20 border-2 ring-0! outline-0! focus:border-primary! focus-within:border-primary! bg-base-100/50;
+        @apply !border-base-content/20 border-2 ring-0! outline-0! focus:border-primary! focus-within:border-primary! bg-base-200/50;
     }
     
     .table {
@@ -68,23 +111,7 @@
         @apply px-2.5 py-1.5 text-sm;
     }
     
-    .advance-select-menu {
-        @apply !border-base-content/20 border-2 ring-0! outline-0! bg-base-200/50 !pt-0 !px-0 !py-0;
-    }
-
-    .advance-select-option {
-        @apply !rounded-none hover:!bg-primary;
-    }
-
-    .advance-select-option.selected {
-        @apply !bg-primary !text-primary-content;
-    }
-
-    .advance-select-toggle {
-        @apply !border-base-content/20 border-2 ring-0! outline-0! focus:border-primary! focus-within:border-primary! bg-base-200/50;
-    }
-
-    .table thead {
-        @apply !normal-case;
+    .dropdown-menu {
+        @apply bg-base-150;
     }
 }

Moonlight.Client.Runtime/Styles/theme.css

@@ -1,35 +1,33 @@
-@plugin "flyonui/theme" {
-    name: "moonlight";
-    prefersdark: true;
-    color-scheme: "dark";
-
-    --color-base-100: #192032;
-    --color-base-200: #101522;
-    --color-base-300: #070a14;
-
-    --color-base-content: #dde5f5;
-    --color-primary: oklch(.511 .262 276.966);
-    --color-primary-content: #dde5f5;
-    --color-secondary: oklch(37% 0.034 259.733);
-    --color-secondary-content: #dde5f5;
-    --color-accent: oklch(49.1% 0.27 292.581);
-    --color-accent-content: #dde5f5;
-    --color-neutral: oklch(27% 0.041 260.031);
-    --color-neutral-content: oklch(92% 0.004 286.32);
-    --color-info: oklch(.546 .245 262.881);
-    --color-info-content: #dde5f5;
-    --color-success: oklch(.627 .194 149.214);
-    --color-success-content: #dde5f5;
-    --color-warning: oklch(.828 .189 84.429);
-    --color-warning-content: #dde5f5;
-    --color-error: oklch(.586 .253 17.585);
-    --color-error-content: #dde5f5;
-    --radius-selector: 0.25rem;
-    --radius-field: 0.5rem;
-    --radius-box: 0.5rem;
-    --size-selector: 0.25rem;
-    --size-field: 0.25rem;
-    --border: 1px;
-    --depth: 0;
-    --noise: 0;
+@theme {
+    --mooncore-color-background: #0c0f18;
+    --mooncore-color-base-100: #1e2b47;
+    --mooncore-color-base-150: #1a2640;
+    --mooncore-color-base-200: #101a2e;
+    --mooncore-color-base-250: #0f1729;
+    --mooncore-color-base-300: #0c1221;
+    --mooncore-color-base-content: #dde5f5;
+    --mooncore-color-primary: oklch(.511 .262 276.966);
+    --mooncore-color-primary-content: #dde5f5;
+    --mooncore-color-secondary: oklch(37% 0.034 259.733);
+    --mooncore-color-secondary-content: #dde5f5;
+    --mooncore-color-accent: oklch(.627 .265 303.9);
+    --mooncore-color-accent-content: #dde5f5;
+    --mooncore-color-neutral: #dde5f5;
+    --mooncore-color-neutral-content: oklch(14% 0.005 285.823);
+    --mooncore-color-info: oklch(.546 .245 262.881);
+    --mooncore-color-info-content: #dde5f5;
+    --mooncore-color-success: oklch(.627 .194 149.214);
+    --mooncore-color-success-content: #dde5f5;
+    --mooncore-color-warning: oklch(.828 .189 84.429);
+    --mooncore-color-warning-content: #dde5f5;
+    --mooncore-color-error: oklch(.586 .253 17.585);
+    --mooncore-color-error-content: #dde5f5;
+    --mooncore-radius-selector: 0.25rem;
+    --mooncore-radius-field: 0.5rem;
+    --mooncore-radius-box: 0.5rem;
+    --mooncore-size-selector: 0.25rem;
+    --mooncore-size-field: 0.25rem;
+    --mooncore-border: 1px;
+    --mooncore-depth: 0;
+    --mooncore-noise: 0;
 }

Moonlight.Client/IAssemblyMarker.cs

@@ -1,3 +0,0 @@
-namespace Moonlight.Client;
-
-public interface IAssemblyMarker;

Moonlight.Client/Implementations/CoreStartup.cs

@@ -7,14 +7,14 @@ namespace Moonlight.Client.Implementations;
 
 public class CoreStartup : IPluginStartup
 {
-    public void AddPlugin(WebAssemblyHostBuilder builder)
+    public Task BuildApplication(IServiceProvider serviceProvider, WebAssemblyHostBuilder builder)
     {
         builder.Services.AddSingleton<ISidebarItemProvider, DefaultSidebarItemProvider>();
         builder.Services.AddSingleton<IOverviewElementProvider, DefaultOverviewElementProvider>();
+        
+        return Task.CompletedTask;
     }
 
-    public void ConfigurePlugin(WebAssemblyHost app)
-    {
-        
-    }
+    public Task ConfigureApplication(IServiceProvider serviceProvider, WebAssemblyHost app)
+        => Task.CompletedTask;
 }

Moonlight.Client/Implementations/LogErrorFilter.cs

@@ -1,19 +0,0 @@
-using MoonCore.Blazor.FlyonUi.Exceptions;
-
-namespace Moonlight.Client.Implementations;
-
-public class LogErrorFilter : IGlobalErrorFilter
-{
-    private readonly ILogger<LogErrorFilter> Logger;
-
-    public LogErrorFilter(ILogger<LogErrorFilter> logger)
-    {
-        Logger = logger;
-    }
-
-    public Task<bool> HandleExceptionAsync(Exception ex)
-    {
-        Logger.LogError(ex, "Global error processed");
-        return Task.FromResult(false);
-    }
-}

Moonlight.Client/Implementations/SystemFsAccess.cs

@@ -1,13 +1,11 @@
 using MoonCore.Blazor.FlyonUi.Files;
 using MoonCore.Blazor.FlyonUi.Files.Manager;
-using MoonCore.Blazor.FlyonUi.Files.Manager.Abstractions;
 using MoonCore.Helpers;
-using Moonlight.Shared.Http.Requests.Admin.Sys.Files;
 using Moonlight.Shared.Http.Responses.Admin.Sys;
 
 namespace Moonlight.Client.Implementations;
 
-public class SystemFsAccess : IFsAccess, ICombineAccess, IArchiveAccess, IDownloadUrlAccess
+public class SystemFsAccess : IFsAccess
 {
     private readonly HttpApiClient ApiClient;
     
@@ -18,21 +16,21 @@ public class SystemFsAccess : IFsAccess, ICombineAccess, IArchiveAccess, IDownlo
         ApiClient = apiClient;
     }
 
-    public async Task CreateFileAsync(string path)
+    public async Task CreateFile(string path)
     {
         await ApiClient.Post(
             $"{BaseApiUrl}/touch?path={path}"
         );
     }
 
-    public async Task CreateDirectoryAsync(string path)
+    public async Task CreateDirectory(string path)
     {
         await ApiClient.Post(
             $"{BaseApiUrl}/mkdir?path={path}"
         );
     }
 
-    public async Task<FsEntry[]> ListAsync(string path)
+    public async Task<FsEntry[]> List(string path)
     {
         var entries = await ApiClient.GetJson<FileSystemEntryResponse[]>(
             $"{BaseApiUrl}/list?path={path}"
@@ -48,107 +46,43 @@ public class SystemFsAccess : IFsAccess, ICombineAccess, IArchiveAccess, IDownlo
         }).ToArray();
     }
 
-    public async Task MoveAsync(string oldPath, string newPath)
+    public async Task Move(string oldPath, string newPath)
     {
         await ApiClient.Post(
             $"{BaseApiUrl}/move?oldPath={oldPath}&newPath={newPath}"
         );
     }
 
-    public async Task ReadAsync(string path, Func<Stream, Task> onHandleData)
+    public Task Read(string path, Func<Stream, Task> onHandleData)
     {
-        await using var stream = await ApiClient.GetStream(
-            $"{BaseApiUrl}/download?path={path}"
-        );
-
-        await onHandleData.Invoke(stream);
-
-        stream.Close();
+        throw new NotImplementedException();
     }
 
-    public async Task WriteAsync(string path, Stream dataStream)
+    public Task Write(string path, Stream dataStream)
     {
-        using var multiPartForm = new MultipartFormDataContent();
-
-        multiPartForm.Add(new StreamContent(dataStream), "file", "file");
-
-        await ApiClient.Post(
-            $"{BaseApiUrl}/upload?path={path}",
-            multiPartForm
-        );
+        throw new NotImplementedException();
     }
 
-    public async Task DeleteAsync(string path)
+    public async Task Delete(string path)
     {
         await ApiClient.Delete(
             $"{BaseApiUrl}/delete?path={path}"
         );
     }
 
-    public async Task CombineAsync(string destination, string[] files)
+    public async Task UploadChunk(string path, int chunkId, long chunkSize, long totalSize, byte[] data)
     {
+        using var formContent = new MultipartFormDataContent();
+        formContent.Add(new ByteArrayContent(data), "file", "file");
+        
         await ApiClient.Post(
-            $"{BaseApiUrl}/combine",
-            new CombineRequest()
-            {
-                Destination = destination,
-                Files = files
-            }
+            $"{BaseApiUrl}/upload?path={path}&chunkId={chunkId}&chunkSize={chunkSize}&totalSize={totalSize}",
+            formContent
         );
     }
 
-    public ArchiveFormat[] ArchiveFormats { get; } =
-    [
-        new("zip", ["zip"], "Zip Archive"),
-        new("tar.gz", ["tar.gz"], "Tar.gz Archive")
-    ];
-
-    public async Task ArchiveAsync(
-        string destination,
-        ArchiveFormat format,
-        string root,
-        FsEntry[] files,
-        Func<string, Task>? onProgress = null
-    )
+    public Task<byte[]> DownloadChunk(string path, int chunkId, long chunkSize)
     {
-        await ApiClient.Post($"{BaseApiUrl}/compress", new CompressRequest()
-        {
-            Destination = destination,
-            Items = files.Select(x => x.Name).ToArray(),
-            Root = root,
-            Format = format.Identifier
-        });
-    }
-
-    public async Task UnarchiveAsync(
-        string path,
-        ArchiveFormat format,
-        string destination,
-        Func<string, Task>? onProgress = null)
-    {
-        await ApiClient.Post(
-            $"{BaseApiUrl}/decompress",
-            new DecompressRequest()
-            {
-                Format = format.Identifier,
-                Destination = destination,
-                Path = path
-            }
-        );
-    }
-
-    public async Task<string> GetFileUrlAsync(string path)
-        => await GetDownloadUrlAsync(path);
-
-    public async Task<string> GetFolderUrlAsync(string path)
-        => await GetDownloadUrlAsync(path);
-
-    private async Task<string> GetDownloadUrlAsync(string path)
-    {
-        var response = await ApiClient.PostJson<DownloadUrlResponse>(
-            $"{BaseApiUrl}/downloadUrl?path={path}"
-        );
-
-        return response.Url;
+        throw new NotImplementedException();
     }
 }

Moonlight.Client/Implementations/UnauthenticatedErrorFilter.cs

@@ -1,32 +0,0 @@
-using Microsoft.AspNetCore.Components;
-using MoonCore.Blazor.FlyonUi.Exceptions;
-using MoonCore.Blazor.FlyonUi.Toasts;
-using MoonCore.Exceptions;
-
-namespace Moonlight.Client.Implementations;
-
-public class UnauthenticatedErrorFilter : IGlobalErrorFilter
-{
-    private readonly NavigationManager Navigation;
-    private readonly ToastService ToastService;
-
-    public UnauthenticatedErrorFilter(
-        NavigationManager navigation,
-        ToastService toastService
-    )
-    {
-        Navigation = navigation;
-        ToastService = toastService;
-    }
-
-    public async Task<bool> HandleExceptionAsync(Exception ex)
-    {
-        if (ex is not HttpApiException { Status: 401 })
-            return false;
-
-        await ToastService.InfoAsync("Session expired", "Your session has expired. Reloading..");
-        
-        Navigation.NavigateTo("/api/auth/logout", true);
-        return true;
-    }
-}

Moonlight.Client/Models/ThemeTransferModel.cs

@@ -1,14 +0,0 @@
-using Moonlight.Shared.Misc;
-
-namespace Moonlight.Client.Models;
-
-public class ThemeTransferModel
-{
-    public string Name { get; set; }
-    public string Author { get; set; }
-    public string Version { get; set; }
-    public string? UpdateUrl { get; set; }
-    public string? DonateUrl { get; set; }
-
-    public ApplicationTheme Content { get; set; } = new();
-}

Moonlight.Client/Moonlight.Client.csproj

@@ -12,7 +12,7 @@
   <PropertyGroup>
     <PackageTags>frontend</PackageTags>
     <PackageId>Moonlight.Client</PackageId>
-    <Version>2.1.15</Version>
+    <Version>2.1.7</Version>
     <Authors>Moonlight Panel</Authors>
     <Description>A build of the client for moonlight development</Description>
     <PackageProjectUrl>https://github.com/Moonlight-Panel/Moonlight</PackageProjectUrl>
@@ -21,20 +21,26 @@
     <CompressionEnabled>false</CompressionEnabled>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Blazor-ApexCharts" Version="6.0.2" />
-    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="9.0.9" />
-    <PackageReference Include="Microsoft.AspNetCore.SignalR.Client" Version="9.0.9" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="9.0.8" />
-    <PackageReference Include="MoonCore" Version="2.0.6" />
-    <PackageReference Include="MoonCore.Blazor.FlyonUi" Version="1.3.4" />
-    <PackageReference Include="System.Security.Claims" Version="4.3.0" />
+    <PackageReference Include="Blazor-ApexCharts" Version="6.0.0" />
+    <PackageReference Include="MoonCore" Version="1.9.2" />
+    <PackageReference Include="MoonCore.Blazor" Version="1.3.1" />
+    <PackageReference Include="MoonCore.Blazor.FlyonUi" Version="1.0.9" />
   </ItemGroup>
   <ItemGroup>
     <Compile Remove="storage\**\*" />
     <Content Remove="storage\**\*" />
     <None Remove="storage\**\*" />
   </ItemGroup>
-  
+  <!-- 
+          Specify the /p:BuildPWA=true flag to build moonlight as a PWA.
+          This flag is by default disabled to allow nuget package generation
+      -->
+  <PropertyGroup Condition="'$(BuildPWA)' == 'true'">
+    <ServiceWorkerAssetsManifest>service-worker-assets.js</ServiceWorkerAssetsManifest>
+  </PropertyGroup>
+  <ItemGroup Condition="'$(BuildPWA)' == 'true'">
+    <ServiceWorker Include="wwwroot\service-worker.js" PublishedContent="wwwroot\service-worker.published.js" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Moonlight.Shared\Moonlight.Shared.csproj" />
   </ItemGroup>

Moonlight.Client/Plugins/IPluginStartup.cs

@@ -4,6 +4,6 @@ namespace Moonlight.Client.Plugins;
 
 public interface IPluginStartup
 {
-    public void AddPlugin(WebAssemblyHostBuilder builder);
-    public void ConfigurePlugin(WebAssemblyHost app);
+    public Task BuildApplication(IServiceProvider serviceProvider, WebAssemblyHostBuilder builder);
+    public Task ConfigureApplication(IServiceProvider serviceProvider, WebAssemblyHost app);
 }