UpdatecoverJob Migrations

Covers get updated on every pull
If a Manga has no DownloadAvailableChaptersJob, Cover is removed
Add endpoint POST Settings/CleanupCovers that removed covers not associated to any Manga

.dockerignore

@@ -1,25 +0,0 @@
-**/.dockerignore
-**/.env
-**/.git
-**/.gitignore
-**/.project
-**/.settings
-**/.toolstarget
-**/.vs
-**/.vscode
-**/.idea
-**/*.*proj.user
-**/*.dbmdl
-**/*.jfm
-**/azds.yaml
-**/bin
-**/charts
-**/docker-compose*
-**/Dockerfile*
-**/node_modules
-**/npm-debug.log
-**/obj
-**/secrets.dev.yaml
-**/values.dev.yaml
-LICENSE
-README.md

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,21 @@
+name: Bug Report
+description: File a bug report
+title: "[It broke]: "
+labels: ["bug"]
+body:
+- type: textarea
+  attributes:
+    label: What is broken?
+    description: What happened? How did we get here?
+    placeholder: The place where you tell me what you expected to happen, and what happened instead.
+  validations:
+    required: true
+- type: textarea
+  attributes: 
+    label: Log-output
+    description: The output of `docker logs tranga-api`
+    render: C#
+- type: textarea
+  attributes: 
+    label: Additional stuff
+    description: Screenshots, anything you think might help

.github/ISSUE_TEMPLATE/new_connector.yml

@@ -0,0 +1,23 @@
+name: New Connector Request
+description: Request a new site to be added
+title: "[New Connector]: "
+labels: ["New Connector"]
+body:
+  - type: input
+    attributes:
+      label: Website-Link
+      placeholder: https://
+    validations:
+      required: true
+  - type: checkboxes
+    attributes:
+      label: Is the Website free to access?
+      description: We can't support pay-to-use sites, or captcha-proxied sites as Cloudflare.
+      options:
+        - label: The Website is freely accessible.
+          required: true
+  - type: textarea
+    attributes:
+      label: Anything else?
+    validations:
+      required: false

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"

.github/workflows/docker-image-cuttingedge.yml

@@ -0,0 +1,45 @@
+name: Docker Image CI
+
+on:
+  push:
+    branches: [ "cuttingedge" ]
+  workflow_dispatch:
+
+jobs:
+
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:      
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # https://github.com/docker/setup-qemu-action#usage
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3.6.0
+
+      # https://github.com/marketplace/actions/docker-setup-buildx
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3.10.0
+      
+      # https://github.com/docker/login-action#docker-hub
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      
+      # https://github.com/docker/build-push-action#multi-platform-image
+      - name: Build and push API
+        uses: docker/build-push-action@v6.15.0
+        with:
+          context: ./
+          file: ./Dockerfile
+          #platforms: linux/amd64,linux/arm64,linux/riscv64,linux/ppc64le,linux/s390x,linux/386,linux/mips64le,linux/mips64,linux/arm/v7,linux/arm/v6
+          platforms: linux/amd64,linux/arm64
+          pull: true
+          push: true
+          tags: |
+            glax/tranga-api:cuttingedge

.github/workflows/docker-image-master.yml

@@ -0,0 +1,45 @@
+name: Docker Image CI
+
+on:
+  push:
+    branches: [ "master" ]
+  workflow_dispatch:
+
+jobs:
+
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # https://github.com/docker/setup-qemu-action#usage
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3.6.0
+
+      # https://github.com/marketplace/actions/docker-setup-buildx
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3.10.0
+      
+      # https://github.com/docker/login-action#docker-hub
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      
+      # https://github.com/docker/build-push-action#multi-platform-image
+      - name: Build and push API
+        uses: docker/build-push-action@v6.15.0
+        with:
+          context: ./
+          file: ./Dockerfile
+          #platforms: linux/amd64,linux/arm64,linux/riscv64,linux/ppc64le,linux/s390x,linux/386,linux/mips64le,linux/mips64,linux/arm/v7,linux/arm/v6
+          platforms: linux/amd64,linux/arm64
+          pull: true
+          push: true
+          tags: |
+            glax/tranga-api:latest

.github/workflows/docker-image-serverv2.yml

@@ -0,0 +1,45 @@
+name: Docker Image CI
+
+on:
+  push:
+    branches: [ "postgres-Server-V2" ]
+  workflow_dispatch:
+
+jobs:
+
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # https://github.com/docker/setup-qemu-action#usage
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3.6.0
+
+      # https://github.com/marketplace/actions/docker-setup-buildx
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3.10.0
+      
+      # https://github.com/docker/login-action#docker-hub
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      
+      # https://github.com/docker/build-push-action#multi-platform-image
+      - name: Build and push API
+        uses: docker/build-push-action@v6.15.0
+        with:
+          context: ./
+          file: ./Dockerfile
+          #platforms: linux/amd64,linux/arm64,linux/riscv64,linux/ppc64le,linux/s390x,linux/386,linux/mips64le,linux/mips64,linux/arm/v7,linux/arm/v6
+          platforms: linux/amd64,linux/arm64
+          pull: true
+          push: true
+          tags: |
+            glax/tranga-api:Server-V2

.gitignore

@@ -17,3 +17,11 @@ riderModule.iml
 /dataSources/
 /dataSources.local.xml
 /.idea
+cover.jpg
+cover.png
+/.vscode
+/.vs/
+Tranga/Properties/launchSettings.json
+/Manga
+/settings
+*.DotSettings.user

API/API.csproj

@@ -0,0 +1,39 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+    <PropertyGroup>
+        <TargetFramework>net9.0</TargetFramework>
+        <Nullable>enable</Nullable>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <NoWarn>$(NoWarn);1591</NoWarn>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" Version="8.1.0" />
+        <PackageReference Include="HtmlAgilityPack" Version="1.12.0" />
+        <PackageReference Include="log4net" Version="3.0.4" />
+        <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="9.0.3" />
+        <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.3" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.3">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Proxies" Version="9.0.5" />
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+        <PackageReference Include="Npgsql" Version="9.0.3" />
+        <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" />
+        <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL.Design" Version="1.1.0" />
+        <PackageReference Include="PuppeteerSharp" Version="20.1.3" />
+        <PackageReference Include="SixLabors.ImageSharp" Version="3.1.7" />
+        <PackageReference Include="Soenneker.Utils.String.NeedlemanWunsch" Version="3.0.929" />
+        <PackageReference Include="Swashbuckle.AspNetCore" Version="8.1.0" />
+        <PackageReference Include="Swashbuckle.AspNetCore.Newtonsoft" Version="8.1.0" />
+        <PackageReference Include="System.Drawing.Common" Version="9.0.3" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <Folder Include="Migrations\" />
+    </ItemGroup>
+
+</Project>

API/API.http

@@ -0,0 +1,6 @@
+@API_HostAddress = http://localhost:5105
+
+GET {{API_HostAddress}}/weatherforecast/
+Accept: application/json
+
+###

API/APIEndpointRecords/DownloadAvailableChaptersJobRecord.cs

@@ -0,0 +1,5 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace API.APIEndpointRecords;
+
+public record DownloadAvailableChaptersJobRecord([Required]string language, [Required]ulong recurrenceTimeMs, [Required]string localLibraryId);

API/APIEndpointRecords/GotifyRecord.cs

@@ -0,0 +1,16 @@
+namespace API.APIEndpointRecords;
+
+public record GotifyRecord(string endpoint, string appToken, int priority)
+{
+    public bool Validate()
+    {
+        if (endpoint == string.Empty)
+            return false;
+        if (appToken == string.Empty)
+            return false;
+        if (priority < 0 || priority > 10)
+            return false;
+
+        return true;
+    }
+}

API/APIEndpointRecords/ModifyJobRecord.cs

@@ -0,0 +1,3 @@
+namespace API.APIEndpointRecords;
+
+public record ModifyJobRecord(ulong? RecurrenceMs, bool? Enabled);

API/APIEndpointRecords/NewLibraryRecord.cs

@@ -0,0 +1,13 @@
+namespace API.APIEndpointRecords;
+
+public record NewLibraryRecord(string path, string name)
+{
+    public bool Validate()
+    {
+        if (path.Length < 1) //TODO Better Path validation
+            return false;
+        if (name.Length < 1)
+            return false;
+        return true;
+    }
+}

API/APIEndpointRecords/NtfyRecord.cs

@@ -0,0 +1,17 @@
+namespace API.APIEndpointRecords;
+
+public record NtfyRecord(string endpoint, string username, string password, string topic, int priority)
+{
+    public bool Validate()
+    {
+        if (endpoint == string.Empty)
+            return false;
+        if (username == string.Empty)
+            return false;
+        if (password == string.Empty)
+            return false;
+        if (priority < 1 || priority > 5)
+            return false;
+        return true;
+    }
+}

API/APIEndpointRecords/PushoverRecord.cs

@@ -0,0 +1,13 @@
+namespace API.APIEndpointRecords;
+
+public record PushoverRecord(string apptoken, string user)
+{
+    public bool Validate()
+    {
+        if (apptoken == string.Empty)
+            return false;
+        if (user == string.Empty)
+            return false;
+        return true;
+    }
+}

API/Controllers/JobController.cs

@@ -0,0 +1,369 @@
+using API.APIEndpointRecords;
+using API.Schema;
+using API.Schema.Contexts;
+using API.Schema.Jobs;
+using Asp.Versioning;
+using log4net;
+using Microsoft.AspNetCore.Mvc;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+// ReSharper disable InconsistentNaming
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Route("v{version:apiVersion}/[controller]")]
+public class JobController(PgsqlContext context, ILog Log) : Controller
+{
+    /// <summary>
+    /// Returns all Jobs
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet]
+    [ProducesResponseType<Job[]>(Status200OK, "application/json")]
+    public IActionResult GetAllJobs()
+    {
+        Job[] ret = context.Jobs.ToArray();
+        return Ok(ret);
+    }
+    
+    /// <summary>
+    /// Returns Jobs with requested Job-IDs
+    /// </summary>
+    /// <param name="ids">Array of Job-IDs</param>
+    /// <response code="200"></response>
+    [HttpPost("WithIDs")]
+    [ProducesResponseType<Job[]>(Status200OK, "application/json")]
+    public IActionResult GetJobs([FromBody]string[] ids)
+    {
+        Job[] ret = context.Jobs.Where(job => ids.Contains(job.JobId)).ToArray();
+        return Ok(ret);
+    }
+
+    /// <summary>
+    /// Get all Jobs in requested State
+    /// </summary>
+    /// <param name="JobState">Requested Job-State</param>
+    /// <response code="200"></response>
+    [HttpGet("State/{JobState}")]
+    [ProducesResponseType<Job[]>(Status200OK, "application/json")]
+    public IActionResult GetJobsInState(JobState JobState)
+    {
+        Job[] jobsInState = context.Jobs.Where(job => job.state == JobState).ToArray();
+        return Ok(jobsInState);
+    }
+
+    /// <summary>
+    /// Returns all Jobs of requested Type
+    /// </summary>
+    /// <param name="JobType">Requested Job-Type</param>
+    /// <response code="200"></response>
+    [HttpGet("Type/{JobType}")]
+    [ProducesResponseType<Job[]>(Status200OK, "application/json")]
+    public IActionResult GetJobsOfType(JobType JobType)
+    {
+        Job[] jobsOfType = context.Jobs.Where(job => job.JobType == JobType).ToArray();
+        return Ok(jobsOfType);
+    }
+
+    /// <summary>
+    /// Returns all Jobs of requested Type and State
+    /// </summary>
+    /// <param name="JobType">Requested Job-Type</param>
+    /// <param name="JobState">Requested Job-State</param>
+    /// <response code="200"></response>
+    [HttpGet("TypeAndState/{JobType}/{JobState}")]
+    [ProducesResponseType<Job[]>(Status200OK, "application/json")]
+    public IActionResult GetJobsOfType(JobType JobType, JobState JobState)
+    {
+        Job[] jobsOfType = context.Jobs.Where(job => job.JobType == JobType && job.state == JobState).ToArray();
+        return Ok(jobsOfType);
+    }
+
+    /// <summary>
+    /// Return Job with ID
+    /// </summary>
+    /// <param name="JobId">Job-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">Job with ID could not be found</response>
+    [HttpGet("{JobId}")]
+    [ProducesResponseType<Job>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetJob(string JobId)
+    {
+        Job? ret = context.Jobs.Find(JobId);
+        return (ret is not null) switch
+        {
+            true => Ok(ret),
+            false => NotFound()
+        };
+    }
+
+    /// <summary>
+    /// Create a new DownloadAvailableChaptersJob
+    /// </summary>
+    /// <param name="MangaId">ID of Manga</param>
+    /// <param name="record">Job-Configuration</param>
+    /// <response code="201">Job-IDs</response>
+    /// <response code="400">Could not find ToLibrary with ID</response>
+    /// <response code="404">Could not find Manga with ID</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("DownloadAvailableChaptersJob/{MangaId}")]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateDownloadAvailableChaptersJob(string MangaId, [FromBody]DownloadAvailableChaptersJobRecord record)
+    {
+        if (context.Mangas.Find(MangaId) is not { } m)
+            return NotFound();
+        else
+        {
+            try
+            {
+                LocalLibrary? l = context.LocalLibraries.Find(record.localLibraryId);
+                if (l is null)
+                    return BadRequest();
+                m.Library = l;
+                context.SaveChanges();
+            }
+            catch (Exception e)
+            {
+                Log.Error(e);
+                return StatusCode(500, e.Message);
+            }
+        }
+        Job retrieveChapters = new RetrieveChaptersJob(m, record.language, record.recurrenceTimeMs);
+        Job updateFilesDownloaded =
+            new UpdateChaptersDownloadedJob(m, record.recurrenceTimeMs, dependsOnJobs: [retrieveChapters]);
+        Job downloadChapters = new DownloadAvailableChaptersJob(m, record.recurrenceTimeMs, dependsOnJobs: [retrieveChapters, updateFilesDownloaded]);
+        Job UpdateCover = new UpdateCoverJob(m, record.recurrenceTimeMs, downloadChapters);
+        retrieveChapters.ParentJob = downloadChapters;
+        updateFilesDownloaded.ParentJob = retrieveChapters;
+        return AddJobs([retrieveChapters, downloadChapters, updateFilesDownloaded, UpdateCover]);
+    }
+
+    /// <summary>
+    /// Create a new DownloadSingleChapterJob
+    /// </summary>
+    /// <param name="ChapterId">ID of the Chapter</param>
+    /// <response code="201">Job-IDs</response>
+    /// <response code="404">Could not find Chapter with ID</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("DownloadSingleChapterJob/{ChapterId}")]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateNewDownloadChapterJob(string ChapterId)
+    {
+        if(context.Chapters.Find(ChapterId) is not { } c)
+            return NotFound();
+        Job job = new DownloadSingleChapterJob(c);
+        return AddJobs([job]);
+    }
+
+    /// <summary>
+    /// Create a new UpdateChaptersDownloadedJob
+    /// </summary>
+    /// <param name="MangaId">ID of the Manga</param>
+    /// <response code="201">Job-IDs</response>
+    /// <response code="201">Could not find Manga with ID</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("UpdateFilesJob/{MangaId}")]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateUpdateFilesDownloadedJob(string MangaId)
+    {
+        if(context.Mangas.Find(MangaId) is not { } m)
+            return NotFound();
+        Job job = new UpdateChaptersDownloadedJob(m, 0);
+        return AddJobs([job]);
+    }
+
+    /// <summary>
+    /// Create a new UpdateMetadataJob for all Manga
+    /// </summary>
+    /// <response code="201">Job-IDs</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("UpdateAllFilesJob")]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateUpdateAllFilesDownloadedJob()
+    {
+        List<UpdateChaptersDownloadedJob> jobs = context.Mangas.Select(m => new UpdateChaptersDownloadedJob(m, 0, null, null)).ToList();
+        try
+        {
+            context.Jobs.AddRange(jobs);
+            context.SaveChanges();
+            return Created();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Not Implemented: Create a new UpdateMetadataJob
+    /// </summary>
+    /// <param name="MangaId">ID of the Manga</param>
+    /// <response code="201">Job-IDs</response>
+    /// <response code="404">Could not find Manga with ID</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("UpdateMetadataJob/{MangaId}")]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateUpdateMetadataJob(string MangaId)
+    {
+        return StatusCode(Status501NotImplemented);
+    }
+
+    /// <summary>
+    /// Not Implemented: Create a new UpdateMetadataJob for all Manga
+    /// </summary>
+    /// <response code="201">Job-IDs</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("UpdateAllMetadataJob")]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateUpdateAllMetadataJob()
+    {
+        return StatusCode(Status501NotImplemented);
+    }
+    
+    private IActionResult AddJobs(Job[] jobs)
+    {
+        try
+        {
+            context.Jobs.AddRange(jobs);
+            context.SaveChanges();
+            return new CreatedResult((string?)null, jobs.Select(j => j.JobId).ToArray());
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Delete Job with ID and all children
+    /// </summary>
+    /// <param name="JobId">Job-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">Job could not be found</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpDelete("{JobId}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult DeleteJob(string JobId)
+    {
+        try
+        {
+            if(context.Jobs.Find(JobId) is not { } ret)
+                return NotFound();
+            
+            context.Remove(ret);
+            context.SaveChanges();
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    private IQueryable<Job> GetChildJobs(string parentJobId)
+    {
+        IQueryable<Job> children = context.Jobs.Where(j => j.ParentJobId == parentJobId);
+        foreach (Job child in children)
+            foreach (Job grandChild in GetChildJobs(child.JobId))
+                children.Append(grandChild);
+        return children;
+    }
+
+    /// <summary>
+    /// Modify Job with ID
+    /// </summary>
+    /// <param name="JobId">Job-ID</param>
+    /// <param name="modifyJobRecord">Fields to modify, set to null to keep previous value</param>
+    /// <response code="202">Job modified</response>
+    /// <response code="400">Malformed request</response>
+    /// <response code="404">Job with ID not found</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPatch("{JobId}")]
+    [ProducesResponseType<Job>(Status202Accepted, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult ModifyJob(string JobId, [FromBody]ModifyJobRecord modifyJobRecord)
+    {
+        try
+        {
+            Job? ret = context.Jobs.Find(JobId);
+            if(ret is null)
+                return NotFound();
+            
+            ret.RecurrenceMs = modifyJobRecord.RecurrenceMs ?? ret.RecurrenceMs;
+            ret.Enabled = modifyJobRecord.Enabled ?? ret.Enabled;
+
+            context.SaveChanges();
+            return new AcceptedResult(ret.JobId, ret);
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Starts the Job with the requested ID
+    /// </summary>
+    /// <param name="JobId">Job-ID</param>
+    /// <response code="202">Job started</response>
+    /// <response code="404">Job with ID not found</response>
+    /// <response code="409">Job was already running</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("{JobId}/Start")]
+    [ProducesResponseType(Status202Accepted)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType(Status409Conflict)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult StartJob(string JobId)
+    {
+        Job? ret = context.Jobs.Find(JobId);
+        if (ret is null)
+            return NotFound();
+        try
+        {
+            if (ret.state >= JobState.Running && ret.state < JobState.Completed)
+                return new ConflictResult();
+            ret.LastExecution = DateTime.UnixEpoch;
+            context.SaveChanges();
+            return Accepted();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Stops the Job with the requested ID
+    /// </summary>
+    /// <param name="JobId">Job-ID</param>
+    /// <remarks><h1>NOT IMPLEMENTED</h1></remarks>
+    [HttpPost("{JobId}/Stop")]
+    [ProducesResponseType(Status501NotImplemented)]
+    public IActionResult StopJob(string JobId)
+    {
+        return StatusCode(Status501NotImplemented);
+    }
+}

API/Controllers/LibraryConnectorController.cs

@@ -0,0 +1,100 @@
+using API.Schema;
+using API.Schema.Contexts;
+using API.Schema.LibraryConnectors;
+using Asp.Versioning;
+using log4net;
+using Microsoft.AspNetCore.Mvc;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Route("v{v:apiVersion}/[controller]")]
+public class LibraryConnectorController(LibraryContext context, ILog Log) : Controller
+{
+    /// <summary>
+    /// Gets all configured ToLibrary-Connectors
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet]
+    [ProducesResponseType<LibraryConnector[]>(Status200OK, "application/json")]
+    public IActionResult GetAllConnectors()
+    {
+        LibraryConnector[] connectors = context.LibraryConnectors.ToArray();
+        return Ok(connectors);
+    }
+    
+    /// <summary>
+    /// Returns ToLibrary-Connector with requested ID
+    /// </summary>
+    /// <param name="LibraryControllerId">ToLibrary-Connector-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">Connector with ID not found.</response>
+    [HttpGet("{LibraryControllerId}")]
+    [ProducesResponseType<LibraryConnector>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetConnector(string LibraryControllerId)
+    {
+        LibraryConnector? ret = context.LibraryConnectors.Find(LibraryControllerId);
+        return (ret is not null) switch
+        {
+            true => Ok(ret),
+            false => NotFound()
+        };
+    }
+    
+    /// <summary>
+    /// Creates a new ToLibrary-Connector
+    /// </summary>
+    /// <param name="libraryConnector">ToLibrary-Connector</param>
+    /// <response code="201"></response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut]
+    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateConnector([FromBody]LibraryConnector libraryConnector)
+    {
+        try
+        {
+            context.LibraryConnectors.Add(libraryConnector);
+            context.SaveChanges();
+            return Created();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+    
+    /// <summary>
+    /// Deletes the ToLibrary-Connector with the requested ID
+    /// </summary>
+    /// <param name="LibraryControllerId">ToLibrary-Connector-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">Connector with ID not found.</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpDelete("{LibraryControllerId}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult DeleteConnector(string LibraryControllerId)
+    {
+        try
+        {
+            LibraryConnector? ret = context.LibraryConnectors.Find(LibraryControllerId);
+            if (ret is null)
+                return NotFound();
+            
+            context.Remove(ret);
+            context.SaveChanges();
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+}

API/Controllers/LocalLibrariesController.cs

@@ -0,0 +1,164 @@
+using API.APIEndpointRecords;
+using API.Schema;
+using API.Schema.Contexts;
+using Asp.Versioning;
+using log4net;
+using Microsoft.AspNetCore.Mvc;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Route("v{v:apiVersion}/[controller]")]
+public class LocalLibrariesController(PgsqlContext context, ILog Log) : Controller
+{
+    [HttpGet]
+    [ProducesResponseType<LocalLibrary[]>(Status200OK, "application/json")]
+    public IActionResult GetLocalLibraries()
+    {
+        return Ok(context.LocalLibraries);
+    }
+
+    [HttpGet("{LibraryId}")]
+    [ProducesResponseType<LocalLibrary>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetLocalLibrary(string LibraryId)
+    {
+        LocalLibrary? library = context.LocalLibraries.Find(LibraryId);
+        if (library is null)
+            return NotFound();
+        return Ok(library);
+    }
+
+    [HttpPatch("{LibraryId}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult UpdateLocalLibrary(string LibraryId, [FromBody]NewLibraryRecord record)
+    {
+        LocalLibrary? library = context.LocalLibraries.Find(LibraryId);
+        if (library is null)
+            return NotFound();
+        if (record.Validate() == false)
+            return BadRequest();
+        
+        try
+        {
+            library.LibraryName = record.name;
+            library.BasePath = record.path;
+            context.SaveChanges();
+
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    [HttpPatch("{LibraryId}/ChangeBasePath")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult ChangeLibraryBasePath(string LibraryId, [FromBody] string newBasePath)
+    {
+        try
+        {
+            LocalLibrary? library = context.LocalLibraries.Find(LibraryId);
+            if (library is null)
+                return NotFound();
+
+            if (false) //TODO implement path check
+                return BadRequest();
+            
+            library.BasePath = newBasePath;
+            context.SaveChanges();
+
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+    
+    [HttpPatch("{LibraryId}/ChangeName")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult ChangeLibraryName(string LibraryId, [FromBody] string newName)
+    {
+        try
+        {
+            LocalLibrary? library = context.LocalLibraries.Find(LibraryId);
+            if (library is null)
+                return NotFound();
+
+            if(newName.Length < 1)
+                return BadRequest();
+            
+            library.LibraryName = newName;
+            context.SaveChanges();
+
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    [HttpPut]
+    [ProducesResponseType<LocalLibrary>(Status200OK, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateNewLibrary([FromBody]NewLibraryRecord library)
+    {
+        if (library.Validate() == false)
+            return BadRequest();
+        try
+        {
+            LocalLibrary newLibrary = new (library.path, library.name);
+            context.LocalLibraries.Add(newLibrary);
+            context.SaveChanges();
+
+            return Ok(newLibrary);
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+    
+    [HttpDelete("{LibraryId}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult DeleteLocalLibrary(string LibraryId)
+    {
+        
+        try
+        {
+            LocalLibrary? library = context.LocalLibraries.Find(LibraryId);
+            if (library is null)
+                return NotFound();
+            context.Remove(library);
+            context.SaveChanges();
+
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+}

API/Controllers/MangaConnectorController.cs

@@ -0,0 +1,107 @@
+using API.Schema.Contexts;
+using API.Schema.MangaConnectors;
+using Asp.Versioning;
+using log4net;
+using Microsoft.AspNetCore.Mvc;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Route("v{v:apiVersion}/[controller]")]
+public class MangaConnectorController(PgsqlContext context, ILog Log) : Controller
+{
+    /// <summary>
+    /// Get all available Connectors (Scanlation-Sites)
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet]
+    [ProducesResponseType<MangaConnector[]>(Status200OK, "application/json")]
+    public IActionResult GetConnectors()
+    {
+        MangaConnector[] connectors = context.MangaConnectors.ToArray();
+        return Ok(connectors);
+    }
+
+    /// <summary>
+    /// Returns the MangaConnector with the requested Name
+    /// </summary>
+    /// <param name="MangaConnectorName"></param>
+    /// <response code="200"></response>
+    /// <response code="404">Connector with ID not found.</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpGet("{MangaConnectorName}")]
+    [ProducesResponseType<MangaConnector>(Status200OK, "application/json")]
+    public IActionResult GetConnector(string MangaConnectorName)
+    {
+        try
+        {
+            if(context.MangaConnectors.Find(MangaConnectorName) is not { } connector)
+                return NotFound();
+
+            return Ok(connector);
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+    
+    /// <summary>
+    /// Get all enabled Connectors (Scanlation-Sites)
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet("enabled")]
+    [ProducesResponseType<MangaConnector[]>(Status200OK, "application/json")]
+    public IActionResult GetEnabledConnectors()
+    {
+        MangaConnector[] connectors = context.MangaConnectors.Where(c => c.Enabled == true).ToArray();
+        return Ok(connectors);
+    }
+    
+    /// <summary>
+    /// Get all disabled Connectors (Scanlation-Sites)
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet("disabled")]
+    [ProducesResponseType<MangaConnector[]>(Status200OK, "application/json")]
+    public IActionResult GetDisabledConnectors()
+    {
+        MangaConnector[] connectors = context.MangaConnectors.Where(c => c.Enabled == false).ToArray();
+        return Ok(connectors);
+    }
+
+    /// <summary>
+    /// Enabled or disables a Connector
+    /// </summary>
+    /// <param name="MangaConnectorName">ID of the connector</param>
+    /// <param name="enabled">Set true to enable</param>
+    /// <response code="200"></response>
+    /// <response code="404">Connector with ID not found.</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPatch("{MangaConnectorName}/SetEnabled/{enabled}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult SetEnabled(string MangaConnectorName, bool enabled)
+    {
+        try
+        {
+            MangaConnector? connector = context.MangaConnectors.Find(MangaConnectorName);
+            if (connector is null)
+                return NotFound();
+            
+            connector.Enabled = enabled;
+            context.SaveChanges();
+
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+}

API/Controllers/MangaController.cs

@@ -0,0 +1,352 @@
+using API.Schema;
+using API.Schema.Contexts;
+using API.Schema.Jobs;
+using Asp.Versioning;
+using log4net;
+using Microsoft.AspNetCore.Mvc;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Formats.Jpeg;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors.Transforms;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+// ReSharper disable InconsistentNaming
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Route("v{v:apiVersion}/[controller]")]
+public class MangaController(PgsqlContext context, ILog Log) : Controller
+{
+    /// <summary>
+    /// Returns all cached Manga
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet]
+    [ProducesResponseType<Manga[]>(Status200OK, "application/json")]
+    public IActionResult GetAllManga()
+    {
+        Manga[] ret = context.Mangas.ToArray();
+        return Ok(ret);
+    }
+    
+    /// <summary>
+    /// Returns all cached Manga with IDs
+    /// </summary>
+    /// <param name="ids">Array of Manga-IDs</param>
+    /// <response code="200"></response>
+    [HttpPost("WithIDs")]
+    [ProducesResponseType<Manga[]>(Status200OK, "application/json")]
+    public IActionResult GetManga([FromBody]string[] ids)
+    {
+        Manga[] ret = context.Mangas.Where(m => ids.Contains(m.MangaId)).ToArray();
+        return Ok(ret);
+    }
+
+    /// <summary>
+    /// Return Manga with ID
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">Manga with ID not found</response>
+    [HttpGet("{MangaId}")]
+    [ProducesResponseType<Manga>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetManga(string MangaId)
+    {
+        Manga? ret = context.Mangas.Find(MangaId);
+        if (ret is null)
+            return NotFound();
+        return Ok(ret);
+    }
+
+    /// <summary>
+    /// Delete Manga with ID
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">Manga with ID not found</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpDelete("{MangaId}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult DeleteManga(string MangaId)
+    {
+        try
+        {
+            Manga? ret = context.Mangas.Find(MangaId);
+            if (ret is null)
+                return NotFound();
+            
+            context.Remove(ret);
+            context.SaveChanges();
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Returns Cover of Manga
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <param name="width">If width is provided, height needs to also be provided</param>
+    /// <param name="height">If height is provided, width needs to also be provided</param>
+    /// <response code="200">JPEG Image</response>
+    /// <response code="204">Cover not loaded</response>
+    /// <response code="400">The formatting-request was invalid</response>
+    /// <response code="404">Manga with ID not found</response>
+    /// <response code="503">Retry later, downloading cover</response>
+    [HttpGet("{MangaId}/Cover")]
+    [ProducesResponseType<byte[]>(Status200OK,"image/jpeg")]
+    [ProducesResponseType(Status204NoContent)]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<int>(Status503ServiceUnavailable, "text/plain")]
+    public IActionResult GetCover(string MangaId, [FromQuery]int? width, [FromQuery]int? height)
+    {
+        if(context.Mangas.Find(MangaId) is not { } m)
+            return NotFound();
+        
+        if (!System.IO.File.Exists(m.CoverFileNameInCache))
+        {
+            List<Job> coverDownloadJobs = context.Jobs.Where(j => j.JobType == JobType.DownloadMangaCoverJob).ToList();
+            if (coverDownloadJobs.Any(j => j is DownloadMangaCoverJob dmc && dmc.MangaId == MangaId && dmc.state < JobState.Completed))
+            {
+                Response.Headers.Append("Retry-After", $"{TrangaSettings.startNewJobTimeoutMs * coverDownloadJobs.Count() * 2  / 1000:D}");
+                return StatusCode(Status503ServiceUnavailable, TrangaSettings.startNewJobTimeoutMs * coverDownloadJobs.Count() * 2  / 1000);
+            }
+            else
+                return NoContent();
+        }
+
+        Image image = Image.Load(m.CoverFileNameInCache);
+
+        if (width is { } w && height is { } h)
+        {
+            if (width < 10 || height < 10 || width > 65535 || height > 65535)
+                return BadRequest();
+            image.Mutate(i => i.ApplyProcessor(new ResizeProcessor(new ResizeOptions()
+            {
+                Mode = ResizeMode.Max,
+                Size = new Size(w, h)
+            }, image.Size)));
+        }
+        
+        using MemoryStream ms = new();
+        image.Save(ms, new JpegEncoder(){Quality = 100});
+        return File(ms.GetBuffer(), "image/jpeg");
+    }
+
+    /// <summary>
+    /// Returns all Chapters of Manga
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">Manga with ID not found</response>
+    [HttpGet("{MangaId}/Chapters")]
+    [ProducesResponseType<Chapter[]>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetChapters(string MangaId)
+    {
+        if(context.Mangas.Find(MangaId) is not { } m)
+            return NotFound();
+        
+        Chapter[] chapters = m.Chapters.ToArray();
+        return Ok(chapters);
+    }
+    
+    /// <summary>
+    /// Returns all downloaded Chapters for Manga with ID
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <response code="200"></response>
+    /// <response code="204">No available chapters</response>
+    /// <response code="404">Manga with ID not found.</response>
+    [HttpGet("{MangaId}/Chapters/Downloaded")]
+    [ProducesResponseType<Chapter[]>(Status200OK, "application/json")]
+    [ProducesResponseType(Status204NoContent)]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetChaptersDownloaded(string MangaId)
+    {
+        if(context.Mangas.Find(MangaId) is not { } m)
+            return NotFound();
+        
+        List<Chapter> chapters = m.Chapters.ToList();
+        if (chapters.Count == 0)
+            return NoContent();
+        
+        return Ok(chapters);
+    }
+    
+    /// <summary>
+    /// Returns all Chapters not downloaded for Manga with ID
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <response code="200"></response>
+    /// <response code="204">No available chapters</response>
+    /// <response code="404">Manga with ID not found.</response>
+    [HttpGet("{MangaId}/Chapters/NotDownloaded")]
+    [ProducesResponseType<Chapter[]>(Status200OK, "application/json")]
+    [ProducesResponseType(Status204NoContent)]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetChaptersNotDownloaded(string MangaId)
+    {
+        if(context.Mangas.Find(MangaId) is not { } m)
+            return NotFound();
+        
+        List<Chapter> chapters = m.Chapters.ToList();
+        if (chapters.Count == 0)
+            return NoContent();
+        
+        return Ok(chapters);
+    }
+    
+    /// <summary>
+    /// Returns the latest Chapter of requested Manga available on Website
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <response code="200"></response>
+    /// <response code="204">No available chapters</response>
+    /// <response code="404">Manga with ID not found.</response>
+    /// <response code="500">Could not retrieve the maximum chapter-number</response>
+    /// <response code="503">Retry after timeout, updating value</response>
+    [HttpGet("{MangaId}/Chapter/LatestAvailable")]
+    [ProducesResponseType<Chapter>(Status200OK, "application/json")]
+    [ProducesResponseType(Status204NoContent)]
+    [ProducesResponseType<string>(Status404NotFound, "text/plain")]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    [ProducesResponseType<int>(Status503ServiceUnavailable, "text/plain")]
+    public IActionResult GetLatestChapter(string MangaId)
+    {
+        if(context.Mangas.Find(MangaId) is not { } m)
+            return NotFound();
+        
+        List<Chapter> chapters = m.Chapters.ToList();
+        if (chapters.Count == 0)
+        {
+            List<Job> retrieveChapterJobs = context.Jobs.Where(j => j.JobType == JobType.RetrieveChaptersJob).ToList();
+            if (retrieveChapterJobs.Any(j => j is RetrieveChaptersJob rcj && rcj.MangaId == MangaId && rcj.state < JobState.Completed))
+            {
+                Response.Headers.Append("Retry-After", $"{TrangaSettings.startNewJobTimeoutMs * retrieveChapterJobs.Count() * 2 / 1000:D}");
+                return StatusCode(Status503ServiceUnavailable, TrangaSettings.startNewJobTimeoutMs * retrieveChapterJobs.Count() * 2/ 1000);
+            }else
+                return Ok(0);
+        }
+        
+        Chapter? max = chapters.Max();
+        if (max is null)
+            return StatusCode(500, "Max chapter could not be found");
+        
+        return Ok(max);
+    }
+    
+    /// <summary>
+    /// Returns the latest Chapter of requested Manga that is downloaded
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <response code="200"></response>
+    /// <response code="204">No available chapters</response>
+    /// <response code="404">Manga with ID not found.</response>
+    /// <response code="500">Could not retrieve the maximum chapter-number</response>
+    /// <response code="503">Retry after timeout, updating value</response>
+    [HttpGet("{MangaId}/Chapter/LatestDownloaded")]
+    [ProducesResponseType<Chapter>(Status200OK, "application/json")]
+    [ProducesResponseType(Status204NoContent)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    [ProducesResponseType<int>(Status503ServiceUnavailable, "text/plain")]
+    public IActionResult GetLatestChapterDownloaded(string MangaId)
+    {
+        if(context.Mangas.Find(MangaId) is not { } m)
+            return NotFound();
+        
+        List<Chapter> chapters = m.Chapters.ToList();
+        if (chapters.Count == 0)
+        {
+            List<Job> retrieveChapterJobs = context.Jobs.Where(j => j.JobType == JobType.RetrieveChaptersJob).ToList();
+            if (retrieveChapterJobs.Any(j => j is RetrieveChaptersJob rcj && rcj.MangaId == MangaId && rcj.state < JobState.Completed))
+            {
+                Response.Headers.Append("Retry-After", $"{TrangaSettings.startNewJobTimeoutMs * retrieveChapterJobs.Count() * 2  / 1000:D}");
+                return StatusCode(Status503ServiceUnavailable, TrangaSettings.startNewJobTimeoutMs * retrieveChapterJobs.Count() * 2  / 1000);
+            }else
+                return NoContent();
+        }
+        
+        Chapter? max = chapters.Max();
+        if (max is null)
+            return StatusCode(500, "Max chapter could not be found");
+        
+        return Ok(max);
+    }
+
+    /// <summary>
+    /// Configure the cut-off for Manga
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <param name="chapterThreshold">Threshold (Chapter Number)</param>
+    /// <response code="200"></response>
+    /// <response code="404">Manga with ID not found.</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPatch("{MangaId}/IgnoreChaptersBefore")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult IgnoreChaptersBefore(string MangaId, [FromBody]float chapterThreshold)
+    {
+        Manga? m = context.Mangas.Find(MangaId);
+        if (m is null)
+            return NotFound();
+        
+        try
+        {
+            m.IgnoreChaptersBefore = chapterThreshold;
+            context.SaveChanges();
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Move Manga to different ToLibrary
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <param name="LibraryId">ToLibrary-Id</param>
+    /// <response code="202">Folder is going to be moved</response>
+    /// <response code="404">MangaId or LibraryId not found</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("{MangaId}/ChangeLibrary/{LibraryId}")]
+    [ProducesResponseType(Status202Accepted)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult MoveFolder(string MangaId, string LibraryId)
+    {
+        if (context.Mangas.Find(MangaId) is not { } manga)
+            return NotFound();
+        if(context.LocalLibraries.Find(LibraryId) is not { } library)
+            return NotFound();
+
+        MoveMangaLibraryJob moveLibrary = new(manga, library);
+        UpdateChaptersDownloadedJob updateDownloadedFiles = new(manga, 0, dependsOnJobs: [moveLibrary]);
+        
+        try
+        {
+            context.Jobs.AddRange(moveLibrary, updateDownloadedFiles);
+            context.SaveChanges();
+            return Accepted();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+}

API/Controllers/NotificationConnectorController.cs

@@ -0,0 +1,192 @@
+using System.Text;
+using API.APIEndpointRecords;
+using API.Schema.Contexts;
+using API.Schema.NotificationConnectors;
+using Asp.Versioning;
+using log4net;
+using Microsoft.AspNetCore.Mvc;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Produces("application/json")]
+[Route("v{v:apiVersion}/[controller]")]
+public class NotificationConnectorController(NotificationsContext context, ILog Log) : Controller
+{
+    /// <summary>
+    /// Gets all configured Notification-Connectors
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet]
+    [ProducesResponseType<NotificationConnector[]>(Status200OK, "application/json")]
+    public IActionResult GetAllConnectors()
+    {
+        NotificationConnector[] ret = context.NotificationConnectors.ToArray();
+        return Ok(ret);
+    }
+    
+    /// <summary>
+    /// Returns Notification-Connector with requested ID
+    /// </summary>
+    /// <param name="NotificationConnectorId">Notification-Connector-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">NotificationConnector with ID not found</response>
+    [HttpGet("{NotificationConnectorId}")]
+    [ProducesResponseType<NotificationConnector>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetConnector(string NotificationConnectorId)
+    {
+        NotificationConnector? ret = context.NotificationConnectors.Find(NotificationConnectorId);
+        return (ret is not null) switch
+        {
+            true => Ok(ret),
+            false => NotFound()
+        };
+    }
+    
+    /// <summary>
+    /// Creates a new REST-Notification-Connector
+    /// </summary>
+    /// <remarks>Formatting placeholders: "%title" and "%text" can be placed in url, header-values and body and will be replaced when notifications are sent</remarks>
+    /// <param name="notificationConnector">Notification-Connector</param>
+    /// <response code="201">ID of new connector</response>
+    /// <response code="409">A NotificationConnector with name already exists</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
+    [ProducesResponseType(Status409Conflict)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateConnector([FromBody]NotificationConnector notificationConnector)
+    {
+        if (context.NotificationConnectors.Find(notificationConnector.Name) is not null)
+            return Conflict();
+        try
+        {
+            context.NotificationConnectors.Add(notificationConnector);
+            context.SaveChanges();
+            return Created(notificationConnector.Name, notificationConnector);
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+    
+    /// <summary>
+    /// Creates a new Gotify-Notification-Connector
+    /// </summary>
+    /// <remarks>Priority needs to be between 0 and 10</remarks>
+    /// <response code="201">ID of new connector</response>
+    /// <response code="400"></response>
+    /// <response code="409">A NotificationConnector with name already exists</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("Gotify")]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status409Conflict)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateGotifyConnector([FromBody]GotifyRecord gotifyData)
+    {
+        if(!gotifyData.Validate())
+            return BadRequest();
+        
+        NotificationConnector gotifyConnector = new NotificationConnector(TokenGen.CreateToken("Gotify"),
+            gotifyData.endpoint, 
+            new Dictionary<string, string>() { { "X-Gotify-Key", gotifyData.appToken } }, 
+            "POST", 
+            $"{{\"message\": \"%text\", \"title\": \"%title\", \"priority\": {gotifyData.priority}}}");
+        return CreateConnector(gotifyConnector);
+    }
+    
+    /// <summary>
+    /// Creates a new Ntfy-Notification-Connector
+    /// </summary>
+    /// <remarks>Priority needs to be between 1 and 5</remarks>
+    /// <response code="201">ID of new connector</response>
+    /// <response code="400"></response>
+    /// <response code="409">A NotificationConnector with name already exists</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("Ntfy")]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status409Conflict)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateNtfyConnector([FromBody]NtfyRecord ntfyRecord)
+    {
+        if(!ntfyRecord.Validate())
+            return BadRequest();
+        
+        string authHeader = "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes($"{ntfyRecord.username}:{ntfyRecord.password}"));
+        string auth = Convert.ToBase64String(Encoding.UTF8.GetBytes(authHeader)).Replace("=","");
+        
+        NotificationConnector ntfyConnector = new (TokenGen.CreateToken("Ntfy"),
+            $"{ntfyRecord.endpoint}?auth={auth}", 
+            new Dictionary<string, string>()
+            {
+                {"Title", "%title"},
+                {"Priority", ntfyRecord.priority.ToString()},
+            }, 
+            "POST", 
+            "%text");
+        return CreateConnector(ntfyConnector);
+    }
+    
+    /// <summary>
+    /// Creates a new Pushover-Notification-Connector
+    /// </summary>
+    /// <remarks>https://pushover.net/api</remarks>
+    /// <response code="201">ID of new connector</response>
+    /// <response code="400"></response>
+    /// <response code="409">A NotificationConnector with name already exists</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("Pushover")]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status409Conflict)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreatePushoverConnector([FromBody]PushoverRecord pushoverRecord)
+    {
+        if(!pushoverRecord.Validate())
+            return BadRequest();
+        
+        NotificationConnector pushoverConnector = new  (TokenGen.CreateToken("Pushover"),
+            $"https://api.pushover.net/1/messages.json", 
+            new Dictionary<string, string>(),
+            "POST", 
+            $"{{\"token\": \"{pushoverRecord.apptoken}\", \"user\": \"{pushoverRecord.user}\", \"message:\":\"%text\", \"%title\" }}");
+        return CreateConnector(pushoverConnector);
+    }
+    
+    /// <summary>
+    /// Deletes the Notification-Connector with the requested ID
+    /// </summary>
+    /// <param name="NotificationConnectorId">Notification-Connector-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">NotificationConnector with ID not found</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpDelete("{NotificationConnectorId}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult DeleteConnector(string NotificationConnectorId)
+    {
+        try
+        {
+            NotificationConnector? ret = context.NotificationConnectors.Find(NotificationConnectorId);
+            if(ret is null)
+                return NotFound();
+            
+            context.Remove(ret);
+            context.SaveChanges();
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+}

API/Controllers/QueryController.cs

@@ -0,0 +1,112 @@
+using API.Schema;
+using API.Schema.Contexts;
+using Asp.Versioning;
+using log4net;
+using Microsoft.AspNetCore.Mvc;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+// ReSharper disable InconsistentNaming
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Route("v{v:apiVersion}/[controller]")]
+public class QueryController(PgsqlContext context, ILog Log) : Controller
+{
+    /// <summary>
+    /// Returns the Author-Information for Author-ID
+    /// </summary>
+    /// <param name="AuthorId">Author-Id</param>
+    /// <response code="200"></response>
+    /// <response code="404">Author with ID not found</response>
+    [HttpGet("Author/{AuthorId}")]
+    [ProducesResponseType<Author>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetAuthor(string AuthorId)
+    {
+        Author? ret = context.Authors.Find(AuthorId);
+        if (ret is null)
+            return NotFound();
+        return Ok(ret);
+    }
+    
+    /// <summary>
+    /// Returns all Mangas which where Authored by Author with AuthorId
+    /// </summary>
+    /// <param name="AuthorId">Author-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">Author not found</response>
+    [HttpGet("Mangas/WithAuthorId/{AuthorId}")]
+    [ProducesResponseType<Manga[]>(Status200OK, "application/json")]
+    public IActionResult GetMangaWithAuthorIds(string AuthorId)
+    {
+        if(context.Authors.Find(AuthorId) is not { } a)
+            return NotFound();
+        return Ok(context.Mangas.Where(m => m.Authors.Contains(a)));
+    }
+    /*
+    /// <summary>
+    /// Returns Link-Information for Link-Id
+    /// </summary>
+    /// <param name="LinkId"></param>
+    /// <response code="200"></response>
+    /// <response code="404">Link with ID not found</response>
+    [HttpGet("Link/{LinkId}")]
+    [ProducesResponseType<Link>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetLink(string LinkId)
+    {
+        Link? ret = context.Links.Find(LinkId);
+        if (ret is null)
+            return NotFound();
+        return Ok(ret);
+    }
+    
+    /// <summary>
+    /// Returns AltTitle-Information for AltTitle-Id
+    /// </summary>
+    /// <param name="AltTitleId"></param>
+    /// <response code="200"></response>
+    /// <response code="404">AltTitle with ID not found</response>
+    [HttpGet("AltTitle/{AltTitleId}")]
+    [ProducesResponseType<MangaAltTitle>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetAltTitle(string AltTitleId)
+    {
+        MangaAltTitle? ret = context.AltTitles.Find(AltTitleId);
+        if (ret is null)
+            return NotFound();
+        return Ok(ret);
+    }*/
+    
+    /// <summary>
+    /// Returns all Manga with Tag
+    /// </summary>
+    /// <param name="Tag"></param>
+    /// <response code="200"></response>
+    /// <response code="404">Tag not found</response>
+    [HttpGet("Mangas/WithTag/{Tag}")]
+    [ProducesResponseType<Manga[]>(Status200OK, "application/json")]
+    public IActionResult GetMangasWithTag(string Tag)
+    {
+        if(context.Tags.Find(Tag) is not { } t)
+            return NotFound();
+        return Ok(context.Mangas.Where(m => m.MangaTags.Contains(t)));
+    }
+    
+    /// <summary>
+    /// Returns Chapter-Information for Chapter-Id
+    /// </summary>
+    /// <param name="ChapterId"></param>
+    /// <response code="200"></response>
+    /// <response code="404">Chapter with ID not found</response>
+    [HttpGet("Chapter/{ChapterId}")]
+    [ProducesResponseType<Chapter>(Status200OK, "application/json")]
+    public IActionResult GetChapter(string ChapterId)
+    {
+        Chapter? ret = context.Chapters.Find(ChapterId);
+        if (ret is null)
+            return NotFound();
+        return Ok(ret);
+    }
+}

API/Controllers/SearchController.cs

@@ -0,0 +1,148 @@
+using API.Schema;
+using API.Schema.Contexts;
+using API.Schema.Jobs;
+using API.Schema.MangaConnectors;
+using Asp.Versioning;
+using log4net;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Soenneker.Utils.String.NeedlemanWunsch;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+// ReSharper disable InconsistentNaming
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Route("v{v:apiVersion}/[controller]")]
+public class SearchController(PgsqlContext context, ILog Log) : Controller
+{
+    /// <summary>
+    /// Initiate a search for a Manga on a specific Connector
+    /// </summary>
+    /// <param name="MangaConnectorName"></param>
+    /// <param name="Query"></param>
+    /// <response code="200"></response>
+    /// <response code="404">MangaConnector with ID not found</response>
+    /// <response code="406">MangaConnector with ID is disabled</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpGet("{MangaConnectorName}/{Query}")]
+    [ProducesResponseType<Manga[]>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType(Status406NotAcceptable)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult SearchManga(string MangaConnectorName, string Query)
+    {
+        if(context.MangaConnectors.Find(MangaConnectorName) is not { } connector)
+            return NotFound();
+        else if (connector.Enabled is false)
+            return StatusCode(Status406NotAcceptable);
+        
+        Manga[] mangas = connector.SearchManga(Query);
+        List<Manga> retMangas = new();
+        foreach (Manga manga in mangas)
+        {
+            try
+            {
+                if(AddMangaToContext(manga) is { } add)
+                    retMangas.Add(add);
+            }
+            catch (DbUpdateException e)
+            {
+                Log.Error(e);
+                return StatusCode(Status500InternalServerError, e.Message);
+            }
+        }
+
+        return Ok(retMangas.ToArray());
+    }
+    
+    /// <summary>
+    /// Search for a known Manga
+    /// </summary>
+    /// <param name="Query"></param>
+    /// <response code="200"></response>
+    [HttpGet("Local/{Query}")]
+    [ProducesResponseType<Manga[]>(Status200OK, "application/json")]
+    public IActionResult SearchMangaLocally(string Query)
+    {
+        Dictionary<Manga, double> distance = context.Mangas
+            .ToArray()
+            .ToDictionary(m => m, m => NeedlemanWunschStringUtil.CalculateSimilarityPercentage(Query, m.Name));
+        return Ok(distance.Where(kv => kv.Value > 50).OrderByDescending(kv => kv.Value).Select(kv => kv.Key).ToArray());
+    }
+
+    /// <summary>
+    /// Returns Manga from MangaConnector associated with URL
+    /// </summary>
+    /// <param name="url">Manga-Page URL</param>
+    /// <response code="200"></response>
+    /// <response code="300">Multiple connectors found for URL</response>
+    /// <response code="400">No Manga at URL</response>
+    /// <response code="404">No connector found for URL</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("Url")]
+    [ProducesResponseType<Manga>(Status200OK, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult GetMangaFromUrl([FromBody]string url)
+    {
+        if (context.MangaConnectors.Find("Global") is not { } connector)
+            return StatusCode(Status500InternalServerError, "Could not find Global Connector.");
+
+        if(connector.GetMangaFromUrl(url) is not { } manga)
+            return BadRequest();
+        try
+        {
+            if(AddMangaToContext(manga) is { } add)
+                return Ok(add);
+            return StatusCode(Status500InternalServerError);
+        }
+        catch (DbUpdateException e)
+        {
+            Log.Error(e);
+            return StatusCode(Status500InternalServerError, e.Message);
+        }
+    }
+    
+    private Manga? AddMangaToContext(Manga manga)
+    {
+        context.Mangas.Load();
+        context.Authors.Load();
+        context.Tags.Load();
+        context.MangaConnectors.Load();
+        
+        IEnumerable<MangaTag> mergedTags = manga.MangaTags.Select(mt =>
+        {
+            MangaTag? inDb = context.Tags.Find(mt.Tag);
+            return inDb ?? mt;
+        });
+        manga.MangaTags = mergedTags.ToList();
+
+        IEnumerable<Author> mergedAuthors = manga.Authors.Select(ma =>
+        {
+            Author? inDb = context.Authors.Find(ma.AuthorId);
+            return inDb ?? ma;
+        });
+        manga.Authors = mergedAuthors.ToList();
+
+        try
+        {
+
+            if (context.Mangas.Find(manga.MangaId) is { } r)
+            {
+                context.Mangas.Remove(r);
+                context.SaveChanges();
+            }
+            context.Mangas.Add(manga);
+            context.Jobs.Add(new DownloadMangaCoverJob(manga));
+            context.SaveChanges();
+        }
+        catch (DbUpdateException e)
+        {
+            Log.Error(e);
+            return null;
+        }
+        return manga;
+    }
+}

API/Controllers/SettingsController.cs

@@ -0,0 +1,294 @@
+using API.MangaDownloadClients;
+using API.Schema;
+using API.Schema.Contexts;
+using API.Schema.Jobs;
+using Asp.Versioning;
+using log4net;
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json.Linq;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Route("v{v:apiVersion}/[controller]")]
+public class SettingsController(PgsqlContext context, ILog Log) : Controller
+{
+    /// <summary>
+    /// Get all Settings
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet]
+    [ProducesResponseType<JObject>(Status200OK, "application/json")]
+    public IActionResult GetSettings()
+    {
+        return Ok(JObject.Parse(TrangaSettings.Serialize()));
+    }
+    
+    /// <summary>
+    /// Get the current UserAgent used by Tranga
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet("UserAgent")]
+    [ProducesResponseType<string>(Status200OK, "text/plain")]
+    public IActionResult GetUserAgent()
+    {
+        return Ok(TrangaSettings.userAgent);
+    }
+    
+    /// <summary>
+    /// Set a new UserAgent
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpPatch("UserAgent")]
+    [ProducesResponseType(Status200OK)]
+    public IActionResult SetUserAgent([FromBody]string userAgent)
+    {
+        TrangaSettings.UpdateUserAgent(userAgent);
+        return Ok();
+    }
+    
+    /// <summary>
+    /// Reset the UserAgent to default
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpDelete("UserAgent")]
+    [ProducesResponseType(Status200OK)]
+    public IActionResult ResetUserAgent()
+    {
+        TrangaSettings.UpdateUserAgent(TrangaSettings.DefaultUserAgent);
+        return Ok();
+    }
+    
+    /// <summary>
+    /// Get all Request-Limits
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet("RequestLimits")]
+    [ProducesResponseType<Dictionary<RequestType,int>>(Status200OK, "application/json")]
+    public IActionResult GetRequestLimits()
+    {
+        return Ok(TrangaSettings.requestLimits);
+    }
+    
+    /// <summary>
+    /// Update all Request-Limits to new values
+    /// </summary>
+    /// <remarks><h1>NOT IMPLEMENTED</h1></remarks>
+    [HttpPatch("RequestLimits")]
+    [ProducesResponseType(Status501NotImplemented)]
+    public IActionResult SetRequestLimits()
+    {
+        return StatusCode(501);
+    }
+
+    /// <summary>
+    /// Updates a Request-Limit value
+    /// </summary>
+    /// <param name="RequestType">Type of Request</param>
+    /// <param name="requestLimit">New limit in Requests/Minute</param>
+    /// <response code="200"></response>
+    /// <response code="400">Limit needs to be greater than 0</response>
+    [HttpPatch("RequestLimits/{RequestType}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status400BadRequest)]
+    public IActionResult SetRequestLimit(RequestType RequestType, [FromBody]int requestLimit)
+    {
+        if (requestLimit <= 0)
+            return BadRequest();
+        TrangaSettings.UpdateRequestLimit(RequestType, requestLimit);
+        return Ok();
+    }
+    
+    /// <summary>
+    /// Reset Request-Limit
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpDelete("RequestLimits/{RequestType}")]
+    [ProducesResponseType<string>(Status200OK)]
+    public IActionResult ResetRequestLimits(RequestType RequestType)
+    {
+        TrangaSettings.UpdateRequestLimit(RequestType, TrangaSettings.DefaultRequestLimits[RequestType]);
+        return Ok();
+    }
+    
+    /// <summary>
+    /// Reset Request-Limit
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpDelete("RequestLimits")]
+    [ProducesResponseType<string>(Status200OK)]
+    public IActionResult ResetRequestLimits()
+    {
+        TrangaSettings.ResetRequestLimits();
+        return Ok();
+    }
+    
+    /// <summary>
+    /// Returns Level of Image-Compression for Images
+    /// </summary>
+    /// <response code="200">JPEG compression-level as Integer</response>
+    [HttpGet("ImageCompression")]
+    [ProducesResponseType<int>(Status200OK, "text/plain")]
+    public IActionResult GetImageCompression()
+    {
+        return Ok(TrangaSettings.compression);
+    }
+    
+    /// <summary>
+    /// Set the Image-Compression-Level for Images
+    /// </summary>
+    /// <param name="level">100 to disable, 0-99 for JPEG compression-Level</param>
+    /// <response code="200"></response>
+    /// <response code="400">Level outside permitted range</response>
+    [HttpPatch("ImageCompression")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status400BadRequest)]
+    public IActionResult SetImageCompression([FromBody]int level)
+    {
+        if (level < 1 || level > 100)
+            return BadRequest();
+        TrangaSettings.UpdateCompressImages(level);
+        return Ok();
+    }
+    
+    /// <summary>
+    /// Get state of Black/White-Image setting
+    /// </summary>
+    /// <response code="200">True if enabled</response>
+    [HttpGet("BWImages")]
+    [ProducesResponseType<bool>(Status200OK, "text/plain")]
+    public IActionResult GetBwImagesToggle()
+    {
+        return Ok(TrangaSettings.bwImages);
+    }
+    
+    /// <summary>
+    /// Enable/Disable conversion of Images to Black and White
+    /// </summary>
+    /// <param name="enabled">true to enable</param>
+    /// <response code="200"></response>
+    [HttpPatch("BWImages")]
+    [ProducesResponseType(Status200OK)]
+    public IActionResult SetBwImagesToggle([FromBody]bool enabled)
+    {
+        TrangaSettings.UpdateBwImages(enabled);
+        return Ok();
+    }
+    
+    /// <summary>
+    /// Get state of April Fools Mode
+    /// </summary>
+    /// <remarks>April Fools Mode disables all downloads on April 1st</remarks>
+    /// <response code="200">True if enabled</response>
+    [HttpGet("AprilFoolsMode")]
+    [ProducesResponseType<bool>(Status200OK, "text/plain")]
+    public IActionResult GetAprilFoolsMode()
+    {
+        return Ok(TrangaSettings.aprilFoolsMode);
+    }
+    
+    /// <summary>
+    /// Enable/Disable April Fools Mode
+    /// </summary>
+    /// <remarks>April Fools Mode disables all downloads on April 1st</remarks>
+    /// <param name="enabled">true to enable</param>
+    /// <response code="200"></response>
+    [HttpPatch("AprilFoolsMode")]
+    [ProducesResponseType(Status200OK)]
+    public IActionResult SetAprilFoolsMode([FromBody]bool enabled)
+    {
+        TrangaSettings.UpdateAprilFoolsMode(enabled);
+        return Ok();
+    }
+    
+    /// <summary>
+    /// Gets the Chapter Naming Scheme
+    /// </summary>
+    /// <remarks>
+    /// Placeholders:
+    /// %M Manga Name
+    /// %V Volume
+    /// %C Chapter
+    /// %T Title
+    /// %A Author (first in list)
+    /// %I Chapter Internal ID
+    /// %i Manga Internal ID
+    /// %Y Year (Manga)
+    ///
+    /// ?_(...) replace _ with a value from above:
+    /// Everything inside the braces will only be added if the value of %_ is not null
+    /// </remarks>
+    /// <response code="200"></response>
+    [HttpGet("ChapterNamingScheme")]
+    [ProducesResponseType<string>(Status200OK, "text/plain")]
+    public IActionResult GetCustomNamingScheme()
+    {
+        return Ok(TrangaSettings.chapterNamingScheme);
+    }
+    
+    /// <summary>
+    /// Sets the Chapter Naming Scheme
+    /// </summary>
+    /// <remarks>
+    /// Placeholders:
+    /// %M Manga Name
+    /// %V Volume
+    /// %C Chapter
+    /// %T Title
+    /// %A Author (first in list)
+    /// %I Chapter Internal ID
+    /// %i Manga Internal ID
+    /// %Y Year (Manga)
+    ///
+    /// ?_(...) replace _ with a value from above:
+    /// Everything inside the braces will only be added if the value of %_ is not null
+    /// </remarks>
+    /// <response code="200"></response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPatch("ChapterNamingScheme")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult SetCustomNamingScheme([FromBody]string namingScheme)
+    {
+        try
+        {
+            Dictionary<Chapter, string> oldPaths = context.Chapters.ToDictionary(c => c, c => c.FullArchiveFilePath);
+            TrangaSettings.UpdateChapterNamingScheme(namingScheme);
+            MoveFileOrFolderJob[] newJobs = oldPaths
+                .Select(kv => new MoveFileOrFolderJob(kv.Value, kv.Key.FullArchiveFilePath)).ToArray();
+            context.Jobs.AddRange(newJobs);
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e);
+        }
+    }
+
+    /// <summary>
+    /// Creates a UpdateCoverJob for all Manga
+    /// </summary>
+    /// <response code="200">Array of JobIds</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("CleanupCovers")]
+    [ProducesResponseType<string[]>(Status200OK)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CleanupCovers()
+    {
+        try
+        {
+            Tranga.RemoveStaleFiles(context);
+            List<UpdateCoverJob> newJobs = context.Mangas.ToList().Select(m => new UpdateCoverJob(m, 0)).ToList();
+            context.Jobs.AddRange(newJobs);
+            return Ok(newJobs.Select(j => j.JobId));
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e);
+        }
+    }
+}

API/HttpRequestTimeFeature.cs

@@ -0,0 +1,35 @@
+namespace API;
+
+public interface IHttpRequestTimeFeature
+{
+    DateTime RequestTime { get; }
+}
+
+public class HttpRequestTimeFeature : IHttpRequestTimeFeature
+{
+    public DateTime RequestTime { get; }    
+
+    public HttpRequestTimeFeature()
+    {
+        RequestTime = DateTime.Now;
+    }
+}
+
+public class RequestTimeMiddleware
+{
+    private readonly RequestDelegate _next;
+
+    public RequestTimeMiddleware(RequestDelegate next)
+    {
+        _next = next;
+    }
+
+    public Task InvokeAsync(HttpContext context)
+    {
+        var httpRequestTimeFeature = new HttpRequestTimeFeature();
+        context.Features.Set<IHttpRequestTimeFeature>(httpRequestTimeFeature);
+
+        // Call the next delegate/middleware in the pipeline
+        return this._next(context);
+    }
+}

API/MangaDownloadClients/ChromiumDownloadClient.cs

@@ -0,0 +1,151 @@
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using HtmlAgilityPack;
+using log4net;
+using PuppeteerSharp;
+
+namespace API.MangaDownloadClients;
+
+internal class ChromiumDownloadClient : DownloadClient
+{
+    private static IBrowser? _browser;
+    private readonly HttpDownloadClient _httpDownloadClient;
+    private readonly Thread _closeStalePagesThread;
+    private readonly List<KeyValuePair<IPage, DateTime>> _openPages = new ();
+    
+    private static async Task<IBrowser> StartBrowser(ILog log)
+    {
+        return await Puppeteer.LaunchAsync(new LaunchOptions
+        {
+            Headless = true,
+            Args = new [] {
+                "--disable-gpu",
+                "--disable-dev-shm-usage",
+                "--disable-setuid-sandbox",
+                "--no-sandbox"},
+            Timeout = 30000
+        }, new LoggerFactory([new Provider(log)]));
+    }
+
+    public ChromiumDownloadClient()
+    {
+        _httpDownloadClient = new();
+        if(_browser is null)
+            _browser = StartBrowser(Log).Result;
+        _closeStalePagesThread = new Thread(CheckStalePages);
+        _closeStalePagesThread.Start();
+    }
+
+    private void CheckStalePages()
+    {
+        while (true)
+        {
+            Thread.Sleep(TimeSpan.FromHours(1));
+            Log.Debug("Removing stale pages");
+            foreach ((IPage? key, DateTime value) in _openPages.Where(kv => kv.Value.Subtract(DateTime.Now) > TimeSpan.FromHours(1)))
+            {
+                Log.Debug($"Closing {key.Url}");
+                key.CloseAsync().Wait();
+            }
+        }
+    }
+
+    private readonly Regex _imageUrlRex = new(@"https?:\/\/.*\.(?:p?jpe?g|gif|a?png|bmp|avif|webp)(\?.*)?");
+    internal override RequestResult MakeRequestInternal(string url, string? referrer = null, string? clickButton = null)
+    {
+        Log.Debug($"Requesting {url}");
+        return _imageUrlRex.IsMatch(url)
+            ? _httpDownloadClient.MakeRequestInternal(url, referrer)
+            : MakeRequestBrowser(url, referrer, clickButton);
+    }
+
+    private RequestResult MakeRequestBrowser(string url, string? referrer = null, string? clickButton = null)
+    {
+        if (_browser is null)
+            return new RequestResult(HttpStatusCode.InternalServerError, null, Stream.Null);
+        IPage page = _browser.NewPageAsync().Result;
+        _openPages.Add(new(page, DateTime.Now));
+        page.SetExtraHttpHeadersAsync(new() { { "Referer", referrer } });
+        page.DefaultTimeout = 30000;
+        IResponse response;
+        try
+        {
+            response = page.GoToAsync(url, WaitUntilNavigation.Networkidle0).Result;
+            Log.Debug($"Page loaded. {url}");
+        }
+        catch (Exception e)
+        {
+            Log.Info($"Could not load Page {url}\n{e.Message}");
+            page.CloseAsync();
+            _openPages.Remove(_openPages.Find(i => i.Key == page));
+            return new RequestResult(HttpStatusCode.InternalServerError, null, Stream.Null);
+        }
+
+        Stream stream = Stream.Null;
+        HtmlDocument? document = null;
+
+        if (response.Headers.TryGetValue("Content-Type", out string? content))
+        {
+            if (content.Contains("text/html"))
+            {
+                if (clickButton is not null && page.QuerySelectorAsync(clickButton).Result is not null)
+                    page.ClickAsync(clickButton).Wait();
+                string htmlString = page.GetContentAsync().Result;
+                stream = new MemoryStream(Encoding.Default.GetBytes(htmlString));
+                document = new ();
+                document.LoadHtml(htmlString);
+            }else if (content.Contains("image"))
+            {
+                stream = new MemoryStream(response.BufferAsync().Result);
+            }
+        }
+        else
+        {
+            page.CloseAsync().Wait();
+            _openPages.Remove(_openPages.Find(i => i.Key == page));
+            return new RequestResult(HttpStatusCode.InternalServerError, null, Stream.Null);
+        }
+        
+        page.CloseAsync().Wait();
+        _openPages.Remove(_openPages.Find(i => i.Key == page));
+        return new RequestResult(response.Status, document, stream, false, "");
+    }
+
+    private class Provider(ILog log) : ILoggerProvider
+    {
+        public void Dispose()
+        {
+            
+        }
+
+        public ILogger CreateLogger(string categoryName)
+        {
+            return new ChromiumLogger(log);
+        }
+    }
+
+    private class ChromiumLogger(ILog log) : ILogger
+    {
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+        {
+            string message = formatter.Invoke(state, exception);
+            switch(logLevel)
+            {
+                case LogLevel.Critical: log.Fatal(message); break;
+                case LogLevel.Error: log.Error(message); break;
+                case LogLevel.Warning: log.Warn(message); break;
+                case LogLevel.Information: log.Info(message); break;
+                case LogLevel.Debug: log.Debug(message); break;
+                default: log.Info(message); break;
+            }
+        }
+
+        public bool IsEnabled(LogLevel logLevel) => true;
+
+        public IDisposable? BeginScope<TState>(TState state) where TState : notnull
+        {
+            return null;
+        }
+    }
+}

API/MangaDownloadClients/DownloadClient.cs

@@ -0,0 +1,47 @@
+using System.Net;
+using log4net;
+
+namespace API.MangaDownloadClients;
+
+internal abstract class DownloadClient
+{
+    private static readonly Dictionary<RequestType, DateTime> LastExecutedRateLimit = new();
+    protected ILog Log { get; init; }
+
+    protected DownloadClient()
+    {
+        this.Log = LogManager.GetLogger(GetType());
+    }
+    
+    public RequestResult MakeRequest(string url, RequestType requestType, string? referrer = null, string? clickButton = null)
+    {
+        Log.Debug($"Requesting {requestType} {url}");
+        if (!TrangaSettings.requestLimits.ContainsKey(requestType))
+        {
+            return new RequestResult(HttpStatusCode.NotAcceptable, null, Stream.Null);
+        }
+
+        int rateLimit = TrangaSettings.userAgent == TrangaSettings.DefaultUserAgent
+            ? TrangaSettings.DefaultRequestLimits[requestType]
+            : TrangaSettings.requestLimits[requestType];
+        
+        TimeSpan timeBetweenRequests = TimeSpan.FromMinutes(1).Divide(rateLimit);
+        DateTime now = DateTime.Now;
+        LastExecutedRateLimit.TryAdd(requestType, now.Subtract(timeBetweenRequests));
+
+        TimeSpan rateLimitTimeout = timeBetweenRequests.Subtract(now.Subtract(LastExecutedRateLimit[requestType]));
+        Log.Debug($"Request limit {requestType} {rateLimit}/Minute timeBetweenRequests: {timeBetweenRequests:ss'.'fffff} Timeout: {rateLimitTimeout:ss'.'fffff}");
+        
+        if (rateLimitTimeout > TimeSpan.Zero)
+        {
+            Thread.Sleep(rateLimitTimeout);
+        }
+
+        RequestResult result = MakeRequestInternal(url, referrer, clickButton);
+        LastExecutedRateLimit[requestType] = DateTime.UtcNow;
+        Log.Debug($"Result {url}: {result}");
+        return result;
+    }
+
+    internal abstract RequestResult MakeRequestInternal(string url, string? referrer = null, string? clickButton = null);
+}

API/MangaDownloadClients/HttpDownloadClient.cs

@@ -0,0 +1,80 @@
+using System.Net;
+using HtmlAgilityPack;
+
+namespace API.MangaDownloadClients;
+
+internal class HttpDownloadClient : DownloadClient
+{
+    private static readonly HttpClient Client = new()
+    {
+        Timeout = TimeSpan.FromSeconds(10)
+    };
+
+    public HttpDownloadClient()
+    {
+        Client.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", TrangaSettings.userAgent);
+    }
+    
+    internal override RequestResult MakeRequestInternal(string url, string? referrer = null, string? clickButton = null)
+    {
+        if (clickButton is not null)
+            Log.Warn("Can not click button on static site.");
+        HttpResponseMessage? response = null;
+        while (response is null)
+        {
+            HttpRequestMessage requestMessage = new(HttpMethod.Get, url);
+            if (referrer is not null)
+                requestMessage.Headers.Referrer = new Uri(referrer);
+            Log.Debug($"Requesting {url}");
+            try
+            {
+                response = Client.Send(requestMessage);
+            }
+            catch (Exception e)
+            {
+                switch (e)
+                {
+                    case TaskCanceledException:
+                        return new RequestResult(HttpStatusCode.RequestTimeout, null, Stream.Null);
+                    case HttpRequestException:
+                        return new RequestResult(HttpStatusCode.BadRequest, null, Stream.Null);
+                }
+            }
+        }
+
+        if (!response.IsSuccessStatusCode)
+        {
+            return new RequestResult(response.StatusCode,  null, Stream.Null);
+        }
+
+        Stream stream;
+        try
+        {
+            stream = response.Content.ReadAsStream();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return new RequestResult(HttpStatusCode.InternalServerError, null, Stream.Null);
+        }
+
+        HtmlDocument? document = null;
+
+        if (response.Content.Headers.ContentType?.MediaType == "text/html")
+        {
+            StreamReader reader = new (stream);
+            document = new ();
+            document.LoadHtml(reader.ReadToEnd());
+            stream.Position = 0;
+        }
+
+        // Request has been redirected to another page. For example, it redirects directly to the results when there is only 1 result
+        if (response.RequestMessage is not null && response.RequestMessage.RequestUri is not null)
+        {
+            return new RequestResult(response.StatusCode, document, stream, true,
+                response.RequestMessage.RequestUri.AbsoluteUri);
+        }
+
+        return new RequestResult(response.StatusCode, document, stream);
+    }
+}

API/MangaDownloadClients/RequestResult.cs

@@ -0,0 +1,33 @@
+using System.Net;
+using HtmlAgilityPack;
+
+namespace API.MangaDownloadClients;
+
+public struct RequestResult
+{
+    public HttpStatusCode statusCode { get; }
+    public Stream result { get; }
+    public bool hasBeenRedirected { get; }
+    public string? redirectedToUrl { get; }
+    public HtmlDocument? htmlDocument { get; }
+
+    public RequestResult(HttpStatusCode statusCode, HtmlDocument? htmlDocument, Stream result)
+    {
+        this.statusCode = statusCode;
+        this.htmlDocument = htmlDocument;
+        this.result = result;
+    }
+
+    public RequestResult(HttpStatusCode statusCode, HtmlDocument? htmlDocument, Stream result, bool hasBeenRedirected, string redirectedTo)
+        : this(statusCode, htmlDocument, result)
+    {
+        this.hasBeenRedirected = hasBeenRedirected;
+        redirectedToUrl = redirectedTo;
+    }
+
+    public override string ToString()
+    {
+        return
+            $"{(int)statusCode} {statusCode.ToString()} {(hasBeenRedirected ? "Redirected: " : "")} {redirectedToUrl}";
+    }
+}

API/MangaDownloadClients/RequestType.cs

@@ -0,0 +1,11 @@
+namespace API.MangaDownloadClients;
+
+public enum RequestType : byte
+{
+    Default = 0,
+    MangaDexFeed = 1,
+    MangaImage = 2,
+    MangaCover = 3,
+    MangaDexImage = 5,
+    MangaInfo = 6
+}

API/Migrations/library/20250515120732_Initial.Designer.cs

@@ -0,0 +1,71 @@
+// <auto-generated />
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.library
+{
+    [DbContext(typeof(LibraryContext))]
+    [Migration("20250515120732_Initial")]
+    partial class Initial
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/library/20250515120732_Initial.cs

@@ -0,0 +1,35 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations.library
+{
+    /// <inheritdoc />
+    public partial class Initial : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "LibraryConnectors",
+                columns: table => new
+                {
+                    LibraryConnectorId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    LibraryType = table.Column<byte>(type: "smallint", nullable: false),
+                    BaseUrl = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Auth = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LibraryConnectors", x => x.LibraryConnectorId);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "LibraryConnectors");
+        }
+    }
+}

API/Migrations/library/LibraryContextModelSnapshot.cs

@@ -0,0 +1,68 @@
+// <auto-generated />
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.library
+{
+    [DbContext(typeof(LibraryContext))]
+    partial class LibraryContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/notifications/20250515120746_Initial.Designer.cs

@@ -0,0 +1,89 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.notifications
+{
+    [DbContext(typeof(NotificationsContext))]
+    [Migration("20250515120746_Initial")]
+    partial class Initial
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/notifications/20250515120746_Initial.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations.notifications
+{
+    /// <inheritdoc />
+    public partial class Initial : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterDatabase()
+                .Annotation("Npgsql:PostgresExtension:hstore", ",,");
+
+            migrationBuilder.CreateTable(
+                name: "NotificationConnectors",
+                columns: table => new
+                {
+                    Name = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    Url = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    Headers = table.Column<Dictionary<string, string>>(type: "hstore", nullable: false),
+                    HttpMethod = table.Column<string>(type: "character varying(8)", maxLength: 8, nullable: false),
+                    Body = table.Column<string>(type: "character varying(4096)", maxLength: 4096, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_NotificationConnectors", x => x.Name);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Notifications",
+                columns: table => new
+                {
+                    NotificationId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    Urgency = table.Column<byte>(type: "smallint", nullable: false),
+                    Title = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
+                    Message = table.Column<string>(type: "character varying(512)", maxLength: 512, nullable: false),
+                    Date = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Notifications", x => x.NotificationId);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "NotificationConnectors");
+
+            migrationBuilder.DropTable(
+                name: "Notifications");
+        }
+    }
+}

API/Migrations/notifications/NotificationsContextModelSnapshot.cs

@@ -0,0 +1,86 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.notifications
+{
+    [DbContext(typeof(NotificationsContext))]
+    partial class NotificationsContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/pgsql/20250515120724_Initial-1.Designer.cs

@@ -0,0 +1,682 @@
+// <auto-generated />
+using System;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250515120724_Initial-1")]
+    partial class Initial1
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LocalLibrary", b =>
+                {
+                    b.Property<string>("LocalLibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("BasePath")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LibraryName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("LocalLibraryId");
+
+                    b.ToTable("LocalLibraries");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DirectoryName")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<float>("IgnoreChaptersBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaConnectorName")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LibraryId");
+
+                    b.HasIndex("MangaConnectorName");
+
+                    b.ToTable("Mangas");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.Property<string>("AuthorIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("AuthorToManga");
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.Property<string>("MangaTagIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaTagIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("MangaTagToManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ToLibraryId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasIndex("ToLibraryId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("MoveMangaLibraryJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)7);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Global", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Global");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany("Chapters")
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.LocalLibrary", "Library")
+                        .WithMany()
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsMany("API.Schema.Link", "Links", b1 =>
+                        {
+                            b1.Property<string>("LinkId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkProvider")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkUrl")
+                                .IsRequired()
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.HasKey("LinkId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("Link");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.OwnsMany("API.Schema.MangaAltTitle", "AltTitles", b1 =>
+                        {
+                            b1.Property<string>("AltTitleId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Language")
+                                .IsRequired()
+                                .HasMaxLength(8)
+                                .HasColumnType("character varying(8)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Title")
+                                .IsRequired()
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.HasKey("AltTitleId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("MangaAltTitle");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Library");
+
+                    b.Navigation("Links");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.LocalLibrary", "ToLibrary")
+                        .WithMany()
+                        .HasForeignKey("ToLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+
+                    b.Navigation("ToLibrary");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/pgsql/20250515120724_Initial-1.cs

@@ -0,0 +1,433 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    /// <inheritdoc />
+    public partial class Initial1 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Authors",
+                columns: table => new
+                {
+                    AuthorId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    AuthorName = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Authors", x => x.AuthorId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "LocalLibraries",
+                columns: table => new
+                {
+                    LocalLibraryId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    BasePath = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    LibraryName = table.Column<string>(type: "character varying(512)", maxLength: 512, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LocalLibraries", x => x.LocalLibraryId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "MangaConnectors",
+                columns: table => new
+                {
+                    Name = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: false),
+                    SupportedLanguages = table.Column<string[]>(type: "text[]", maxLength: 8, nullable: false),
+                    IconUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    BaseUris = table.Column<string[]>(type: "text[]", maxLength: 256, nullable: false),
+                    Enabled = table.Column<bool>(type: "boolean", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MangaConnectors", x => x.Name);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Tags",
+                columns: table => new
+                {
+                    Tag = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Tags", x => x.Tag);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Mangas",
+                columns: table => new
+                {
+                    MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    IdOnConnectorSite = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Name = table.Column<string>(type: "character varying(512)", maxLength: 512, nullable: false),
+                    Description = table.Column<string>(type: "text", nullable: false),
+                    WebsiteUrl = table.Column<string>(type: "character varying(512)", maxLength: 512, nullable: false),
+                    CoverUrl = table.Column<string>(type: "character varying(512)", maxLength: 512, nullable: false),
+                    ReleaseStatus = table.Column<byte>(type: "smallint", nullable: false),
+                    LibraryId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    MangaConnectorName = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: false),
+                    IgnoreChaptersBefore = table.Column<float>(type: "real", nullable: false),
+                    DirectoryName = table.Column<string>(type: "character varying(1024)", maxLength: 1024, nullable: false),
+                    CoverFileNameInCache = table.Column<string>(type: "character varying(512)", maxLength: 512, nullable: true),
+                    Year = table.Column<long>(type: "bigint", nullable: false),
+                    OriginalLanguage = table.Column<string>(type: "character varying(8)", maxLength: 8, nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Mangas", x => x.MangaId);
+                    table.ForeignKey(
+                        name: "FK_Mangas_LocalLibraries_LibraryId",
+                        column: x => x.LibraryId,
+                        principalTable: "LocalLibraries",
+                        principalColumn: "LocalLibraryId",
+                        onDelete: ReferentialAction.SetNull);
+                    table.ForeignKey(
+                        name: "FK_Mangas_MangaConnectors_MangaConnectorName",
+                        column: x => x.MangaConnectorName,
+                        principalTable: "MangaConnectors",
+                        principalColumn: "Name",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AuthorToManga",
+                columns: table => new
+                {
+                    AuthorIds = table.Column<string>(type: "character varying(64)", nullable: false),
+                    MangaIds = table.Column<string>(type: "character varying(64)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AuthorToManga", x => new { x.AuthorIds, x.MangaIds });
+                    table.ForeignKey(
+                        name: "FK_AuthorToManga_Authors_AuthorIds",
+                        column: x => x.AuthorIds,
+                        principalTable: "Authors",
+                        principalColumn: "AuthorId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_AuthorToManga_Mangas_MangaIds",
+                        column: x => x.MangaIds,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Chapters",
+                columns: table => new
+                {
+                    ChapterId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    ParentMangaId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    VolumeNumber = table.Column<int>(type: "integer", nullable: true),
+                    ChapterNumber = table.Column<string>(type: "character varying(10)", maxLength: 10, nullable: false),
+                    Url = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    Title = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    FileName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Downloaded = table.Column<bool>(type: "boolean", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Chapters", x => x.ChapterId);
+                    table.ForeignKey(
+                        name: "FK_Chapters_Mangas_ParentMangaId",
+                        column: x => x.ParentMangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Link",
+                columns: table => new
+                {
+                    LinkId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    LinkProvider = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    LinkUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    MangaId = table.Column<string>(type: "character varying(64)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Link", x => x.LinkId);
+                    table.ForeignKey(
+                        name: "FK_Link_Mangas_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "MangaAltTitle",
+                columns: table => new
+                {
+                    AltTitleId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    Language = table.Column<string>(type: "character varying(8)", maxLength: 8, nullable: false),
+                    Title = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    MangaId = table.Column<string>(type: "character varying(64)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MangaAltTitle", x => x.AltTitleId);
+                    table.ForeignKey(
+                        name: "FK_MangaAltTitle_Mangas_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "MangaTagToManga",
+                columns: table => new
+                {
+                    MangaTagIds = table.Column<string>(type: "character varying(64)", nullable: false),
+                    MangaIds = table.Column<string>(type: "character varying(64)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MangaTagToManga", x => new { x.MangaTagIds, x.MangaIds });
+                    table.ForeignKey(
+                        name: "FK_MangaTagToManga_Mangas_MangaIds",
+                        column: x => x.MangaIds,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_MangaTagToManga_Tags_MangaTagIds",
+                        column: x => x.MangaTagIds,
+                        principalTable: "Tags",
+                        principalColumn: "Tag",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Jobs",
+                columns: table => new
+                {
+                    JobId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    ParentJobId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    JobType = table.Column<byte>(type: "smallint", nullable: false),
+                    RecurrenceMs = table.Column<decimal>(type: "numeric(20,0)", nullable: false),
+                    LastExecution = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    state = table.Column<byte>(type: "smallint", nullable: false),
+                    Enabled = table.Column<bool>(type: "boolean", nullable: false),
+                    DownloadAvailableChaptersJob_MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    ChapterId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    FromLocation = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    ToLocation = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    MoveMangaLibraryJob_MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    ToLibraryId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    RetrieveChaptersJob_MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    Language = table.Column<string>(type: "character varying(8)", maxLength: 8, nullable: true),
+                    UpdateFilesDownloadedJob_MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Jobs", x => x.JobId);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Chapters_ChapterId",
+                        column: x => x.ChapterId,
+                        principalTable: "Chapters",
+                        principalColumn: "ChapterId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Jobs_ParentJobId",
+                        column: x => x.ParentJobId,
+                        principalTable: "Jobs",
+                        principalColumn: "JobId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_LocalLibraries_ToLibraryId",
+                        column: x => x.ToLibraryId,
+                        principalTable: "LocalLibraries",
+                        principalColumn: "LocalLibraryId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Mangas_DownloadAvailableChaptersJob_MangaId",
+                        column: x => x.DownloadAvailableChaptersJob_MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Mangas_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Mangas_MoveMangaLibraryJob_MangaId",
+                        column: x => x.MoveMangaLibraryJob_MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Mangas_RetrieveChaptersJob_MangaId",
+                        column: x => x.RetrieveChaptersJob_MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Mangas_UpdateFilesDownloadedJob_MangaId",
+                        column: x => x.UpdateFilesDownloadedJob_MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "JobJob",
+                columns: table => new
+                {
+                    DependsOnJobsJobId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    JobId = table.Column<string>(type: "character varying(64)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_JobJob", x => new { x.DependsOnJobsJobId, x.JobId });
+                    table.ForeignKey(
+                        name: "FK_JobJob_Jobs_DependsOnJobsJobId",
+                        column: x => x.DependsOnJobsJobId,
+                        principalTable: "Jobs",
+                        principalColumn: "JobId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_JobJob_Jobs_JobId",
+                        column: x => x.JobId,
+                        principalTable: "Jobs",
+                        principalColumn: "JobId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AuthorToManga_MangaIds",
+                table: "AuthorToManga",
+                column: "MangaIds");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Chapters_ParentMangaId",
+                table: "Chapters",
+                column: "ParentMangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_JobJob_JobId",
+                table: "JobJob",
+                column: "JobId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_ChapterId",
+                table: "Jobs",
+                column: "ChapterId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_DownloadAvailableChaptersJob_MangaId",
+                table: "Jobs",
+                column: "DownloadAvailableChaptersJob_MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_MangaId",
+                table: "Jobs",
+                column: "MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_MoveMangaLibraryJob_MangaId",
+                table: "Jobs",
+                column: "MoveMangaLibraryJob_MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_ParentJobId",
+                table: "Jobs",
+                column: "ParentJobId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_RetrieveChaptersJob_MangaId",
+                table: "Jobs",
+                column: "RetrieveChaptersJob_MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_ToLibraryId",
+                table: "Jobs",
+                column: "ToLibraryId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_UpdateFilesDownloadedJob_MangaId",
+                table: "Jobs",
+                column: "UpdateFilesDownloadedJob_MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Link_MangaId",
+                table: "Link",
+                column: "MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MangaAltTitle_MangaId",
+                table: "MangaAltTitle",
+                column: "MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Mangas_LibraryId",
+                table: "Mangas",
+                column: "LibraryId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Mangas_MangaConnectorName",
+                table: "Mangas",
+                column: "MangaConnectorName");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MangaTagToManga_MangaIds",
+                table: "MangaTagToManga",
+                column: "MangaIds");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "AuthorToManga");
+
+            migrationBuilder.DropTable(
+                name: "JobJob");
+
+            migrationBuilder.DropTable(
+                name: "Link");
+
+            migrationBuilder.DropTable(
+                name: "MangaAltTitle");
+
+            migrationBuilder.DropTable(
+                name: "MangaTagToManga");
+
+            migrationBuilder.DropTable(
+                name: "Authors");
+
+            migrationBuilder.DropTable(
+                name: "Jobs");
+
+            migrationBuilder.DropTable(
+                name: "Tags");
+
+            migrationBuilder.DropTable(
+                name: "Chapters");
+
+            migrationBuilder.DropTable(
+                name: "Mangas");
+
+            migrationBuilder.DropTable(
+                name: "LocalLibraries");
+
+            migrationBuilder.DropTable(
+                name: "MangaConnectors");
+        }
+    }
+}

API/Migrations/pgsql/20250516121442_AltTitle-Owned.Designer.cs

@@ -0,0 +1,688 @@
+// <auto-generated />
+using System;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250516121442_AltTitle-Owned")]
+    partial class AltTitleOwned
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LocalLibrary", b =>
+                {
+                    b.Property<string>("LocalLibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("BasePath")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LibraryName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("LocalLibraryId");
+
+                    b.ToTable("LocalLibraries");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DirectoryName")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<float>("IgnoreChaptersBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaConnectorName")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LibraryId");
+
+                    b.HasIndex("MangaConnectorName");
+
+                    b.ToTable("Mangas");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.Property<string>("AuthorIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("AuthorToManga");
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.Property<string>("MangaTagIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaTagIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("MangaTagToManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ToLibraryId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasIndex("ToLibraryId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("MoveMangaLibraryJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)7);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ComickIo", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ComickIo");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Global", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Global");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany("Chapters")
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.LocalLibrary", "Library")
+                        .WithMany()
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsMany("API.Schema.Link", "Links", b1 =>
+                        {
+                            b1.Property<string>("LinkId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkProvider")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkUrl")
+                                .IsRequired()
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.HasKey("LinkId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("Link");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.OwnsMany("API.Schema.MangaAltTitle", "AltTitles", b1 =>
+                        {
+                            b1.Property<string>("MangaId")
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("integer");
+
+                            NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b1.Property<int>("Id"));
+
+                            b1.Property<string>("Language")
+                                .IsRequired()
+                                .HasMaxLength(8)
+                                .HasColumnType("character varying(8)");
+
+                            b1.Property<string>("Title")
+                                .IsRequired()
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.HasKey("MangaId", "Id");
+
+                            b1.ToTable("MangaAltTitle");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Library");
+
+                    b.Navigation("Links");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.LocalLibrary", "ToLibrary")
+                        .WithMany()
+                        .HasForeignKey("ToLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+
+                    b.Navigation("ToLibrary");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/pgsql/20250516121442_AltTitle-Owned.cs

@@ -0,0 +1,70 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    /// <inheritdoc />
+    public partial class AltTitleOwned : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_MangaAltTitle",
+                table: "MangaAltTitle");
+
+            migrationBuilder.DropIndex(
+                name: "IX_MangaAltTitle_MangaId",
+                table: "MangaAltTitle");
+
+            migrationBuilder.DropColumn(
+                name: "AltTitleId",
+                table: "MangaAltTitle");
+
+            migrationBuilder.AddColumn<int>(
+                name: "Id",
+                table: "MangaAltTitle",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0)
+                .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_MangaAltTitle",
+                table: "MangaAltTitle",
+                columns: new[] { "MangaId", "Id" });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_MangaAltTitle",
+                table: "MangaAltTitle");
+
+            migrationBuilder.DropColumn(
+                name: "Id",
+                table: "MangaAltTitle");
+
+            migrationBuilder.AddColumn<string>(
+                name: "AltTitleId",
+                table: "MangaAltTitle",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_MangaAltTitle",
+                table: "MangaAltTitle",
+                column: "AltTitleId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MangaAltTitle_MangaId",
+                table: "MangaAltTitle",
+                column: "MangaId");
+        }
+    }
+}

API/Migrations/pgsql/20250516121725_Manga-Year-Nullable.Designer.cs

@@ -0,0 +1,688 @@
+// <auto-generated />
+using System;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250516121725_Manga-Year-Nullable")]
+    partial class MangaYearNullable
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LocalLibrary", b =>
+                {
+                    b.Property<string>("LocalLibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("BasePath")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LibraryName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("LocalLibraryId");
+
+                    b.ToTable("LocalLibraries");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DirectoryName")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<float>("IgnoreChaptersBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaConnectorName")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<long?>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LibraryId");
+
+                    b.HasIndex("MangaConnectorName");
+
+                    b.ToTable("Mangas");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.Property<string>("AuthorIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("AuthorToManga");
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.Property<string>("MangaTagIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaTagIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("MangaTagToManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ToLibraryId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasIndex("ToLibraryId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("MoveMangaLibraryJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)7);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ComickIo", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ComickIo");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Global", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Global");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany("Chapters")
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.LocalLibrary", "Library")
+                        .WithMany()
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsMany("API.Schema.Link", "Links", b1 =>
+                        {
+                            b1.Property<string>("LinkId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkProvider")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkUrl")
+                                .IsRequired()
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.HasKey("LinkId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("Link");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.OwnsMany("API.Schema.MangaAltTitle", "AltTitles", b1 =>
+                        {
+                            b1.Property<string>("MangaId")
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("integer");
+
+                            NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b1.Property<int>("Id"));
+
+                            b1.Property<string>("Language")
+                                .IsRequired()
+                                .HasMaxLength(8)
+                                .HasColumnType("character varying(8)");
+
+                            b1.Property<string>("Title")
+                                .IsRequired()
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.HasKey("MangaId", "Id");
+
+                            b1.ToTable("MangaAltTitle");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Library");
+
+                    b.Navigation("Links");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.LocalLibrary", "ToLibrary")
+                        .WithMany()
+                        .HasForeignKey("ToLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+
+                    b.Navigation("ToLibrary");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/pgsql/20250516121725_Manga-Year-Nullable.cs

@@ -0,0 +1,36 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    /// <inheritdoc />
+    public partial class MangaYearNullable : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<long>(
+                name: "Year",
+                table: "Mangas",
+                type: "bigint",
+                nullable: true,
+                oldClrType: typeof(long),
+                oldType: "bigint");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<long>(
+                name: "Year",
+                table: "Mangas",
+                type: "bigint",
+                nullable: false,
+                defaultValue: 0L,
+                oldClrType: typeof(long),
+                oldType: "bigint",
+                oldNullable: true);
+        }
+    }
+}

API/Migrations/pgsql/20250516122242_AltTitle-Owned-WithId.Designer.cs

@@ -0,0 +1,689 @@
+// <auto-generated />
+using System;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250516122242_AltTitle-Owned-WithId")]
+    partial class AltTitleOwnedWithId
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LocalLibrary", b =>
+                {
+                    b.Property<string>("LocalLibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("BasePath")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LibraryName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("LocalLibraryId");
+
+                    b.ToTable("LocalLibraries");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DirectoryName")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<float>("IgnoreChaptersBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaConnectorName")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<long?>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LibraryId");
+
+                    b.HasIndex("MangaConnectorName");
+
+                    b.ToTable("Mangas");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.Property<string>("AuthorIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("AuthorToManga");
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.Property<string>("MangaTagIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaTagIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("MangaTagToManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ToLibraryId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasIndex("ToLibraryId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("MoveMangaLibraryJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)7);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ComickIo", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ComickIo");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Global", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Global");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany("Chapters")
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.LocalLibrary", "Library")
+                        .WithMany()
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsMany("API.Schema.Link", "Links", b1 =>
+                        {
+                            b1.Property<string>("LinkId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkProvider")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkUrl")
+                                .IsRequired()
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.HasKey("LinkId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("Link");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.OwnsMany("API.Schema.MangaAltTitle", "AltTitles", b1 =>
+                        {
+                            b1.Property<string>("AltTitleId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Language")
+                                .IsRequired()
+                                .HasMaxLength(8)
+                                .HasColumnType("character varying(8)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Title")
+                                .IsRequired()
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.HasKey("AltTitleId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("MangaAltTitle");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Library");
+
+                    b.Navigation("Links");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.LocalLibrary", "ToLibrary")
+                        .WithMany()
+                        .HasForeignKey("ToLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+
+                    b.Navigation("ToLibrary");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/pgsql/20250516122242_AltTitle-Owned-WithId.cs

@@ -0,0 +1,70 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    /// <inheritdoc />
+    public partial class AltTitleOwnedWithId : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_MangaAltTitle",
+                table: "MangaAltTitle");
+
+            migrationBuilder.DropColumn(
+                name: "Id",
+                table: "MangaAltTitle");
+
+            migrationBuilder.AddColumn<string>(
+                name: "AltTitleId",
+                table: "MangaAltTitle",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_MangaAltTitle",
+                table: "MangaAltTitle",
+                column: "AltTitleId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MangaAltTitle_MangaId",
+                table: "MangaAltTitle",
+                column: "MangaId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_MangaAltTitle",
+                table: "MangaAltTitle");
+
+            migrationBuilder.DropIndex(
+                name: "IX_MangaAltTitle_MangaId",
+                table: "MangaAltTitle");
+
+            migrationBuilder.DropColumn(
+                name: "AltTitleId",
+                table: "MangaAltTitle");
+
+            migrationBuilder.AddColumn<int>(
+                name: "Id",
+                table: "MangaAltTitle",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0)
+                .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_MangaAltTitle",
+                table: "MangaAltTitle",
+                columns: new[] { "MangaId", "Id" });
+        }
+    }
+}

API/Migrations/pgsql/20250516180953_Split-UpdateChaptersDownloadedJob-Into-UpdateSingleChapterDownloadedJob.Designer.cs

@@ -0,0 +1,720 @@
+// <auto-generated />
+using System;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250516180953_Split-UpdateChaptersDownloadedJob-Into-UpdateSingleChapterDownloadedJob")]
+    partial class SplitUpdateChaptersDownloadedJobIntoUpdateSingleChapterDownloadedJob
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LocalLibrary", b =>
+                {
+                    b.Property<string>("LocalLibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("BasePath")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LibraryName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("LocalLibraryId");
+
+                    b.ToTable("LocalLibraries");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DirectoryName")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<float>("IgnoreChaptersBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaConnectorName")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<long?>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LibraryId");
+
+                    b.HasIndex("MangaConnectorName");
+
+                    b.ToTable("Mangas");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.Property<string>("AuthorIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("AuthorToManga");
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.Property<string>("MangaTagIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaTagIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("MangaTagToManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ToLibraryId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasIndex("ToLibraryId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("MoveMangaLibraryJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)7);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateChaptersDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateSingleChapterDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("ChapterId")
+                                .HasColumnName("UpdateSingleChapterDownloadedJob_ChapterId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)8);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ComickIo", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ComickIo");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Global", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Global");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany("Chapters")
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.LocalLibrary", "Library")
+                        .WithMany()
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsMany("API.Schema.Link", "Links", b1 =>
+                        {
+                            b1.Property<string>("LinkId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkProvider")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkUrl")
+                                .IsRequired()
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.HasKey("LinkId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("Link");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.OwnsMany("API.Schema.MangaAltTitle", "AltTitles", b1 =>
+                        {
+                            b1.Property<string>("AltTitleId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Language")
+                                .IsRequired()
+                                .HasMaxLength(8)
+                                .HasColumnType("character varying(8)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Title")
+                                .IsRequired()
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.HasKey("AltTitleId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("MangaAltTitle");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Library");
+
+                    b.Navigation("Links");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.LocalLibrary", "ToLibrary")
+                        .WithMany()
+                        .HasForeignKey("ToLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+
+                    b.Navigation("ToLibrary");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateSingleChapterDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/pgsql/20250516180953_Split-UpdateChaptersDownloadedJob-Into-UpdateSingleChapterDownloadedJob.cs

@@ -0,0 +1,94 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    /// <inheritdoc />
+    public partial class SplitUpdateChaptersDownloadedJobIntoUpdateSingleChapterDownloadedJob : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Jobs_Mangas_UpdateFilesDownloadedJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.RenameColumn(
+                name: "UpdateFilesDownloadedJob_MangaId",
+                table: "Jobs",
+                newName: "UpdateChaptersDownloadedJob_MangaId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Jobs_UpdateFilesDownloadedJob_MangaId",
+                table: "Jobs",
+                newName: "IX_Jobs_UpdateChaptersDownloadedJob_MangaId");
+
+            migrationBuilder.AddColumn<string>(
+                name: "UpdateSingleChapterDownloadedJob_ChapterId",
+                table: "Jobs",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_UpdateSingleChapterDownloadedJob_ChapterId",
+                table: "Jobs",
+                column: "UpdateSingleChapterDownloadedJob_ChapterId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Jobs_Chapters_UpdateSingleChapterDownloadedJob_ChapterId",
+                table: "Jobs",
+                column: "UpdateSingleChapterDownloadedJob_ChapterId",
+                principalTable: "Chapters",
+                principalColumn: "ChapterId",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Jobs_Mangas_UpdateChaptersDownloadedJob_MangaId",
+                table: "Jobs",
+                column: "UpdateChaptersDownloadedJob_MangaId",
+                principalTable: "Mangas",
+                principalColumn: "MangaId",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Jobs_Chapters_UpdateSingleChapterDownloadedJob_ChapterId",
+                table: "Jobs");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Jobs_Mangas_UpdateChaptersDownloadedJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Jobs_UpdateSingleChapterDownloadedJob_ChapterId",
+                table: "Jobs");
+
+            migrationBuilder.DropColumn(
+                name: "UpdateSingleChapterDownloadedJob_ChapterId",
+                table: "Jobs");
+
+            migrationBuilder.RenameColumn(
+                name: "UpdateChaptersDownloadedJob_MangaId",
+                table: "Jobs",
+                newName: "UpdateFilesDownloadedJob_MangaId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Jobs_UpdateChaptersDownloadedJob_MangaId",
+                table: "Jobs",
+                newName: "IX_Jobs_UpdateFilesDownloadedJob_MangaId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Jobs_Mangas_UpdateFilesDownloadedJob_MangaId",
+                table: "Jobs",
+                column: "UpdateFilesDownloadedJob_MangaId",
+                principalTable: "Mangas",
+                principalColumn: "MangaId",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

API/Migrations/pgsql/20250518142903_Chapter-IdOnConnectorSite.Designer.cs

@@ -0,0 +1,724 @@
+// <auto-generated />
+using System;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250518142903_Chapter-IdOnConnectorSite")]
+    partial class ChapterIdOnConnectorSite
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LocalLibrary", b =>
+                {
+                    b.Property<string>("LocalLibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("BasePath")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LibraryName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("LocalLibraryId");
+
+                    b.ToTable("LocalLibraries");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DirectoryName")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<float>("IgnoreChaptersBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaConnectorName")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<long?>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LibraryId");
+
+                    b.HasIndex("MangaConnectorName");
+
+                    b.ToTable("Mangas");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.Property<string>("AuthorIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("AuthorToManga");
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.Property<string>("MangaTagIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaTagIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("MangaTagToManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ToLibraryId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasIndex("ToLibraryId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("MoveMangaLibraryJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)7);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateChaptersDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateSingleChapterDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("ChapterId")
+                                .HasColumnName("UpdateSingleChapterDownloadedJob_ChapterId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)8);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ComickIo", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ComickIo");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Global", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Global");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany("Chapters")
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.LocalLibrary", "Library")
+                        .WithMany()
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsMany("API.Schema.Link", "Links", b1 =>
+                        {
+                            b1.Property<string>("LinkId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkProvider")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkUrl")
+                                .IsRequired()
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.HasKey("LinkId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("Link");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.OwnsMany("API.Schema.MangaAltTitle", "AltTitles", b1 =>
+                        {
+                            b1.Property<string>("AltTitleId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Language")
+                                .IsRequired()
+                                .HasMaxLength(8)
+                                .HasColumnType("character varying(8)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Title")
+                                .IsRequired()
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.HasKey("AltTitleId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("MangaAltTitle");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Library");
+
+                    b.Navigation("Links");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.LocalLibrary", "ToLibrary")
+                        .WithMany()
+                        .HasForeignKey("ToLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+
+                    b.Navigation("ToLibrary");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateSingleChapterDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/pgsql/20250518142903_Chapter-IdOnConnectorSite.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    /// <inheritdoc />
+    public partial class ChapterIdOnConnectorSite : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "IdOnConnectorSite",
+                table: "Chapters",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IdOnConnectorSite",
+                table: "Chapters");
+        }
+    }
+}

API/Migrations/pgsql/20250518161710_UpdateCoverJob.Designer.cs

@@ -0,0 +1,755 @@
+// <auto-generated />
+using System;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250518161710_UpdateCoverJob")]
+    partial class UpdateCoverJob
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LocalLibrary", b =>
+                {
+                    b.Property<string>("LocalLibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("BasePath")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LibraryName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("LocalLibraryId");
+
+                    b.ToTable("LocalLibraries");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DirectoryName")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<float>("IgnoreChaptersBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaConnectorName")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<long?>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LibraryId");
+
+                    b.HasIndex("MangaConnectorName");
+
+                    b.ToTable("Mangas");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.Property<string>("AuthorIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("AuthorToManga");
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.Property<string>("MangaTagIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaTagIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("MangaTagToManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ToLibraryId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasIndex("ToLibraryId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("MoveMangaLibraryJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)7);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateChaptersDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateCoverJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)9);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateSingleChapterDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("ChapterId")
+                                .HasColumnName("UpdateSingleChapterDownloadedJob_ChapterId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)8);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ComickIo", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ComickIo");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Global", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Global");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany("Chapters")
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.LocalLibrary", "Library")
+                        .WithMany()
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsMany("API.Schema.Link", "Links", b1 =>
+                        {
+                            b1.Property<string>("LinkId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkProvider")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkUrl")
+                                .IsRequired()
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.HasKey("LinkId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("Link");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.OwnsMany("API.Schema.MangaAltTitle", "AltTitles", b1 =>
+                        {
+                            b1.Property<string>("AltTitleId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Language")
+                                .IsRequired()
+                                .HasMaxLength(8)
+                                .HasColumnType("character varying(8)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Title")
+                                .IsRequired()
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.HasKey("AltTitleId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("MangaAltTitle");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Library");
+
+                    b.Navigation("Links");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.LocalLibrary", "ToLibrary")
+                        .WithMany()
+                        .HasForeignKey("ToLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+
+                    b.Navigation("ToLibrary");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateSingleChapterDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/pgsql/20250518161710_UpdateCoverJob.cs

@@ -0,0 +1,50 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    /// <inheritdoc />
+    public partial class UpdateCoverJob : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "UpdateCoverJob_MangaId",
+                table: "Jobs",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_UpdateCoverJob_MangaId",
+                table: "Jobs",
+                column: "UpdateCoverJob_MangaId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Jobs_Mangas_UpdateCoverJob_MangaId",
+                table: "Jobs",
+                column: "UpdateCoverJob_MangaId",
+                principalTable: "Mangas",
+                principalColumn: "MangaId",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Jobs_Mangas_UpdateCoverJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Jobs_UpdateCoverJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.DropColumn(
+                name: "UpdateCoverJob_MangaId",
+                table: "Jobs");
+        }
+    }
+}

API/Migrations/pgsql/PgsqlContextModelSnapshot.cs

@@ -0,0 +1,752 @@
+// <auto-generated />
+using System;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    [DbContext(typeof(PgsqlContext))]
+    partial class PgsqlContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LocalLibrary", b =>
+                {
+                    b.Property<string>("LocalLibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("BasePath")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LibraryName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("LocalLibraryId");
+
+                    b.ToTable("LocalLibraries");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DirectoryName")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<float>("IgnoreChaptersBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaConnectorName")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<long?>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LibraryId");
+
+                    b.HasIndex("MangaConnectorName");
+
+                    b.ToTable("Mangas");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.Property<string>("AuthorIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("AuthorToManga");
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.Property<string>("MangaTagIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaTagIds", "MangaIds");
+
+                    b.HasIndex("MangaIds");
+
+                    b.ToTable("MangaTagToManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ToLibraryId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasIndex("ToLibraryId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("MoveMangaLibraryJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)7);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateChaptersDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateCoverJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)9);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateSingleChapterDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("ChapterId")
+                                .HasColumnName("UpdateSingleChapterDownloadedJob_ChapterId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)8);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ComickIo", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ComickIo");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Global", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Global");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany("Chapters")
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.LocalLibrary", "Library")
+                        .WithMany()
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsMany("API.Schema.Link", "Links", b1 =>
+                        {
+                            b1.Property<string>("LinkId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkProvider")
+                                .IsRequired()
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("LinkUrl")
+                                .IsRequired()
+                                .HasMaxLength(2048)
+                                .HasColumnType("character varying(2048)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.HasKey("LinkId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("Link");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.OwnsMany("API.Schema.MangaAltTitle", "AltTitles", b1 =>
+                        {
+                            b1.Property<string>("AltTitleId")
+                                .HasMaxLength(64)
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Language")
+                                .IsRequired()
+                                .HasMaxLength(8)
+                                .HasColumnType("character varying(8)");
+
+                            b1.Property<string>("MangaId")
+                                .IsRequired()
+                                .HasColumnType("character varying(64)");
+
+                            b1.Property<string>("Title")
+                                .IsRequired()
+                                .HasMaxLength(256)
+                                .HasColumnType("character varying(256)");
+
+                            b1.HasKey("AltTitleId");
+
+                            b1.HasIndex("MangaId");
+
+                            b1.ToTable("MangaAltTitle");
+
+                            b1.WithOwner()
+                                .HasForeignKey("MangaId");
+                        });
+
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Library");
+
+                    b.Navigation("Links");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("AuthorToManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaTagToManga", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveMangaLibraryJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.LocalLibrary", "ToLibrary")
+                        .WithMany()
+                        .HasForeignKey("ToLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+
+                    b.Navigation("ToLibrary");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateChaptersDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateSingleChapterDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/NamedSwaggerGenOptions.cs

@@ -0,0 +1,46 @@
+using Asp.Versioning.ApiExplorer;
+using Microsoft.Extensions.Options;
+using Microsoft.OpenApi.Models;
+using Swashbuckle.AspNetCore.SwaggerGen;
+
+namespace API;
+
+public class NamedSwaggerGenOptions : IConfigureNamedOptions<SwaggerGenOptions>
+{
+    private readonly IApiVersionDescriptionProvider provider;
+    public NamedSwaggerGenOptions(IApiVersionDescriptionProvider provider)
+    {
+        this.provider = provider;
+    }
+
+    public void Configure(string? name, SwaggerGenOptions options)
+    {
+        Configure(options);
+    }
+        
+    public void Configure(SwaggerGenOptions options)
+    {
+        // add swagger document for every API version discovered
+        foreach (var description in provider.ApiVersionDescriptions)
+        {
+            options.SwaggerDoc(
+                description.GroupName,
+                CreateVersionInfo(description));
+        }
+    }
+        
+    private OpenApiInfo CreateVersionInfo(
+        ApiVersionDescription description)
+    {
+        var info = new OpenApiInfo()
+        {
+            Title = "Test API " + description.GroupName,
+            Version = description.ApiVersion.ToString()
+        };
+        if (description.IsDeprecated)
+        {
+            info.Description += " This API version has been deprecated.";
+        }
+        return info;
+    }
+}

API/Program.cs

@@ -0,0 +1,163 @@
+using System.Reflection;
+using API;
+using API.Schema;
+using API.Schema.Contexts;
+using API.Schema.Jobs;
+using API.Schema.MangaConnectors;
+using Asp.Versioning;
+using Asp.Versioning.Builder;
+using Asp.Versioning.Conventions;
+using log4net;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddCors(options =>
+{
+    options.AddPolicy("AllowAll",
+        policy =>
+        {
+            policy
+                .AllowAnyOrigin()
+                .AllowAnyMethod()
+                .AllowAnyHeader();
+        });
+});
+
+builder.Services.AddApiVersioning(option =>
+    {
+        option.AssumeDefaultVersionWhenUnspecified = true;
+        option.DefaultApiVersion = new ApiVersion(2);
+        option.ReportApiVersions = true;
+        option.ApiVersionReader = ApiVersionReader.Combine(
+            new UrlSegmentApiVersionReader(),
+            new QueryStringApiVersionReader("api-version"),
+            new HeaderApiVersionReader("X-Version"),
+            new MediaTypeApiVersionReader("x-version"));
+    })
+    .AddMvc(options =>
+    {
+        options.Conventions.Add(new VersionByNamespaceConvention());
+    })
+    .AddApiExplorer(options =>
+    {
+        options.GroupNameFormat = "'v'V";
+        options.SubstituteApiVersionInUrl = true;
+    });
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGenNewtonsoftSupport();
+builder.Services.AddSwaggerGen(opt =>
+{
+    var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
+    opt.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, xmlFilename));
+});
+builder.Services.ConfigureOptions<NamedSwaggerGenOptions>();
+
+string ConnectionString = $"Host={Environment.GetEnvironmentVariable("POSTGRES_HOST") ?? "localhost:5432"}; " +
+                          $"Database={Environment.GetEnvironmentVariable("POSTGRES_DB") ?? "postgres"}; " +
+                          $"Username={Environment.GetEnvironmentVariable("POSTGRES_USER") ?? "postgres"}; " +
+                          $"Password={Environment.GetEnvironmentVariable("POSTGRES_PASSWORD") ?? "postgres"}";
+
+builder.Services.AddDbContext<PgsqlContext>(options =>
+    options.UseNpgsql(ConnectionString));
+builder.Services.AddDbContext<NotificationsContext>(options =>
+    options.UseNpgsql(ConnectionString));
+builder.Services.AddDbContext<LibraryContext>(options =>
+    options.UseNpgsql(ConnectionString));
+
+builder.Services.AddControllers(options =>
+{
+    options.AllowEmptyInputInBodyModelBinding = true;
+});
+builder.Services.AddControllers().AddNewtonsoftJson(opts =>
+{
+    opts.SerializerSettings.Converters.Add(new StringEnumConverter());
+    opts.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
+});
+builder.Services.AddScoped<ILog>(opts => LogManager.GetLogger("API"));
+
+builder.WebHost.UseUrls("http://*:6531");
+
+var app = builder.Build();
+
+ApiVersionSet apiVersionSet = app.NewApiVersionSet()
+    .HasApiVersion(new ApiVersion(2))
+    .ReportApiVersions()
+    .Build();
+
+
+app.UseCors("AllowAll");
+
+app.MapControllers()
+    .WithApiVersionSet(apiVersionSet)
+    .MapToApiVersion(2);
+
+app.UseSwagger();
+app.UseSwaggerUI(options =>
+{
+    options.SwaggerEndpoint(
+            $"/swagger/v2/swagger.json", "v2"); 
+});
+
+app.UseHttpsRedirection();
+
+app.UseMiddleware<RequestTimeMiddleware>();
+
+using (IServiceScope scope = app.Services.CreateScope())
+{
+    PgsqlContext context = scope.ServiceProvider.GetRequiredService<PgsqlContext>();
+    context.Database.Migrate();
+    
+    MangaConnector[] connectors =
+    [
+        new MangaDex(),
+        new ComickIo(),
+        new Global(scope.ServiceProvider.GetService<PgsqlContext>()!)
+    ];
+    MangaConnector[] newConnectors = connectors.Where(c => !context.MangaConnectors.Contains(c)).ToArray();
+    context.MangaConnectors.AddRange(newConnectors);
+    if (!context.LocalLibraries.Any())
+        context.LocalLibraries.Add(new LocalLibrary(TrangaSettings.downloadLocation, "Default Library"));
+
+    context.Jobs.AddRange(context.Jobs.Where(j => j.JobType == JobType.DownloadAvailableChaptersJob)
+        .Include(downloadAvailableChaptersJob => ((DownloadAvailableChaptersJob)downloadAvailableChaptersJob).Manga)
+        .ToList()
+        .Select(dacj => new UpdateChaptersDownloadedJob(((DownloadAvailableChaptersJob)dacj).Manga, 0)));
+    context.Jobs.RemoveRange(context.Jobs.Where(j => j.state == JobState.Completed && j.RecurrenceMs < 1));
+    foreach (Job job in context.Jobs.Where(j => j.state == JobState.Running))
+    {
+        job.state = JobState.FirstExecution;
+        job.LastExecution = DateTime.UnixEpoch;
+    }
+    
+    context.SaveChanges();
+}
+
+using (IServiceScope scope = app.Services.CreateScope())
+{
+    NotificationsContext context = scope.ServiceProvider.GetRequiredService<NotificationsContext>();
+    context.Database.Migrate();
+    
+    string[] emojis = { "(•‿•)", "(づ \u25d5‿\u25d5 )づ", "( \u02d8\u25bd\u02d8)っ\u2668", "=\uff3e\u25cf \u22cf \u25cf\uff3e=", "（ΦωΦ）", "(\u272a\u3268\u272a)", "( ﾉ･o･ )ﾉ", "（〜^\u2207^ )〜", "~(\u2267ω\u2266)~","૮ \u00b4• ﻌ \u00b4• ა", "(\u02c3ᆺ\u02c2)", "(=\ud83d\udf66 \u0f1d \ud83d\udf66=)"};
+    context.Notifications.Add(new Notification("Tranga Started", emojis[Random.Shared.Next(0, emojis.Length - 1)], NotificationUrgency.High));
+    
+    context.SaveChanges();
+}
+
+
+TrangaSettings.Load();
+Tranga.StartLogger();
+
+using (IServiceScope scope = app.Services.CreateScope())
+{
+    PgsqlContext context = scope.ServiceProvider.GetRequiredService<PgsqlContext>();
+    Tranga.RemoveStaleFiles(context);
+}
+Tranga.JobStarterThread.Start(app.Services);
+//Tranga.NotificationSenderThread.Start(app.Services); //TODO RE-ENABLE
+
+app.UseCors("AllowAll");
+
+app.Run();

API/Properties/launchSettings.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:5976",
+      "sslPort": 44332,
+      "environmentVariables": {
+        "POSTGRES_Host": "localhost:5432"
+      }
+    }
+  },
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "http://localhost:5287",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "POSTGRES_Host": "localhost:5432"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:7206;http://localhost:5287",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "POSTGRES_Host": "localhost:5432"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "POSTGRES_Host": "localhost:5432"
+      }
+    }
+  }
+}

API/Schema/Author.cs

@@ -0,0 +1,20 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("AuthorId")]
+public class Author(string authorName)
+{
+    [StringLength(64)]
+    [Required]
+    public string AuthorId { get; init; } = TokenGen.CreateToken(typeof(Author), authorName);
+    [StringLength(128)]
+    [Required]
+    public string AuthorName { get; init; } = authorName;
+
+    public override string ToString()
+    {
+        return $"{AuthorId} {AuthorName}";
+    }
+}

API/Schema/Chapter.cs

@@ -0,0 +1,197 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml.Linq;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+
+namespace API.Schema;
+
+[PrimaryKey("ChapterId")]
+public class Chapter : IComparable<Chapter>
+{
+    [StringLength(64)] [Required] public string ChapterId { get; init; }
+
+    [StringLength(256)]public string? IdOnConnectorSite { get; init; }
+    public string ParentMangaId { get; init; }
+    [JsonIgnore] public Manga ParentManga { get; init; } = null!;
+
+    public int? VolumeNumber { get; private set; }
+    [StringLength(10)] [Required] public string ChapterNumber { get; private set; }
+
+    [StringLength(2048)] [Required] [Url] public string Url { get; internal set; }
+
+    [StringLength(256)] public string? Title { get; private set; }
+
+    [StringLength(256)] [Required] public string FileName { get; private set; }
+
+    [Required] public bool Downloaded { get; internal set; }
+    [NotMapped] public string FullArchiveFilePath => Path.Join(ParentManga.FullDirectoryPath, FileName);
+
+    public Chapter(Manga parentManga, string url, string chapterNumber, int? volumeNumber = null, string? idOnConnectorSite = null, string? title = null)
+    {
+        this.ChapterId = TokenGen.CreateToken(typeof(Chapter), parentManga.MangaId, chapterNumber);
+        this.IdOnConnectorSite = idOnConnectorSite;
+        this.ParentMangaId = parentManga.MangaId;
+        this.ParentManga = parentManga;
+        this.VolumeNumber = volumeNumber;
+        this.ChapterNumber = chapterNumber;
+        this.Url = url;
+        this.Title = title;
+        this.FileName = GetArchiveFilePath();
+        this.Downloaded = false;
+    }
+
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    internal Chapter(string chapterId, string parentMangaId, int? volumeNumber, string chapterNumber, string url, string? idOnConnectorSite, string? title, string fileName, bool downloaded)
+    {
+        this.ChapterId = chapterId;
+        this.IdOnConnectorSite = idOnConnectorSite;
+        this.ParentMangaId = parentMangaId;
+        this.VolumeNumber = volumeNumber;
+        this.ChapterNumber = chapterNumber;
+        this.Url = url;
+        this.Title = title;
+        this.FileName = fileName;
+        this.Downloaded = downloaded;
+    }
+
+    public int CompareTo(Chapter? other)
+    {
+        if (other is not { } otherChapter)
+            throw new ArgumentException($"{other} can not be compared to {this}");
+        return VolumeNumber?.CompareTo(otherChapter.VolumeNumber) switch
+        {
+            < 0 => -1,
+            > 0 => 1,
+            _ => CompareChapterNumbers(ChapterNumber, otherChapter.ChapterNumber)
+        };
+    }
+
+    /// <summary>
+    /// Checks the filesystem if an archive at the ArchiveFilePath exists
+    /// </summary>
+    /// <returns>True if archive exists on disk</returns>
+    public bool CheckDownloaded() => File.Exists(FullArchiveFilePath);
+
+    /// Placeholders:
+    /// %M Manga Name
+    /// %V Volume
+    /// %C Chapter
+    /// %T Title
+    /// %A Author (first in list)
+    /// %I Chapter Internal ID
+    /// %i Manga Internal ID
+    /// %Y Year (Manga)
+    private static readonly Regex NullableRex = new(@"\?([a-zA-Z])\(([^\)]*)\)|(.+?)");
+    private static readonly Regex ReplaceRexx = new(@"%([a-zA-Z])|(.+?)");
+    private string GetArchiveFilePath()
+    {
+        string archiveNamingScheme = TrangaSettings.chapterNamingScheme;
+        StringBuilder stringBuilder = new();
+        foreach (Match nullable in  NullableRex.Matches(archiveNamingScheme))
+        {
+            if (nullable.Groups[3].Success)
+            {
+                stringBuilder.Append(nullable.Groups[3].Value);
+                continue;
+            }
+
+            char placeholder = nullable.Groups[1].Value[0];
+            bool isNull = placeholder switch
+            {
+                'M' => ParentManga?.Name is null,
+                'V' => VolumeNumber is null,
+                'C' => ChapterNumber is null,
+                'T' => Title is null,
+                'A' => ParentManga?.Authors?.FirstOrDefault()?.AuthorName is null,
+                'I' => ChapterId is null,
+                'i' => ParentManga?.MangaId is null,
+                'Y' => ParentManga?.Year is null,
+                _ => true
+            };
+            if(!isNull)
+                stringBuilder.Append(nullable.Groups[2].Value);
+        }
+        
+        string checkedString = stringBuilder.ToString();
+        stringBuilder = new();
+        
+        foreach (Match replace in ReplaceRexx.Matches(checkedString))
+        {
+            if (replace.Groups[2].Success)
+            {
+                stringBuilder.Append(replace.Groups[2].Value);
+                continue;
+            }
+            
+            char placeholder = replace.Groups[1].Value[0];
+            string? value = placeholder switch
+            {
+                'M' => ParentManga?.Name,
+                'V' => VolumeNumber?.ToString(),
+                'C' => ChapterNumber,
+                'T' => Title,
+                'A' => ParentManga?.Authors?.FirstOrDefault()?.AuthorName,
+                'I' => ChapterId,
+                'i' => ParentManga?.MangaId,
+                'Y' => ParentManga?.Year.ToString(),
+                _ => null
+            };
+            stringBuilder.Append(value);
+        }
+
+        stringBuilder.Append(".cbz");
+
+        return stringBuilder.ToString();
+    }
+
+    private static int CompareChapterNumbers(string ch1, string ch2)
+    {
+        int[] ch1Arr = ch1.Split('.').Select(c => int.TryParse(c, out int result) ? result : -1).ToArray();
+        int[] ch2Arr = ch2.Split('.').Select(c => int.TryParse(c, out int result) ? result : -1).ToArray();
+        
+        if (ch1Arr.Contains(-1) || ch2Arr.Contains(-1))
+            throw new ArgumentException("Chapter number is not in correct format");
+        
+        int i = 0, j = 0;
+
+        while (i < ch1Arr.Length && j < ch2Arr.Length)
+        {
+            if (ch1Arr[i] < ch2Arr[j])
+                return -1;
+            if (ch1Arr[i] > ch2Arr[j])
+                return 1;
+            i++;
+            j++;
+        }
+
+        return 0;
+    }
+
+    internal string GetComicInfoXmlString()
+    {
+        XElement comicInfo = new("ComicInfo",
+            new XElement("Number", ChapterNumber)
+        );
+        if(Title is not null)
+            comicInfo.Add(new XElement("Title", Title));
+        if(ParentManga.MangaTags.Count > 0)
+            comicInfo.Add(new XElement("Tags", string.Join(',', ParentManga.MangaTags.Select(tag => tag.Tag))));
+        if(VolumeNumber is not null)
+            comicInfo.Add(new XElement("Volume", VolumeNumber));
+        if(ParentManga.Authors.Count > 0)
+            comicInfo.Add(new XElement("Writer", string.Join(',', ParentManga.Authors.Select(author => author.AuthorName))));
+        if(ParentManga.OriginalLanguage is not null)
+            comicInfo.Add(new XElement("LanguageISO", ParentManga.OriginalLanguage));
+        return comicInfo.ToString();
+    }
+
+    public override string ToString()
+    {
+        return $"{ChapterId} Vol.{VolumeNumber} Ch.{ChapterNumber} - {Title}";
+    }
+}

API/Schema/Contexts/LibraryContext.cs

@@ -0,0 +1,32 @@
+using API.Schema.LibraryConnectors;
+using log4net;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+
+namespace API.Schema.Contexts;
+
+public class LibraryContext(DbContextOptions<LibraryContext> options) : DbContext(options)
+{
+    public DbSet<LibraryConnector> LibraryConnectors { get; set; }
+    
+    private ILog Log => LogManager.GetLogger(GetType());
+
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+    {
+        base.OnConfiguring(optionsBuilder);
+        optionsBuilder.EnableSensitiveDataLogging();
+        optionsBuilder.LogTo(s =>
+        {
+            Log.Debug(s);
+        }, [DbLoggerCategory.Query.Name], LogLevel.Trace, DbContextLoggerOptions.Level | DbContextLoggerOptions.Category);
+    }
+    
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        //LibraryConnector Types
+        modelBuilder.Entity<LibraryConnector>()
+            .HasDiscriminator(l => l.LibraryType)
+            .HasValue<Komga>(LibraryType.Komga)
+            .HasValue<Kavita>(LibraryType.Kavita);
+    }
+}

API/Schema/Contexts/NotificationsContext.cs

@@ -0,0 +1,23 @@
+using API.Schema.NotificationConnectors;
+using log4net;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+
+namespace API.Schema.Contexts;
+
+public class NotificationsContext(DbContextOptions<NotificationsContext> options) : DbContext(options)
+{
+    public DbSet<NotificationConnector> NotificationConnectors { get; set; }
+    public DbSet<Notification> Notifications { get; set; }
+    
+    private ILog Log => LogManager.GetLogger(GetType());
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+    {
+        base.OnConfiguring(optionsBuilder);
+        optionsBuilder.EnableSensitiveDataLogging();
+        optionsBuilder.LogTo(s =>
+        {
+            Log.Debug(s);
+        }, [DbLoggerCategory.Query.Name], LogLevel.Trace, DbContextLoggerOptions.Level | DbContextLoggerOptions.Category);
+    }
+}

API/Schema/Contexts/PgsqlContext.cs

@@ -0,0 +1,196 @@
+using API.Schema.Jobs;
+using API.Schema.MangaConnectors;
+using log4net;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+
+namespace API.Schema.Contexts;
+
+public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(options)
+{
+    public DbSet<Job> Jobs { get; set; }
+    public DbSet<MangaConnector> MangaConnectors { get; set; }
+    public DbSet<Manga> Mangas { get; set; }
+    public DbSet<LocalLibrary> LocalLibraries { get; set; }
+    public DbSet<Chapter> Chapters { get; set; }
+    public DbSet<Author> Authors { get; set; }
+    public DbSet<MangaTag> Tags { get; set; }
+    private ILog Log => LogManager.GetLogger(GetType());
+    
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+    {
+        base.OnConfiguring(optionsBuilder);
+        optionsBuilder.EnableSensitiveDataLogging();
+        optionsBuilder.LogTo(s =>
+        {
+            Log.Debug(s);
+        }, [DbLoggerCategory.Query.Name], LogLevel.Trace, DbContextLoggerOptions.Level | DbContextLoggerOptions.Category);
+    }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        //Job Types
+        modelBuilder.Entity<Job>()
+            .HasDiscriminator(j => j.JobType)
+            .HasValue<MoveFileOrFolderJob>(JobType.MoveFileOrFolderJob)
+            .HasValue<MoveMangaLibraryJob>(JobType.MoveMangaLibraryJob)
+            .HasValue<DownloadAvailableChaptersJob>(JobType.DownloadAvailableChaptersJob)
+            .HasValue<DownloadSingleChapterJob>(JobType.DownloadSingleChapterJob)
+            .HasValue<DownloadMangaCoverJob>(JobType.DownloadMangaCoverJob)
+            .HasValue<RetrieveChaptersJob>(JobType.RetrieveChaptersJob)
+            .HasValue<UpdateCoverJob>(JobType.UpdateCoverJob)
+            .HasValue<UpdateChaptersDownloadedJob>(JobType.UpdateChaptersDownloadedJob)
+            .HasValue<UpdateSingleChapterDownloadedJob>(JobType.UpdateSingleChapterDownloadedJob);
+        
+        //Job specification
+        modelBuilder.Entity<DownloadAvailableChaptersJob>()
+            .HasOne<Manga>(j => j.Manga)
+            .WithMany()
+            .HasForeignKey(j => j.MangaId)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<DownloadAvailableChaptersJob>()
+            .Navigation(j => j.Manga)
+            .EnableLazyLoading();
+        modelBuilder.Entity<DownloadMangaCoverJob>()
+            .HasOne<Manga>(j => j.Manga)
+            .WithMany()
+            .HasForeignKey(j => j.MangaId)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<DownloadMangaCoverJob>()
+            .Navigation(j => j.Manga)
+            .EnableLazyLoading();
+        modelBuilder.Entity<DownloadSingleChapterJob>()
+            .HasOne<Chapter>(j => j.Chapter)
+            .WithMany()
+            .HasForeignKey(j => j.ChapterId)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<DownloadSingleChapterJob>()
+            .Navigation(j => j.Chapter)
+            .EnableLazyLoading();
+        modelBuilder.Entity<MoveMangaLibraryJob>()
+            .HasOne<Manga>(j => j.Manga)
+            .WithMany()
+            .HasForeignKey(j => j.MangaId)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<MoveMangaLibraryJob>()
+            .Navigation(j => j.Manga)
+            .EnableLazyLoading();
+        modelBuilder.Entity<MoveMangaLibraryJob>()
+            .HasOne<LocalLibrary>(j => j.ToLibrary)
+            .WithMany()
+            .HasForeignKey(j => j.ToLibraryId)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<MoveMangaLibraryJob>()
+            .Navigation(j => j.ToLibrary)
+            .EnableLazyLoading();
+        modelBuilder.Entity<RetrieveChaptersJob>()
+            .HasOne<Manga>(j => j.Manga)
+            .WithMany()
+            .HasForeignKey(j => j.MangaId)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<RetrieveChaptersJob>()
+            .Navigation(j => j.Manga)
+            .EnableLazyLoading();
+        modelBuilder.Entity<UpdateChaptersDownloadedJob>()
+            .HasOne<Manga>(j => j.Manga)
+            .WithMany()
+            .HasForeignKey(j => j.MangaId)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<UpdateChaptersDownloadedJob>()
+            .Navigation(j => j.Manga)
+            .EnableLazyLoading();
+        
+        //Job has possible ParentJob
+        modelBuilder.Entity<Job>()
+            .HasOne<Job>(childJob => childJob.ParentJob)
+            .WithMany()
+            .HasForeignKey(childjob => childjob.ParentJobId)
+            .OnDelete(DeleteBehavior.Cascade);
+        //Job might be dependent on other Jobs
+        modelBuilder.Entity<Job>()
+            .HasMany<Job>(root => root.DependsOnJobs)
+            .WithMany();
+        modelBuilder.Entity<Job>()
+            .Navigation(j => j.DependsOnJobs)
+            .AutoInclude(false)
+            .EnableLazyLoading();
+        
+        //MangaConnector Types
+        modelBuilder.Entity<MangaConnector>()
+            .HasDiscriminator(c => c.Name)
+            .HasValue<Global>("Global")
+            .HasValue<MangaDex>("MangaDex")
+            .HasValue<ComickIo>("ComickIo");
+        //MangaConnector is responsible for many Manga
+        modelBuilder.Entity<MangaConnector>()
+            .HasMany<Manga>()
+            .WithOne(m => m.MangaConnector)
+            .HasForeignKey(m => m.MangaConnectorName)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.MangaConnector)
+            .AutoInclude();
+
+        //Manga has many Chapters
+        modelBuilder.Entity<Manga>()
+            .HasMany<Chapter>(m => m.Chapters)
+            .WithOne(c => c.ParentManga)
+            .HasForeignKey(c => c.ParentMangaId)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<Chapter>()
+            .Navigation(c => c.ParentManga)
+            .AutoInclude();
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.Chapters)
+            .AutoInclude(false)
+            .EnableLazyLoading();
+        //Manga owns MangaAltTitles
+        modelBuilder.Entity<Manga>()
+            .OwnsMany<MangaAltTitle>(m => m.AltTitles)
+            .WithOwner();
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.AltTitles)
+            .AutoInclude();
+        //Manga owns Links
+        modelBuilder.Entity<Manga>()
+            .OwnsMany<Link>(m => m.Links)
+            .WithOwner();
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.Links)
+            .AutoInclude();
+        //Manga has many Tags associated with many Manga
+        modelBuilder.Entity<Manga>()
+            .HasMany<MangaTag>(m => m.MangaTags)
+            .WithMany()
+            .UsingEntity("MangaTagToManga",
+                l=> l.HasOne(typeof(MangaTag)).WithMany().HasForeignKey("MangaTagIds").HasPrincipalKey(nameof(MangaTag.Tag)),
+                r => r.HasOne(typeof(Manga)).WithMany().HasForeignKey("MangaIds").HasPrincipalKey(nameof(Manga.MangaId)),
+                j => j.HasKey("MangaTagIds", "MangaIds")
+            );
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.MangaTags)
+            .AutoInclude();
+        //Manga has many Authors associated with many Manga
+        modelBuilder.Entity<Manga>()
+            .HasMany<Author>(m => m.Authors)
+            .WithMany()
+            .UsingEntity("AuthorToManga",
+                l=> l.HasOne(typeof(Author)).WithMany().HasForeignKey("AuthorIds").HasPrincipalKey(nameof(Author.AuthorId)),
+                r => r.HasOne(typeof(Manga)).WithMany().HasForeignKey("MangaIds").HasPrincipalKey(nameof(Manga.MangaId)),
+                j => j.HasKey("AuthorIds", "MangaIds")
+            );
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.Authors)
+            .AutoInclude();
+        
+        //LocalLibrary has many Mangas
+        modelBuilder.Entity<LocalLibrary>()
+            .HasMany<Manga>()
+            .WithOne(m => m.Library)
+            .HasForeignKey(m => m.LibraryId)
+            .OnDelete(DeleteBehavior.SetNull);
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.Library)
+            .AutoInclude();
+    }
+}

API/Schema/Jobs/DownloadAvailableChaptersJob.cs

@@ -0,0 +1,42 @@
+using System.ComponentModel.DataAnnotations;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class DownloadAvailableChaptersJob : Job
+{
+    [StringLength(64)] [Required] public string MangaId { get; init; }
+
+    private Manga _manga = null!;
+    
+    [JsonIgnore]
+    public Manga Manga 
+    {
+        get => LazyLoader.Load(this, ref _manga);
+        init => _manga = value;
+    }
+    
+    public DownloadAvailableChaptersJob(Manga manga, ulong recurrenceMs, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
+        : base(TokenGen.CreateToken(typeof(DownloadAvailableChaptersJob)), JobType.DownloadAvailableChaptersJob, recurrenceMs, parentJob, dependsOnJobs)
+    {
+        this.MangaId = manga.MangaId;
+        this.Manga = manga;
+    }
+    
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    internal DownloadAvailableChaptersJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string mangaId, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.DownloadAvailableChaptersJob, recurrenceMs, parentJobId)
+    {
+        this.MangaId = mangaId;
+    }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        context.Entry(Manga).Reference<LocalLibrary>(m => m.Library).Load();
+        return Manga.Chapters.Where(c => c.Downloaded == false).Select(chapter => new DownloadSingleChapterJob(chapter, this));
+    }
+}

API/Schema/Jobs/DownloadMangaCoverJob.cs

@@ -0,0 +1,51 @@
+using System.ComponentModel.DataAnnotations;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class DownloadMangaCoverJob : Job
+{
+    [StringLength(64)] [Required] public string MangaId { get; init; }
+
+    private Manga _manga = null!;
+    
+    [JsonIgnore]
+    public Manga Manga 
+    {
+        get => LazyLoader.Load(this, ref _manga);
+        init => _manga = value;
+    }
+
+    public DownloadMangaCoverJob(Manga manga, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
+        : base(TokenGen.CreateToken(typeof(DownloadMangaCoverJob)), JobType.DownloadMangaCoverJob, 0, parentJob, dependsOnJobs)
+    {
+        this.MangaId = manga.MangaId;
+        this.Manga = manga;
+    }
+    
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    internal DownloadMangaCoverJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string mangaId, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.DownloadMangaCoverJob, recurrenceMs, parentJobId)
+    {
+        this.MangaId = mangaId;
+    }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        try
+        {
+            Manga.CoverFileNameInCache = Manga.MangaConnector.SaveCoverImageToCache(Manga);
+            context.SaveChanges();
+        }
+        catch (DbUpdateException e)
+        {
+            Log.Error(e);
+        }
+        return [];
+    }
+}

API/Schema/Jobs/DownloadSingleChapterJob.cs

@@ -0,0 +1,190 @@
+using System.ComponentModel.DataAnnotations;
+using System.IO.Compression;
+using System.Runtime.InteropServices;
+using API.MangaDownloadClients;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Formats.Jpeg;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors.Binarization;
+using static System.IO.UnixFileMode;
+
+namespace API.Schema.Jobs;
+
+public class DownloadSingleChapterJob : Job
+{
+    [StringLength(64)] [Required] public string ChapterId { get; init; }
+
+    private Chapter _chapter = null!;
+    
+    [JsonIgnore]
+    public Chapter Chapter 
+    {
+        get => LazyLoader.Load(this, ref _chapter);
+        init => _chapter = value;
+    }
+
+    public DownloadSingleChapterJob(Chapter chapter, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
+        : base(TokenGen.CreateToken(typeof(DownloadSingleChapterJob)), JobType.DownloadSingleChapterJob, 0, parentJob, dependsOnJobs)
+    {
+        this.ChapterId = chapter.ChapterId;
+        this.Chapter = chapter;
+    }
+    
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    internal DownloadSingleChapterJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string chapterId, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.DownloadSingleChapterJob, recurrenceMs, parentJobId)
+    {
+        this.ChapterId = chapterId;
+    }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        string[] imageUrls = Chapter.ParentManga.MangaConnector.GetChapterImageUrls(Chapter);
+        if (imageUrls.Length < 1)
+        {
+            Log.Info($"No imageUrls for chapter {ChapterId}");
+            return [];
+        }
+        context.Entry(Chapter.ParentManga).Reference<LocalLibrary>(m => m.Library).Load(); //Need to explicitly load, because we are not accessing navigation directly...
+        string saveArchiveFilePath = Chapter.FullArchiveFilePath;
+        Log.Debug($"Chapter path: {saveArchiveFilePath}");
+        
+        //Check if Publication Directory already exists
+        string? directoryPath = Path.GetDirectoryName(saveArchiveFilePath);
+        if (directoryPath is null)
+        {
+            Log.Error($"Directory path could not be found: {saveArchiveFilePath}");
+            this.state = JobState.Failed;
+            return [];
+        }
+        if (!Directory.Exists(directoryPath))
+        {
+            Log.Info($"Creating publication Directory: {directoryPath}");
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                Directory.CreateDirectory(directoryPath,
+                    UserRead | UserWrite | UserExecute | GroupRead | GroupWrite | GroupExecute );
+            else
+                Directory.CreateDirectory(directoryPath);
+        }
+
+        if (File.Exists(saveArchiveFilePath)) //Don't download twice. Redownload
+        {
+            Log.Info($"Archive {saveArchiveFilePath} already existed, but deleting and re-downloading.");
+            File.Delete(saveArchiveFilePath);
+        }
+        
+        //Create a temporary folder to store images
+        string tempFolder = Directory.CreateTempSubdirectory("trangatemp").FullName;
+        Log.Debug($"Created temp folder: {tempFolder}");
+
+        Log.Info($"Downloading images: {ChapterId}");
+        int chapterNum = 0;
+        //Download all Images to temporary Folder
+        foreach (string imageUrl in imageUrls)
+        {
+            string extension = imageUrl.Split('.')[^1].Split('?')[0];
+            string imagePath = Path.Join(tempFolder, $"{chapterNum++}.{extension}");
+            bool status = DownloadImage(imageUrl, imagePath);
+            if (status is false)
+            {
+                Log.Error($"Failed to download image: {imageUrl}");
+                return [];
+            }
+        }
+        
+        CopyCoverFromCacheToDownloadLocation(Chapter.ParentManga);
+        
+        Log.Debug($"Creating ComicInfo.xml {ChapterId}");
+        File.WriteAllText(Path.Join(tempFolder, "ComicInfo.xml"), Chapter.GetComicInfoXmlString());
+        
+        Log.Debug($"Packaging images to archive {ChapterId}");
+        //ZIP-it and ship-it
+        ZipFile.CreateFromDirectory(tempFolder, saveArchiveFilePath);
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            File.SetUnixFileMode(saveArchiveFilePath, UserRead | UserWrite | UserExecute | GroupRead | GroupWrite | GroupExecute | OtherRead | OtherExecute);
+        Directory.Delete(tempFolder, true); //Cleanup
+        
+        Chapter.Downloaded = true;
+        context.SaveChanges();
+
+        if (context.Jobs.ToList().Any(j =>
+            {
+                if (j.JobType != JobType.UpdateChaptersDownloadedJob)
+                    return false;
+                UpdateChaptersDownloadedJob job = (UpdateChaptersDownloadedJob)j;
+                return job.MangaId == this.Chapter.ParentMangaId;
+            }))
+            return [];
+
+        return [new UpdateChaptersDownloadedJob(Chapter.ParentManga, 0, this.ParentJob)];
+    }
+    
+    private void ProcessImage(string imagePath)
+    {
+        if (!TrangaSettings.bwImages && TrangaSettings.compression == 100)
+        {
+            Log.Debug($"No processing requested for image");
+            return;
+        }
+        
+        Log.Debug($"Processing image: {imagePath}");
+        
+        using Image image = Image.Load(imagePath);
+        File.Delete(imagePath);
+        if(TrangaSettings.bwImages) 
+            image.Mutate(i => i.ApplyProcessor(new AdaptiveThresholdProcessor()));
+        image.SaveAsJpeg(imagePath, new JpegEncoder()
+        {
+            Quality = TrangaSettings.compression
+        });
+    }
+    
+    private void CopyCoverFromCacheToDownloadLocation(Manga manga)
+    {
+        //Check if Publication already has a Folder and cover
+        string publicationFolder = manga.CreatePublicationFolder();
+        DirectoryInfo dirInfo = new (publicationFolder);
+        if (dirInfo.EnumerateFiles().Any(info => info.Name.Contains("cover", StringComparison.InvariantCultureIgnoreCase)))
+        {
+            Log.Debug($"Cover already exists at {publicationFolder}");
+            return;
+        }
+
+        Log.Info($"Copying cover to {publicationFolder}");
+        string? fileInCache = manga.CoverFileNameInCache ?? manga.MangaConnector.SaveCoverImageToCache(manga);
+        if (fileInCache is null)
+        {
+            Log.Error($"File {fileInCache} does not exist");
+            return;
+        }
+        
+        string newFilePath = Path.Join(publicationFolder, $"cover.{Path.GetFileName(fileInCache).Split('.')[^1]}" );
+        File.Copy(fileInCache, newFilePath, true);
+        if(RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            File.SetUnixFileMode(newFilePath, GroupRead | GroupWrite | UserRead | UserWrite);
+        Log.Debug($"Copied cover from {fileInCache} to {newFilePath}");
+    }
+    
+    private bool DownloadImage(string imageUrl, string savePath)
+    {
+        HttpDownloadClient downloadClient = new();
+        RequestResult requestResult = downloadClient.MakeRequest(imageUrl, RequestType.MangaImage);
+        
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return false;
+        if (requestResult.result == Stream.Null)
+            return false;
+
+        FileStream fs = new (savePath, FileMode.Create, FileAccess.Write, FileShare.None);
+        requestResult.result.CopyTo(fs);
+        fs.Close();
+        ProcessImage(savePath);
+        return true;
+    }
+}

API/Schema/Jobs/Job.cs

@@ -0,0 +1,113 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using API.Schema.Contexts;
+using log4net;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+[PrimaryKey("JobId")]
+public abstract class Job 
+{
+    [StringLength(64)]
+    [Required]
+    public string JobId { get; init; }
+
+    [StringLength(64)] public string? ParentJobId { get; private set; }
+    [JsonIgnore] public Job? ParentJob { get; internal set; }
+    private ICollection<Job> _dependsOnJobs = null!;
+    [JsonIgnore] public ICollection<Job> DependsOnJobs
+    {
+        get => LazyLoader.Load(this, ref _dependsOnJobs);
+        init => _dependsOnJobs = value;
+    }
+
+    [Required] public JobType JobType { get; init; }
+
+    [Required] public ulong RecurrenceMs { get; set; }
+
+    [Required] public DateTime LastExecution { get; internal set; } = DateTime.UnixEpoch;
+
+    [NotMapped] [Required] public DateTime NextExecution => LastExecution.AddMilliseconds(RecurrenceMs);
+    [Required] public JobState state { get; internal set; } = JobState.FirstExecution;
+    [Required] public bool Enabled { get; internal set; } = true;
+
+    [JsonIgnore] [NotMapped] internal bool IsCompleted => state is >= (JobState)128 and < (JobState)192;
+
+    [NotMapped] [JsonIgnore] protected ILog Log { get; init; }
+    [NotMapped] [JsonIgnore] protected ILazyLoader LazyLoader { get; init; }
+
+    protected Job(string jobId, JobType jobType, ulong recurrenceMs, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
+    {
+        this.JobId = jobId;
+        this.JobType = jobType;
+        this.RecurrenceMs = recurrenceMs;
+        this.ParentJobId = parentJob?.JobId;
+        this.ParentJob = parentJob;
+        this.DependsOnJobs = dependsOnJobs ?? [];
+        
+        this.Log = LogManager.GetLogger(this.GetType());
+    }
+
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    protected internal Job(ILazyLoader lazyLoader, string jobId, JobType jobType, ulong recurrenceMs, string? parentJobId)
+    {
+        this.LazyLoader = lazyLoader;
+        this.JobId = jobId;
+        this.JobType = jobType;
+        this.RecurrenceMs = recurrenceMs;
+        this.ParentJobId = parentJobId;
+        this.DependsOnJobs = [];
+        
+        this.Log = LogManager.GetLogger(this.GetType());
+    }
+
+    public IEnumerable<Job> Run(PgsqlContext context)
+    {
+        Log.Info($"Running job {JobId}");
+        DateTime jobStart = DateTime.UtcNow;
+        context.Attach(this);
+        Job[]? ret = null;
+
+        try
+        {
+            this.state = JobState.Running;
+            context.SaveChanges();
+            ret = RunInternal(context).ToArray();
+            this.state = this.RecurrenceMs > 0 ? JobState.CompletedWaiting : JobState.Completed;
+            this.LastExecution = DateTime.UtcNow;
+            context.Jobs.AddRange(ret);
+            Log.Info($"Job {JobId} completed. Generated {ret.Length} new jobs.");
+            context.SaveChanges();
+        }
+        catch (Exception e)
+        {
+            if (e is not DbUpdateException)
+            {
+                this.state = JobState.Failed;
+                this.Enabled = false;
+                this.LastExecution = DateTime.UtcNow;
+                Log.Error($"Failed to run job {JobId}", e);
+                context.SaveChanges();
+            }
+            else
+            {
+                Log.Error($"Failed to update Database {JobId}", e);
+            }
+        }
+        
+        Log.Info($"Finished Job {JobId}! (took {DateTime.UtcNow.Subtract(jobStart).TotalMilliseconds}ms)");
+        return ret ?? [];
+    }
+    
+    protected abstract IEnumerable<Job> RunInternal(PgsqlContext context);
+
+    public override string ToString()
+    {
+        return $"{JobId}";
+    }
+}

API/Schema/Jobs/JobState.cs

@@ -0,0 +1,14 @@
+namespace API.Schema.Jobs;
+
+public enum JobState : byte
+{
+    //Values 0-63 Preparation Stages
+    FirstExecution = 0, 
+    //64-127 Running Stages
+    Running = 64,
+    //128-191 Completion Stages
+    Completed = 128,
+    CompletedWaiting = 159,
+    //192-255 Error stages
+    Failed = 192
+}

API/Schema/Jobs/JobType.cs

@@ -0,0 +1,16 @@
+namespace API.Schema.Jobs;
+
+
+public enum JobType : byte
+{
+    DownloadSingleChapterJob = 0, 
+    DownloadAvailableChaptersJob = 1, 
+    UpdateMetaDataJob = 2,
+    MoveFileOrFolderJob = 3,
+    DownloadMangaCoverJob = 4,
+    RetrieveChaptersJob = 5,
+    UpdateChaptersDownloadedJob = 6,
+    MoveMangaLibraryJob = 7,
+    UpdateSingleChapterDownloadedJob = 8,
+    UpdateCoverJob = 9,
+}

API/Schema/Jobs/MoveFileOrFolderJob.cs

@@ -0,0 +1,71 @@
+using System.ComponentModel.DataAnnotations;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace API.Schema.Jobs;
+
+public class MoveFileOrFolderJob : Job
+{
+    [StringLength(256)]
+    [Required]
+    public string FromLocation { get; init; }
+    [StringLength(256)]
+    [Required]
+    public string ToLocation { get; init; }
+    
+    public MoveFileOrFolderJob(string fromLocation, string toLocation, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
+        : base(TokenGen.CreateToken(typeof(MoveFileOrFolderJob)), JobType.MoveFileOrFolderJob, 0, parentJob, dependsOnJobs)
+    {
+        this.FromLocation = fromLocation;
+        this.ToLocation = toLocation;
+    }
+    
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    internal MoveFileOrFolderJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string fromLocation, string toLocation, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.MoveFileOrFolderJob, recurrenceMs, parentJobId)
+    {
+        this.FromLocation = fromLocation;
+        this.ToLocation = toLocation;
+    }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        try
+        {
+            FileInfo fi = new (FromLocation);
+            if (!fi.Exists)
+            {
+                Log.Error($"File does not exist at {FromLocation}");
+                return [];
+            }
+
+            if (File.Exists(ToLocation))//Do not override existing
+            {
+                Log.Error($"File already exists at {ToLocation}");
+                return [];
+            } 
+            if(fi.Attributes.HasFlag(FileAttributes.Directory))
+                MoveDirectory(fi, ToLocation);
+            else
+                MoveFile(fi, ToLocation);
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+        }
+
+        return [];
+    }
+
+    private void MoveDirectory(FileInfo from, string toLocation)
+    {
+        Directory.Move(from.FullName, toLocation);        
+    }
+
+    private void MoveFile(FileInfo from, string toLocation)
+    {
+        File.Move(from.FullName, toLocation);
+    }
+}

API/Schema/Jobs/MoveMangaLibraryJob.cs

@@ -0,0 +1,60 @@
+using System.ComponentModel.DataAnnotations;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class MoveMangaLibraryJob : Job
+{
+    [StringLength(64)] [Required] public string MangaId { get; init; }
+
+    private Manga _manga = null!;
+    
+    [JsonIgnore]
+    public Manga Manga 
+    {
+        get => LazyLoader.Load(this, ref _manga);
+        init => _manga = value;
+    }
+    [StringLength(64)] [Required] public string ToLibraryId { get; init; }
+    public LocalLibrary ToLibrary { get; init; } = null!;
+    
+    public MoveMangaLibraryJob(Manga manga, LocalLibrary toLibrary, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
+        : base(TokenGen.CreateToken(typeof(MoveMangaLibraryJob)), JobType.MoveMangaLibraryJob, 0, parentJob, dependsOnJobs)
+    {
+        this.MangaId = manga.MangaId;
+        this.Manga = manga;
+        this.ToLibraryId = toLibrary.LocalLibraryId;
+        this.ToLibrary = toLibrary;
+    }
+    
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    internal MoveMangaLibraryJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string mangaId, string toLibraryId, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.MoveMangaLibraryJob, recurrenceMs, parentJobId)
+    {
+        this.MangaId = mangaId;
+        this.ToLibraryId = toLibraryId;
+    }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        context.Entry(Manga).Reference<LocalLibrary>(m => m.Library).Load();
+        Dictionary<Chapter, string> oldPath = Manga.Chapters.ToDictionary(c => c, c => c.FullArchiveFilePath);
+        Manga.Library = ToLibrary;
+        try
+        {
+            context.SaveChanges();
+        }
+        catch (DbUpdateException e)
+        {
+            Log.Error(e);
+            return [];
+        }
+
+        return Manga.Chapters.Select(c => new MoveFileOrFolderJob(oldPath[c], c.FullArchiveFilePath));
+    }
+}

API/Schema/Jobs/RetrieveChaptersJob.cs

@@ -0,0 +1,61 @@
+using System.ComponentModel.DataAnnotations;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class RetrieveChaptersJob : Job
+{
+    [StringLength(64)] [Required] public string MangaId { get; init; }
+
+    private Manga _manga = null!;
+    
+    [JsonIgnore]
+    public Manga Manga 
+    {
+        get => LazyLoader.Load(this, ref _manga);
+        init => _manga = value;
+    }
+    [StringLength(8)] [Required] public string Language { get; private set; }
+    
+    public RetrieveChaptersJob(Manga manga, string language, ulong recurrenceMs, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
+        : base(TokenGen.CreateToken(typeof(RetrieveChaptersJob)), JobType.RetrieveChaptersJob, recurrenceMs, parentJob, dependsOnJobs)
+    {
+        this.MangaId = manga.MangaId;
+        this.Manga = manga;
+        this.Language = language;
+    }
+    
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    internal RetrieveChaptersJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string mangaId, string language, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.RetrieveChaptersJob, recurrenceMs, parentJobId)
+    {
+        this.MangaId = mangaId;
+        this.Language = language;
+    }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        // This gets all chapters that are not downloaded
+        Chapter[] allChapters = Manga.MangaConnector.GetChapters(Manga, Language).DistinctBy(c => c.ChapterId).ToArray();
+        Chapter[] newChapters = allChapters.Where(chapter => Manga.Chapters.Select(c => c.ChapterId).Contains(chapter.ChapterId) == false).ToArray();
+        Log.Info($"{Manga.Chapters.Count} existing + {newChapters.Length} new chapters.");
+
+        try
+        {
+            foreach (Chapter newChapter in newChapters)
+                Manga.Chapters.Add(newChapter);
+            context.SaveChanges();
+        }
+        catch (DbUpdateException e)
+        {
+            Log.Error(e);
+        }
+
+        return [];
+    }
+}

API/Schema/Jobs/UpdateChaptersDownloadedJob.cs

@@ -0,0 +1,41 @@
+using System.ComponentModel.DataAnnotations;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class UpdateChaptersDownloadedJob : Job
+{
+    [StringLength(64)] [Required] public string MangaId { get; init; }
+
+    private Manga _manga = null!;
+    
+    [JsonIgnore]
+    public Manga Manga 
+    {
+        get => LazyLoader.Load(this, ref _manga);
+        init => _manga = value;
+    }
+    
+    public UpdateChaptersDownloadedJob(Manga manga, ulong recurrenceMs, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
+        : base(TokenGen.CreateToken(typeof(UpdateChaptersDownloadedJob)), JobType.UpdateChaptersDownloadedJob, recurrenceMs, parentJob, dependsOnJobs)
+    {
+        this.MangaId = manga.MangaId;
+        this.Manga = manga;
+    }
+    
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    internal UpdateChaptersDownloadedJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string mangaId, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.UpdateChaptersDownloadedJob, recurrenceMs, parentJobId)
+    {
+        this.MangaId = mangaId;
+    }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        return Manga.Chapters.Select(c => new UpdateSingleChapterDownloadedJob(c, this));
+    }
+}

API/Schema/Jobs/UpdateCoverJob.cs

@@ -0,0 +1,65 @@
+using System.ComponentModel.DataAnnotations;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class UpdateCoverJob : Job
+{
+    [StringLength(64)] [Required] public string MangaId { get; init; }
+
+    private Manga _manga = null!;
+    
+    [JsonIgnore]
+    public Manga Manga 
+    {
+        get => LazyLoader.Load(this, ref _manga);
+        init => _manga = value;
+    }
+    
+    
+    public UpdateCoverJob(Manga manga, ulong recurrenceMs, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
+        : base(TokenGen.CreateToken(typeof(UpdateCoverJob)), JobType.UpdateCoverJob, recurrenceMs, parentJob, dependsOnJobs)
+    {
+        this.MangaId = manga.MangaId;
+        this.Manga = manga;
+    }
+    
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    internal UpdateCoverJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string mangaId, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.UpdateCoverJob, recurrenceMs, parentJobId)
+    {
+        this.MangaId = mangaId;
+    }
+
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        bool keepCover = context.Jobs
+            .Any(job => job.JobType == JobType.DownloadAvailableChaptersJob
+                        && ((DownloadAvailableChaptersJob)job).MangaId == MangaId);
+        if (!keepCover)
+        {
+            if(File.Exists(Manga.CoverFileNameInCache))
+                File.Delete(Manga.CoverFileNameInCache);
+            try
+            {
+                Manga.CoverFileNameInCache = null;
+                context.Jobs.Remove(this);
+                context.SaveChanges();
+            }
+            catch (DbUpdateException e)
+            {
+                Log.Error(e);
+            }
+        }
+        else
+        {
+            return [new DownloadMangaCoverJob(Manga, this)];
+        }
+        return [];
+    }
+}

API/Schema/Jobs/UpdateSingleChapterDownloadedJob.cs

@@ -0,0 +1,54 @@
+using System.ComponentModel.DataAnnotations;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class UpdateSingleChapterDownloadedJob : Job
+{
+    [StringLength(64)] [Required] public string ChapterId { get; init; }
+
+    private Chapter _chapter = null!;
+    
+    [JsonIgnore]
+    public Chapter Chapter 
+    {
+        get => LazyLoader.Load(this, ref _chapter);
+        init => _chapter = value;
+    }
+    
+    public UpdateSingleChapterDownloadedJob(Chapter chapter, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
+        : base(TokenGen.CreateToken(typeof(UpdateSingleChapterDownloadedJob)), JobType.UpdateSingleChapterDownloadedJob, 0, parentJob, dependsOnJobs)
+    {
+        this.ChapterId = chapter.ChapterId;
+        this.Chapter = chapter;
+    }
+    
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    internal UpdateSingleChapterDownloadedJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string chapterId, string? parentJobId) 
+        : base(lazyLoader, jobId, JobType.UpdateSingleChapterDownloadedJob, recurrenceMs, parentJobId)
+    {
+        this.ChapterId = chapterId;
+    }
+
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        context.Entry(Chapter).Reference<Manga>(c => c.ParentManga).Load();
+        context.Entry(Chapter.ParentManga).Reference<LocalLibrary>(m => m.Library).Load();
+        Chapter.Downloaded = Chapter.CheckDownloaded();
+
+        try
+        {
+            context.SaveChanges();
+        }
+        catch (DbUpdateException e)
+        {
+            Log.Error(e);
+        }
+        return [];
+    }
+}

API/Schema/LibraryConnectors/Kavita.cs

@@ -0,0 +1,113 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace API.Schema.LibraryConnectors;
+
+public class Kavita : LibraryConnector
+{
+
+    public Kavita(string baseUrl, string auth) : base(TokenGen.CreateToken(typeof(Kavita), baseUrl), LibraryType.Kavita, baseUrl, auth)
+    {
+    }
+    
+    public Kavita(string baseUrl, string username, string password) : 
+        this(baseUrl, GetToken(baseUrl, username, password))
+    {
+    }
+    
+    
+    private static string GetToken(string baseUrl, string username, string password)
+    {
+        HttpClient client = new()
+        {
+            DefaultRequestHeaders =
+            {
+                { "Accept", "application/json" }
+            }
+        };
+        HttpRequestMessage requestMessage = new ()
+        {
+            Method = HttpMethod.Post,
+            RequestUri = new Uri($"{baseUrl}/api/Account/login"),
+            Content = new StringContent($"{{\"username\":\"{username}\",\"password\":\"{password}\"}}", System.Text.Encoding.UTF8, "application/json")
+        };
+        try
+        {
+            HttpResponseMessage response = client.Send(requestMessage);
+            if (response.IsSuccessStatusCode)
+            {
+                JsonObject? result = JsonSerializer.Deserialize<JsonObject>(response.Content.ReadAsStream());
+                if (result is not null)
+                    return result["token"]!.GetValue<string>();
+            }
+            else
+            {
+            }
+        }
+        catch (HttpRequestException e)
+        {
+        }
+        return "";
+    }
+
+    protected override void UpdateLibraryInternal()
+    {
+        foreach (KavitaLibrary lib in GetLibraries())
+            NetClient.MakePost($"{BaseUrl}/api/ToLibrary/scan?libraryId={lib.id}", "Bearer", Auth);
+    }
+
+    internal override bool Test()
+    {
+        foreach (KavitaLibrary lib in GetLibraries())
+            if (NetClient.MakePost($"{BaseUrl}/api/ToLibrary/scan?libraryId={lib.id}", "Bearer", Auth))
+                return true;
+        return false;
+    }
+
+    /// <summary>
+    /// Fetches all libraries available to the user
+    /// </summary>
+    /// <returns>Array of KavitaLibrary</returns>
+    private IEnumerable<KavitaLibrary> GetLibraries()
+    {
+        Stream data = NetClient.MakeRequest($"{BaseUrl}/api/ToLibrary/libraries", "Bearer", Auth);
+        if (data == Stream.Null)
+        {
+            Log.Info("No libraries found");
+            return [];
+        }
+        JsonArray? result = JsonSerializer.Deserialize<JsonArray>(data);
+        if (result is null)
+        {
+            Log.Info("No libraries found");
+            return [];
+        }
+
+        List<KavitaLibrary> ret = new();
+
+        foreach (JsonNode? jsonNode in result)
+        {
+            JsonObject? jObject = (JsonObject?)jsonNode;
+            if(jObject is null)
+                continue;
+            int libraryId = jObject!["id"]!.GetValue<int>();
+            string libraryName = jObject["name"]!.GetValue<string>();
+            ret.Add(new KavitaLibrary(libraryId, libraryName));
+        }
+
+        return ret;
+    }
+    
+    private struct KavitaLibrary
+    {
+        public int id { get; }
+        // ReSharper disable once UnusedAutoPropertyAccessor.Local
+        public string name { get; }
+
+        public KavitaLibrary(int id, string name)
+        {
+            this.id = id;
+            this.name = name;
+        }
+    }
+}

API/Schema/LibraryConnectors/Komga.cs

@@ -0,0 +1,76 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace API.Schema.LibraryConnectors;
+
+public class Komga : LibraryConnector
+{
+    public Komga(string baseUrl, string auth) : base(TokenGen.CreateToken(typeof(Komga), baseUrl), LibraryType.Komga,
+        baseUrl, auth)
+    {
+    }
+    
+    public Komga(string baseUrl, string username, string password)
+        : this(baseUrl, Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes($"{username}:{password}")))
+    {
+    }
+    
+    protected override void UpdateLibraryInternal()
+    {
+        foreach (KomgaLibrary lib in GetLibraries())
+            NetClient.MakePost($"{BaseUrl}/api/v1/libraries/{lib.id}/scan", "Basic", Auth);
+    }
+
+    internal override bool Test()
+    {
+        foreach (KomgaLibrary lib in GetLibraries())
+            if (NetClient.MakePost($"{BaseUrl}/api/v1/libraries/{lib.id}/scan", "Basic", Auth))
+                return true;
+        return false;
+    }
+
+    /// <summary>
+    /// Fetches all libraries available to the user
+    /// </summary>
+    /// <returns>Array of KomgaLibraries</returns>
+    private IEnumerable<KomgaLibrary> GetLibraries()
+    {
+        Stream data = NetClient.MakeRequest($"{BaseUrl}/api/v1/libraries", "Basic", Auth);
+        if (data == Stream.Null)
+        {
+            Log.Info("No libraries found");
+            return [];
+        }
+        JsonArray? result = JsonSerializer.Deserialize<JsonArray>(data);
+        if (result is null)
+        {
+            Log.Info("No libraries found");
+            return [];
+        }
+
+        HashSet<KomgaLibrary> ret = new();
+
+        foreach (JsonNode? jsonNode in result)
+        {
+            var jObject = (JsonObject?)jsonNode;
+            string libraryId = jObject!["id"]!.GetValue<string>();
+            string libraryName = jObject["name"]!.GetValue<string>();
+            ret.Add(new KomgaLibrary(libraryId, libraryName));
+        }
+
+        return ret;
+    }
+
+    private struct KomgaLibrary
+    {
+        public string id { get; }
+        // ReSharper disable once UnusedAutoPropertyAccessor.Local
+        public string name { get; }
+
+        public KomgaLibrary(string id, string name)
+        {
+            this.id = id;
+            this.name = name;
+        }
+    }
+}

API/Schema/LibraryConnectors/LibraryConnector.cs

@@ -0,0 +1,32 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using log4net;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+
+namespace API.Schema.LibraryConnectors;
+
+[PrimaryKey("LibraryConnectorId")]
+public abstract class LibraryConnector(string libraryConnectorId, LibraryType libraryType, string baseUrl, string auth)
+{
+    [StringLength(64)]
+    [Required]
+    public string LibraryConnectorId { get; } = libraryConnectorId;
+
+    [Required]
+    public LibraryType LibraryType { get; init; } = libraryType;
+    [StringLength(256)]
+    [Required]
+    [Url]
+    public string BaseUrl { get; init; } = baseUrl;
+    [StringLength(256)]
+    [Required]
+    public string Auth { get; init; } = auth;
+    
+    [JsonIgnore]
+    [NotMapped]
+    protected ILog Log { get; init; } = LogManager.GetLogger($"{libraryType.ToString()} {baseUrl}");
+    
+    protected abstract void UpdateLibraryInternal();
+    internal abstract bool Test();
+}

API/Schema/LibraryConnectors/LibraryType.cs

@@ -0,0 +1,7 @@
+namespace API.Schema.LibraryConnectors;
+
+public enum LibraryType : byte
+{
+    Komga = 0,
+    Kavita = 1
+}

API/Schema/LibraryConnectors/NetClient.cs

@@ -0,0 +1,73 @@
+using System.Net;
+using System.Net.Http.Headers;
+using log4net;
+
+namespace API.Schema.LibraryConnectors;
+
+public class NetClient
+{
+    private static ILog Log = LogManager.GetLogger(typeof(NetClient));
+
+    public static Stream MakeRequest(string url, string authScheme, string auth)
+    {
+        Log.Debug($"Requesting {url}");
+        HttpClient client = new();
+        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(authScheme, auth);
+
+        HttpRequestMessage requestMessage = new()
+        {
+            Method = HttpMethod.Get,
+            RequestUri = new Uri(url)
+        };
+        try
+        {
+            HttpResponseMessage response = client.Send(requestMessage);
+
+            if (response.StatusCode is HttpStatusCode.Unauthorized &&
+                response.RequestMessage!.RequestUri!.AbsoluteUri != url)
+                return MakeRequest(response.RequestMessage!.RequestUri!.AbsoluteUri, authScheme, auth);
+            else if (response.IsSuccessStatusCode)
+                return response.Content.ReadAsStream();
+            else
+                return Stream.Null;
+        }
+        catch (Exception e)
+        {
+            switch (e)
+            {
+                case HttpRequestException:
+                    Log.Debug(e);
+                    break;
+                default:
+                    throw;
+            }
+            Log.Info("Failed to make request");
+            return Stream.Null;
+        }
+    }
+
+    public static bool MakePost(string url, string authScheme, string auth)
+        {
+            HttpClient client = new()
+            {
+                DefaultRequestHeaders =
+                {
+                    { "Accept", "application/json" },
+                    { "Authorization", new AuthenticationHeaderValue(authScheme, auth).ToString() }
+                }
+            };
+            HttpRequestMessage requestMessage = new ()
+            {
+                Method = HttpMethod.Post,
+                RequestUri = new Uri(url)
+            };
+            HttpResponseMessage response = client.Send(requestMessage);
+            
+            if(response.StatusCode is HttpStatusCode.Unauthorized && response.RequestMessage!.RequestUri!.AbsoluteUri != url)
+                return MakePost(response.RequestMessage!.RequestUri!.AbsoluteUri, authScheme, auth);
+            else if (response.IsSuccessStatusCode)
+                return true;
+            else 
+                return false;
+        }
+}

API/Schema/Link.cs

@@ -0,0 +1,24 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("LinkId")]
+public class Link(string linkProvider, string linkUrl)
+{
+    [StringLength(64)]
+    [Required]
+    public string LinkId { get; init; } = TokenGen.CreateToken(typeof(Link), linkProvider, linkUrl);
+    [StringLength(64)]
+    [Required]
+    public string LinkProvider { get; init; } = linkProvider;
+    [StringLength(2048)]
+    [Required]
+    [Url]
+    public string LinkUrl { get; init; } = linkUrl;
+
+    public override string ToString()
+    {
+        return $"{LinkId} {LinkProvider} {LinkUrl}";
+    }
+}

API/Schema/LocalLibrary.cs

@@ -0,0 +1,22 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace API.Schema;
+
+public class LocalLibrary(string basePath, string libraryName)
+{
+    [StringLength(64)] 
+    [Required]
+    public string LocalLibraryId { get; init; } = TokenGen.CreateToken(typeof(LocalLibrary), basePath);
+    [StringLength(256)]
+    [Required]
+    public string BasePath { get; internal set; } = basePath;
+
+    [StringLength(512)]
+    [Required]
+    public string LibraryName { get; internal set; } = libraryName;
+
+    public override string ToString()
+    {
+        return $"{LocalLibraryId} {LibraryName} - {BasePath}";
+    }
+}

API/Schema/Manga.cs

@@ -0,0 +1,161 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Runtime.InteropServices;
+using System.Text;
+using API.Schema.MangaConnectors;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+using static System.IO.UnixFileMode;
+
+namespace API.Schema;
+
+[PrimaryKey("MangaId")]
+public class Manga
+{
+    [StringLength(64)]
+    [Required]
+    public string MangaId { get; init; }
+    [StringLength(256)] [Required] public string IdOnConnectorSite { get; init; }
+    [StringLength(512)] [Required] public string Name { get; internal set; }
+    [Required] public string Description { get; internal set; }
+    [Url] [StringLength(512)] [Required] public string WebsiteUrl { get; internal init; }
+    [JsonIgnore] [Url] [StringLength(512)] public string CoverUrl { get; internal set; }
+    [Required] public MangaReleaseStatus ReleaseStatus { get; internal set; }
+    
+    [StringLength(64)] 
+    public string? LibraryId { get; init; }
+    [JsonIgnore] public LocalLibrary? Library { get; internal set; }
+    
+    [StringLength(32)]
+    [Required]
+    public string MangaConnectorName { get; init; }
+    [JsonIgnore] public MangaConnector MangaConnector { get; init; } = null!;
+
+    public ICollection<Author> Authors { get; internal set; }= null!;
+    public ICollection<MangaTag> MangaTags { get; internal set; }= null!;
+    public ICollection<Link> Links { get; internal set; }= null!;
+    public ICollection<MangaAltTitle> AltTitles { get; internal set; } = null!;
+    [Required] public float IgnoreChaptersBefore { get; internal set; }
+    [StringLength(1024)] [Required] public string DirectoryName { get; private set; }
+
+    [JsonIgnore] [StringLength(512)] public string? CoverFileNameInCache { get; internal set; } = null;
+    public uint? Year { get; internal init; }
+    [StringLength(8)] public string? OriginalLanguage { get; internal init; }
+
+    [JsonIgnore]
+    [NotMapped]
+    public string? FullDirectoryPath => Library is not null ? Path.Join(Library.BasePath, DirectoryName) : null;
+
+    [NotMapped] public ICollection<string> ChapterIds => Chapters.Select(c => c.ChapterId).ToList();
+    private readonly ILazyLoader _lazyLoader = null!;
+    private ICollection<Chapter> _chapters = null!;
+    [JsonIgnore] 
+    public ICollection<Chapter> Chapters 
+    {
+        get => _lazyLoader.Load(this, ref _chapters);
+        init => _chapters = value;
+    }
+
+    public Manga(string idOnConnector, string name, string description, string websiteUrl, string coverUrl, MangaReleaseStatus releaseStatus,
+        MangaConnector mangaConnector, ICollection<Author> authors, ICollection<MangaTag> mangaTags, ICollection<Link> links, ICollection<MangaAltTitle> altTitles,
+        LocalLibrary? library = null, float ignoreChaptersBefore = 0f, uint? year = null, string? originalLanguage = null)
+    {
+        this.MangaId = TokenGen.CreateToken(typeof(Manga), mangaConnector.Name, idOnConnector);
+        this.IdOnConnectorSite = idOnConnector;
+        this.Name = name;
+        this.Description = description;
+        this.WebsiteUrl = websiteUrl;
+        this.CoverUrl = coverUrl;
+        this.ReleaseStatus = releaseStatus;
+        this.LibraryId = library?.LocalLibraryId;
+        this.Library = library;
+        this.MangaConnectorName = mangaConnector.Name;
+        this.MangaConnector = mangaConnector;
+        this.Authors = authors;
+        this.MangaTags = mangaTags;
+        this.Links = links;
+        this.AltTitles = altTitles;
+        this.IgnoreChaptersBefore = ignoreChaptersBefore;
+        this.DirectoryName = CleanDirectoryName(name);
+        this.Year = year;
+        this.OriginalLanguage = originalLanguage;
+        this.Chapters = [];
+    }
+
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    public Manga(ILazyLoader lazyLoader, string mangaId, string idOnConnectorSite, string name, string description, string websiteUrl, string coverUrl, MangaReleaseStatus releaseStatus,
+        string mangaConnectorName, string directoryName, float ignoreChaptersBefore, string? libraryId, uint? year, string? originalLanguage)
+    {
+        this._lazyLoader = lazyLoader;
+        this.MangaId = mangaId;
+        this.IdOnConnectorSite = idOnConnectorSite;
+        this.Name = name;
+        this.Description = description;
+        this.WebsiteUrl = websiteUrl;
+        this.CoverUrl = coverUrl;
+        this.ReleaseStatus = releaseStatus;
+        this.MangaConnectorName = mangaConnectorName;
+        this.DirectoryName = directoryName;
+        this.LibraryId = libraryId;
+        this.IgnoreChaptersBefore = ignoreChaptersBefore;
+        this.Year = year;
+        this.OriginalLanguage = originalLanguage;
+    }
+    
+    
+    public string CreatePublicationFolder()
+    {
+        string? publicationFolder = FullDirectoryPath;
+        if (publicationFolder is null)
+            throw new DirectoryNotFoundException("Publication folder not found");
+        if(!Directory.Exists(publicationFolder))
+            Directory.CreateDirectory(publicationFolder);
+        if(RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            File.SetUnixFileMode(publicationFolder, GroupRead | GroupWrite | GroupExecute | OtherRead | OtherWrite | OtherExecute | UserRead | UserWrite | UserExecute);
+        return publicationFolder;
+    }
+
+    //https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
+    //less than 32 is control *forbidden*
+    //34 is " *forbidden*
+    //42 is * *forbidden*
+    //47 is / *forbidden*
+    //58 is : *forbidden*
+    //60 is < *forbidden*
+    //62 is > *forbidden*
+    //63 is ? *forbidden*
+    //92 is \ *forbidden*
+    //124 is | *forbidden*
+    //127 is delete *forbidden*
+    //Below 127 all except *******
+    private static readonly int[] ForbiddenCharsBelow127 = [34, 42, 47, 58, 60, 62, 63, 92, 124, 127];
+    //Above 127 none except *******
+    private static readonly int[] IncludeCharsAbove127 = [128, 138, 142];
+    //128 is € include
+    //138 is Š include
+    //142 is Ž include
+    //152 through 255 looks fine except 157, 172, 173, 175 *******
+    private static readonly int[] ForbiddenCharsAbove152 = [157, 172, 173, 175];
+    private static string CleanDirectoryName(string name)
+    {
+        StringBuilder sb = new ();
+        foreach (char c in name)
+        {
+            if (c >= 32 && c < 127 && ForbiddenCharsBelow127.Contains(c) == false)
+                sb.Append(c);
+            else if (c > 127 && c < 152 && IncludeCharsAbove127.Contains(c))
+                sb.Append(c);
+            else if(c >= 152 && c <= 255 && ForbiddenCharsAbove152.Contains(c) == false)
+                sb.Append(c);
+        }
+        return sb.ToString();
+    }
+
+    public override string ToString()
+    {
+        return $"{MangaId} {Name}";
+    }
+}

API/Schema/MangaAltTitle.cs

@@ -0,0 +1,23 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("AltTitleId")]
+public class MangaAltTitle(string language, string title)
+{
+    [StringLength(64)]
+    [Required]
+    public string AltTitleId { get; init; } = TokenGen.CreateToken("AltTitle");
+    [StringLength(8)]
+    [Required]
+    public string Language { get; init; } = language;
+    [StringLength(256)]
+    [Required]
+    public string Title { get; set; } = title;
+
+    public override string ToString()
+    {
+        return $"{AltTitleId} {Language} {Title}";
+    }
+}

API/Schema/MangaConnectors/ComickIo.cs

@@ -0,0 +1,247 @@
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using Newtonsoft.Json.Linq;
+
+namespace API.Schema.MangaConnectors;
+
+public class ComickIo : MangaConnector
+{
+    //https://api.comick.io/docs/
+    //https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes
+    
+    public ComickIo() : base("ComickIo", 
+        ["en","pt","pt-br","it","de","ru","aa","ab","ae","af","ak","am","an","ar-ae","ar-bh","ar-dz","ar-eg","ar-iq","ar-jo","ar-kw","ar-lb","ar-ly","ar-ma","ar-om","ar-qa","ar-sa","ar-sy","ar-tn","ar-ye","ar","as","av","ay","az","ba","be","bg","bh","bi","bm","bn","bo","br","bs","ca","ce","ch","co","cr","cs","cu","cv","cy","da","de-at","de-ch","de-de","de-li","de-lu","div","dv","dz","ee","el","en-au","en-bz","en-ca","en-cb","en-gb","en-ie","en-jm","en-nz","en-ph","en-tt","en-us","en-za","en-zw","eo","es-ar","es-bo","es-cl","es-co","es-cr","es-do","es-ec","es-es","es-gt","es-hn","es-la","es-mx","es-ni","es-pa","es-pe","es-pr","es-py","es-sv","es-us","es-uy","es-ve","es","et","eu","fa","ff","fi","fj","fo","fr-be","fr-ca","fr-ch","fr-fr","fr-lu","fr-mc","fr","fy","ga","gd","gl","gn","gu","gv","ha","he","hi","ho","hr-ba","hr-hr","hr","ht","hu","hy","hz","ia","id","ie","ig","ii","ik","in","io","is","it-ch","it-it","iu","iw","ja","ja-ro","ji","jv","jw","ka","kg","ki","kj","kk","kl","km","kn","ko","ko-ro","kr","ks","ku","kv","kw","ky","kz","la","lb","lg","li","ln","lo","ls","lt","lu","lv","mg","mh","mi","mk","ml","mn","mo","mr","ms-bn","ms-my","ms","mt","my","na","nb","nd","ne","ng","nl-be","nl-nl","nl","nn","no","nr","ns","nv","ny","oc","oj","om","or","os","pa","pi","pl","ps","pt-pt","qu-bo","qu-ec","qu-pe","qu","rm","rn","ro","rw","sa","sb","sc","sd","se-fi","se-no","se-se","se","sg","sh","si","sk","sl","sm","sn","so","sq","sr-ba","sr-sp","sr","ss","st","su","sv-fi","sv-se","sv","sw","sx","syr","ta","te","tg","th","ti","tk","tl","tn","to","tr","ts","tt","tw","ty","ug","uk","ur","us","uz","ve","vi","vo","wa","wo","xh","yi","yo","za","zh-cn","zh-hk","zh-mo","zh-ro","zh-sg","zh-tw","zh","zu"],
+        ["comick.io"], 
+        "https://comick.io/static/icons/unicorn-64.png")
+    {
+        this.downloadClient = new HttpDownloadClient();
+    }
+
+    public override Manga[] SearchManga(string mangaSearchName)
+    {
+        Log.Info($"Searching Manga: {mangaSearchName}");
+
+        List<string> slugs = new();
+        int page = 1;
+        while(page < 50)
+        {
+            string requestUrl = $"https://api.comick.fun/v1.0/search/?type=comic&t=false&limit=100&showall=true&" +
+                                $"page={page}&q={mangaSearchName}";
+
+            RequestResult result = downloadClient.MakeRequest(requestUrl, RequestType.Default);
+            if ((int)result.statusCode < 200 || (int)result.statusCode >= 300)
+            {
+                Log.Error("Request failed");
+                return [];
+            }
+
+            using StreamReader sr = new (result.result);
+            JArray data = JArray.Parse(sr.ReadToEnd());
+
+            if (data.Count < 1)
+                break;
+            
+            slugs.AddRange(data.Select(token => token.Value<string>("slug")!));
+            page++;
+        }
+        Log.Debug($"Search {mangaSearchName} yielded {slugs.Count} slugs. Requesting mangas now...");
+
+        List<Manga> mangas = slugs.Select(GetMangaFromId).ToList()!;
+        
+        Log.Info($"Search {mangaSearchName} yielded {mangas.Count} results.");
+        return mangas.ToArray();
+    }
+
+    private readonly Regex _getSlugFromTitleRex = new(@"https?:\/\/comick\.io\/comic\/(.+)(?:\/.*)*");
+    public override Manga? GetMangaFromUrl(string url)
+    {
+        Match m = _getSlugFromTitleRex.Match(url);
+        return m.Groups[1].Success ? GetMangaFromId(m.Groups[1].Value) : null;
+    }
+
+    public override Manga? GetMangaFromId(string mangaIdOnSite)
+    {
+        string requestUrl = $"https://api.comick.fun/comic/{mangaIdOnSite}";
+
+        RequestResult result = downloadClient.MakeRequest(requestUrl, RequestType.MangaInfo);
+        if ((int)result.statusCode < 200 || (int)result.statusCode >= 300)
+        {
+            Log.Error("Request failed");
+            return null;
+        }
+        using StreamReader sr = new (result.result);
+        JToken data = JToken.Parse(sr.ReadToEnd());
+
+        return ParseMangaFromJToken(data);
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string? language = null)
+    {
+        Log.Info($"Getting Chapters: {manga.IdOnConnectorSite}");
+        List<string> chapterHids = new();
+        int page = 1;
+        while(page < 50)
+        {
+            string requestUrl = $"https://api.comick.fun/comic/{manga.IdOnConnectorSite}/chapters?limit=100&page={page}&lang={language}";
+
+            RequestResult result = downloadClient.MakeRequest(requestUrl, RequestType.MangaInfo);
+            if ((int)result.statusCode < 200 || (int)result.statusCode >= 300)
+            {
+                Log.Error("Request failed");
+                return [];
+            }
+
+            using StreamReader sr = new (result.result);
+            JToken data = JToken.Parse(sr.ReadToEnd());
+            JArray? chaptersArray = data["chapters"] as JArray;
+
+            if (chaptersArray?.Count < 1)
+                break;
+            
+            chapterHids.AddRange(chaptersArray?.Select(token => token.Value<string>("hid")!)!);
+
+            page++;
+        }
+        Log.Debug($"Getting chapters for {manga.Name} yielded {chapterHids.Count} hids. Requesting chapters now...");
+
+        List<Chapter> chapters = chapterHids.Select(hid => ChapterFromHid(manga, hid)).ToList();
+
+        return chapters.ToArray();
+    }
+
+    private readonly Regex _hidFromUrl = new(@"https?:\/\/comick\.io\/comic\/.+\/([^-]+).*");
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        Match m = _hidFromUrl.Match(chapter.Url);
+        if (!m.Groups[1].Success)
+            return [];
+        
+        string hid = m.Groups[1].Value;
+        
+        string requestUrl = $"https://api.comick.fun/chapter/{hid}/get_images";
+        RequestResult result = downloadClient.MakeRequest(requestUrl, RequestType.MangaInfo);
+        if ((int)result.statusCode < 200 || (int)result.statusCode >= 300)
+        {
+            Log.Error("Request failed");
+            return [];
+        }
+        
+        using StreamReader sr = new (result.result);
+        JArray data = JArray.Parse(sr.ReadToEnd());
+
+        return data.Select(token =>
+        {
+            string url = $"https://meo.comick.pictures/{token.Value<string>("b2key")}";
+            return url;
+        }).ToArray();
+    }
+
+    private Manga ParseMangaFromJToken(JToken json)
+    {
+        string? hid = json["comic"]?.Value<string>("hid");
+        string? slug = json["comic"]?.Value<string>("slug");
+        string? name = json["comic"]?.Value<string>("title");
+        string? description = json["comic"]?.Value<string>("desc");
+        string? originalLanguage = json["comic"]?.Value<string>("country");
+        string url = $"https://comick.io/comic/{slug}";
+        string? coverName = json["comic"]?["md_covers"]?.First?.Value<string>("b2key");
+        string coverUrl = $"https://meo.comick.pictures/{coverName}";
+        int? releaseStatusStr = json["comic"]?.Value<int>("status");
+        MangaReleaseStatus status = releaseStatusStr switch
+        {
+            1 => MangaReleaseStatus.Continuing,
+            2 => MangaReleaseStatus.Completed,
+            3 => MangaReleaseStatus.Cancelled,
+            4 => MangaReleaseStatus.OnHiatus,
+            _ => MangaReleaseStatus.Unreleased
+        };
+        uint? year = json["comic"]?.Value<uint?>("year");
+        JArray? altTitlesArray = json["comic"]?["md_titles"] as JArray;
+        //Cant let language be null, so fill with whatever.
+        byte whatever = 0;
+        List<MangaAltTitle> altTitles = altTitlesArray?
+            .Select(token => new MangaAltTitle(token.Value<string>("lang")??whatever++.ToString(), token.Value<string>("title")!))
+            .ToList()!;
+        
+        JArray? authorsArray = json["authors"] as JArray;
+        JArray? artistsArray = json["artists"] as JArray;
+        List<Author> authors = authorsArray?.Concat(artistsArray!)
+            .Select(token => new Author(token.Value<string>("name")!))
+            .DistinctBy(a => a.AuthorId)
+            .ToList()!;
+        
+        JArray? genreArray = json["comic"]?["md_comic_md_genres"] as JArray;
+        List<MangaTag> tags = genreArray?
+            .Select(token => new MangaTag(token["md_genres"]?.Value<string>("name")!))
+            .ToList()!;
+        
+        JArray? linksArray = json["comic"]?["links"] as JArray;
+        List<Link> links = linksArray?
+            .ToObject<Dictionary<string,string>>()?
+            .Select(kv =>
+            {
+                string fullUrl = kv.Key switch
+                {
+                    "al" => $"https://anilist.co/manga/{kv.Value}",
+                    "ap" => $"https://www.anime-planet.com/manga/{kv.Value}",
+                    "bw" => $"https://bookwalker.jp/{kv.Value}",
+                    "mu" => $"https://www.mangaupdates.com/series.html?id={kv.Value}",
+                    "nu" => $"https://www.novelupdates.com/series/{kv.Value}",
+                    "mal" => $"https://myanimelist.net/manga/{kv.Value}",
+                    _ => kv.Value
+                };
+                string key = kv.Key switch
+                {
+                    "al" => "AniList",
+                    "ap" => "Anime Planet",
+                    "bw" => "BookWalker",
+                    "mu" => "Manga Updates",
+                    "nu" => "Novel Updates",
+                    "kt" => "Kitsu.io",
+                    "amz" => "Amazon",
+                    "ebj" => "eBookJapan",
+                    "mal" => "MyAnimeList",
+                    "cdj" => "CDJapan",
+                    _ => kv.Key
+                };
+                return new Link(key, fullUrl);
+            }).ToList()!;
+        
+        if(hid is null)
+            throw new Exception("hid is null");
+        if(slug is null)
+            throw new Exception("slug is null");
+        if(name is null)
+            throw new Exception("name is null");
+        
+        return new Manga(hid, name, description??"", url, coverUrl, status, this,
+            authors, tags, links, altTitles,
+            year: year, originalLanguage: originalLanguage);
+    }
+
+    private Chapter ChapterFromHid(Manga parentManga, string hid)
+    {
+        string requestUrl = $"https://api.comick.fun/chapter/{hid}";
+        RequestResult result = downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)result.statusCode < 200 || (int)result.statusCode >= 300)
+        {
+            Log.Error("Request failed");
+            throw new Exception("Request failed");
+        }
+        
+        using StreamReader sr = new (result.result);
+        JToken data = JToken.Parse(sr.ReadToEnd());
+
+        string? canonical = data.Value<string>("canonical");
+        string? chapterNum = data["chapter"]?.Value<string>("chap");
+        string? volumeNumStr = data["chapter"]?.Value<string>("vol");
+        int? volumeNum = volumeNumStr is null ? null : int.Parse(volumeNumStr);
+        string? title = data["chapter"]?.Value<string>("title");
+        
+        if(chapterNum is null)
+            throw new Exception("chapterNum is null");
+
+        string url = $"https://comick.io{canonical}";
+        return new Chapter(parentManga, url, chapterNum, volumeNum, hid, title);
+    }
+}

API/Schema/MangaConnectors/Global.cs

@@ -0,0 +1,55 @@
+using API.Schema.Contexts;
+
+namespace API.Schema.MangaConnectors;
+
+public class Global : MangaConnector
+{
+    private PgsqlContext context { get; init; }
+    public Global(PgsqlContext context) : base("Global", ["all"], [""], "")
+    {
+        this.context = context;
+    }
+
+    public override Manga[] SearchManga(string mangaSearchName)
+    {
+        //Get all enabled Connectors
+        MangaConnector[] enabledConnectors = context.MangaConnectors.Where(c => c.Enabled && c.Name != "Global").ToArray();
+        
+        //Create Task for each MangaConnector to search simulatneously
+        Task<Manga[]>[] tasks =
+            enabledConnectors.Select(c => new Task<Manga[]>(() => c.SearchManga(mangaSearchName))).ToArray();
+        foreach (var task in tasks)
+            task.Start();
+        
+        //Wait for all tasks to finish
+        do
+        {
+            Thread.Sleep(50);
+        }while(tasks.Any(t => t.Status < TaskStatus.RanToCompletion));
+        
+        //Concatenate all results into one
+        Manga[] ret = tasks.Select(t => t.IsCompletedSuccessfully ? t.Result : []).ToArray().SelectMany(i => i).ToArray();
+        return ret;
+    }
+
+    public override Manga? GetMangaFromUrl(string url)
+    {
+        MangaConnector? mc = context.MangaConnectors.ToArray().FirstOrDefault(c => c.UrlMatchesConnector(url));
+        return mc?.GetMangaFromUrl(url) ?? null;
+    }
+
+    public override Manga? GetMangaFromId(string mangaIdOnSite)
+    {
+        return null;
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string? language = null)
+    {
+        return manga.MangaConnector.GetChapters(manga, language);
+    }
+
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        return chapter.ParentManga.MangaConnector.GetChapterImageUrls(chapter);
+    }
+}

API/Schema/MangaConnectors/MangaConnector.cs

@@ -0,0 +1,74 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using log4net;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+
+namespace API.Schema.MangaConnectors;
+
+[PrimaryKey("Name")]
+public abstract class MangaConnector(string name, string[] supportedLanguages, string[] baseUris, string iconUrl)
+{
+    [JsonIgnore]
+    [NotMapped]
+    internal DownloadClient downloadClient { get; init; } = null!;
+
+    [JsonIgnore]
+    [NotMapped]
+    protected ILog Log { get; init; } = LogManager.GetLogger(name);
+    
+    [StringLength(32)]
+    [Required]
+    public string Name { get; init; } = name;
+    [StringLength(8)]
+    [Required]
+    public string[] SupportedLanguages { get; init; } = supportedLanguages;
+    [StringLength(2048)]
+    [Required]
+    public string IconUrl { get; init; } = iconUrl;
+    [StringLength(256)]
+    [Required]
+    public string[] BaseUris { get; init; } = baseUris;
+    [Required]
+    public bool Enabled { get; internal set; } = true;
+    
+    public abstract Manga[] SearchManga(string mangaSearchName);
+
+    public abstract Manga? GetMangaFromUrl(string url);
+
+    public abstract Manga? GetMangaFromId(string mangaIdOnSite);
+    
+    public abstract Chapter[] GetChapters(Manga manga, string? language = null);
+
+    internal abstract string[] GetChapterImageUrls(Chapter chapter);
+
+    public bool UrlMatchesConnector(string url) => BaseUris.Any(baseUri => Regex.IsMatch(url, "https?://" + baseUri + "/.*"));
+    
+    internal string? SaveCoverImageToCache(Manga manga, int retries = 3)
+    {
+        if(retries < 0)
+            return null;
+        
+        Regex urlRex = new (@"https?:\/\/((?:[a-zA-Z0-9-]+\.)+[a-zA-Z0-9]+)\/(?:.+\/)*(.+\.([a-zA-Z]+))");
+        //https?:\/\/[a-zA-Z0-9-]+\.([a-zA-Z0-9-]+\.[a-zA-Z0-9]+)\/(?:.+\/)*(.+\.([a-zA-Z]+)) for only second level domains
+        Match match = urlRex.Match(manga.CoverUrl);
+        string filename = $"{match.Groups[1].Value}-{manga.MangaId}.{match.Groups[3].Value}";
+        string saveImagePath = Path.Join(TrangaSettings.coverImageCache, filename);
+
+        if (File.Exists(saveImagePath))
+            return saveImagePath;
+        
+        RequestResult coverResult = downloadClient.MakeRequest(manga.CoverUrl, RequestType.MangaCover, $"https://{match.Groups[1].Value}");
+        if ((int)coverResult.statusCode < 200 || (int)coverResult.statusCode >= 300)
+            return SaveCoverImageToCache(manga, --retries);
+            
+        using MemoryStream ms = new();
+        coverResult.result.CopyTo(ms);
+        Directory.CreateDirectory(TrangaSettings.coverImageCache);
+        File.WriteAllBytes(saveImagePath, ms.ToArray());
+        
+        return saveImagePath;
+    }
+}

API/Schema/MangaConnectors/MangaDex.cs

@@ -0,0 +1,335 @@
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using Newtonsoft.Json.Linq;
+
+namespace API.Schema.MangaConnectors;
+
+public class MangaDex : MangaConnector
+{
+    //https://api.mangadex.org/docs/3-enumerations/#language-codes--localization
+    //https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes
+    //https://gist.github.com/Josantonius/b455e315bc7f790d14b136d61d9ae469
+    public MangaDex() : base("MangaDex", 
+        ["en","pt","pt-br","it","de","ru","aa","ab","ae","af","ak","am","an","ar-ae","ar-bh","ar-dz","ar-eg","ar-iq","ar-jo","ar-kw","ar-lb","ar-ly","ar-ma","ar-om","ar-qa","ar-sa","ar-sy","ar-tn","ar-ye","ar","as","av","ay","az","ba","be","bg","bh","bi","bm","bn","bo","br","bs","ca","ce","ch","co","cr","cs","cu","cv","cy","da","de-at","de-ch","de-de","de-li","de-lu","div","dv","dz","ee","el","en-au","en-bz","en-ca","en-cb","en-gb","en-ie","en-jm","en-nz","en-ph","en-tt","en-us","en-za","en-zw","eo","es-ar","es-bo","es-cl","es-co","es-cr","es-do","es-ec","es-es","es-gt","es-hn","es-la","es-mx","es-ni","es-pa","es-pe","es-pr","es-py","es-sv","es-us","es-uy","es-ve","es","et","eu","fa","ff","fi","fj","fo","fr-be","fr-ca","fr-ch","fr-fr","fr-lu","fr-mc","fr","fy","ga","gd","gl","gn","gu","gv","ha","he","hi","ho","hr-ba","hr-hr","hr","ht","hu","hy","hz","ia","id","ie","ig","ii","ik","in","io","is","it-ch","it-it","iu","iw","ja","ja-ro","ji","jv","jw","ka","kg","ki","kj","kk","kl","km","kn","ko","ko-ro","kr","ks","ku","kv","kw","ky","kz","la","lb","lg","li","ln","lo","ls","lt","lu","lv","mg","mh","mi","mk","ml","mn","mo","mr","ms-bn","ms-my","ms","mt","my","na","nb","nd","ne","ng","nl-be","nl-nl","nl","nn","no","nr","ns","nv","ny","oc","oj","om","or","os","pa","pi","pl","ps","pt-pt","qu-bo","qu-ec","qu-pe","qu","rm","rn","ro","rw","sa","sb","sc","sd","se-fi","se-no","se-se","se","sg","sh","si","sk","sl","sm","sn","so","sq","sr-ba","sr-sp","sr","ss","st","su","sv-fi","sv-se","sv","sw","sx","syr","ta","te","tg","th","ti","tk","tl","tn","to","tr","ts","tt","tw","ty","ug","uk","ur","us","uz","ve","vi","vo","wa","wo","xh","yi","yo","za","zh-cn","zh-hk","zh-mo","zh-ro","zh-sg","zh-tw","zh","zu"],
+        ["mangadex.org"], 
+        "https://mangadex.org/favicon.ico")
+    {
+        this.downloadClient = new HttpDownloadClient();
+    }
+
+    private const int Limit = 100;
+    public override Manga[] SearchManga(string mangaSearchName)
+    {
+        Log.Info($"Searching Manga: {mangaSearchName}");
+        List<Manga> mangas = new ();
+        
+        int offset = 0;
+        int total = int.MaxValue;
+        while(offset < total)
+        {
+            string requestUrl =
+                $"https://api.mangadex.org/manga?limit={Limit}&offset={offset}&title={mangaSearchName}" +
+                $"&contentRating%5B%5D=safe&contentRating%5B%5D=suggestive&contentRating%5B%5D=erotica" +
+                $"&includes%5B%5D=manga&includes%5B%5D=cover_art&includes%5B%5D=author&includes%5B%5D=artist&includes%5B%5D=tag'";
+            offset += Limit;
+
+            RequestResult result = downloadClient.MakeRequest(requestUrl, RequestType.MangaDexFeed);
+            if ((int)result.statusCode < 200 || (int)result.statusCode >= 300)
+            {
+                Log.Error("Request failed");
+                return [];
+            }
+
+            using StreamReader sr = new (result.result);
+            JObject jObject = JObject.Parse(sr.ReadToEnd());
+
+            if (jObject.Value<string>("result") != "ok")
+            {
+                JArray? errors = jObject["errors"] as JArray;
+                Log.Error($"Request failed: {string.Join(',', errors?.Select(e => e.Value<string>("title")) ?? [])}");
+                return [];
+            }
+
+            total = jObject.Value<int>("total");
+            
+            JArray? data = jObject.Value<JArray>("data");
+            if (data is null)
+            {
+                Log.Error("Data was null");
+                return [];
+            }
+            
+            mangas.AddRange(data.Select(ParseMangaFromJToken));
+        }
+        
+        Log.Info($"Search {mangaSearchName} yielded {mangas.Count} results.");
+        return mangas.ToArray();
+    }
+
+    private static readonly Regex GetMangaIdFromUrl = new(@"https?:\/\/mangadex\.org\/title\/([a-z0-9-]+)\/?.*");
+    public override Manga? GetMangaFromUrl(string url)
+    {
+        Log.Info($"Getting Manga: {url}");
+        if (!UrlMatchesConnector(url))
+        {
+            Log.Debug($"Url is not for Connector. {url}");
+            return null;
+        }
+
+        Match match = GetMangaIdFromUrl.Match(url);
+        if (!match.Success || !match.Groups[1].Success)
+        {
+            Log.Debug($"Url is not for Connector (Could not retrieve id). {url}");
+            return null;
+        }
+        string id = match.Groups[1].Value;
+
+        return GetMangaFromId(id);
+    }
+
+    public override Manga? GetMangaFromId(string mangaIdOnSite)
+    {
+        Log.Info($"Getting Manga: {mangaIdOnSite}");
+        string requestUrl =
+            $"https://api.mangadex.org/manga/{mangaIdOnSite}" +
+            $"?includes%5B%5D=manga&includes%5B%5D=cover_art&includes%5B%5D=author&includes%5B%5D=artist&includes%5B%5D=tag'";
+        
+        RequestResult result = downloadClient.MakeRequest(requestUrl, RequestType.MangaDexFeed);
+        if ((int)result.statusCode < 200 || (int)result.statusCode >= 300)
+        {
+            Log.Error("Request failed");
+            return null;
+        }
+
+        using StreamReader sr = new (result.result);
+        JObject jObject = JObject.Parse(sr.ReadToEnd());
+
+        if (jObject.Value<string>("result") != "ok")
+        {
+            JArray? errors = jObject["errors"] as JArray;
+            Log.Error($"Request failed: {string.Join(',', errors?.Select(e => e.Value<string>("title")) ?? [])}");
+            return null;
+        }
+        
+        JObject? data = jObject["data"] as JObject;
+        if (data is null)
+        {
+            Log.Error("Data was null");
+            return null;
+        }
+
+        Manga manga = ParseMangaFromJToken(data);
+        return manga;
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string? language = null)
+    {
+        Log.Info($"Getting Chapters: {manga.IdOnConnectorSite}");
+        List<Chapter> chapters = new ();
+        
+        int offset = 0;
+        int total = int.MaxValue;
+        while(offset < total)
+        {
+            string requestUrl =
+                $"https://api.mangadex.org/manga/{manga.IdOnConnectorSite}/feed?limit={Limit}&offset={offset}&" +
+                $"translatedLanguage%5B%5D={language}&" +
+                $"contentRating%5B%5D=safe&contentRating%5B%5D=suggestive&contentRating%5B%5D=erotica&includeFutureUpdates=0&includes%5B%5D=";
+            offset += Limit;
+
+            RequestResult result = downloadClient.MakeRequest(requestUrl, RequestType.MangaDexFeed);
+            if ((int)result.statusCode < 200 || (int)result.statusCode >= 300)
+            {
+                Log.Error("Request failed");
+                return [];
+            }
+
+            using StreamReader sr = new (result.result);
+            JObject jObject = JObject.Parse(sr.ReadToEnd());
+
+            if (jObject.Value<string>("result") != "ok")
+            {
+                JArray? errors = jObject["errors"] as JArray;
+                Log.Error($"Request failed: {string.Join(',', errors?.Select(e => e.Value<string>("title")) ?? [])}");
+                return [];
+            }
+
+            total = jObject.Value<int>("total");
+            
+            JArray? data = jObject.Value<JArray>("data");
+            if (data is null)
+            {
+                Log.Error("Data was null");
+                return [];
+            }
+            
+            chapters.AddRange(data.Select(d => ParseChapterFromJToken(manga, d)));
+        }
+        
+        Log.Info($"Request for chapters for {manga.Name} yielded {chapters.Count} results.");
+        return chapters.ToArray();
+    }
+
+    private static readonly Regex GetChapterIdFromUrl = new(@"https?:\/\/mangadex\.org\/chapter\/([a-z0-9-]+)\/?.*");
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        Log.Info($"Getting Chapter Image-Urls: {chapter.Url}");
+        if (!UrlMatchesConnector(chapter.Url))
+        {
+            Log.Debug($"Url is not for Connector. {chapter.Url}");
+            return [];
+        }
+
+        Match match = GetChapterIdFromUrl.Match(chapter.Url);
+        if (!match.Success || !match.Groups[1].Success)
+        {
+            Log.Debug($"Url is not for Connector (Could not retrieve id). {chapter.Url}");
+            return [];
+        }
+        
+        string id = match.Groups[1].Value;
+        string requestUrl = $"https://api.mangadex.org/at-home/server/{id}";
+        
+        RequestResult result = downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)result.statusCode < 200 || (int)result.statusCode >= 300)
+        {
+            Log.Error("Request failed");
+            return [];
+        }
+
+        using StreamReader sr = new (result.result);
+        JObject jObject = JObject.Parse(sr.ReadToEnd());
+        
+        if (jObject.Value<string>("result") != "ok")
+        {
+            JArray? errors = jObject["errors"] as JArray;
+            Log.Error($"Request failed: {string.Join(',', errors?.Select(e => e.Value<string>("title")) ?? [])}");
+            return [];
+        }
+        
+        string? baseUrl = jObject.Value<string>("baseUrl");
+        JToken? chapterToken = jObject["chapter"];
+        string? hash = chapterToken?.Value<string>("hash");
+        JArray? data = chapterToken?["data"] as JArray;
+
+        if (baseUrl is null || hash is null || data is null)
+        {
+            Log.Error("Data was null");
+            return [];
+        }
+
+        IEnumerable<string> urls = data.Select(t => $"{baseUrl}/data/{hash}/{t.Value<string>()}");
+        
+        return urls.ToArray();
+    }
+
+    private Manga ParseMangaFromJToken(JToken jToken)
+    {
+        string? id = jToken.Value<string>("id");
+        
+        JObject? attributes = jToken["attributes"] as JObject;
+        string? name = attributes?["title"]?.Value<string>("en") ?? attributes?["title"]?.First?.First?.Value<string>();
+        string? description = attributes?["description"]?.Value<string>("en")??attributes?["description"]?.First?.First?.Value<string>();
+        string? status = attributes?["status"]?.Value<string>();
+        uint? year = attributes?["year"]?.Value<uint>();
+        string? originalLanguage = attributes?["originalLanguage"]?.Value<string>();
+        JArray? altTitlesJArray = attributes?["altTitles"] as JArray;
+        JArray? tagsJArray = attributes?["tags"] as JArray;
+        
+        JArray? relationships = jToken["relationships"] as JArray;
+        string? coverFileName =
+            relationships?.FirstOrDefault(r => r["type"]?.Value<string>() == "cover_art")?["attributes"]?.Value<string>("fileName");
+
+        if (id is null || attributes is null || name is null || description is null || status is null ||
+            altTitlesJArray is null || tagsJArray is null || relationships is null || coverFileName is null)
+            throw new Exception("jToken was not in expected format");
+        
+        List<Link> links = attributes["links"]?
+            .ToObject<Dictionary<string,string>>()?
+            .Select(kv =>
+            {
+                //https://api.mangadex.org/docs/3-enumerations/#manga-links-data
+                string url = kv.Key switch
+                {
+                    "al" => $"https://anilist.co/manga/{kv.Value}",
+                    "ap" => $"https://www.anime-planet.com/manga/{kv.Value}",
+                    "bw" => $"https://bookwalker.jp/{kv.Value}",
+                    "mu" => $"https://www.mangaupdates.com/series.html?id={kv.Value}",
+                    "nu" => $"https://www.novelupdates.com/series/{kv.Value}",
+                    "mal" => $"https://myanimelist.net/manga/{kv.Value}",
+                    _ => kv.Value
+                };
+                string key = kv.Key switch
+                {
+                    "al" => "AniList",
+                    "ap" => "Anime Planet",
+                    "bw" => "BookWalker",
+                    "mu" => "Manga Updates",
+                    "nu" => "Novel Updates",
+                    "kt" => "Kitsu.io",
+                    "amz" => "Amazon",
+                    "ebj" => "eBookJapan",
+                    "mal" => "MyAnimeList",
+                    "cdj" => "CDJapan",
+                    _ => kv.Key
+                };
+                return new Link(key, url);
+            }).ToList()!;
+
+        List<MangaAltTitle> altTitles = altTitlesJArray
+            .Select(t =>
+            {
+                JObject? j = t as JObject;
+                JProperty? p = j?.Properties().First();
+                if (p is null)
+                    return null;
+                return new MangaAltTitle(p.Name, p.Value.ToString());
+            }).Where(x => x is not null).ToList()!;
+        
+        List<MangaTag> tags = tagsJArray
+            .Where(t => t.Value<string>("type") == "tag")
+            .Select(t => t["attributes"]?["name"]?.Value<string>("en")??t["attributes"]?["name"]?.First?.First?.Value<string>())
+            .Select(str => str is not null ? new MangaTag(str) : null)
+            .Where(x => x is not null).ToList()!;
+        
+        List<Author> authors = relationships
+            .Where(r => r["type"]?.Value<string>() == "author")
+            .Select(t => t["attributes"]?.Value<string>("name"))
+            .Select(str => str is not null ? new Author(str) : null)
+            .Where(x => x is not null).ToList()!;
+            
+        
+        MangaReleaseStatus releaseStatus = status switch
+        {
+            "completed" => MangaReleaseStatus.Completed,
+            "ongoing" => MangaReleaseStatus.Continuing,
+            "cancelled" => MangaReleaseStatus.Cancelled,
+            "hiatus" => MangaReleaseStatus.OnHiatus,
+            _ => MangaReleaseStatus.Unreleased
+        };
+        string websiteUrl = $"https://mangadex.org/title/{id}";
+        string coverUrl = $"https://uploads.mangadex.org/covers/{id}/{coverFileName}";
+
+        return new Manga(id, name, description, websiteUrl, coverUrl, releaseStatus, this,
+            authors, tags, links,altTitles,
+            null, 0f, year, originalLanguage);
+    }
+
+    private Chapter ParseChapterFromJToken(Manga parentManga, JToken jToken)
+    {
+        string? id = jToken.Value<string>("id");
+        JToken? attributes = jToken["attributes"];
+        string? chapter = attributes?.Value<string>("chapter");
+        string? volumeStr = attributes?.Value<string>("volume");
+        int? volume = null;
+        string? title = attributes?.Value<string>("title");
+        
+        if(id is null || chapter is null)
+            throw new Exception("jToken was not in expected format");
+        if(volumeStr is not null)
+            volume = int.Parse(volumeStr);
+        
+        string url = $"https://mangadex.org/chapter/{id}";
+        return new Chapter(parentManga, url, chapter, volume, id, title);
+    }
+}

API/Schema/MangaReleaseStatus.cs

@@ -0,0 +1,10 @@
+namespace API.Schema;
+
+public enum MangaReleaseStatus : byte
+{
+    Continuing = 0,
+    Completed = 1,
+    OnHiatus = 2,
+    Cancelled = 3,
+    Unreleased = 4
+}

API/Schema/MangaTag.cs

@@ -0,0 +1,17 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("Tag")]
+public class MangaTag(string tag)
+{
+    [StringLength(64)]
+    [Required]
+    public string Tag { get; init; } = tag;
+
+    public override string ToString()
+    {
+        return $"{Tag}";
+    }
+}

API/Schema/Notification.cs

@@ -0,0 +1,52 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("NotificationId")]
+public class Notification
+{
+    [StringLength(64)]
+    [Required]
+    public string NotificationId { get; init; }
+
+    [Required]
+    public NotificationUrgency Urgency { get; init; }
+
+    [StringLength(128)]
+    [Required]
+    public string Title { get; init; }
+
+    [StringLength(512)]
+    [Required]
+    public string Message { get; init; }
+    
+    [Required]
+    public DateTime Date { get; init; }
+
+    public Notification(string title, string message = "", NotificationUrgency urgency = NotificationUrgency.Normal, DateTime? date = null)
+    {
+        this.NotificationId = TokenGen.CreateToken("Notification");
+        this.Title = title;
+        this.Message = message;
+        this.Urgency = urgency;
+        this.Date = date ?? DateTime.UtcNow;
+    }
+
+    /// <summary>
+    /// EF ONLY!!!
+    /// </summary>
+    public Notification(string notificationId, string title, string message, NotificationUrgency urgency, DateTime date)
+    {
+        this.NotificationId = notificationId;
+        this.Title = title;
+        this.Message = message;
+        this.Urgency = urgency;
+        this.Date = date;
+    }
+
+    public override string ToString()
+    {
+        return $"{NotificationId} {Urgency} {Title}";
+    }
+}

API/Schema/NotificationConnectors/NotificationConnector.cs

@@ -0,0 +1,82 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Text;
+using log4net;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+
+namespace API.Schema.NotificationConnectors;
+
+[PrimaryKey("Name")]
+public class NotificationConnector(string name, string url, Dictionary<string, string> headers, string httpMethod, string body)
+{
+    [StringLength(64)]
+    [Required]
+    public string Name { get; init; } = name;
+    
+    [StringLength(2048)]
+    [Required]
+    [Url]
+    public string Url { get; internal set; } = url;
+
+    [Required]
+    public Dictionary<string, string> Headers { get; internal set; } = headers;
+
+    [StringLength(8)]
+    [Required]
+    public string HttpMethod { get; internal set; } = httpMethod;
+
+    [StringLength(4096)]
+    [Required]
+    public string Body { get; internal set; } = body;
+
+    [JsonIgnore]
+    [NotMapped]
+    private readonly HttpClient Client = new()
+    {
+        DefaultRequestHeaders = { { "User-Agent", TrangaSettings.userAgent } }
+    };
+    
+    [JsonIgnore]
+    [NotMapped]
+    protected ILog Log = LogManager.GetLogger(name);
+
+    public void SendNotification(string title, string notificationText)
+    {
+        Log.Info($"Sending notification: {title} - {notificationText}");
+        CustomWebhookFormatProvider formatProvider = new (title, notificationText);
+        string formattedUrl = string.Format(formatProvider, Url);
+        string formattedBody = string.Format(formatProvider, Body, title, notificationText);
+        Dictionary<string, string> formattedHeaders = Headers.ToDictionary(h => h.Key, 
+            h => string.Format(formatProvider, h.Value, title, notificationText));
+
+        HttpRequestMessage request = new(System.Net.Http.HttpMethod.Parse(HttpMethod), formattedUrl);
+        foreach (var (key, value) in formattedHeaders)
+            request.Headers.Add(key, value);
+        request.Content = new StringContent(formattedBody);
+        Log.Debug($"Request: {request}");
+
+        HttpResponseMessage response = Client.Send(request);
+        Log.Debug($"Response status code: {response.StatusCode}");
+    }
+
+    private class CustomWebhookFormatProvider(string title, string text) : IFormatProvider
+    {
+        public object? GetFormat(Type? formatType)
+        {
+            return this;
+        }
+
+        public string Format(string fmt, object arg, IFormatProvider provider)
+        {
+            if(arg.GetType() != typeof(string))
+                return arg.ToString() ?? string.Empty;
+
+            StringBuilder sb = new StringBuilder(fmt);
+            sb.Replace("%title", title);
+            sb.Replace("%text", text);
+            
+            return sb.ToString();
+        }
+    }
+}

API/Schema/NotificationUrgency.cs

@@ -0,0 +1,8 @@
+namespace API.Schema;
+
+public enum NotificationUrgency : byte
+{
+    Low = 1,
+    Normal = 3,
+    High = 5
+}

API/TokenGen.cs

@@ -0,0 +1,37 @@
+using System.Security.Cryptography;
+using System.Text;
+
+namespace API;
+
+public static class TokenGen
+{
+    private const int MinimumLength = 16;
+    private const int MaximumLength = 64;
+    private const string Chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+
+    public static string CreateToken(Type t, params string[] identifiers) => CreateToken(t.Name, identifiers);
+    
+    public static string CreateToken(string prefix, params string[] identifiers)
+    {
+        if (prefix.Length + 1 >= MaximumLength - MinimumLength)
+            throw new ArgumentException("Prefix to long to create Token of meaningful length.");
+        
+        int tokenLength = MaximumLength - prefix.Length - 1;
+        
+        if (identifiers.Length == 0)
+        {
+            // No identifier, just create a random token
+            byte[] rng = new byte[tokenLength];
+            RandomNumberGenerator.Create().GetBytes(rng);
+            string key = new(rng.Select(b => Chars[b % Chars.Length]).ToArray());
+            key = string.Join('-', prefix, key);
+            return key;
+        }
+
+        // Identifier provided, create a token based on the identifier hashed
+        byte[] hash = MD5.HashData(Encoding.UTF8.GetBytes(string.Join("", identifiers)));
+        string token = Convert.ToHexStringLower(hash);
+        
+        return string.Join('-', prefix, token);
+    }
+}

API/Tranga.cs

@@ -0,0 +1,256 @@
+using API.Schema;
+using API.Schema.Contexts;
+using API.Schema.Jobs;
+using API.Schema.MangaConnectors;
+using API.Schema.NotificationConnectors;
+using log4net;
+using log4net.Config;
+using Microsoft.EntityFrameworkCore;
+
+namespace API;
+
+public static class Tranga
+{
+
+    // ReSharper disable once InconsistentNaming
+    private const string TRANGA = 
+        "\n\n" +
+        " _______                                 v2\n" +
+        "|_     _|.----..---.-..-----..-----..---.-.\n" +
+        "  |   |  |   _||  _  ||     ||  _  ||  _  |\n" +
+        "  |___|  |__|  |___._||__|__||___  ||___._|\n" +
+        "                             |_____|       \n\n";
+    
+    public static Thread NotificationSenderThread { get; } = new (NotificationSender);
+    public static Thread JobStarterThread { get; } = new (JobStarter);
+    private static readonly ILog Log = LogManager.GetLogger(typeof(Tranga));
+
+    internal static void StartLogger()
+    {
+        BasicConfigurator.Configure();
+        Log.Info("Logger Configured.");
+        Log.Info(TRANGA);
+    }
+
+    internal static void RemoveStaleFiles(PgsqlContext context)
+    {
+        Log.Info($"Removing stale files...");
+        string[] usedFiles = context.Mangas.Select(m => m.CoverFileNameInCache).Where(s => s != null).ToArray()!;
+        string[] extraneousFiles = new DirectoryInfo(TrangaSettings.coverImageCache).GetFiles()
+            .Where(f => usedFiles.Contains(f.FullName) == false)
+            .Select(f => f.FullName)
+            .ToArray();
+        foreach (string path in extraneousFiles)
+        {
+            Log.Info($"Deleting {path}");
+            File.Delete(path);
+        }
+    }
+    
+    private static void NotificationSender(object? serviceProviderObj)
+    {
+        if (serviceProviderObj is null)
+        {
+            Log.Error("serviceProviderObj is null");
+            return;
+        }
+        IServiceProvider serviceProvider = (IServiceProvider)serviceProviderObj!;
+        using IServiceScope scope = serviceProvider.CreateScope();
+        NotificationsContext context = scope.ServiceProvider.GetRequiredService<NotificationsContext>();
+
+        try
+        {
+            //Removing Notifications from previous runs
+            IQueryable<Notification> staleNotifications =
+                context.Notifications.Where(n => n.Urgency < NotificationUrgency.Normal);
+            context.Notifications.RemoveRange(staleNotifications);
+            context.SaveChanges();
+        }
+        catch (DbUpdateException e)
+        {
+            Log.Error("Error removing stale notifications.", e);
+        }
+        
+        while (true)
+        {
+            SendNotifications(serviceProvider, NotificationUrgency.High);
+            SendNotifications(serviceProvider, NotificationUrgency.Normal);
+            SendNotifications(serviceProvider, NotificationUrgency.Low);
+            
+            Thread.Sleep(2000);
+        }
+    }
+
+    private static void SendNotifications(IServiceProvider serviceProvider, NotificationUrgency urgency)
+    {
+        Log.Debug($"Sending notifications for {urgency}");
+        using IServiceScope scope = serviceProvider.CreateScope();
+        NotificationsContext context = scope.ServiceProvider.GetRequiredService<NotificationsContext>();
+        
+        List<Notification> notifications = context.Notifications.Where(n => n.Urgency == urgency).ToList();
+        if (!notifications.Any())
+            return;
+
+        try
+        {
+            foreach (NotificationConnector notificationConnector in context.NotificationConnectors)
+            {
+                foreach (Notification notification in notifications)
+                    notificationConnector.SendNotification(notification.Title, notification.Message);
+            }
+
+            context.Notifications.RemoveRange(notifications);
+            context.SaveChangesAsync();
+        }
+        catch (DbUpdateException e)
+        {
+            Log.Error("Error sending notifications.", e);
+        }
+    }
+    private static readonly Dictionary<Thread, Job> RunningJobs = new();
+    private static void JobStarter(object? serviceProviderObj)
+    {
+        Log.Info("JobStarter Thread running.");
+        if (serviceProviderObj is null)
+        {
+            Log.Error("serviceProviderObj is null");
+            return;
+        }
+        IServiceProvider serviceProvider = (IServiceProvider)serviceProviderObj;
+        using IServiceScope scope = serviceProvider.CreateScope();
+        
+        while (true)
+        {            
+            Log.Debug("Starting Job-Cycle...");
+            DateTime cycleStart = DateTime.UtcNow;
+            PgsqlContext cycleContext = scope.ServiceProvider.GetRequiredService<PgsqlContext>();
+            Log.Debug("Loading Jobs...");
+            DateTime loadStart = DateTime.UtcNow;
+            Log.Debug($"Jobs Loaded! (took {DateTime.UtcNow.Subtract(loadStart).TotalMilliseconds}ms)");
+            //Update finished Jobs to new states
+            IQueryable<Job> completedJobs = cycleContext.Jobs.Where(j => j.state == JobState.Completed);
+            foreach (Job completedJob in completedJobs)
+                if (completedJob.RecurrenceMs <= 0)
+                {
+                    cycleContext.Jobs.Remove(completedJob);
+                }
+
+            //Retrieve waiting and due Jobs
+            IQueryable<Job> runningJobs = cycleContext.Jobs.Where(j => j.state == JobState.Running);
+            
+            DateTime filterStart = DateTime.UtcNow;
+            Log.Debug("Filtering Jobs...");
+            List<MangaConnector> busyConnectors = GetBusyConnectors(runningJobs);
+
+            IQueryable<Job> waitingJobs = cycleContext.Jobs.Where(j => j.state == JobState.CompletedWaiting || j.state == JobState.FirstExecution);
+            List<Job> dueJobs = FilterDueJobs(waitingJobs);
+            List<Job> jobsWithoutBusyConnectors = FilterJobWithBusyConnectors(dueJobs, busyConnectors);
+            List<Job> jobsWithoutMissingDependencies = FilterJobDependencies(jobsWithoutBusyConnectors);
+
+            List<Job> jobsWithoutDownloading =
+                jobsWithoutMissingDependencies
+                    .Where(j => j.JobType != JobType.DownloadSingleChapterJob)
+                    .DistinctBy(j => j.JobType)
+                    .ToList();
+            List<Job> firstChapterPerConnector =
+                jobsWithoutMissingDependencies
+                    .Where(j => j.JobType == JobType.DownloadSingleChapterJob)
+                    .AsEnumerable()
+                    .OrderBy(j =>
+                    {
+                        DownloadSingleChapterJob dscj = (DownloadSingleChapterJob)j;
+                        return dscj.Chapter;
+                    })
+                    .DistinctBy(j =>
+                    {
+                        DownloadSingleChapterJob dscj = (DownloadSingleChapterJob)j;
+                        return dscj.Chapter.ParentManga.MangaConnector;
+                    })
+                    .ToList();
+
+            List<Job> startJobs = jobsWithoutDownloading.Concat(firstChapterPerConnector).ToList();
+            Log.Debug($"Jobs Filtered! (took {DateTime.UtcNow.Subtract(filterStart).TotalMilliseconds}ms)");
+            
+            
+            //Start Jobs that are allowed to run (preconditions match)
+            foreach (Job job in startJobs)
+            {
+                Thread t = new(() =>
+                {
+                    using IServiceScope jobScope = serviceProvider.CreateScope();
+                    PgsqlContext jobContext = jobScope.ServiceProvider.GetRequiredService<PgsqlContext>();
+                    jobContext.Jobs.Find(job.JobId)?.Run(jobContext); //FIND the job IN THE NEW CONTEXT!!!!!!! SO WE DON'T GET TRACKING PROBLEMS AND AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+                });
+                RunningJobs.Add(t, job);
+                t.Start();
+            }
+            Log.Debug($"Jobs Completed: {completedJobs.Count()} Running: {runningJobs.Count()}\n" +
+                      $"Waiting: {waitingJobs.Count()}\n" +
+                      $"\tof which Due: {dueJobs.Count()}\n" +
+                      $"\t\tof which can be started: {jobsWithoutMissingDependencies.Count()}\n" +
+                      $"\t\t\tof which started: {startJobs.Count()}");
+
+            (Thread, Job)[] removeFromThreadsList = RunningJobs.Where(t => !t.Key.IsAlive)
+                .Select(t => (t.Key, t.Value)).ToArray();
+            Log.Debug($"Remove from Threads List: {removeFromThreadsList.Length}");
+            foreach ((Thread thread, Job job) thread in removeFromThreadsList)
+            {
+                RunningJobs.Remove(thread.thread);
+            }
+
+            try
+            {
+                cycleContext.SaveChanges();
+            }
+            catch (DbUpdateException e)
+            {
+                Log.Error("Failed saving Job changes.", e);
+            }
+            Log.Debug($"Job-Cycle over! (took {DateTime.UtcNow.Subtract(cycleStart).TotalMilliseconds}ms)");
+            Thread.Sleep(TrangaSettings.startNewJobTimeoutMs);
+        }
+    }
+
+    private static List<MangaConnector> GetBusyConnectors(IQueryable<Job> runningJobs)
+    {
+        HashSet<MangaConnector> busyConnectors = new();
+        foreach (Job runningJob in runningJobs)
+        {
+            if(GetJobConnector(runningJob) is { } mangaConnector)
+                busyConnectors.Add(mangaConnector);
+        }
+        return busyConnectors.ToList();
+    }
+
+    private static List<Job> FilterDueJobs(IQueryable<Job> jobs) =>
+        jobs.ToList()
+            .Where(j => j.NextExecution < DateTime.UtcNow)
+            .ToList();
+
+    private static List<Job> FilterJobDependencies(List<Job> jobs) =>
+        jobs
+            .Where(job => job.DependsOnJobs.All(j => j.IsCompleted))
+            .ToList();
+
+    private static List<Job> FilterJobWithBusyConnectors(List<Job> jobs, List<MangaConnector> busyConnectors) =>
+        jobs.Where(j =>
+            {
+                //Filter jobs with busy connectors
+                if (GetJobConnector(j) is { } mangaConnector)
+                    return busyConnectors.Contains(mangaConnector) == false;
+                return true;
+            }).ToList();
+
+    private static MangaConnector? GetJobConnector(Job job)
+    {
+        if (job is DownloadAvailableChaptersJob dacj)
+            return dacj.Manga.MangaConnector;
+        if (job is DownloadMangaCoverJob dmcj)
+            return  dmcj.Manga.MangaConnector;
+        if (job is DownloadSingleChapterJob dscj)
+            return  dscj.Chapter.ParentManga.MangaConnector;
+        if (job is RetrieveChaptersJob rcj)
+            return rcj.Manga.MangaConnector;
+        return null;
+    }
+}

API/TrangaSettings.cs

@@ -0,0 +1,178 @@
+using System.Runtime.InteropServices;
+using API.MangaDownloadClients;
+using API.Schema;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace API;
+
+public static class TrangaSettings
+{
+    public static string downloadLocation { get; private set; } = (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "/Manga" : Path.Join(Directory.GetCurrentDirectory(), "Downloads"));
+    public static string workingDirectory { get; private set; } = Path.Join(RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "/usr/share" : Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "tranga-api");
+    [JsonIgnore]
+    internal static readonly string DefaultUserAgent = $"Tranga ({Enum.GetName(Environment.OSVersion.Platform)}; {(Environment.Is64BitOperatingSystem ? "x64" : "")}) / 1.0";
+    public static string userAgent { get; private set; } = DefaultUserAgent;
+    public static int compression{ get; private set; } = 40;
+    public static bool bwImages { get; private set; } = false;
+    /// <summary>
+    /// Placeholders:
+    /// %M Manga Name
+    /// %V Volume
+    /// %C Chapter
+    /// %T Title
+    /// %A Author (first in list)
+    /// %I Chapter Internal ID
+    /// %i Manga Internal ID
+    /// %Y Year (Manga)
+    ///
+    /// ?_(...) replace _ with a value from above:
+    /// Everything inside the braces will only be added if the value of %_ is not null
+    /// </summary>
+    public static string chapterNamingScheme { get; private set; } = "%M - ?V(Vol.%V )Ch.%C?T( - %T)";
+    [JsonIgnore]
+    public static string settingsFilePath => Path.Join(workingDirectory, "settings.json");
+    [JsonIgnore]
+    public static string coverImageCache => Path.Join(workingDirectory, "imageCache");
+    public static bool aprilFoolsMode { get; private set; } = true;
+    public static int startNewJobTimeoutMs { get; private set; } = 1000;
+    [JsonIgnore]
+    internal static readonly Dictionary<RequestType, int> DefaultRequestLimits = new ()
+    {
+        {RequestType.MangaInfo, 60},
+        {RequestType.MangaDexFeed, 60},
+        {RequestType.MangaDexImage, 40},
+        {RequestType.MangaImage, 60},
+        {RequestType.MangaCover, 60},
+        {RequestType.Default, 60}
+    };
+    public static Dictionary<RequestType, int> requestLimits { get; private set; } = DefaultRequestLimits;
+
+    public static TimeSpan NotificationUrgencyDelay(NotificationUrgency urgency) => urgency switch
+    {
+        NotificationUrgency.High => TimeSpan.Zero,
+        NotificationUrgency.Normal => TimeSpan.FromMinutes(5),
+        NotificationUrgency.Low => TimeSpan.FromMinutes(10),
+        _ => TimeSpan.FromHours(1)
+    }; //TODO make this a setting?
+
+    public static void Load()
+    {
+        if(File.Exists(settingsFilePath))
+            Deserialize(File.ReadAllText(settingsFilePath));
+        else return;
+
+        Directory.CreateDirectory(downloadLocation);
+        ExportSettings();
+    }
+
+    public static void UpdateAprilFoolsMode(bool enabled)
+    {
+        aprilFoolsMode = enabled;
+        ExportSettings();
+    }
+
+    public static void UpdateCompressImages(int value)
+    {
+        compression = int.Clamp(value, 1, 100);
+        ExportSettings();
+    }
+
+    public static void UpdateBwImages(bool enabled)
+    {
+        bwImages = enabled;
+        ExportSettings();
+    }
+
+    public static void UpdateUserAgent(string? customUserAgent)
+    {
+        userAgent = customUserAgent ?? DefaultUserAgent;
+        ExportSettings();
+    }
+
+    public static void UpdateRequestLimit(RequestType requestType, int newLimit)
+    {
+        requestLimits[requestType] = newLimit;
+        ExportSettings();
+    }
+
+    public static void UpdateChapterNamingScheme(string namingScheme)
+    {
+        chapterNamingScheme = namingScheme;
+        ExportSettings();
+    }
+
+    public static void ResetRequestLimits()
+    {
+        requestLimits = DefaultRequestLimits;
+        ExportSettings();
+    }
+
+    public static void ExportSettings()
+    {
+        if (File.Exists(settingsFilePath))
+        {
+            while(IsFileInUse(settingsFilePath))
+                Thread.Sleep(100);
+        }
+        else
+            Directory.CreateDirectory(new FileInfo(settingsFilePath).DirectoryName!);
+        File.WriteAllText(settingsFilePath, Serialize());
+    }
+    
+    internal static bool IsFileInUse(string filePath)
+    {
+        if (!File.Exists(filePath))
+            return false;
+        try
+        {
+            using FileStream stream = new (filePath, FileMode.Open, FileAccess.Read, FileShare.None);
+            stream.Close();
+            return false;
+        }
+        catch (IOException)
+        {
+            return true;
+        }
+    }
+
+    public static JObject AsJObject()
+    {
+        JObject jobj = new ();
+        jobj.Add("downloadLocation", JToken.FromObject(downloadLocation));
+        jobj.Add("workingDirectory", JToken.FromObject(workingDirectory));
+        jobj.Add("userAgent", JToken.FromObject(userAgent));
+        jobj.Add("aprilFoolsMode", JToken.FromObject(aprilFoolsMode));
+        jobj.Add("requestLimits", JToken.FromObject(requestLimits));
+        jobj.Add("compression", JToken.FromObject(compression));
+        jobj.Add("bwImages", JToken.FromObject(bwImages));
+        jobj.Add("startNewJobTimeoutMs", JToken.FromObject(startNewJobTimeoutMs));
+        jobj.Add("chapterNamingScheme", JToken.FromObject(chapterNamingScheme));
+        return jobj;
+    }
+
+    public static string Serialize() => AsJObject().ToString();
+
+    public static void Deserialize(string serialized)
+    {
+        JObject jobj = JObject.Parse(serialized);
+        if (jobj.TryGetValue("downloadLocation", out JToken? dl))
+            downloadLocation = dl.Value<string>()!;
+        if (jobj.TryGetValue("workingDirectory", out JToken? wd))
+            workingDirectory = wd.Value<string>()!;
+        if (jobj.TryGetValue("userAgent", out JToken? ua))
+            userAgent = ua.Value<string>()!;
+        if (jobj.TryGetValue("aprilFoolsMode", out JToken? afm))
+            aprilFoolsMode = afm.Value<bool>()!;
+        if (jobj.TryGetValue("requestLimits", out JToken? rl))
+            requestLimits = rl.ToObject<Dictionary<RequestType, int>>()!;
+        if (jobj.TryGetValue("compression", out JToken? ci))
+            compression = ci.Value<int>()!;
+        if (jobj.TryGetValue("bwImages", out JToken? bwi))
+            bwImages = bwi.Value<bool>()!;
+        if (jobj.TryGetValue("startNewJobTimeoutMs", out JToken? snjt))
+            startNewJobTimeoutMs = snjt.Value<int>()!;
+        if (jobj.TryGetValue("chapterNamingScheme", out JToken? cns))
+            chapterNamingScheme = cns.Value<string>()!;
+    }
+}

API/appsettings.Development.json

@@ -1,7 +1,7 @@
 {
   "Logging": {
     "LogLevel": {
-      "Default": "Information",
+      "Default": "Error",
       "Microsoft.AspNetCore": "Warning"
     }
   }

API/appsettings.json

@@ -1,7 +1,7 @@
 {
   "Logging": {
     "LogLevel": {
-      "Default": "Information",
+      "Default": "Error",
       "Microsoft.AspNetCore": "Warning"
     }
   },

Dockerfile

@@ -0,0 +1,42 @@
+# syntax=docker/dockerfile:1
+ARG DOTNET=9.0
+
+FROM --platform=$TARGETPLATFORM mcr.microsoft.com/dotnet/aspnet:$DOTNET AS base
+WORKDIR /publish
+ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true
+ENV PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium
+ENV XDG_CONFIG_HOME=/tmp/.chromium
+ENV XDG_CACHE_HOME=/tmp/.chromium
+RUN apt-get update \
+  && apt-get install -y libx11-6 libx11-xcb1 libatk1.0-0 libgtk-3-0 libcups2 libdrm2 libxkbcommon0 libxcomposite1 libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 libcairo2 libasound2 libxshmfence1 libnss3 chromium \
+  && apt-get autopurge -y \
+  && apt-get autoclean -y
+
+FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:$DOTNET AS build-env
+WORKDIR /src
+
+COPY Tranga.sln /src
+COPY API/API.csproj /src/API/API.csproj
+RUN dotnet restore /src/Tranga.sln
+
+COPY . /src/
+RUN dotnet publish -c Release --property:OutputPath=/publish -maxcpucount:1 
+
+FROM --platform=$TARGETPLATFORM base AS runtime
+EXPOSE 6531
+ARG UNAME=tranga
+ARG UID=1000
+ARG GID=1000
+RUN groupadd -g $GID -o $UNAME \
+  && useradd -m -u $UID -g $GID -o -s /bin/bash $UNAME \
+  && mkdir /usr/share/tranga-api \
+  && mkdir /Manga \
+  && chown 1000:1000 /usr/share/tranga-api \
+  && chown 1000:1000 /Manga 
+USER $UNAME
+
+WORKDIR /publish
+COPY --chown=1000:1000 --from=build-env /publish .
+USER 0
+ENTRYPOINT ["dotnet", "/publish/API.dll"]
+CMD ["-f", "-c", "-l", "/usr/share/tranga-api/logs"]

Logging/FileLogger.cs

@@ -1,19 +0,0 @@
-using System.Text;
-using System.Text.Json.Serialization;
-
-namespace Logging;
-
-public class FileLogger : LoggerBase
-{
-    private string logFilePath { get; }
-
-    public FileLogger(string logFilePath, TextWriter? stdOut, Encoding? encoding = null) : base (stdOut, encoding)
-    {
-        this.logFilePath = logFilePath;
-    }
-    
-    protected override void Write(LogMessage logMessage)
-    {
-        File.AppendAllText(logFilePath, logMessage.ToString());
-    }
-}

Logging/FormattedConsoleLogger.cs

@@ -1,17 +0,0 @@
-using System.Text;
-
-namespace Logging;
-
-public class FormattedConsoleLogger : LoggerBase
-{
-    
-    public FormattedConsoleLogger(TextWriter? stdOut, Encoding? encoding = null) : base(stdOut, encoding)
-    {
-        
-    }
-
-    protected override void Write(LogMessage message)
-    {
-        //Nothing to do yet
-    }
-}

Logging/Logger.cs

@@ -1,54 +0,0 @@
-using System.Net.Mime;
-using System.Text;
-
-namespace Logging;
-
-public class Logger : TextWriter
-{
-    public override Encoding Encoding { get; }
-    public enum LoggerType
-    {
-        FileLogger,
-        ConsoleLogger,
-        MemoryLogger
-    }
-
-    private FileLogger? _fileLogger;
-    private FormattedConsoleLogger? _formattedConsoleLogger;
-    private MemoryLogger? _memoryLogger;
-    private TextWriter? stdOut;
-
-    public Logger(LoggerType[] enabledLoggers, TextWriter? stdOut, Encoding? encoding, string? logFilePath)
-    {
-        this.Encoding = encoding ?? Encoding.ASCII;
-        this.stdOut = stdOut ?? null;
-        if (enabledLoggers.Contains(LoggerType.FileLogger) && logFilePath is not null)
-            _fileLogger = new FileLogger(logFilePath, null, encoding);
-        else
-        {
-            _fileLogger = null;
-            throw new ArgumentException($"logFilePath can not be null for LoggerType {LoggerType.FileLogger}");
-        }
-        _formattedConsoleLogger = enabledLoggers.Contains(LoggerType.ConsoleLogger) ? new FormattedConsoleLogger(null, encoding) : null;
-        _memoryLogger = enabledLoggers.Contains(LoggerType.MemoryLogger) ? new MemoryLogger(null, encoding) : null;
-    }
-
-    public void WriteLine(string caller, string? value)
-    {
-        value = value is null ? Environment.NewLine : string.Concat(value, Environment.NewLine);
-
-        Write(caller, value);
-    }
-
-    public void Write(string caller, string? value)
-    {
-        if (value is null)
-            return;
-        
-        _fileLogger?.Write(caller, value);
-        _memoryLogger?.Write(caller, value);
-        _formattedConsoleLogger?.Write(caller, value);
-        
-        stdOut?.Write(value);
-    }
-}

Logging/LoggerBase.cs

@@ -1,58 +0,0 @@
-using System.Text;
-
-namespace Logging;
-
-public abstract class LoggerBase : TextWriter
-{
-    public override Encoding Encoding { get; }
-    private TextWriter? stdOut { get; }
-
-    public LoggerBase(TextWriter? stdOut, Encoding? encoding = null)
-    {
-        this.Encoding = encoding ?? Encoding.ASCII;
-        this.stdOut = stdOut;
-    }
-    
-    public void WriteLine(string caller, string? value)
-    {
-        value = value is null ? Environment.NewLine : string.Join(value, Environment.NewLine);
-
-        LogMessage message = new LogMessage(DateTime.Now, caller, value);
-        
-        Write(message);
-    }
-
-    public void Write(string caller, string? value)
-    {
-        if (value is null)
-            return;
-
-        LogMessage message = new LogMessage(DateTime.Now, caller, value);
-        
-        stdOut?.Write(message.ToString());
-        
-        Write(message);
-    }
-
-    protected abstract void Write(LogMessage message);
-
-    public class LogMessage
-    {
-        public DateTime logTime { get; }
-        public string caller { get; }
-        public string value { get; }
-
-        public LogMessage(DateTime now, string caller, string value)
-        {
-            this.logTime = now;
-            this.caller = caller;
-            this.value = value;
-        }
-
-        public override string ToString()
-        {
-            string dateTimeString = $"{logTime.ToShortDateString()} {logTime.ToLongTimeString()}";
-            return $"[{dateTimeString}] {caller,-30} | {value}";
-        }
-    }
-}