TokenGen CreateTokenHash from array of strings.

# Conflicts:
#	API/Schema/MangaConnectors/Mangaworld.cs

.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.
+      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.2.0
+
+      # https://github.com/marketplace/actions/docker-setup-buildx
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3.8.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.9.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-dev.yml

@@ -0,0 +1,45 @@
+name: Docker Image CI
+
+on:
+  push:
+    branches: [ "dev" ]
+  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.2.0
+
+      # https://github.com/marketplace/actions/docker-setup-buildx
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3.8.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.9.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:dev

.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.2.0
+
+      # https://github.com/marketplace/actions/docker-setup-buildx
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3.8.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.9.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: [ "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.2.0
+
+      # https://github.com/marketplace/actions/docker-setup-buildx
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3.8.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.9.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

@@ -16,4 +16,12 @@ riderModule.iml
 # Datasource local storage ignored files
 /dataSources/
 /dataSources.local.xml
-/.idea
+/.idea
+cover.jpg
+cover.png
+/.vscode
+/.vs/
+Tranga/Properties/launchSettings.json
+/Manga
+/settings
+*.DotSettings.user

API/API.csproj

@@ -0,0 +1,37 @@
+<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.11.71" />
+        <PackageReference Include="log4net" Version="3.0.3" />
+        <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="9.0.0" />
+        <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.0" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.0">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+        <PackageReference Include="Npgsql" Version="9.0.2" />
+        <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.2" />
+        <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL.Design" Version="1.1.0" />
+        <PackageReference Include="PuppeteerSharp" Version="20.0.5" />
+        <PackageReference Include="SixLabors.ImageSharp" Version="3.1.5" />
+        <PackageReference Include="Soenneker.Utils.String.NeedlemanWunsch" Version="3.0.697" />
+        <PackageReference Include="Swashbuckle.AspNetCore" Version="7.2.0" />
+        <PackageReference Include="System.Drawing.Common" Version="9.0.0" />
+    </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/Controllers/JobController.cs

@@ -0,0 +1,223 @@
+using API.Schema;
+using API.Schema.Jobs;
+using Asp.Versioning;
+using Microsoft.AspNetCore.Mvc;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Produces("application/json")]
+[Route("v{version:apiVersion}/[controller]")]
+public class JobController(PgsqlContext context) : Controller
+{
+    /// <summary>
+    /// Returns all Jobs
+    /// </summary>
+    /// <returns>Array of Jobs</returns>
+    [HttpGet]
+    [ProducesResponseType<Job[]>(Status200OK)]
+    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>
+    /// <returns>Array of Jobs</returns>
+    [HttpPost("WithIDs")]
+    [ProducesResponseType<Job[]>(Status200OK)]
+    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="state">Requested Job-State</param>
+    /// <returns>Array of Jobs</returns>
+    [HttpGet("State/{state}")]
+    [ProducesResponseType<Job[]>(Status200OK)]
+    public IActionResult GetJobsInState(JobState state)
+    {
+        Job[] jobsInState = context.Jobs.Where(job => job.state == state).ToArray();
+        return Ok(jobsInState);
+    }
+
+    /// <summary>
+    /// Returns all Jobs of requested Type
+    /// </summary>
+    /// <param name="type">Requested Job-Type</param>
+    /// <returns>Array of Jobs</returns>
+    [HttpGet("Type/{type}")]
+    [ProducesResponseType<Job[]>(Status200OK)]
+    public IActionResult GetJobsOfType(JobType type)
+    {
+        Job[] jobsOfType = context.Jobs.Where(job => job.JobType == type).ToArray();
+        return Ok(jobsOfType);
+    }
+
+    /// <summary>
+    /// Return Job with ID
+    /// </summary>
+    /// <param name="id">Job-ID</param>
+    /// <returns>Job</returns>
+    [HttpGet("{id}")]
+    [ProducesResponseType<Job>(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetJob(string id)
+    {
+        Job? ret = context.Jobs.Find(id);
+        return (ret is not null) switch
+        {
+            true => Ok(ret),
+            false => NotFound()
+        };
+    }
+
+    /// <summary>
+    /// Create a new CreateNewDownloadChapterJob
+    /// </summary>
+    /// <param name="request">ID of the Manga, and how often we check again</param>
+    /// <returns>Nothing</returns>
+    [HttpPut("NewDownloadChapterJob/{mangaId}")]
+    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult CreateNewDownloadChapterJob(string mangaId, [FromBody]ulong recurrenceTime)
+    {
+        Job job = new DownloadNewChaptersJob(recurrenceTime, mangaId);
+        return AddJob(job);
+    }
+
+    /// <summary>
+    /// Create a new DownloadSingleChapterJob
+    /// </summary>
+    /// <param name="chapterId">ID of the Chapter</param>
+    /// <returns>Nothing</returns>
+    [HttpPut("DownloadSingleChapterJob/{chapterId}")]
+    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult CreateNewDownloadChapterJob(string chapterId)
+    {
+        Job job = new DownloadSingleChapterJob(chapterId);
+        return AddJob(job);
+    }
+
+    /// <summary>
+    /// Create a new UpdateMetadataJob
+    /// </summary>
+    /// <param name="mangaId">ID of the Manga</param>
+    /// <returns>Nothing</returns>
+    [HttpPut("UpdateMetadataJob/{mangaId}")]
+    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult CreateUpdateMetadataJob(string mangaId)
+    {
+        Job job = new UpdateMetadataJob(0, mangaId);
+        return AddJob(job);
+    }
+
+    /// <summary>
+    /// Create a new UpdateMetadataJob for all Manga
+    /// </summary>
+    /// <returns>Nothing</returns>
+    [HttpPut("UpdateMetadataJob")]
+    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult CreateUpdateAllMetadataJob()
+    {
+        List<string> ids = context.Manga.Select(m => m.MangaId).ToList();
+        List<UpdateMetadataJob> jobs =  ids.Select(id => new UpdateMetadataJob(0, id)).ToList();
+        try
+        {
+            context.Jobs.AddRange(jobs);
+            context.SaveChanges();
+            return Created();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+    
+    private IActionResult AddJob(Job job)
+    {
+        try
+        {
+            context.Jobs.Add(job);
+            context.SaveChanges();
+            return Created();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Delete Job with ID
+    /// </summary>
+    /// <param name="id">Job-ID</param>
+    /// <returns>Nothing</returns>
+    [HttpDelete("{id}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType(Status500InternalServerError)]
+    public IActionResult DeleteJob(string id)
+    {
+        try
+        {
+            Job? ret = context.Jobs.Find(id);
+            switch (ret is not null)
+            {
+                case true:
+                    context.Remove(ret);
+                    context.SaveChanges();
+                    return Ok();
+                case false: return NotFound();
+            }
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Starts the Job with the requested ID
+    /// </summary>
+    /// <param name="id">Job-ID</param>
+    /// <returns>Nothing</returns>
+    [HttpPost("{id}/Start")]
+    [ProducesResponseType(Status202Accepted)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType(Status500InternalServerError)]
+    public IActionResult StartJob(string id)
+    {
+        Job? ret = context.Jobs.Find(id);
+        if (ret is null)
+            return NotFound();
+        try
+        {
+            context.Update(ret);
+            context.SaveChanges();
+            return Accepted();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    [HttpPost("{id}/Stop")]
+    public IActionResult StopJob(string id)
+    {
+        return NotFound(new ProblemResponse("Not implemented")); //TODO
+    }
+}

API/Controllers/LibraryConnectorController.cs

@@ -0,0 +1,95 @@
+using API.Schema;
+using API.Schema.LibraryConnectors;
+using Asp.Versioning;
+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 LibraryConnectorController(PgsqlContext context) : Controller
+{
+    /// <summary>
+    /// Gets all configured Library-Connectors
+    /// </summary>
+    /// <returns>Array of configured Library-Connectors</returns>
+    [HttpGet]
+    [ProducesResponseType<LibraryConnector[]>(Status200OK)]
+    public IActionResult GetAllConnectors()
+    {
+        LibraryConnector[] connectors = context.LibraryConnectors.ToArray();
+        return Ok(connectors);
+    }
+    
+    /// <summary>
+    /// Returns Library-Connector with requested ID
+    /// </summary>
+    /// <param name="id">Library-Connector-ID</param>
+    /// <returns>Library-Connector</returns>
+    [HttpGet("{id}")]
+    [ProducesResponseType<LibraryConnector>(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetConnector(string id)
+    {
+        LibraryConnector? ret = context.LibraryConnectors.Find(id);
+        return (ret is not null) switch
+        {
+            true => Ok(ret),
+            false => NotFound()
+        };
+    }
+    
+    /// <summary>
+    /// Creates a new Library-Connector
+    /// </summary>
+    /// <param name="libraryConnector">Library-Connector</param>
+    /// <returns>Nothing</returns>
+    [HttpPut]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult CreateConnector([FromBody]LibraryConnector libraryConnector)
+    {
+        try
+        {
+            context.LibraryConnectors.Add(libraryConnector);
+            context.SaveChanges();
+            return Created();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+    
+    /// <summary>
+    /// Deletes the Library-Connector with the requested ID
+    /// </summary>
+    /// <param name="id">Library-Connector-ID</param>
+    /// <returns>Nothing</returns>
+    [HttpDelete("{id}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType(Status500InternalServerError)]
+    public IActionResult DeleteConnector(string id)
+    {
+        try
+        {
+            LibraryConnector? ret = context.LibraryConnectors.Find(id);
+            switch (ret is not null)
+            {
+                case true:
+                    context.Remove(ret);
+                    context.SaveChanges();
+                    return Ok();
+                case false: return NotFound();
+            }
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+}

API/Controllers/MangaController.cs

@@ -0,0 +1,163 @@
+using API.Schema;
+using Asp.Versioning;
+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 MangaController(PgsqlContext context) : Controller
+{
+    /// <summary>
+    /// Returns all cached Manga
+    /// </summary>
+    /// <returns>Array of Manga</returns>
+    [HttpGet]
+    [ProducesResponseType<Manga[]>(Status200OK)]
+    public IActionResult GetAllManga()
+    {
+        Manga[] ret = context.Manga.ToArray();
+        return Ok(ret);
+    }
+    
+    /// <summary>
+    /// Returns all cached Manga with IDs
+    /// </summary>
+    /// <param name="ids">Array of Manga-IDs</param>
+    /// <returns>Array of Manga</returns>
+    [HttpPost("WithIDs")]
+    [ProducesResponseType<Manga[]>(Status200OK)]
+    public IActionResult GetManga([FromBody]string[] ids)
+    {
+        Manga[] ret = context.Manga.Where(m => ids.Contains(m.MangaId)).ToArray();
+        return Ok(ret);
+    }
+
+    /// <summary>
+    /// Return Manga with ID
+    /// </summary>
+    /// <param name="id">Manga-ID</param>
+    /// <returns>Manga</returns>
+    [HttpGet("{id}")]
+    [ProducesResponseType<Manga>(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetManga(string id)
+    {
+        Manga? ret = context.Manga.Find(id);
+        return (ret is not null) switch
+        {
+            true => Ok(ret),
+            false => NotFound()
+        };
+    }
+
+    /// <summary>
+    /// Delete Manga with ID
+    /// </summary>
+    /// <param name="id">Manga-ID</param>
+    /// <returns>Nothing</returns>
+    [HttpDelete("{id}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType(Status500InternalServerError)]
+    public IActionResult DeleteManga(string id)
+    {
+        try
+        {
+            Manga? ret = context.Manga.Find(id);
+            switch (ret is not null)
+            {
+                case true:
+                    context.Remove(ret);
+                    context.SaveChanges();
+                    return Ok();
+                case false: return NotFound();
+            }
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Returns URL of Cover of Manga
+    /// </summary>
+    /// <param name="id">Manga-ID</param>
+    /// <returns>URL of Cover</returns>
+    [HttpGet("{id}/Cover")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult GetCover(string id)
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+
+    /// <summary>
+    /// Returns all Chapters of Manga
+    /// </summary>
+    /// <param name="id">Manga-ID</param>
+    /// <returns>Array of Chapters</returns>
+    [HttpGet("{id}/Chapters")]
+    [ProducesResponseType<Chapter[]>(Status200OK)]
+    [ProducesResponseType<string>(Status404NotFound)]
+    public IActionResult GetChapters(string id)
+    {
+        Manga? m = context.Manga.Find(id);
+        if (m is null)
+            return NotFound("Manga could not be found");
+        Chapter[] ret = context.Chapters.Where(c => c.ParentManga.MangaId == m.MangaId).ToArray();
+        return Ok(ret);
+    }
+    
+    /// <summary>
+    /// Returns the latest Chapter of requested Manga
+    /// </summary>
+    /// <param name="id">Manga-ID</param>
+    /// <returns>Latest Chapter</returns>
+    [HttpGet("{id}/Chapter/Latest")]
+    [ProducesResponseType<Chapter>(Status200OK)]
+    [ProducesResponseType<string>(Status404NotFound)]
+    public IActionResult GetLatestChapter(string id)
+    {
+        Manga? m = context.Manga.Find(id);
+        if (m is null)
+            return NotFound("Manga could not be found");
+        List<Chapter> chapters = context.Chapters.Where(c => c.ParentManga.MangaId == m.MangaId).ToList();
+        Chapter? max = chapters.Max();
+        if (max is null)
+            return NotFound("Chapter could not be found");
+        return Ok(max);
+    }
+    
+    /// <summary>
+    /// Configure the cut-off for Manga
+    /// </summary>
+    /// <remarks>This is important for the DownloadNewChapters-Job</remarks>
+    /// <param name="id">Manga-ID</param>
+    /// <returns>Nothing</returns>
+    [HttpPatch("{id}/IgnoreChaptersBefore")]
+    [ProducesResponseType<float>(Status200OK)]
+    public IActionResult IgnoreChaptersBefore(string id)
+    {
+        Manga? m = context.Manga.Find(id);
+        if (m is null)
+            return NotFound("Manga could not be found");
+        return Ok(m.IgnoreChapterBefore);
+    }
+    
+    /// <summary>
+    /// Move the Directory the .cbz-files are located in
+    /// </summary>
+    /// <param name="id">Manga-ID</param>
+    /// <param name="folder">New Directory-Path</param>
+    /// <returns>Nothing</returns>
+    [HttpPost("{id}/MoveFolder")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult MoveFolder(string id, [FromBody]string folder)
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+}

API/Controllers/MiscController.cs

@@ -0,0 +1,26 @@
+using API.Schema;
+using API.Schema.MangaConnectors;
+using Asp.Versioning;
+using Microsoft.AspNetCore.Mvc;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Produces("application/json")]
+[Route("v{v:apiVersion}")]
+public class MiscController(PgsqlContext context) : Controller
+{
+    /// <summary>
+    /// Get all available Connectors (Scanlation-Sites)
+    /// </summary>
+    /// <returns>Array of MangaConnector</returns>
+    [HttpGet("GetConnectors")]
+    [ProducesResponseType<MangaConnector[]>(Status200OK)]
+    public IActionResult GetConnectors()
+    {
+        MangaConnector[] connectors = context.MangaConnectors.ToArray();
+        return Ok(connectors);
+    }
+}

API/Controllers/NotificationConnectorController.cs

@@ -0,0 +1,95 @@
+using API.Schema;
+using API.Schema.NotificationConnectors;
+using Asp.Versioning;
+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(PgsqlContext context) : Controller
+{
+    /// <summary>
+    /// Gets all configured Notification-Connectors
+    /// </summary>
+    /// <returns>Array of configured Notification-Connectors</returns>
+    [HttpGet]
+    [ProducesResponseType<NotificationConnector[]>(Status200OK)]
+    public IActionResult GetAllConnectors()
+    {
+        NotificationConnector[] ret = context.NotificationConnectors.ToArray();
+        return Ok(ret);
+    }
+    
+    /// <summary>
+    /// Returns Notification-Connector with requested ID
+    /// </summary>
+    /// <param name="id">Notification-Connector-ID</param>
+    /// <returns>Notification-Connector</returns>
+    [HttpGet("{id}")]
+    [ProducesResponseType<NotificationConnector>(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetConnector(string id)
+    {
+        NotificationConnector? ret = context.NotificationConnectors.Find(id);
+        return (ret is not null) switch
+        {
+            true => Ok(ret),
+            false => NotFound()
+        };
+    }
+    
+    /// <summary>
+    /// Creates a new Notification-Connector
+    /// </summary>
+    /// <param name="notificationConnector">Notification-Connector</param>
+    /// <returns>Nothing</returns>
+    [HttpPut]
+    [ProducesResponseType<NotificationConnector[]>(Status200OK)]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult CreateConnector([FromBody]NotificationConnector notificationConnector)
+    {
+        try
+        {
+            context.NotificationConnectors.Add(notificationConnector);
+            context.SaveChanges();
+            return Created();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+    
+    /// <summary>
+    /// Deletes the Notification-Connector with the requested ID
+    /// </summary>
+    /// <param name="id">Notification-Connector-ID</param>
+    /// <returns>Nothing</returns>
+    [HttpDelete("{id}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType(Status500InternalServerError)]
+    public IActionResult DeleteConnector(string id)
+    {
+        try
+        {
+            NotificationConnector? ret = context.NotificationConnectors.Find(id);
+            switch (ret is not null)
+            {
+                case true:
+                    context.Remove(ret);
+                    context.SaveChanges();
+                    return Ok();
+                case false: return NotFound();
+            }
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+}

API/Controllers/SearchController.cs

@@ -0,0 +1,150 @@
+using API.Schema;
+using API.Schema.MangaConnectors;
+using Asp.Versioning;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Produces("application/json")]
+[Route("v{v:apiVersion}/[controller]")]
+public class SearchController(PgsqlContext context) : Controller
+{
+    
+    /// <summary>
+    /// Initiate a search for a Manga on all Connectors
+    /// </summary>
+    /// <param name="name">Name/Title of the Manga</param>
+    /// <returns>Array of Manga</returns>
+    [HttpPost("{name}")]
+    [ProducesResponseType<Manga[]>(Status500InternalServerError)]
+    public IActionResult SearchMangaGlobal(string name)
+    {
+        List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> allManga = new();
+        foreach (MangaConnector contextMangaConnector in context.MangaConnectors)
+            allManga.AddRange(contextMangaConnector.GetManga(name));
+        List<Manga> retMangas = new();
+        foreach ((Manga? manga, List<Author>? authors, List<MangaTag>? tags, List<Link>? links, List<MangaAltTitle>? altTitles) in allManga)
+        {
+            try
+            {
+                Manga? add = AddMangaToContext(manga, authors, tags, links, altTitles);
+                if(add is not null)
+                    retMangas.Add(add);
+            }
+            catch (DbUpdateException)
+            {
+                return StatusCode(500, new ProblemResponse("An error occurred while processing your request."));
+            }
+        }
+        return Ok(retMangas.ToArray());
+    }
+    
+    /// <summary>
+    /// Initiate a search for a Manga on a specific Connector
+    /// </summary>
+    /// <param name="id">Manga-Connector-ID</param>
+    /// <param name="name">Name/Title of the Manga</param>
+    /// <returns>Manga</returns>
+    [HttpPost("{id}/{name}")]
+    [ProducesResponseType<Manga[]>(Status200OK)]
+    [ProducesResponseType<ProblemResponse>(Status404NotFound)]
+    [ProducesResponseType<ProblemResponse>(Status500InternalServerError)]
+    public IActionResult SearchManga(string id, string name)
+    {
+        MangaConnector? connector = context.MangaConnectors.Find(id);
+        if (connector is null)
+            return NotFound(new ProblemResponse("Connector not found."));
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] mangas = connector.GetManga(name);
+        List<Manga> retMangas = new();
+        foreach ((Manga? manga, List<Author>? authors, List<MangaTag>? tags, List<Link>? links, List<MangaAltTitle>? altTitles) in mangas)
+        {
+            try
+            {
+                Manga? add = AddMangaToContext(manga, authors, tags, links, altTitles);
+                if(add is not null)
+                    retMangas.Add(add);
+            }
+            catch (DbUpdateException e)
+            {
+                return StatusCode(500, new ProblemResponse("An error occurred while processing your request.", e.Message));
+            }
+        }
+
+        return Ok(retMangas.ToArray());
+    }
+
+    private Manga? AddMangaToContext(Manga? manga, List<Author>? authors, List<MangaTag>? tags, List<Link>? links,
+        List<MangaAltTitle>? altTitles)
+    {
+        if (manga is null)
+            return null;
+        Manga? existing = context.Manga.FirstOrDefault(m =>
+            m.MangaConnector == manga.MangaConnector && m.ConnectorId == manga.ConnectorId);
+        
+        if (tags is not null)
+        {
+            IEnumerable<MangaTag> mergedTags = tags.Select(mt =>
+            {
+                MangaTag? inDb = context.Tags.FirstOrDefault(t => t.Equals(mt));
+                return inDb ?? mt;
+            });
+            manga.Tags = mergedTags.ToList();
+            IEnumerable<MangaTag> newTags = manga.Tags.Where(mt => !context.Tags.Any(t => t.Tag.Equals(mt.Tag)));
+            context.Tags.AddRange(newTags);
+        }
+
+        if (authors is not null)
+        {
+            IEnumerable<Author> mergedAuthors = authors.Select(ma =>
+            {
+                Author? inDb = context.Authors.FirstOrDefault(a => a.AuthorName == ma.AuthorName);
+                return inDb ?? ma;
+            });
+            manga.Authors = mergedAuthors.ToList();
+            IEnumerable<Author> newAuthors = manga.Authors.Where(ma => !context.Authors.Any(a =>
+                a.AuthorName == ma.AuthorName));
+            context.Authors.AddRange(newAuthors);
+        }
+
+        if (links is not null)
+        {
+            IEnumerable<Link> mergedLinks = links.Select(ml =>
+            {
+                Link? inDb = context.Link.FirstOrDefault(l =>
+                    l.LinkProvider == ml.LinkProvider && l.LinkUrl == ml.LinkUrl);
+                return inDb ?? ml;
+            });
+            manga.Links = mergedLinks.ToList();
+            IEnumerable<Link> newLinks = manga.Links.Where(ml => !context.Link.Any(l =>
+                l.LinkProvider == ml.LinkProvider && l.LinkUrl == ml.LinkUrl));
+            context.Link.AddRange(newLinks);
+        }
+
+        if (altTitles is not null)
+        {
+            IEnumerable<MangaAltTitle> mergedAltTitles = altTitles.Select(mat =>
+            {
+                MangaAltTitle? inDb = context.AltTitles.FirstOrDefault(at =>
+                    at.Language == mat.Language && at.Title == mat.Title);
+                return inDb ?? mat;
+            });
+            manga.AltTitles = mergedAltTitles.ToList();
+            IEnumerable<MangaAltTitle> newAltTitles = manga.AltTitles.Where(mat =>
+                !context.AltTitles.Any(at => at.Language == mat.Language && at.Title == mat.Title));
+            context.AltTitles.AddRange(newAltTitles);
+        }
+        
+        existing?.UpdateWithInfo(manga);
+        if(existing is not null)
+            context.Manga.Update(existing);
+        else
+            context.Manga.Add(manga);
+        
+        context.SaveChanges();
+        return existing ?? manga;
+    }
+}

API/Controllers/SettingsController.cs

@@ -0,0 +1,161 @@
+using API.Schema;
+using Asp.Versioning;
+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 SettingsController(PgsqlContext context) : Controller
+{
+    /// <summary>
+    /// Get all Settings
+    /// </summary>
+    /// <returns></returns>
+    [HttpGet]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult GetSettings()
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <summary>
+    /// Get the current UserAgent used by Tranga
+    /// </summary>
+    /// <returns>UserAgent as string</returns>
+    [HttpGet("UserAgent")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult GetUserAgent()
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <summary>
+    /// Set a new UserAgent
+    /// </summary>
+    /// <returns>Nothing</returns>
+    [HttpPatch("UserAgent")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult SetUserAgent()
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <summary>
+    /// Reset the UserAgent to default
+    /// </summary>
+    /// <returns>Nothing</returns>
+    [HttpDelete("UserAgent")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult ResetUserAgent()
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <summary>
+    /// Get all Request-Limits
+    /// </summary>
+    /// <returns></returns>
+    [HttpGet("RequestLimits")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult GetRequestLimits()
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <summary>
+    /// Update all Request-Limits to new values
+    /// </summary>
+    /// <returns>Nothing</returns>
+    [HttpPatch("RequestLimits")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult SetRequestLimits()
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <summary>
+    /// Reset all Request-Limits
+    /// </summary>
+    /// <returns>Nothing</returns>
+    [HttpDelete("RequestLimits")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult ResetRequestLimits()
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <summary>
+    /// Returns Level of Image-Compression for Images
+    /// </summary>
+    /// <returns></returns>
+    [HttpGet("ImageCompression")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult GetImageCompression()
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <summary>
+    /// Set the Image-Compression-Level for Images
+    /// </summary>
+    /// <param name="percentage">100 to disable, 0-99 for JPEG compression-Level</param>
+    /// <returns>Nothing</returns>
+    [HttpPatch("ImageCompression")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult SetImageCompression(int percentage)
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <summary>
+    /// Get state of Black/White-Image setting
+    /// </summary>
+    /// <returns>True if enabled</returns>
+    [HttpGet("BWImages")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult GetBwImagesToggle()
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <summary>
+    /// Enable/Disable conversion of Images to Black and White
+    /// </summary>
+    /// <param name="enabled">true to enable</param>
+    /// <returns>Nothing</returns>
+    [HttpPatch("BWImages")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult SetBwImagesToggle(bool enabled)
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <summary>
+    /// Get state of April Fools Mode
+    /// </summary>
+    /// <remarks>April Fools Mode disables all downloads on April 1st</remarks>
+    /// <returns>True if enabled</returns>
+    [HttpGet("AprilFoolsMode")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult GetAprilFoolsMode()
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+    
+    /// <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>
+    /// <returns>Nothing</returns>
+    [HttpPatch("AprilFoolsMode")]
+    [ProducesResponseType<string>(Status500InternalServerError)]
+    public IActionResult SetAprilFoolsMode(bool enabled)
+    {
+        return StatusCode(500, "Not implemented"); //TODO
+    }
+}

API/MangaDownloadClients/ChromiumDownloadClient.cs

@@ -0,0 +1,110 @@
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using HtmlAgilityPack;
+using PuppeteerSharp;
+
+namespace API.MangaDownloadClients;
+
+internal class ChromiumDownloadClient : DownloadClient
+{
+    private static IBrowser? _browser;
+    private const int StartTimeoutMs = 10000;
+    private readonly HttpDownloadClient _httpDownloadClient;
+    
+    private static async Task<IBrowser> StartBrowser()
+    {
+        return await Puppeteer.LaunchAsync(new LaunchOptions
+        {
+            Headless = true,
+            Args = new [] {
+                "--disable-gpu",
+                "--disable-dev-shm-usage",
+                "--disable-setuid-sandbox",
+                "--no-sandbox"},
+            Timeout = StartTimeoutMs
+        }, new LoggerFactory([new LogProvider()])); //TODO
+    }
+
+    private class LogProvider : ILoggerProvider
+    {
+        //TODO
+        public void Dispose() { }
+
+        public ILogger CreateLogger(string categoryName) => new Logger();
+    }
+
+    private class Logger : ILogger
+    {
+        public Logger() : base() { }
+
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+        {
+            if (logLevel <= LogLevel.Information)
+                return;
+            //TODO
+        }
+
+        public bool IsEnabled(LogLevel logLevel) => true;
+
+        public IDisposable? BeginScope<TState>(TState state) where TState : notnull => null;
+    }
+
+    public ChromiumDownloadClient()
+    {
+        _httpDownloadClient = new();
+        if(_browser is null)
+            _browser = StartBrowser().Result;
+    }
+
+    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)
+    {
+        return _imageUrlRex.IsMatch(url)
+            ? _httpDownloadClient.MakeRequestInternal(url, referrer)
+            : MakeRequestBrowser(url, referrer, clickButton);
+    }
+
+    private RequestResult MakeRequestBrowser(string url, string? referrer = null, string? clickButton = null)
+    {
+        IPage page = _browser.NewPageAsync().Result;
+        page.DefaultTimeout = 10000;
+        IResponse response;
+        try
+        {
+            response = page.GoToAsync(url, WaitUntilNavigation.Networkidle0).Result;
+        }
+        catch (Exception e)
+        {
+            page.CloseAsync();
+            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();
+            return new RequestResult(HttpStatusCode.InternalServerError, null, Stream.Null);
+        }
+        
+        page.CloseAsync();
+        return new RequestResult(response.Status, document, stream, false, "");
+    }
+}

API/MangaDownloadClients/DownloadClient.cs

@@ -0,0 +1,42 @@
+using System.Net;
+using API.Schema;
+
+namespace API.MangaDownloadClients;
+
+internal abstract class DownloadClient
+{
+    private readonly Dictionary<RequestType, DateTime> _lastExecutedRateLimit;
+
+    protected DownloadClient()
+    {
+        this._lastExecutedRateLimit = new();
+    }
+    
+    public RequestResult MakeRequest(string url, RequestType requestType, string? referrer = null, string? clickButton = null)
+    {
+        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);
+        _lastExecutedRateLimit.TryAdd(requestType, DateTime.Now.Subtract(timeBetweenRequests));
+
+        TimeSpan rateLimitTimeout = timeBetweenRequests.Subtract(DateTime.Now.Subtract(_lastExecutedRateLimit[requestType]));
+
+        if (rateLimitTimeout > TimeSpan.Zero)
+        {
+            Thread.Sleep(rateLimitTimeout);
+        }
+
+        RequestResult result = MakeRequestInternal(url, referrer, clickButton);
+        _lastExecutedRateLimit[requestType] = DateTime.Now;
+        return result;
+    }
+
+    internal abstract RequestResult MakeRequestInternal(string url, string? referrer = null, string? clickButton = null);
+}

API/MangaDownloadClients/HttpDownloadClient.cs

@@ -0,0 +1,73 @@
+using System.Net;
+using API.Schema;
+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)
+    {
+        //TODO
+        //if (clickButton is not null)
+            //Log("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($"Requesting {requestType} {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 = response.Content.ReadAsStream();
+
+        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,27 @@
+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;
+    }
+}

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/20241201235443_Initial.Designer.cs

@@ -0,0 +1,781 @@
+// <auto-generated />
+using System;
+using API.Schema;
+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
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20241201235443_Initial")]
+    partial class Initial
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.0")
+                .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()
+                        .HasColumnType("text");
+
+                    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>("ArchiveFileName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChapterIds")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<float>("ChapterNumber")
+                        .HasColumnType("real");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<float?>("VolumeNumber")
+                        .HasColumnType("real");
+
+                    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.PrimitiveCollection<string[]>("DependsOnJobIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("JobId1")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("NextExecution")
+                        .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<int>("state")
+                        .HasColumnType("integer");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("JobId1");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkIds")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Link");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("AltTitleIds")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("AuthorIds")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("ConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LatestChapterAvailableId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LatestChapterDownloadedId")
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("LinkIds")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("MangaConnectorName")
+                        .IsRequired()
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("MangaIds")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasColumnType("text");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.PrimitiveCollection<string[]>("TagIds")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<long>("year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LatestChapterAvailableId")
+                        .IsUnique();
+
+                    b.HasIndex("LatestChapterDownloadedId")
+                        .IsUnique();
+
+                    b.HasIndex("MangaConnectorName");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AltTitleIds")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasColumnType("text");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("NotificationConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<byte>("NotificationConnectorType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationConnectorId");
+
+                    b.ToTable("NotificationConnectors");
+
+                    b.HasDiscriminator<byte>("NotificationConnectorType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("MangaAuthor", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorIds")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MangaIds")
+                        .HasColumnType("text");
+
+                    b.HasKey("MangaId", "AuthorId");
+
+                    b.HasIndex("AuthorId");
+
+                    b.ToTable("MangaAuthor");
+                });
+
+            modelBuilder.Entity("MangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Tag")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MangaIds")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TagIds")
+                        .HasColumnType("text");
+
+                    b.HasKey("MangaId", "Tag");
+
+                    b.HasIndex("MangaIds");
+
+                    b.HasIndex("Tag");
+
+                    b.ToTable("MangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.CreateArchiveJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ComicInfoLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ImagesLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasIndex("ChapterId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("ChapterId")
+                                .HasColumnName("CreateArchiveJob_ChapterId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.CreateComicInfoXmlJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasIndex("ChapterId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("ChapterId")
+                                .HasColumnName("CreateComicInfoXmlJob_ChapterId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadNewChaptersJob", 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)1);
+                });
+
+            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()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.ProcessImagesJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<bool>("Bw")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("Compression")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("Path")
+                                .HasColumnName("ProcessImagesJob_Path");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.SearchMangaJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaConnectorName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SearchString")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)7);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", 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("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            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);
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.Gotify", b =>
+                {
+                    b.HasBaseType("API.Schema.NotificationConnectors.NotificationConnector");
+
+                    b.Property<string>("AppToken")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Endpoint")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.Lunasea", b =>
+                {
+                    b.HasBaseType("API.Schema.NotificationConnectors.NotificationConnector");
+
+                    b.Property<string>("Id")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.Ntfy", b =>
+                {
+                    b.HasBaseType("API.Schema.NotificationConnectors.NotificationConnector");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Endpoint")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Topic")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.ToTable("NotificationConnectors", t =>
+                        {
+                            t.Property("Endpoint")
+                                .HasColumnName("Ntfy_Endpoint");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            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", null)
+                        .WithMany("DependsOnJobs")
+                        .HasForeignKey("JobId1");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "LatestChapterAvailable")
+                        .WithOne()
+                        .HasForeignKey("API.Schema.Manga", "LatestChapterAvailableId");
+
+                    b.HasOne("API.Schema.Chapter", "LatestChapterDownloaded")
+                        .WithOne()
+                        .HasForeignKey("API.Schema.Manga", "LatestChapterDownloadedId");
+
+                    b.HasOne("API.Schema.MangaConnector", "MangaConnector")
+                        .WithMany("Mangas")
+                        .HasForeignKey("MangaConnectorName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LatestChapterAvailable");
+
+                    b.Navigation("LatestChapterDownloaded");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("MangaAuthor", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaIds")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("Tag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.CreateArchiveJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.CreateComicInfoXmlJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadNewChaptersJob", 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.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Navigation("DependsOnJobs");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Chapters");
+
+                    b.Navigation("Links");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnector", b =>
+                {
+                    b.Navigation("Mangas");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20241201235443_Initial.cs

@@ -0,0 +1,447 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class Initial : 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: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Authors", x => x.AuthorId);
+                });
+
+            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: "text", nullable: false),
+                    Auth = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LibraryConnectors", x => x.LibraryConnectorId);
+                });
+
+            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[]", nullable: false),
+                    BaseUris = table.Column<string[]>(type: "text[]", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MangaConnectors", x => x.Name);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "NotificationConnectors",
+                columns: table => new
+                {
+                    NotificationConnectorId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    NotificationConnectorType = table.Column<byte>(type: "smallint", nullable: false),
+                    Endpoint = table.Column<string>(type: "text", nullable: true),
+                    AppToken = table.Column<string>(type: "text", nullable: true),
+                    Id = table.Column<string>(type: "text", nullable: true),
+                    Ntfy_Endpoint = table.Column<string>(type: "text", nullable: true),
+                    Auth = table.Column<string>(type: "text", nullable: true),
+                    Topic = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_NotificationConnectors", x => x.NotificationConnectorId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Tags",
+                columns: table => new
+                {
+                    Tag = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Tags", x => x.Tag);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AltTitles",
+                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: "text", nullable: false),
+                    MangaId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    AltTitleIds = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AltTitles", x => x.AltTitleId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Chapters",
+                columns: table => new
+                {
+                    ChapterId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    VolumeNumber = table.Column<float>(type: "real", nullable: true),
+                    ChapterNumber = table.Column<float>(type: "real", nullable: false),
+                    Url = table.Column<string>(type: "text", nullable: false),
+                    Title = table.Column<string>(type: "text", nullable: true),
+                    ArchiveFileName = table.Column<string>(type: "text", nullable: false),
+                    Downloaded = table.Column<bool>(type: "boolean", nullable: false),
+                    ParentMangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    ChapterIds = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Chapters", x => x.ChapterId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Manga",
+                columns: table => new
+                {
+                    MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    ConnectorId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false),
+                    Description = table.Column<string>(type: "text", nullable: false),
+                    CoverUrl = table.Column<string>(type: "text", nullable: false),
+                    CoverFileNameInCache = table.Column<string>(type: "text", nullable: true),
+                    year = table.Column<long>(type: "bigint", nullable: false),
+                    OriginalLanguage = table.Column<string>(type: "text", nullable: true),
+                    ReleaseStatus = table.Column<byte>(type: "smallint", nullable: false),
+                    FolderName = table.Column<string>(type: "text", nullable: false),
+                    IgnoreChapterBefore = table.Column<float>(type: "real", nullable: false),
+                    LatestChapterDownloadedId = table.Column<string>(type: "character varying(64)", nullable: true),
+                    LatestChapterAvailableId = table.Column<string>(type: "character varying(64)", nullable: true),
+                    MangaConnectorName = table.Column<string>(type: "character varying(32)", nullable: false),
+                    AuthorIds = table.Column<string[]>(type: "text[]", nullable: false),
+                    TagIds = table.Column<string[]>(type: "text[]", nullable: false),
+                    LinkIds = table.Column<string[]>(type: "text[]", nullable: false),
+                    AltTitleIds = table.Column<string[]>(type: "text[]", nullable: false),
+                    MangaIds = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Manga", x => x.MangaId);
+                    table.ForeignKey(
+                        name: "FK_Manga_Chapters_LatestChapterAvailableId",
+                        column: x => x.LatestChapterAvailableId,
+                        principalTable: "Chapters",
+                        principalColumn: "ChapterId");
+                    table.ForeignKey(
+                        name: "FK_Manga_Chapters_LatestChapterDownloadedId",
+                        column: x => x.LatestChapterDownloadedId,
+                        principalTable: "Chapters",
+                        principalColumn: "ChapterId");
+                    table.ForeignKey(
+                        name: "FK_Manga_MangaConnectors_MangaConnectorName",
+                        column: x => x.MangaConnectorName,
+                        principalTable: "MangaConnectors",
+                        principalColumn: "Name",
+                        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),
+                    DependsOnJobIds = table.Column<string[]>(type: "text[]", 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),
+                    NextExecution = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    state = table.Column<int>(type: "integer", nullable: false),
+                    JobId1 = table.Column<string>(type: "character varying(64)", nullable: true),
+                    ImagesLocation = table.Column<string>(type: "text", nullable: true),
+                    ComicInfoLocation = table.Column<string>(type: "text", nullable: true),
+                    CreateArchiveJob_ChapterId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    Path = table.Column<string>(type: "text", nullable: true),
+                    CreateComicInfoXmlJob_ChapterId = 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: "text", nullable: true),
+                    ToLocation = table.Column<string>(type: "text", nullable: true),
+                    ProcessImagesJob_Path = table.Column<string>(type: "text", nullable: true),
+                    Bw = table.Column<bool>(type: "boolean", nullable: true),
+                    Compression = table.Column<int>(type: "integer", nullable: true),
+                    SearchString = table.Column<string>(type: "text", nullable: true),
+                    MangaConnectorName = table.Column<string>(type: "text", nullable: true),
+                    UpdateMetadataJob_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_Chapters_CreateArchiveJob_ChapterId",
+                        column: x => x.CreateArchiveJob_ChapterId,
+                        principalTable: "Chapters",
+                        principalColumn: "ChapterId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Chapters_CreateComicInfoXmlJob_ChapterId",
+                        column: x => x.CreateComicInfoXmlJob_ChapterId,
+                        principalTable: "Chapters",
+                        principalColumn: "ChapterId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Jobs_JobId1",
+                        column: x => x.JobId1,
+                        principalTable: "Jobs",
+                        principalColumn: "JobId");
+                    table.ForeignKey(
+                        name: "FK_Jobs_Manga_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Manga",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Manga_UpdateMetadataJob_MangaId",
+                        column: x => x.UpdateMetadataJob_MangaId,
+                        principalTable: "Manga",
+                        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: "text", nullable: false),
+                    LinkUrl = table.Column<string>(type: "text", nullable: false),
+                    MangaId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    LinkIds = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Link", x => x.LinkId);
+                    table.ForeignKey(
+                        name: "FK_Link_Manga_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Manga",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "MangaAuthor",
+                columns: table => new
+                {
+                    MangaId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    AuthorId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    AuthorIds = table.Column<string>(type: "text", nullable: true),
+                    MangaIds = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MangaAuthor", x => new { x.MangaId, x.AuthorId });
+                    table.ForeignKey(
+                        name: "FK_MangaAuthor_Authors_AuthorId",
+                        column: x => x.AuthorId,
+                        principalTable: "Authors",
+                        principalColumn: "AuthorId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_MangaAuthor_Manga_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Manga",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "MangaTag",
+                columns: table => new
+                {
+                    MangaId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    Tag = table.Column<string>(type: "text", nullable: false),
+                    MangaIds = table.Column<string>(type: "text", nullable: false),
+                    TagIds = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MangaTag", x => new { x.MangaId, x.Tag });
+                    table.ForeignKey(
+                        name: "FK_MangaTag_Manga_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Manga",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_MangaTag_Tags_MangaIds",
+                        column: x => x.MangaIds,
+                        principalTable: "Tags",
+                        principalColumn: "Tag",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_MangaTag_Tags_Tag",
+                        column: x => x.Tag,
+                        principalTable: "Tags",
+                        principalColumn: "Tag",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AltTitles_MangaId",
+                table: "AltTitles",
+                column: "MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Chapters_ParentMangaId",
+                table: "Chapters",
+                column: "ParentMangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_ChapterId",
+                table: "Jobs",
+                column: "ChapterId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_CreateArchiveJob_ChapterId",
+                table: "Jobs",
+                column: "CreateArchiveJob_ChapterId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_CreateComicInfoXmlJob_ChapterId",
+                table: "Jobs",
+                column: "CreateComicInfoXmlJob_ChapterId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_JobId1",
+                table: "Jobs",
+                column: "JobId1");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_MangaId",
+                table: "Jobs",
+                column: "MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_UpdateMetadataJob_MangaId",
+                table: "Jobs",
+                column: "UpdateMetadataJob_MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Link_MangaId",
+                table: "Link",
+                column: "MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Manga_LatestChapterAvailableId",
+                table: "Manga",
+                column: "LatestChapterAvailableId",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Manga_LatestChapterDownloadedId",
+                table: "Manga",
+                column: "LatestChapterDownloadedId",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Manga_MangaConnectorName",
+                table: "Manga",
+                column: "MangaConnectorName");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MangaAuthor_AuthorId",
+                table: "MangaAuthor",
+                column: "AuthorId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MangaTag_MangaIds",
+                table: "MangaTag",
+                column: "MangaIds");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MangaTag_Tag",
+                table: "MangaTag",
+                column: "Tag");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AltTitles_Manga_MangaId",
+                table: "AltTitles",
+                column: "MangaId",
+                principalTable: "Manga",
+                principalColumn: "MangaId",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Chapters_Manga_ParentMangaId",
+                table: "Chapters",
+                column: "ParentMangaId",
+                principalTable: "Manga",
+                principalColumn: "MangaId",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Chapters_Manga_ParentMangaId",
+                table: "Chapters");
+
+            migrationBuilder.DropTable(
+                name: "AltTitles");
+
+            migrationBuilder.DropTable(
+                name: "Jobs");
+
+            migrationBuilder.DropTable(
+                name: "LibraryConnectors");
+
+            migrationBuilder.DropTable(
+                name: "Link");
+
+            migrationBuilder.DropTable(
+                name: "MangaAuthor");
+
+            migrationBuilder.DropTable(
+                name: "MangaTag");
+
+            migrationBuilder.DropTable(
+                name: "NotificationConnectors");
+
+            migrationBuilder.DropTable(
+                name: "Authors");
+
+            migrationBuilder.DropTable(
+                name: "Tags");
+
+            migrationBuilder.DropTable(
+                name: "Manga");
+
+            migrationBuilder.DropTable(
+                name: "Chapters");
+
+            migrationBuilder.DropTable(
+                name: "MangaConnectors");
+        }
+    }
+}

API/Migrations/PgsqlContextModelSnapshot.cs

@@ -0,0 +1,688 @@
+// <auto-generated />
+using System;
+using API.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    [DbContext(typeof(PgsqlContext))]
+    partial class PgsqlContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.0")
+                .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()
+                        .HasColumnType("text");
+
+                    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>("ArchiveFileName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<float>("ChapterNumber")
+                        .HasColumnType("real");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<float?>("VolumeNumber")
+                        .HasColumnType("real");
+
+                    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.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("JobId1")
+                        .HasColumnType("character varying(64)");
+
+                    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<int>("state")
+                        .HasColumnType("integer");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("JobId1");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Link");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasColumnType("text");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .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")
+                        .HasColumnType("text");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            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()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("NotificationConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<byte>("NotificationConnectorType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationConnectorId");
+
+                    b.ToTable("NotificationConnectors");
+
+                    b.HasDiscriminator<byte>("NotificationConnectorType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.Property<string>("AuthorsAuthorId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorsAuthorId", "MangaId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AuthorManga");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("TagsTag")
+                        .HasColumnType("text");
+
+                    b.HasKey("MangaId", "TagsTag");
+
+                    b.HasIndex("TagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadNewChaptersJob", 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)1);
+                });
+
+            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()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", 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("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            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);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.AsuraToon", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("AsuraToon");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Bato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Bato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaHere", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaHere");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaKatana", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaKatana");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaLife", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manga4Life");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Mangasee", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Mangasee");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Mangaworld", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Mangaworld");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ManhuaPlus", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ManhuaPlus");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Weebcentral", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Weebcentral");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.Gotify", b =>
+                {
+                    b.HasBaseType("API.Schema.NotificationConnectors.NotificationConnector");
+
+                    b.Property<string>("AppToken")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Endpoint")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.Lunasea", b =>
+                {
+                    b.HasBaseType("API.Schema.NotificationConnectors.NotificationConnector");
+
+                    b.Property<string>("Id")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.Ntfy", b =>
+                {
+                    b.HasBaseType("API.Schema.NotificationConnectors.NotificationConnector");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Endpoint")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Topic")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.ToTable("NotificationConnectors", t =>
+                        {
+                            t.Property("Endpoint")
+                                .HasColumnName("Ntfy_Endpoint");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany()
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany("DependsOnJobs")
+                        .HasForeignKey("JobId1");
+
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId");
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorsAuthorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("TagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadNewChaptersJob", 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.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Navigation("DependsOnJobs");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#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/ProblemResponse.cs

@@ -0,0 +1,3 @@
+namespace API;
+
+public record ProblemResponse(string title, string? message = null);

API/Program.cs

@@ -0,0 +1,133 @@
+using System.Reflection;
+using System.Text.Json.Serialization;
+using API;
+using API.Schema;
+using API.Schema.Jobs;
+using API.Schema.MangaConnectors;
+using Asp.Versioning;
+using Asp.Versioning.Builder;
+using Asp.Versioning.Conventions;
+using Microsoft.EntityFrameworkCore;
+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.AddSwaggerGen(opt =>
+{
+    var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
+    opt.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, xmlFilename));
+});
+builder.Services.ConfigureOptions<NamedSwaggerGenOptions>();
+
+builder.Services.AddDbContext<PgsqlContext>(options =>
+    options.UseNpgsql($"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.AddControllers().AddNewtonsoftJson(opts =>
+{
+    opts.SerializerSettings.Converters.Add(new StringEnumConverter());
+});
+
+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();
+
+using (var scope = app.Services.CreateScope())
+{
+    var db = scope.ServiceProvider.GetRequiredService<PgsqlContext>();
+    db.Database.Migrate();
+}
+
+using (var scope = app.Services.CreateScope())
+{
+    PgsqlContext context = scope.ServiceProvider.GetService<PgsqlContext>()!;
+    
+    MangaConnector[] connectors =
+        [
+            new AsuraToon(),
+            new Bato(),
+            new MangaDex(),
+            new MangaHere(),
+            new MangaKatana(),
+            new MangaLife(),
+            new Manganato(),
+            new Mangasee(),
+            new Mangaworld(),
+            new ManhuaPlus(),
+            new Weebcentral()
+        ];
+    MangaConnector[] newConnectors = connectors.Where(c => !context.MangaConnectors.Contains(c)).ToArray();
+    context.MangaConnectors.AddRange(newConnectors);
+    
+    context.Jobs.RemoveRange(context.Jobs.Where(j => j.state == JobState.Completed && j.RecurrenceMs < 1));
+    
+    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();
+Tranga.JobStarterThread.Start(app.Services.CreateScope().ServiceProvider.GetService<PgsqlContext>());
+Tranga.NotificationSenderThread.Start(app.Services.CreateScope().ServiceProvider.GetService<PgsqlContext>());
+
+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,12 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("AuthorId")]
+public class Author(string authorName)
+{
+    [MaxLength(64)]
+    public string AuthorId { get; init; } = TokenGen.CreateToken(typeof(Author), 64);
+    public string AuthorName { get; init; } = authorName;
+}

API/Schema/Chapter.cs

@@ -0,0 +1,113 @@
+using System.ComponentModel.DataAnnotations;
+using System.Xml.Linq;
+using API.Schema.Jobs;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("ChapterId")]
+public class Chapter : IComparable<Chapter>
+{
+    [MaxLength(64)]
+    public string ChapterId { get; init; } = TokenGen.CreateToken(typeof(Chapter), 64);
+    public int? VolumeNumber { get; private set; }
+    public ChapterNumber ChapterNumber { get; private set; }
+    public string Url { get; internal set; }
+    public string? Title { get; private set; }
+    public string ArchiveFileName { get; private set; }
+    public bool Downloaded { get; internal set; } = false;
+    
+    public string ParentMangaId { get; internal set; }
+    public Manga? ParentManga { get; init; }
+
+    public Chapter(Manga parentManga, string url, ChapterNumber chapterNumber, int? volumeNumber = null, string? title = null)
+        : this(parentManga.MangaId, url, chapterNumber, volumeNumber, title)
+    {
+        this.ParentManga = parentManga;
+    }
+    
+    public Chapter(string parentMangaId, string url, ChapterNumber chapterNumber,
+        int? volumeNumber = null, string? title = null)
+    {
+        this.ParentMangaId = parentMangaId;
+        this.Url = url;
+        this.ChapterNumber = chapterNumber;
+        this.VolumeNumber = volumeNumber;
+        this.Title = title;
+        this.ArchiveFileName = BuildArchiveFileName();
+    }
+
+    public MoveFileOrFolderJob? UpdateChapterNumber(ChapterNumber chapterNumber)
+    {
+        this.ChapterNumber = chapterNumber;
+        return UpdateArchiveFileName();
+    }
+
+    public MoveFileOrFolderJob? UpdateVolumeNumber(int? volumeNumber)
+    {
+        this.VolumeNumber = volumeNumber;
+        return UpdateArchiveFileName();
+    }
+
+    public MoveFileOrFolderJob? UpdateTitle(string? title)
+    {
+        this.Title = title;
+        return UpdateArchiveFileName();
+    }
+
+    private string BuildArchiveFileName()
+    {
+        return $"{this.ParentManga.Name} - Vol.{this.VolumeNumber ?? 0} Ch.{this.ChapterNumber}{(this.Title is null ? "" : $" - {this.Title}")}.cbz";
+    }
+
+    private MoveFileOrFolderJob? UpdateArchiveFileName()
+    {
+        string oldPath = GetArchiveFilePath();
+        this.ArchiveFileName = BuildArchiveFileName();
+        if (Downloaded)
+        {
+            return new MoveFileOrFolderJob(oldPath, GetArchiveFilePath());
+        }
+        return null;
+    }
+    
+    /// <summary>
+    /// Creates full file path of chapter-archive
+    /// </summary>
+    /// <returns>Filepath</returns>
+    internal string GetArchiveFilePath()
+    {
+        return Path.Join(TrangaSettings.downloadLocation, ParentManga.FolderName, ArchiveFileName);
+    }
+
+    public bool IsDownloaded()
+    {
+        string path = GetArchiveFilePath();
+        return File.Exists(path);
+    }
+
+    public int CompareTo(Chapter? other)
+    {
+        if(other is not { } otherChapter)
+            throw new ArgumentException($"{other} can not be compared to {this}");
+        return this.VolumeNumber?.CompareTo(otherChapter.VolumeNumber) switch
+        {
+            <0 => -1,
+            >0 => 1,
+            _ => this.ChapterNumber.CompareTo(otherChapter.ChapterNumber)
+        };
+    }
+    
+    internal string GetComicInfoXmlString()
+    {
+        XElement comicInfo = new XElement("ComicInfo",
+            new XElement("Tags", string.Join(',', ParentManga.Tags.Select(tag => tag.Tag))),
+            new XElement("LanguageISO", ParentManga.OriginalLanguage),
+            new XElement("Title", this.Title),
+            new XElement("Writer", string.Join(',', ParentManga.Authors.Select(author => author.AuthorName))),
+            new XElement("Volume", this.VolumeNumber),
+            new XElement("Number", this.ChapterNumber)
+        );
+        return comicInfo.ToString();
+    }
+}

API/Schema/ChapterNumber.cs

@@ -0,0 +1,305 @@
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Numerics;
+using System.Text.RegularExpressions;
+
+namespace API.Schema;
+
+public readonly struct ChapterNumber : INumber<ChapterNumber>
+{
+    private readonly uint[] _numbers;
+    private readonly bool _naN;
+
+    private ChapterNumber(uint[] numbers, bool naN = false)
+    {
+        this._numbers = numbers;
+        this._naN = naN;
+    }
+
+    public ChapterNumber(string number)
+    {
+        if (!CanParse(number))
+        {
+            this._numbers = [];
+            this._naN = true;
+        }
+        this._numbers = number.Split('.').Select(uint.Parse).ToArray();
+    }
+
+    public ChapterNumber(float number) : this(number.ToString("F")) {}
+
+    public ChapterNumber(double number) : this((float)number) {}
+    
+    public ChapterNumber(uint number)
+    { 
+        this._numbers = [number];
+        this._naN = false;
+    }
+
+    public ChapterNumber(int number)
+    {
+        if (int.IsNegative(number))
+        {
+            this._numbers = [];
+            this._naN = true;
+        }
+        this._numbers = [(uint)number];
+        this._naN = false;
+    }
+    
+    public int CompareTo(ChapterNumber other)
+    {
+        byte index = 0;
+        do
+        {
+            if (this._numbers[index] < other._numbers[index])
+                return -1;
+            else if (this._numbers[index] > other._numbers[index])
+                return 1;
+        }while(index < this._numbers.Length && index < other._numbers.Length);
+
+        if (index >= this._numbers.Length && index >= other._numbers.Length)
+            return 0;
+        else if (index >= this._numbers.Length)
+            return -1;
+        else if (index >= other._numbers.Length)
+            return 1;
+        throw new UnreachableException();
+    }
+
+    private static readonly Regex Pattern = new(@"[0-9]+(?:\.[0-9]+)*");
+    public static bool CanParse(string? number) => number is not null && Pattern.Match(number).Length == number.Length && number.Length > 0;
+
+    public bool Equals(ChapterNumber other) => CompareTo(other) == 0;
+
+    public string ToString(string? format, IFormatProvider? formatProvider)
+    {
+        return string.Join('.', _numbers);
+    }
+    
+    public override bool Equals(object? obj)
+    {
+        return obj is ChapterNumber other && Equals(other);
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(_numbers, _naN);
+    }
+
+    public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+    {
+        throw new NotImplementedException();
+    }
+
+    public int CompareTo(object? obj)
+    {
+        if(obj is ChapterNumber other)
+            return CompareTo(other);
+        throw new ArgumentException();
+    }
+
+    public static ChapterNumber Parse(string s, IFormatProvider? provider)
+    {
+        if(!CanParse(s))
+            throw new FormatException($"Invalid ChapterNumber-String: {s}");
+        return new ChapterNumber(s);
+    }
+
+    public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, out ChapterNumber result)
+    {
+        result = new ChapterNumber([], true);;
+        if (!CanParse(s))
+            return false;
+        if (s is null)
+            return false;
+        result = new ChapterNumber(s);
+        return true;
+    }
+
+    public static ChapterNumber Parse(ReadOnlySpan<char> s, IFormatProvider? provider) => Parse(s.ToString(), provider);
+
+    public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out ChapterNumber result) => TryParse(s.ToString(), provider, out result);
+
+    public static ChapterNumber operator +(ChapterNumber left, ChapterNumber right)
+    {
+        if (IsNaN(left) || IsNaN(right))
+            return new ChapterNumber([], true);
+        int size = left._numbers.Length > right._numbers.Length ? left._numbers.Length : right._numbers.Length;
+        uint[] numbers = new uint[size];
+        for (int i = 0; i < size; i++)
+        {
+            if(left._numbers.Length < i)
+                numbers[i] = right._numbers[i];
+            else if(right._numbers.Length < i)
+                numbers[i] = left._numbers[i];
+            else
+                numbers[i] = left._numbers[i] + right._numbers[i];
+        }
+        return new ChapterNumber(numbers);
+    }
+    
+    private static bool BothNotNaN(ChapterNumber left, ChapterNumber right) => !IsNaN(left) && !IsNaN(right);
+
+    public static ChapterNumber AdditiveIdentity => Zero;
+    
+    public static bool operator ==(ChapterNumber left, ChapterNumber right) => BothNotNaN(left, right) && left.Equals(right);
+
+    public static bool operator !=(ChapterNumber left, ChapterNumber right) => !(left == right);
+
+    public static bool operator >(ChapterNumber left, ChapterNumber right) => BothNotNaN(left, right) && left.CompareTo(right) > 0;
+
+    public static bool operator >=(ChapterNumber left, ChapterNumber right) => BothNotNaN(left, right) && left.CompareTo(right) >= 0;
+
+    public static bool operator <(ChapterNumber left, ChapterNumber right) => BothNotNaN(left, right) && left.CompareTo(right) < 0;
+
+    public static bool operator <=(ChapterNumber left, ChapterNumber right) => BothNotNaN(left, right) && left.CompareTo(right) <= 0;
+
+    public static ChapterNumber operator %(ChapterNumber left, ChapterNumber right) => throw new ArithmeticException();
+
+    public static ChapterNumber operator +(ChapterNumber value) => throw new InvalidOperationException();
+
+    public static ChapterNumber operator --(ChapterNumber value)
+    {
+        if (IsNaN(value))
+            return value;
+        uint[] numbers = value._numbers;
+        numbers[0]--;
+        return new ChapterNumber(numbers);
+    }
+
+    public static ChapterNumber operator /(ChapterNumber left, ChapterNumber right) => throw new InvalidOperationException();
+
+    public static ChapterNumber operator ++(ChapterNumber value)
+    {
+        if (IsNaN(value))
+            return value;
+        uint[] numbers = value._numbers;
+        numbers[0]++;
+        return new ChapterNumber(numbers);
+    }
+
+    public static ChapterNumber MultiplicativeIdentity => One;
+    public static ChapterNumber operator *(ChapterNumber left, ChapterNumber right) => throw new InvalidOperationException();
+
+    public static ChapterNumber operator -(ChapterNumber left, ChapterNumber right) => throw new InvalidOperationException();
+
+    public static ChapterNumber operator -(ChapterNumber value) => throw new InvalidOperationException();
+
+    public static ChapterNumber Abs(ChapterNumber value) => value;
+
+    public static bool IsCanonical(ChapterNumber value) => true;
+
+    public static bool IsComplexNumber(ChapterNumber value) => false;
+
+    public static bool IsEvenInteger(ChapterNumber value) => IsInteger(value) && uint.IsEvenInteger(value._numbers[0]);
+
+    public static bool IsFinite(ChapterNumber value) => true;
+
+    public static bool IsImaginaryNumber(ChapterNumber value) => false;
+
+    public static bool IsInfinity(ChapterNumber value) => false;
+
+    public static bool IsInteger(ChapterNumber value) => !IsNaN(value) && value._numbers.Length == 1;
+
+    public static bool IsNaN(ChapterNumber value) => value._naN;
+
+    public static bool IsNegative(ChapterNumber value) => false;
+
+    public static bool IsNegativeInfinity(ChapterNumber value) => false;
+
+    public static bool IsNormal(ChapterNumber value) => true;
+    
+    public static bool IsOddInteger(ChapterNumber value) => false;
+
+    public static bool IsPositive(ChapterNumber value) => true;
+
+    public static bool IsPositiveInfinity(ChapterNumber value) => false;
+
+    public static bool IsRealNumber(ChapterNumber value) => false;
+
+    public static bool IsSubnormal(ChapterNumber value) => false;
+
+    public static bool IsZero(ChapterNumber value) => value._numbers.All(n => n == 0);
+
+    public static ChapterNumber MaxMagnitude(ChapterNumber x, ChapterNumber y)
+    {
+        if(IsNaN(x))
+            return new ChapterNumber([], true);
+        if (IsNaN(y))
+            return new ChapterNumber([], true);
+        return x >= y ? x : y;
+    }
+
+    public static ChapterNumber MaxMagnitudeNumber(ChapterNumber x, ChapterNumber y)
+    {
+        if (IsNaN(x))
+            return y;
+        if (IsNaN(y))
+            return x;
+        return x >= y ? x : y;
+    }
+
+    public static ChapterNumber MinMagnitude(ChapterNumber x, ChapterNumber y)
+    {
+        if(IsNaN(x))
+            return new ChapterNumber([], true);
+        if (IsNaN(y))
+            return new ChapterNumber([], true);
+        return x <= y ? x : y;
+    }
+
+    public static ChapterNumber MinMagnitudeNumber(ChapterNumber x, ChapterNumber y)
+    {
+        if (IsNaN(x))
+            return y;
+        if (IsNaN(y))
+            return x;
+        return x <= y ? x : y;
+    }
+
+    public static ChapterNumber Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider) => throw new NotImplementedException();
+
+    public static ChapterNumber Parse(string s, NumberStyles style, IFormatProvider? provider) => throw new NotImplementedException();
+
+    public static bool TryConvertFromChecked<TOther>(TOther value, out ChapterNumber result) where TOther : INumberBase<TOther>
+    {
+        throw new NotImplementedException();
+    }
+
+    public static bool TryConvertFromSaturating<TOther>(TOther value, out ChapterNumber result) where TOther : INumberBase<TOther>
+    {
+        throw new NotImplementedException();
+    }
+
+    public static bool TryConvertFromTruncating<TOther>(TOther value, out ChapterNumber result) where TOther : INumberBase<TOther>
+    {
+        throw new NotImplementedException();
+    }
+
+    public static bool TryConvertToChecked<TOther>(ChapterNumber value, [MaybeNullWhen(false)] out TOther result) where TOther : INumberBase<TOther>
+    {
+        throw new NotImplementedException();
+    }
+
+    public static bool TryConvertToSaturating<TOther>(ChapterNumber value, [MaybeNullWhen(false)] out TOther result) where TOther : INumberBase<TOther>
+    {
+        throw new NotImplementedException();
+    }
+
+    public static bool TryConvertToTruncating<TOther>(ChapterNumber value, [MaybeNullWhen(false)] out TOther result) where TOther : INumberBase<TOther>
+    {
+        throw new NotImplementedException();
+    }
+
+    public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out ChapterNumber result)
+        => TryParse(s.ToString(), style, provider, out result);
+
+    public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out ChapterNumber result)
+        => TryParse(s, provider, out result);
+
+    public static ChapterNumber One => new(1);
+    public static int Radix => 10;
+    public static ChapterNumber Zero => new(0);
+}

API/Schema/Jobs/DownloadMangaCoverJob.cs

@@ -0,0 +1,136 @@
+using System.ComponentModel.DataAnnotations;
+using System.IO.Compression;
+using System.Runtime.InteropServices;
+using API.MangaDownloadClients;
+using API.Schema.MangaConnectors;
+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 DownloadMangaCoverJob(string chapterId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(DownloadMangaCoverJob), 64), JobType.DownloadMangaCoverJob, 0, parentJobId, dependsOnJobsIds)
+{
+    [MaxLength(64)]
+    public string ChapterId { get; init; } = chapterId;
+    public Chapter? Chapter { get; init; }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        MangaConnector connector = Chapter.ParentManga?.MangaConnector ?? context.MangaConnectors.Find(context.Manga.Find(Chapter.ParentMangaId)?.MangaId)!;
+        DownloadChapterImages(Chapter, connector);
+        return [];
+    }
+    
+    private bool DownloadChapterImages(Chapter chapter, MangaConnector connector)
+    {
+        string[] imageUrls = connector.GetChapterImageUrls(Chapter);
+        string saveArchiveFilePath = chapter.GetArchiveFilePath();
+        
+        //Check if Publication Directory already exists
+        string directoryPath = Path.GetDirectoryName(saveArchiveFilePath)!;
+        if (!Directory.Exists(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
+            File.Delete(saveArchiveFilePath);
+        
+        //Create a temporary folder to store images
+        string tempFolder = Directory.CreateTempSubdirectory("trangatemp").FullName;
+
+        int chapterNum = 0;
+        //Download all Images to temporary Folder
+        if (imageUrls.Length == 0)
+        {
+            Directory.Delete(tempFolder, true);
+            return false;
+        }
+        
+        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)
+                return false;
+        }
+
+        CopyCoverFromCacheToDownloadLocation();
+        
+        File.WriteAllText(Path.Join(tempFolder, "ComicInfo.xml"), chapter.GetComicInfoXmlString());
+        
+        //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
+        
+        return true;
+    }
+    
+    private void ProcessImage(string imagePath)
+    {
+        if (!TrangaSettings.bwImages && TrangaSettings.compression == 100)
+            return;
+        DateTime start = DateTime.Now;
+        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(int? retries = 1)
+    {
+        //Check if Publication already has a Folder and cover
+        string publicationFolder = Chapter.ParentManga.CreatePublicationFolder();
+        DirectoryInfo dirInfo = new (publicationFolder);
+        if (dirInfo.EnumerateFiles().Any(info => info.Name.Contains("cover", StringComparison.InvariantCultureIgnoreCase)))
+        {
+            return;
+        }
+
+        string? fileInCache = Chapter.ParentManga.CoverFileNameInCache;
+        if (fileInCache is null || !File.Exists(fileInCache))
+        {
+            if (retries > 0 && Chapter.ParentManga.CoverUrl is not null)
+            {
+                Chapter.ParentManga.SaveCoverImageToCache();
+                CopyCoverFromCacheToDownloadLocation(--retries);
+            }
+
+            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);
+    }
+    
+    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);
+        requestResult.result.CopyTo(fs);
+        fs.Close();
+        ProcessImage(savePath);
+        return true;
+    }
+}

API/Schema/Jobs/DownloadNewChaptersJob.cs

@@ -0,0 +1,22 @@
+using System.ComponentModel.DataAnnotations;
+using API.Schema.MangaConnectors;
+
+namespace API.Schema.Jobs;
+
+public class DownloadNewChaptersJob(ulong recurrenceMs, string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(DownloadNewChaptersJob), 64), JobType.DownloadNewChaptersJob, recurrenceMs, parentJobId, dependsOnJobsIds)
+{
+    [MaxLength(64)]
+    public string MangaId { get; init; } = mangaId;
+    public Manga? Manga { get; init; }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        Manga m = Manga ?? context.Manga.Find(MangaId)!;
+        MangaConnector connector = m.MangaConnector ?? context.MangaConnectors.Find(m.MangaConnectorId)!;
+        Chapter[] newChapters = connector.GetNewChapters(m);
+        context.Chapters.AddRangeAsync(newChapters).Wait();
+        context.SaveChangesAsync().Wait();
+        return newChapters.Select(chapter => new DownloadSingleChapterJob(chapter.ChapterId, this.JobId));
+    }
+}

API/Schema/Jobs/DownloadSingleChapterJob.cs

@@ -0,0 +1,138 @@
+using System.ComponentModel.DataAnnotations;
+using System.IO.Compression;
+using System.Runtime.InteropServices;
+using API.MangaDownloadClients;
+using API.Schema.MangaConnectors;
+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(string chapterId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(DownloadSingleChapterJob), 64), JobType.DownloadSingleChapterJob, 0, parentJobId, dependsOnJobsIds)
+{
+    [MaxLength(64)]
+    public string ChapterId { get; init; } = chapterId;
+    public Chapter? Chapter { get; init; }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        Chapter c = Chapter ?? context.Chapters.Find(ChapterId)!;
+        Manga m = c.ParentManga ?? context.Manga.Find(c.ParentMangaId)!;
+        MangaConnector connector = m.MangaConnector ?? context.MangaConnectors.Find(m.MangaConnectorId)!;
+        DownloadChapterImages(c, connector, m);
+        return [];
+    }
+    
+    private bool DownloadChapterImages(Chapter chapter, MangaConnector connector, Manga manga)
+    {
+        string[] imageUrls = connector.GetChapterImageUrls(chapter);
+        string saveArchiveFilePath = chapter.GetArchiveFilePath();
+        
+        //Check if Publication Directory already exists
+        string directoryPath = Path.GetDirectoryName(saveArchiveFilePath)!;
+        if (!Directory.Exists(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
+            File.Delete(saveArchiveFilePath);
+        
+        //Create a temporary folder to store images
+        string tempFolder = Directory.CreateTempSubdirectory("trangatemp").FullName;
+
+        int chapterNum = 0;
+        //Download all Images to temporary Folder
+        if (imageUrls.Length == 0)
+        {
+            Directory.Delete(tempFolder, true);
+            return false;
+        }
+        
+        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)
+                return false;
+        }
+
+        CopyCoverFromCacheToDownloadLocation(manga);
+        
+        File.WriteAllText(Path.Join(tempFolder, "ComicInfo.xml"), chapter.GetComicInfoXmlString());
+        
+        //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
+        
+        return true;
+    }
+    
+    private void ProcessImage(string imagePath)
+    {
+        if (!TrangaSettings.bwImages && TrangaSettings.compression == 100)
+            return;
+        DateTime start = DateTime.Now;
+        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, int? retries = 1)
+    {
+        //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)))
+        {
+            return;
+        }
+
+        string? fileInCache = manga.CoverFileNameInCache;
+        if (fileInCache is null || !File.Exists(fileInCache))
+        {
+            if (retries > 0)
+            {
+                manga.SaveCoverImageToCache();
+                CopyCoverFromCacheToDownloadLocation(manga, --retries);
+            }
+
+            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);
+    }
+    
+    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);
+        requestResult.result.CopyTo(fs);
+        fs.Close();
+        ProcessImage(savePath);
+        return true;
+    }
+}

API/Schema/Jobs/Job.cs

@@ -0,0 +1,55 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+[PrimaryKey("JobId")]
+public abstract class Job 
+{
+    [MaxLength(64)]
+    public string JobId { get; init; }
+    
+    [MaxLength(64)]
+    public string? ParentJobId { get; init; }
+    public Job? ParentJob { get; init; }
+    
+    [MaxLength(64)]
+    public ICollection<string>? DependsOnJobsIds { get; init; }
+    public ICollection<Job>? DependsOnJobs { get; init; }
+    
+    public JobType JobType { get; init; }
+    public ulong RecurrenceMs { get; set; }
+    public DateTime LastExecution { get; internal set; } = DateTime.UnixEpoch;
+    
+    [NotMapped]
+    public DateTime NextExecution => LastExecution.AddMilliseconds(RecurrenceMs);
+    public JobState state { get; internal set; } = JobState.Waiting;
+
+    public Job(string jobId, JobType jobType, ulong recurrenceMs, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
+        : this(jobId, jobType, recurrenceMs, parentJob?.JobId, dependsOnJobs?.Select(j => j.JobId).ToList())
+    {
+        this.ParentJob = parentJob;
+        this.DependsOnJobs = dependsOnJobs;
+    }
+
+    public Job(string jobId, JobType jobType, ulong recurrenceMs, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    {
+        JobId = jobId;
+        ParentJobId = parentJobId;
+        DependsOnJobsIds = dependsOnJobsIds;
+        JobType = jobType;
+        RecurrenceMs = recurrenceMs;
+    }
+
+    public IEnumerable<Job> Run(PgsqlContext context)
+    {
+        this.state = JobState.Running;
+        IEnumerable<Job> newJobs = RunInternal(context);
+        this.state = JobState.Completed;
+        return newJobs;
+    }
+    
+    protected abstract IEnumerable<Job> RunInternal(PgsqlContext context);
+}

API/Schema/Jobs/JobJsonDeserializer.cs

@@ -0,0 +1,29 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using JsonSerializer = Newtonsoft.Json.JsonSerializer;
+
+namespace API.Schema.Jobs;
+
+public class JobJsonDeserializer : JsonConverter<Job>
+{
+    public override bool CanWrite { get; } = false;
+
+    public override void WriteJson(JsonWriter writer, Job? value, JsonSerializer serializer)
+    {
+        throw new NotImplementedException();
+    }
+
+    public override Job? ReadJson(JsonReader reader, Type objectType, Job? existingValue, bool hasExistingValue, JsonSerializer serializer)
+    {
+        JObject j = JObject.Load(reader);
+        JobType? type = Enum.Parse<JobType>(j.GetValue("jobType")!.Value<string>()!);
+        return type switch
+        {
+            JobType.DownloadSingleChapterJob => j.ToObject<DownloadSingleChapterJob>(),
+            JobType.DownloadNewChaptersJob => j.ToObject<DownloadNewChaptersJob>(), 
+            JobType.UpdateMetaDataJob => j.ToObject<UpdateMetadataJob>(),
+            JobType.MoveFileOrFolderJob => j.ToObject<MoveFileOrFolderJob>(),
+            _ => null
+        };
+    }
+}

API/Schema/Jobs/JobState.cs

@@ -0,0 +1,8 @@
+namespace API.Schema.Jobs;
+
+public enum JobState
+{
+    Waiting,
+    Running,
+    Completed
+}

API/Schema/Jobs/JobType.cs

@@ -0,0 +1,11 @@
+namespace API.Schema.Jobs;
+
+
+public enum JobType : byte
+{
+    DownloadSingleChapterJob = 0, 
+    DownloadNewChaptersJob = 1, 
+    UpdateMetaDataJob = 2,
+    MoveFileOrFolderJob = 3,
+    DownloadMangaCoverJob = 4
+}

API/Schema/Jobs/MoveFileOrFolderJob.cs

@@ -0,0 +1,13 @@
+namespace API.Schema.Jobs;
+
+public class MoveFileOrFolderJob(string fromLocation, string toLocation, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(MoveFileOrFolderJob), 64), JobType.MoveFileOrFolderJob, 0, parentJobId, dependsOnJobsIds)
+{
+    public string FromLocation { get; init; } = fromLocation;
+    public string ToLocation { get; init; } = toLocation;
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        throw new NotImplementedException();
+    }
+}

API/Schema/Jobs/UpdateMetadataJob.cs

@@ -0,0 +1,16 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace API.Schema.Jobs;
+
+public class UpdateMetadataJob(ulong recurrenceMs, string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(UpdateMetadataJob), 64), JobType.UpdateMetaDataJob, recurrenceMs, parentJobId, dependsOnJobsIds)
+{
+    [MaxLength(64)]
+    public string MangaId { get; init; } = mangaId;
+    public virtual Manga Manga { get; init; }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        throw new NotImplementedException();
+    }
+}

API/Schema/LibraryConnectors/Kavita.cs

@@ -0,0 +1,111 @@
+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), 64), 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/Library/scan?libraryId={lib.id}", "Bearer", Auth);
+    }
+
+    internal override bool Test()
+    {
+        foreach (KavitaLibrary lib in GetLibraries())
+            if (NetClient.MakePost($"{BaseUrl}/api/Library/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/Library/libraries", "Bearer", Auth);
+        if (data == Stream.Null)
+        {
+            return Array.Empty<KavitaLibrary>();
+        }
+        JsonArray? result = JsonSerializer.Deserialize<JsonArray>(data);
+        if (result is null)
+        {
+            return Array.Empty<KavitaLibrary>();
+        }
+
+        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,74 @@
+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), 64), 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)
+        {
+            return Array.Empty<KomgaLibrary>();
+        }
+        JsonArray? result = JsonSerializer.Deserialize<JsonArray>(data);
+        if (result is null)
+        {
+            return Array.Empty<KomgaLibrary>();
+        }
+
+        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,18 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema.LibraryConnectors;
+
+[PrimaryKey("LibraryConnectorId")]
+public abstract class LibraryConnector(string libraryConnectorId, LibraryType libraryType, string baseUrl, string auth)
+{
+    [MaxLength(64)]
+    public string LibraryConnectorId { get; } = libraryConnectorId;
+
+    public LibraryType LibraryType { get; init; } = libraryType;
+    public string BaseUrl { get; init; } = baseUrl;
+    public string Auth { get; init; } = auth;
+    
+    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,69 @@
+using System.Net;
+using System.Net.Http.Headers;
+
+namespace API.Schema.LibraryConnectors;
+
+public class NetClient
+{
+    public static Stream MakeRequest(string url, string authScheme, string auth)
+        {
+            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:
+                        
+                        break;
+                    default:
+                        throw;
+                }
+                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,20 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("LinkId")]
+public class Link(string linkProvider, string linkUrl)
+{
+    [MaxLength(64)]
+    public string LinkId { get; init; } = TokenGen.CreateToken(typeof(Link), 64);
+    public string LinkProvider { get; init; } = linkProvider;
+    public string LinkUrl { get; init; } = linkUrl;
+
+    public override bool Equals(object? obj)
+    {
+        if (obj is not Link other)
+            return false;
+        return other.LinkProvider == LinkProvider && other.LinkUrl == LinkUrl;
+    }
+}

API/Schema/Manga.cs

@@ -0,0 +1,130 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using API.Schema.Jobs;
+using API.Schema.MangaConnectors;
+using Microsoft.EntityFrameworkCore;
+using static System.IO.UnixFileMode;
+
+namespace API.Schema;
+
+[PrimaryKey("MangaId")]
+public class Manga
+{
+    [MaxLength(64)]
+    public string MangaId { get; init; } = TokenGen.CreateToken(typeof(Manga), 64);
+    [MaxLength(64)]
+    public string ConnectorId { get; init; }
+
+    public string Name { get; internal set; }
+    public string Description { get; internal set; }
+    public string WebsiteUrl { get; internal set; }
+    public string CoverUrl { get; internal set; }
+    public string? CoverFileNameInCache { get; internal set; }
+    public uint Year { get; internal set; }
+    public string? OriginalLanguage { get; internal set; }
+    public MangaReleaseStatus ReleaseStatus { get; internal set; }
+    public string FolderName { get; private set; }
+    public float IgnoreChapterBefore { get; internal set; }
+
+    public string MangaConnectorId { get; private set; }
+    public MangaConnector? MangaConnector { get; private set; }
+    
+    public ICollection<Author>? Authors { get; internal set; }
+    
+    public ICollection<MangaTag>? Tags { get; internal set; }
+    
+    public ICollection<Link>? Links { get; internal set; }
+    
+    public ICollection<MangaAltTitle>? AltTitles { get; internal set; }
+
+    public Manga(string connectorId, string name, string description, string websiteUrl, string coverUrl,
+        string? coverFileNameInCache, uint year, string? originalLanguage, MangaReleaseStatus releaseStatus,
+        float ignoreChapterBefore, MangaConnector mangaConnector, ICollection<Author> authors,
+        ICollection<MangaTag> tags, ICollection<Link> links, ICollection<MangaAltTitle> altTitles)
+        : this(connectorId, name, description, websiteUrl, coverUrl, coverFileNameInCache, year, originalLanguage,
+            releaseStatus, ignoreChapterBefore, mangaConnector.Name)
+    {
+        this.Authors = authors;
+        this.Tags = tags;
+        this.Links = links;
+        this.AltTitles = altTitles;
+    }
+    
+    public Manga(string connectorId, string name, string description, string websiteUrl, string coverUrl,
+        string? coverFileNameInCache, uint year, string? originalLanguage, MangaReleaseStatus releaseStatus,
+        float ignoreChapterBefore, string mangaConnectorId)
+    {
+        ConnectorId = connectorId;
+        Name = name;
+        Description = description;
+        WebsiteUrl = websiteUrl;
+        CoverUrl = coverUrl;
+        CoverFileNameInCache = coverFileNameInCache;
+        Year = year;
+        OriginalLanguage = originalLanguage;
+        ReleaseStatus = releaseStatus;
+        IgnoreChapterBefore = ignoreChapterBefore;
+        MangaConnectorId = mangaConnectorId;
+        FolderName = BuildFolderName(name);
+    }
+
+    public MoveFileOrFolderJob UpdateFolderName(string downloadLocation, string newName)
+    {
+        string oldName = this.FolderName;
+        this.FolderName = newName;
+        return new MoveFileOrFolderJob(Path.Join(downloadLocation, oldName), Path.Join(downloadLocation, this.FolderName));
+    }
+
+    internal void UpdateWithInfo(Manga other)
+    {
+        this.Name = other.Name;
+        this.Year = other.Year;
+        this.Description = other.Description;
+        this.CoverUrl = other.CoverUrl;
+        this.OriginalLanguage = other.OriginalLanguage;
+        this.Authors = other.Authors;
+        this.Links = other.Links;
+        this.Tags = other.Tags;
+        this.AltTitles = other.AltTitles;
+        this.ReleaseStatus = other.ReleaseStatus;
+    }
+
+    private static string BuildFolderName(string mangaName)
+    {
+        return mangaName;
+    }
+    
+    internal string SaveCoverImageToCache()
+    {
+        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(CoverUrl);
+        string filename = $"{match.Groups[1].Value}-{MangaId}.{match.Groups[3].Value}";
+        string saveImagePath = Path.Join(TrangaSettings.coverImageCache, filename);
+
+        if (File.Exists(saveImagePath))
+            return saveImagePath;
+        
+        RequestResult coverResult = new HttpDownloadClient().MakeRequest(CoverUrl, RequestType.MangaCover);
+        using MemoryStream ms = new();
+        coverResult.result.CopyTo(ms);
+        Directory.CreateDirectory(TrangaSettings.coverImageCache);
+        File.WriteAllBytes(saveImagePath, ms.ToArray());
+        return saveImagePath;
+    }
+    
+    public string CreatePublicationFolder()
+    {
+        string publicationFolder = Path.Join(TrangaSettings.downloadLocation, this.FolderName);
+        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;
+    }
+    
+    //TODO onchanges create job to update metadata files in archives, etc.
+}

API/Schema/MangaAltTitle.cs

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

API/Schema/MangaConnectors/AsuraToon.cs

@@ -0,0 +1,192 @@
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+
+namespace API.Schema.MangaConnectors;
+
+public class AsuraToon : MangaConnector
+{
+	
+	public AsuraToon() : base("AsuraToon", ["en"], ["https://asuracomic.net"])
+	{
+		this.downloadClient = new ChromiumDownloadClient();
+	}
+
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
+	{
+		string sanitizedTitle = string.Join(' ', Regex.Matches(publicationTitle, "[A-z]*").Where(m => m.Value.Length > 0)).ToLower();
+		string requestUrl = $"https://asuracomic.net/series?name={sanitizedTitle}";
+		RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, RequestType.Default);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return [];
+
+		if (requestResult.htmlDocument is null)
+		{
+			return [];
+		}
+			
+		(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
+		return publications;
+	}
+
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+	{
+		return GetMangaFromUrl($"https://asuracomic.net/series/{publicationId}");
+	}
+
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
+	{
+		RequestResult requestResult = downloadClient.MakeRequest(url, RequestType.MangaInfo);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return null;
+		if (requestResult.htmlDocument is null)
+		{
+			return null;
+		}
+		return ParseSinglePublicationFromHtml(requestResult.htmlDocument, url.Split('/')[^1], url);
+	}
+
+	private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(HtmlDocument document)
+	{
+		HtmlNodeCollection mangaList = document.DocumentNode.SelectNodes("//a[starts-with(@href,'series')]");
+		if (mangaList is null || mangaList.Count < 1)
+			return [];
+
+		IEnumerable<string> urls = mangaList.Select(a => $"https://asuracomic.net/{a.GetAttributeValue("href", "")}");
+		
+		List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
+		foreach (string url in urls)
+		{
+			(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+			if (manga is { } x)
+				ret.Add(x);
+		}
+
+		return ret.ToArray();
+	}
+
+	private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+	{
+		string? originalLanguage = null;
+		Dictionary<string, string> altTitles = new(), links = new();
+
+		HtmlNodeCollection genreNodes = document.DocumentNode.SelectNodes("//h3[text()='Genres']/../div/button");
+		string[] tags = genreNodes.Select(b => b.InnerText).ToArray();
+		List<MangaTag> mangaTags = tags.Select(t => new MangaTag(t)).ToList();
+		
+		HtmlNode statusNode = document.DocumentNode.SelectSingleNode("//h3[text()='Status']/../h3[2]");
+		MangaReleaseStatus releaseStatus = statusNode.InnerText.ToLower() switch
+		{
+			"ongoing" => MangaReleaseStatus.Continuing,
+			"hiatus" => MangaReleaseStatus.OnHiatus,
+			"completed" => MangaReleaseStatus.Completed,
+			"dropped" => MangaReleaseStatus.Cancelled,
+			"season end" => MangaReleaseStatus.Continuing,
+			"coming soon" => MangaReleaseStatus.Unreleased,
+			_ => MangaReleaseStatus.Unreleased
+		};
+		
+		HtmlNode coverNode = 
+			document.DocumentNode.SelectSingleNode("//img[@alt='poster']");
+		string coverUrl = coverNode.GetAttributeValue("src", "");
+		
+		HtmlNode titleNode = 
+			document.DocumentNode.SelectSingleNode("//title");
+		string sortName = Regex.Match(titleNode.InnerText, @"(.*) - Asura Scans").Groups[1].Value;
+		
+		HtmlNode descriptionNode =
+			document.DocumentNode.SelectSingleNode("//h3[starts-with(text(),'Synopsis')]/../span");
+		string description = descriptionNode?.InnerText??"";
+		
+		HtmlNodeCollection authorNodes = document.DocumentNode.SelectNodes("//h3[text()='Author']/../h3[not(text()='Author' or text()='_')]");
+		HtmlNodeCollection artistNodes = document.DocumentNode.SelectNodes("//h3[text()='Artist']/../h3[not(text()='Artist' or text()='_')]");
+		IEnumerable<string> authorNames = authorNodes is null ? [] : authorNodes.Select(a => a.InnerText);
+		IEnumerable<string> artistNames = artistNodes is null ? [] : artistNodes.Select(a => a.InnerText);
+		List<string> authorStrings = authorNames.Concat(artistNames).ToList();
+		List<Author> authors = authorStrings.Select(author => new Author(author)).ToList();
+
+		HtmlNode? firstChapterNode = document.DocumentNode.SelectSingleNode("//a[contains(@href, 'chapter/1')]/../following-sibling::h3");
+		uint year = uint.Parse(firstChapterNode?.InnerText.Split(' ')[^1] ?? "2000");
+
+		Manga manga = new (publicationId, sortName, description, websiteUrl, coverUrl, null, year,
+			originalLanguage, releaseStatus, -1,
+			this, 
+			authors, 
+			mangaTags, 
+			[],
+			[]);
+		
+		return (manga, authors, mangaTags, [], []);
+	}
+
+	public override Chapter[] GetChapters(Manga manga, string language="en")
+	{
+		string requestUrl = $"https://asuracomic.net/series/{manga.MangaId}";
+		// Leaving this in for verification if the page exists
+		RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, RequestType.Default);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return [];
+
+		//Return Chapters ordered by Chapter-Number
+		List<Chapter> chapters = ParseChaptersFromHtml(manga, requestUrl);
+		return chapters.Order().ToArray();
+	}
+
+	private List<Chapter> ParseChaptersFromHtml(Manga manga, string mangaUrl)
+	{
+		RequestResult result = downloadClient.MakeRequest(mangaUrl, RequestType.Default);
+		if ((int)result.statusCode < 200 || (int)result.statusCode >= 300 || result.htmlDocument is null)
+		{
+			return new List<Chapter>();
+		}
+
+		List<Chapter> ret = new();
+
+		HtmlNodeCollection chapterURLNodes = result.htmlDocument.DocumentNode.SelectNodes("//a[contains(@href, '/chapter/')]");
+		Regex infoRex = new(@"Chapter ([0-9]+)(.*)?");
+
+		foreach (HtmlNode chapterInfo in chapterURLNodes)
+		{
+			string chapterUrl = chapterInfo.GetAttributeValue("href", "");
+
+			Match match = infoRex.Match(chapterInfo.InnerText);
+			if(!ChapterNumber.CanParse(match.Groups[1].Value))
+				continue;
+			ChapterNumber chapterNumber = new(match.Groups[1].Value);
+			string? chapterName = match.Groups[2].Success && match.Groups[2].Length > 1 ? match.Groups[2].Value : null;
+			string url = $"https://asuracomic.net/series/{chapterUrl}";
+			try
+			{
+				ret.Add(new Chapter(manga, url, chapterNumber, null, chapterName));
+			}
+			catch (Exception e)
+			{
+			}
+		}
+		
+		return ret;
+	}
+
+	internal override string[] GetChapterImageUrls(Chapter chapter)
+	{
+		string requestUrl = chapter.Url;
+		// Leaving this in to check if the page exists
+		RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, RequestType.Default);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+		{
+			return [];
+		}
+		string[] imageUrls = ParseImageUrlsFromHtml(requestResult.htmlDocument);
+		return imageUrls;
+	}
+
+	private string[] ParseImageUrlsFromHtml(HtmlDocument document)
+	{
+		HtmlNodeCollection images = document.DocumentNode.SelectNodes("//img[contains(@alt, 'chapter page')]");
+
+		return images.Select(i => i.GetAttributeValue("src", "")).ToArray();
+	}
+}

API/Schema/MangaConnectors/Bato.cs

@@ -0,0 +1,205 @@
+using System.Net;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+
+namespace API.Schema.MangaConnectors;
+
+public class Bato : MangaConnector
+{
+	
+	public Bato() : base("Bato", ["en"], ["bato.to"])
+	{
+		this.downloadClient = new HttpDownloadClient();
+	}
+
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
+	{
+		string sanitizedTitle = string.Join(' ', Regex.Matches(publicationTitle, "[A-z]*").Where(m => m.Value.Length > 0)).ToLower();
+		string requestUrl = $"https://bato.to/v3x-search?word={sanitizedTitle}&lang=en";
+		RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, RequestType.Default);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return [];
+
+		if (requestResult.htmlDocument is null)
+		{
+			return [];
+		}
+			
+		(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
+		return publications;
+	}
+
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+	{
+		return GetMangaFromUrl($"https://bato.to/title/{publicationId}");
+	}
+
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
+	{
+		RequestResult requestResult = downloadClient.MakeRequest(url, RequestType.MangaInfo);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return null;
+		if (requestResult.htmlDocument is null)
+		{
+			return null;
+		}
+		return ParseSinglePublicationFromHtml(requestResult.htmlDocument, url.Split('/')[^1], url);
+	}
+
+	private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(HtmlDocument document)
+	{
+		HtmlNode mangaList = document.DocumentNode.SelectSingleNode("//div[@data-hk='0-0-2']");
+		if (!mangaList.ChildNodes.Any(node => node.Name == "div"))
+			return [];
+
+		List<string> urls = mangaList.ChildNodes
+			.Select(node => $"https://bato.to{node.Descendants("div").First().FirstChild.GetAttributeValue("href", "")}").ToList();
+		
+		HashSet<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
+		foreach (string url in urls)
+		{
+			(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+			if (manga is { } x)
+				ret.Add(x);
+		}
+
+		return ret.ToArray();
+	}
+
+	private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+	{
+		HtmlNode infoNode = document.DocumentNode.SelectSingleNode("/html/body/div/main/div[1]/div[2]");
+
+		string sortName = infoNode.Descendants("h3").First().InnerText;
+		string description = document.DocumentNode
+			.SelectSingleNode("//div[contains(concat(' ',normalize-space(@class),' '),'prose')]").InnerText;
+
+		string[] altTitlesList = infoNode.ChildNodes[1].ChildNodes[2].InnerText.Split('/');
+		int i = 0;
+		List<MangaAltTitle> altTitles = altTitlesList.Select(a => new MangaAltTitle(i++.ToString(), a)).ToList();
+
+		string coverUrl = document.DocumentNode.SelectNodes("//img")
+			.First(child => child.GetAttributeValue("data-hk", "") == "0-1-0").GetAttributeValue("src", "").Replace("&amp;", "&");
+
+		List<HtmlNode> genreNodes = document.DocumentNode.SelectSingleNode("//b[text()='Genres:']/..").SelectNodes("span").ToList();
+		string[] tags = genreNodes.Select(node => node.FirstChild.InnerText).ToArray();
+		List<MangaTag> mangaTags = tags.Select(s => new MangaTag(s)).ToList();
+
+		List<HtmlNode> authorsNodes = infoNode.ChildNodes[1].ChildNodes[3].Descendants("a").ToList();
+		List<string> authorNames = authorsNodes.Select(node => node.InnerText.Replace("amp;", "")).ToList();
+		List<Author> authors = authorNames.Select(n => new Author(n)).ToList();
+
+		HtmlNode? originalLanguageNode = document.DocumentNode.SelectSingleNode("//span[text()='Tr From']/..");
+		string originalLanguage = originalLanguageNode is not null ? originalLanguageNode.LastChild.InnerText : "";
+		
+		if (!uint.TryParse(
+			    document.DocumentNode.SelectSingleNode("//span[text()='Original Publication:']/..").LastChild.InnerText.Split('-')[0],
+			    out uint year))
+			year = (uint)DateTime.Now.Year;
+
+		string status = document.DocumentNode.SelectSingleNode("//span[text()='Original Publication:']/..")
+			.ChildNodes[2].InnerText;
+		MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
+		switch (status.ToLower())
+		{
+			case "ongoing": releaseStatus = MangaReleaseStatus.Continuing; break;
+			case "completed": releaseStatus = MangaReleaseStatus.Completed; break;
+			case "hiatus": releaseStatus = MangaReleaseStatus.OnHiatus; break;
+			case "cancelled": releaseStatus = MangaReleaseStatus.Cancelled; break;
+			case "pending": releaseStatus = MangaReleaseStatus.Unreleased; break;
+		}
+
+		Manga manga = new (publicationId, sortName, description, websiteUrl, coverUrl, null, year,
+			originalLanguage, releaseStatus, -1,
+			this, 
+			authors, 
+			mangaTags, 
+			[],
+			altTitles);
+		
+		return (manga, authors, mangaTags, [], altTitles);
+	}
+
+	public override Chapter[] GetChapters(Manga manga, string language="en")
+	{
+		string requestUrl = $"https://bato.to/title/{manga.MangaId}";
+		// Leaving this in for verification if the page exists
+		RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, RequestType.Default);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return [];
+
+		//Return Chapters ordered by Chapter-Number
+		List<Chapter> chapters = ParseChaptersFromHtml(manga, requestUrl);
+		return chapters.Order().ToArray();
+	}
+
+	private List<Chapter> ParseChaptersFromHtml(Manga manga, string mangaUrl)
+	{
+		RequestResult result = downloadClient.MakeRequest(mangaUrl, RequestType.Default);
+		if ((int)result.statusCode < 200 || (int)result.statusCode >= 300 || result.htmlDocument is null)
+		{
+			return new List<Chapter>();
+		}
+
+		List<Chapter> ret = new();
+
+		HtmlNode chapterList =
+			result.htmlDocument.DocumentNode.SelectSingleNode("/html/body/div/main/div[3]/astro-island/div/div[2]/div/div/astro-slot");
+
+		Regex numberRex = new(@"\/title\/.+\/([0-9])+(?:-vol_([0-9]+))?-ch_([0-9\.]+)");
+
+		foreach (HtmlNode chapterInfo in chapterList.SelectNodes("div"))
+		{
+			HtmlNode infoNode = chapterInfo.FirstChild.FirstChild;
+			string chapterUrl = infoNode.GetAttributeValue("href", "");
+
+			Match match = numberRex.Match(chapterUrl);
+			string id = match.Groups[1].Value;
+			int? volumeNumber = match.Groups[2].Success ? int.Parse(match.Groups[2].Value) : null;
+			if(ChapterNumber.CanParse(match.Groups[3].Value))
+				continue;
+			ChapterNumber chapterNumber = new(match.Groups[3].Value);
+			string url = $"https://bato.to{chapterUrl}?load=2";
+			try
+			{
+				ret.Add(new Chapter(manga, url, chapterNumber, volumeNumber, null));
+			}
+			catch (Exception e)
+			{
+			}
+		}
+		
+		return ret;
+	}
+
+	internal override string[] GetChapterImageUrls(Chapter chapter)
+	{
+		string requestUrl = chapter.Url;
+		// Leaving this in to check if the page exists
+		RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, RequestType.Default);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+		{
+			return [];
+		}
+
+		string[] imageUrls = ParseImageUrlsFromHtml(requestResult.htmlDocument);
+		return imageUrls;
+	}
+
+	private string[] ParseImageUrlsFromHtml(HtmlDocument document)
+	{
+		HtmlNode images = document.DocumentNode.SelectNodes("//astro-island").First(node =>
+			node.GetAttributeValue("component-url", "").Contains("/_astro/ImageList."));
+
+		string weirdString = images.OuterHtml;
+		string weirdString2 = Regex.Match(weirdString, @"props=\""(.*)}\""").Groups[1].Value;
+		string[] urls = Regex.Matches(weirdString2, @"(https:\/\/[A-z\-0-9\.\?\&\;\=\/]+)\\")
+			.Select(match => match.Groups[1].Value.Replace("&amp;", "&")).ToArray();
+		
+		return urls;
+	}
+}

API/Schema/MangaConnectors/MangaConnector.cs

@@ -0,0 +1,39 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using API.MangaDownloadClients;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+
+namespace API.Schema.MangaConnectors;
+
+[PrimaryKey("Name")]
+public abstract class MangaConnector(string name, string[] supportedLanguages, string[] baseUris)
+{
+    [MaxLength(32)]
+    public string Name { get; init; } = name;
+    public string[] SupportedLanguages { get; init; } = supportedLanguages;
+    public string[] BaseUris { get; init; } = baseUris;
+    
+    public abstract (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "");
+
+    public abstract (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url);
+
+    public abstract (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId);
+    
+    public abstract Chapter[] GetChapters(Manga manga, string language="en");
+    
+    [JsonIgnore]
+    [NotMapped]
+    internal DownloadClient downloadClient { get; init; } = null!;
+    
+    public Chapter[] GetNewChapters(Manga manga)
+    {
+        Chapter[] allChapters = GetChapters(manga);
+        if (allChapters.Length < 1)
+            return [];
+        
+        return allChapters.Where(chapter => !chapter.IsDownloaded()).ToArray();
+    }
+
+    internal abstract string[] GetChapterImageUrls(Chapter chapter);
+}

API/Schema/MangaConnectors/MangaDex.cs

@@ -0,0 +1,281 @@
+using System.Net;
+using System.Text.Json.Nodes;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using JsonSerializer = System.Text.Json.JsonSerializer;
+
+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"])
+    {
+        this.downloadClient = new HttpDownloadClient();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
+    {
+        const int limit = 100; //How many values we want returned at once
+        int offset = 0; //"Page"
+        int total = int.MaxValue; //How many total results are there, is updated on first request
+        HashSet<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> retManga = new();
+        int loadedPublicationData = 0;
+        List<JsonNode> results = new();
+        
+        //Request all search-results
+        while (offset < total) //As long as we haven't requested all "Pages"
+        {
+            //Request next Page
+            RequestResult requestResult = downloadClient.MakeRequest(
+                    $"https://api.mangadex.org/manga?limit={limit}&title={publicationTitle}&offset={offset}" +
+                    $"&contentRating%5B%5D=safe&contentRating%5B%5D=suggestive&contentRating%5B%5D=erotica" +
+                    $"&contentRating%5B%5D=pornographic" +
+                    $"&includes%5B%5D=manga&includes%5B%5D=cover_art&includes%5B%5D=author" +
+                    $"&includes%5B%5D=artist&includes%5B%5D=tag", RequestType.MangaInfo);
+            if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+                break;
+            JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
+            
+            offset += limit;
+            if (result is null)
+                break;
+            
+            if(result.ContainsKey("total"))
+                total = result["total"]!.GetValue<int>(); //Update the total number of Publications
+            else continue;
+
+            if (result.ContainsKey("data"))
+                results.AddRange(result["data"]!.AsArray()!);//Manga-data-Array
+        }
+        
+        foreach (JsonNode mangaNode in results)
+        {
+            if(MangaFromJsonObject(mangaNode.AsObject()) is { } manga)
+                retManga.Add(manga); //Add Publication (Manga) to result
+        }
+        return retManga.ToArray();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+    {
+        RequestResult requestResult =
+            downloadClient.MakeRequest($"https://api.mangadex.org/manga/{publicationId}?includes%5B%5D=manga&includes%5B%5D=cover_art&includes%5B%5D=author&includes%5B%5D=artist&includes%5B%5D=tag", RequestType.MangaInfo);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return null;
+        JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
+        if(result is not null)
+            return MangaFromJsonObject(result["data"]!.AsObject());
+        return null;
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
+    {
+        Regex idRex = new (@"https:\/\/mangadex.org\/title\/([A-z0-9-]*)\/.*");
+        string id = idRex.Match(url).Groups[1].Value;
+        return GetMangaFromId(id);
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? MangaFromJsonObject(JsonObject manga)
+    {
+        if (!manga.TryGetPropertyValue("id", out JsonNode? idNode))
+            return null;
+        string publicationId = idNode!.GetValue<string>();
+            
+        if (!manga.TryGetPropertyValue("attributes", out JsonNode? attributesNode))
+            return null;
+        JsonObject attributes = attributesNode!.AsObject();
+
+        if (!attributes.TryGetPropertyValue("title", out JsonNode? titleNode))
+            return null;
+        string sortName = titleNode!.AsObject().ContainsKey("en") switch
+        {
+            true => titleNode.AsObject()["en"]!.GetValue<string>(),
+            false => titleNode.AsObject().First().Value!.GetValue<string>()
+        };
+        
+        Dictionary<string, string> altTitlesDict = new();
+        if (attributes.TryGetPropertyValue("altTitles", out JsonNode? altTitlesNode))
+        {
+            foreach (JsonNode? altTitleNode in altTitlesNode!.AsArray())
+            {
+                JsonObject altTitleNodeObject = altTitleNode!.AsObject();
+                altTitlesDict.TryAdd(altTitleNodeObject.First().Key, altTitleNodeObject.First().Value!.GetValue<string>());
+            }
+        }
+        List<MangaAltTitle> altTitles = altTitlesDict.Select(t => new MangaAltTitle(t.Key, t.Value)).ToList();
+
+        if (!attributes.TryGetPropertyValue("description", out JsonNode? descriptionNode))
+            return null;
+        string description = descriptionNode!.AsObject().ContainsKey("en") switch
+        {
+            true => descriptionNode.AsObject()["en"]!.GetValue<string>(),
+            false => descriptionNode.AsObject().FirstOrDefault().Value?.GetValue<string>() ?? ""
+        };
+
+        Dictionary<string, string> linksDict = new();
+        if (attributes.TryGetPropertyValue("links", out JsonNode? linksNode) && linksNode is not null)
+            foreach (KeyValuePair<string, JsonNode?> linkKv in linksNode!.AsObject())
+                linksDict.TryAdd(linkKv.Key, linkKv.Value.GetValue<string>());
+        List<Link> links = linksDict.Select(x => new Link(x.Key, x.Value)).ToList();
+
+        string? originalLanguage =
+            attributes.TryGetPropertyValue("originalLanguage", out JsonNode? originalLanguageNode) switch
+            {
+                true => originalLanguageNode?.GetValue<string>(),
+                false => null
+            };
+        
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
+        if (attributes.TryGetPropertyValue("status", out JsonNode? statusNode))
+        {
+            releaseStatus = statusNode?.GetValue<string>().ToLower() switch
+            {
+                "ongoing" => MangaReleaseStatus.Continuing,
+                "completed" => MangaReleaseStatus.Completed,
+                "hiatus" => MangaReleaseStatus.OnHiatus,
+                "cancelled" => MangaReleaseStatus.Cancelled,
+                _ => MangaReleaseStatus.Unreleased
+            };
+        }
+
+        uint year = attributes.TryGetPropertyValue("year", out JsonNode? yearNode) switch
+        {
+            true => yearNode?.GetValue<uint>()??0,
+            false => 0
+        };
+        
+        HashSet<string> tags = new(128);
+        if (attributes.TryGetPropertyValue("tags", out JsonNode? tagsNode))
+            foreach (JsonNode? tagNode in tagsNode!.AsArray())
+                tags.Add(tagNode!["attributes"]!["name"]!["en"]!.GetValue<string>());
+        List<MangaTag> mangaTags = tags.Select(t => new MangaTag(t)).ToList();
+        
+        if (!manga.TryGetPropertyValue("relationships", out JsonNode? relationshipsNode))
+            return null;
+        
+        JsonNode? coverNode = relationshipsNode!.AsArray()
+            .FirstOrDefault(rel => rel!["type"]!.GetValue<string>().Equals("cover_art"));
+        if (coverNode is null)
+            return null;
+        string fileName = coverNode["attributes"]!["fileName"]!.GetValue<string>();
+        string coverUrl = $"https://uploads.mangadex.org/covers/{publicationId}/{fileName}";
+        
+        List<string> authorNames = new();
+        JsonNode?[] authorNodes = relationshipsNode.AsArray()
+            .Where(rel => rel!["type"]!.GetValue<string>().Equals("author") || rel!["type"]!.GetValue<string>().Equals("artist")).ToArray();
+        foreach (JsonNode? authorNode in authorNodes)
+        {
+            string authorName = authorNode!["attributes"]!["name"]!.GetValue<string>();
+            if(!authorNames.Contains(authorName))
+               authorNames.Add(authorName);
+        }
+        List<Author> authors = authorNames.Select(a => new Author(a)).ToList();
+
+        Manga pub = new (publicationId, sortName, description, $"https://mangadex.org/title/{publicationId}", coverUrl, null, year,
+            originalLanguage, releaseStatus, -1,
+            this, 
+            authors, 
+            mangaTags, 
+            links,
+            altTitles);
+		
+        return (pub, authors, mangaTags, links, altTitles);
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string language="en")
+    {
+        const int limit = 100; //How many values we want returned at once
+        int offset = 0; //"Page"
+        int total = int.MaxValue; //How many total results are there, is updated on first request
+        List<Chapter> chapters = new();
+        //As long as we haven't requested all "Pages"
+        while (offset < total)
+        {
+            //Request next "Page"
+            RequestResult requestResult =
+                downloadClient.MakeRequest(
+                    $"https://api.mangadex.org/manga/{manga.ConnectorId}/feed?limit={limit}&offset={offset}&translatedLanguage%5B%5D={language}&contentRating%5B%5D=safe&contentRating%5B%5D=suggestive&contentRating%5B%5D=erotica&contentRating%5B%5D=pornographic", RequestType.MangaDexFeed);
+            if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+                break;
+            JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
+            
+            offset += limit;
+            if (result is null)
+                break;
+            
+            total = result["total"]!.GetValue<int>();
+            JsonArray chaptersInResult = result["data"]!.AsArray();
+            //Loop through all Chapters in result and extract information from JSON
+            foreach (JsonNode? jsonNode in chaptersInResult)
+            {
+                JsonObject chapter = (JsonObject)jsonNode!;
+                JsonObject attributes = chapter["attributes"]!.AsObject();
+                
+                string chapterId = chapter["id"]!.GetValue<string>();
+                string url = $"https://mangadex.org/chapter/{chapterId}";
+                
+                string? title = attributes.ContainsKey("title") && attributes["title"] is not null
+                    ? attributes["title"]!.GetValue<string>()
+                    : null;
+                
+                int? volume = attributes.ContainsKey("volume") && attributes["volume"] is not null
+                    ? int.Parse(attributes["volume"]!.GetValue<string>())
+                    : null;
+                
+                string? chapterNumStr = attributes.ContainsKey("chapter") && attributes["chapter"] is not null
+                    ? attributes["chapter"]!.GetValue<string>()
+                    : null;
+                
+                if(chapterNumStr is null || ChapterNumber.CanParse(chapterNumStr))
+                    continue;
+                ChapterNumber chapterNumber = new(chapterNumStr);
+                
+                
+                if (attributes.ContainsKey("pages") && attributes["pages"] is not null &&
+                    attributes["pages"]!.GetValue<int>() < 1)
+                {
+                    continue;
+                }
+                
+                try
+                {
+                    Chapter newChapter = new Chapter(manga, url, chapterNumber, volume, title);
+                    if(!chapters.Contains(newChapter))
+                        chapters.Add(newChapter);
+                }
+                catch (Exception e)
+                {
+                }
+            }
+        }
+
+        //Return Chapters ordered by Chapter-Number
+        return chapters.Order().ToArray();
+    }
+
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {//Request URLs for Chapter-Images
+        RequestResult requestResult =
+            downloadClient.MakeRequest($"https://api.mangadex.org/at-home/server/{chapter.ChapterId}?forcePort443=false", RequestType.MangaDexImage);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+        {
+            return [];
+        }
+        JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
+        if (result is null)
+        {
+            return [];
+        }
+        string baseUrl = result["baseUrl"]!.GetValue<string>();
+        string hash = result["chapter"]!["hash"]!.GetValue<string>();
+        JsonArray imageFileNames = result["chapter"]!["data"]!.AsArray();
+        //Loop through all imageNames and construct urls (imageUrl)
+        List<string> imageUrls = new();
+        foreach (JsonNode? image in imageFileNames)
+            imageUrls.Add($"{baseUrl}/data/{hash}/{image!.GetValue<string>()}");
+        return imageUrls.ToArray();
+    }
+}

API/Schema/MangaConnectors/MangaHere.cs

@@ -0,0 +1,185 @@
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+
+namespace API.Schema.MangaConnectors;
+
+public class MangaHere : MangaConnector
+{
+    public MangaHere() : base("MangaHere", ["en"], ["www.mangahere.cc"])
+    {
+        this.downloadClient = new ChromiumDownloadClient();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
+    {
+        string sanitizedTitle = string.Join('+', Regex.Matches(publicationTitle, "[A-z]*").Where(str => str.Length > 0)).ToLower();
+        string requestUrl = $"https://www.mangahere.cc/search?title={sanitizedTitle}";
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+            return [];
+        
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
+        return publications;
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(HtmlDocument document)
+    {
+        if (document.DocumentNode.SelectNodes("//div[contains(concat(' ',normalize-space(@class),' '),' container ')]").Any(node => node.ChildNodes.Any(cNode => cNode.HasClass("search-keywords"))))
+            return [];
+        
+        List<string> urls = document.DocumentNode
+            .SelectNodes("//a[contains(@href, '/manga/') and not(contains(@href, '.html'))]")
+            .Select(thumb => $"https://www.mangahere.cc{thumb.GetAttributeValue("href", "")}").Distinct().ToList();
+
+        HashSet<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
+        foreach (string url in urls)
+        {
+            (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+            if (manga is { } x)
+                ret.Add(x);
+        }
+
+        return ret.ToArray();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+    {
+        return GetMangaFromUrl($"https://www.mangahere.cc/manga/{publicationId}");
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
+    {
+        RequestResult requestResult =
+            downloadClient.MakeRequest(url, RequestType.MangaInfo);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+            return null;
+        
+        Regex idRex = new (@"https:\/\/www\.mangahere\.[a-z]{0,63}\/manga\/([0-9A-z\-]+).*");
+        string id = idRex.Match(url).Groups[1].Value;
+        return ParseSinglePublicationFromHtml(requestResult.htmlDocument, id, url);
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    {
+        string originalLanguage = "", status = "";
+        Dictionary<string, string> altTitles = new(), links = new();
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
+
+        //We dont get posters, because same origin bs HtmlNode posterNode = document.DocumentNode.SelectSingleNode("//img[contains(concat(' ',normalize-space(@class),' '),' detail-info-cover-img ')]");
+        string coverUrl = "http://static.mangahere.cc/v20230914/mangahere/images/nopicture.jpg";
+
+        HtmlNode titleNode = document.DocumentNode.SelectSingleNode("//span[contains(concat(' ',normalize-space(@class),' '),' detail-info-right-title-font ')]");
+        string sortName = titleNode.InnerText;
+        
+        List<string> authorNames = document.DocumentNode
+            .SelectNodes("//p[contains(concat(' ',normalize-space(@class),' '),' detail-info-right-say ')]/a")
+            .Select(node => node.InnerText)
+            .ToList();
+        List<Author> authors = authorNames.Select(n => new Author(n)).ToList();
+
+        HashSet<string> tags = document.DocumentNode
+            .SelectNodes("//p[contains(concat(' ',normalize-space(@class),' '),' detail-info-right-tag-list ')]/a")
+            .Select(node => node.InnerText)
+            .ToHashSet();
+        List<MangaTag> mangaTags = tags.Select(n => new MangaTag(n)).ToList();
+
+        status = document.DocumentNode.SelectSingleNode("//span[contains(concat(' ',normalize-space(@class),' '),' detail-info-right-title-tip ')]").InnerText;
+        switch (status.ToLower())
+        {
+            case "cancelled": releaseStatus = MangaReleaseStatus.Cancelled; break;
+            case "hiatus": releaseStatus = MangaReleaseStatus.OnHiatus; break;
+            case "discontinued": releaseStatus = MangaReleaseStatus.Cancelled; break;
+            case "complete": releaseStatus = MangaReleaseStatus.Completed; break;
+            case "ongoing": releaseStatus = MangaReleaseStatus.Continuing; break;
+        }
+
+        HtmlNode descriptionNode = document.DocumentNode
+            .SelectSingleNode("//p[contains(concat(' ',normalize-space(@class),' '),' fullcontent ')]");
+        string description = descriptionNode.InnerText;
+
+        Manga manga = new (publicationId, sortName, description, websiteUrl, coverUrl, null, 0,
+            originalLanguage, releaseStatus, -1,
+            this, 
+            authors, 
+            mangaTags, 
+            [],
+            []);
+		
+        return (manga, authors, mangaTags, [], []);
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string language="en")
+    {
+        string requestUrl = $"https://www.mangahere.cc/manga/{manga.MangaId}";
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+            return Array.Empty<Chapter>();
+        
+        List<string> urls = requestResult.htmlDocument.DocumentNode.SelectNodes("//div[@id='list-1']/ul//li//a[contains(@href, '/manga/')]")
+            .Select(node => node.GetAttributeValue("href", "")).ToList();
+        Regex chapterRex = new(@".*\/manga\/[a-zA-Z0-9\-\._\~\!\$\&\'\(\)\*\+\,\;\=\:\@]+\/v([0-9(TBD)]+)\/c([0-9\.]+)\/.*");
+        
+        List<Chapter> chapters = new();
+        foreach (string url in urls)
+        {
+            Match rexMatch = chapterRex.Match(url);
+
+            int? volumeNumber = rexMatch.Groups[1].Value == "TBD" ? null : int.Parse(rexMatch.Groups[1].Value);
+            if(!ChapterNumber.CanParse(rexMatch.Groups[2].Value))
+                continue;
+            ChapterNumber chapterNumber = new(rexMatch.Groups[2].Value);
+            string fullUrl = $"https://www.mangahere.cc{url}";
+                
+            try
+            {
+                chapters.Add(new Chapter(manga, fullUrl, chapterNumber, volumeNumber, null));
+            }
+            catch (Exception e)
+            {
+            }
+        }
+        //Return Chapters ordered by Chapter-Number
+        return chapters.Order().ToArray();
+    }
+
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        List<string> imageUrls = new();
+
+        int downloaded = 1;
+        int images = 1;
+        string url = string.Join('/', chapter.Url.Split('/')[..^1]);
+        do
+        {
+            RequestResult requestResult =
+                downloadClient.MakeRequest($"{url}/{downloaded}.html", RequestType.Default);
+            if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+            {
+                return [];
+            }
+            
+            imageUrls.AddRange(ParseImageUrlsFromHtml(requestResult.htmlDocument));
+
+            images = requestResult.htmlDocument.DocumentNode
+                .SelectNodes("//a[contains(@href, '/manga/')]")
+                .MaxBy(node => node.GetAttributeValue("data-page", 0))!.GetAttributeValue("data-page", 0);
+        } while (downloaded++ <= images);
+        
+        return imageUrls.ToArray();
+    }
+
+    private string[] ParseImageUrlsFromHtml(HtmlDocument document)
+    {
+        return document.DocumentNode
+            .SelectNodes("//img[contains(concat(' ',normalize-space(@class),' '),' reader-main-img ')]")
+            .Select(node =>
+            {
+                string url = node.GetAttributeValue("src", "");
+                return url.StartsWith("//") ? $"https:{url}" : url;
+            })
+            .ToArray();
+    }
+}

API/Schema/MangaConnectors/MangaKatana.cs

@@ -0,0 +1,234 @@
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+
+namespace API.Schema.MangaConnectors;
+
+public class MangaKatana : MangaConnector
+{
+	public MangaKatana() : base("MangaKatana", ["en"], ["mangakatana.com"])
+	{
+		this.downloadClient = new HttpDownloadClient();
+	}
+
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
+	{
+		string sanitizedTitle = string.Join("%20", Regex.Matches(publicationTitle, "[A-z]*").Where(m => m.Value.Length > 0)).ToLower();
+		string requestUrl = $"https://mangakatana.com/?search={sanitizedTitle}&search_by=book_name";
+		RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, RequestType.Default);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return [];
+
+		// ReSharper disable once MergeIntoPattern
+		// If a single result is found, the user will be redirected to the results directly instead of a result page
+		if(requestResult.hasBeenRedirected
+		    && requestResult.redirectedToUrl is not null
+			&& requestResult.redirectedToUrl.Contains("mangakatana.com/manga"))
+		{
+			return new [] { ParseSinglePublicationFromHtml(requestResult.result, requestResult.redirectedToUrl.Split('/')[^1], requestResult.redirectedToUrl) };
+		}
+
+		(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.result);
+		return publications;
+	}
+
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+	{
+		return GetMangaFromUrl($"https://mangakatana.com/manga/{publicationId}");
+	}
+
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
+	{
+		RequestResult requestResult =
+			downloadClient.MakeRequest(url, RequestType.MangaInfo);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return null;
+		return ParseSinglePublicationFromHtml(requestResult.result, url.Split('/')[^1], url);
+	}
+
+	private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(Stream html)
+	{
+		StreamReader reader = new(html);
+		string htmlString = reader.ReadToEnd();
+		HtmlDocument document = new();
+		document.LoadHtml(htmlString);
+		IEnumerable<HtmlNode> searchResults = document.DocumentNode.SelectNodes("//*[@id='book_list']/div");
+		if (searchResults is null || !searchResults.Any())
+			return [];
+		List<string> urls = new();
+		foreach (HtmlNode mangaResult in searchResults)
+		{
+			urls.Add(mangaResult.Descendants("a").First().GetAttributes()
+				.First(a => a.Name == "href").Value);
+		}
+
+		HashSet<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
+		foreach (string url in urls)
+		{
+			(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+			if (manga is { } x)
+				ret.Add(x);
+		}
+
+		return ret.ToArray();
+	}
+
+	private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(Stream html, string publicationId, string websiteUrl)
+	{
+		StreamReader reader = new(html);
+		string htmlString = reader.ReadToEnd();
+		HtmlDocument document = new();
+		document.LoadHtml(htmlString);
+		Dictionary<string, string> altTitlesDict = new();
+		Dictionary<string, string>? links = null;
+		HashSet<string> tags = new();
+		string[] authorNames = [];
+		string originalLanguage = "";
+		MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
+
+		HtmlNode infoNode = document.DocumentNode.SelectSingleNode("//*[@id='single_book']");
+		string sortName = infoNode.Descendants("h1").First(n => n.HasClass("heading")).InnerText;
+		HtmlNode infoTable = infoNode.SelectSingleNode("//*[@id='single_book']/div[2]/div/ul");
+
+		foreach (HtmlNode row in infoTable.Descendants("li"))
+		{
+			string key = row.SelectNodes("div").First().InnerText.ToLower();
+			string value = row.SelectNodes("div").Last().InnerText;
+			string keySanitized = string.Concat(Regex.Matches(key, "[a-z]"));
+
+			switch (keySanitized)
+			{
+				case "altnames":
+					string[] alts = value.Split(" ; ");
+					for (int i = 0; i < alts.Length; i++)
+						altTitlesDict.Add(i.ToString(), alts[i]);
+					break;
+				case "authorsartists":
+					authorNames = value.Split(',');
+					break;
+				case "status":
+					switch (value.ToLower())
+					{
+						case "ongoing": releaseStatus = MangaReleaseStatus.Continuing; break;
+						case "completed": releaseStatus = MangaReleaseStatus.Completed; break;
+					}
+					break;
+				case "genres":
+					tags = row.SelectNodes("div").Last().Descendants("a").Select(a => a.InnerText).ToHashSet();
+					break;
+			}
+		}
+
+		string coverUrl = document.DocumentNode.SelectSingleNode("//*[@id='single_book']/div[1]/div").Descendants("img").First()
+			.GetAttributes().First(a => a.Name == "src").Value;
+
+		string description = document.DocumentNode.SelectSingleNode("//*[@id='single_book']/div[3]/p").InnerText;
+		while (description.StartsWith('\n'))
+			description = description.Substring(1);
+
+		uint year = (uint)DateTime.Now.Year;
+		string yearString = infoTable.Descendants("div").First(d => d.HasClass("updateAt"))
+			.InnerText.Split('-')[^1];
+
+		if(yearString.Contains("ago") == false)
+		{
+			year = uint.Parse(yearString);
+		}
+		List<Author> authors = authorNames.Select(n => new Author(n)).ToList();
+		List<MangaTag> mangaTags = tags.Select(n => new MangaTag(n)).ToList();
+		List<MangaAltTitle> altTitles = altTitlesDict.Select(x => new MangaAltTitle(x.Key, x.Value)).ToList();
+
+		Manga manga = new (publicationId, sortName, description, websiteUrl, coverUrl, null, year,
+			originalLanguage, releaseStatus, -1,
+			this, 
+			authors, 
+			mangaTags, 
+			[],
+			altTitles);
+		
+		return (manga, authors, mangaTags, [], altTitles);
+	}
+
+	public override Chapter[] GetChapters(Manga manga, string language="en")
+	{
+		string requestUrl = $"https://mangakatana.com/manga/{manga.MangaId}";
+		// Leaving this in for verification if the page exists
+		RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, RequestType.Default);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+			return Array.Empty<Chapter>();
+
+		//Return Chapters ordered by Chapter-Number
+		List<Chapter> chapters = ParseChaptersFromHtml(manga, requestUrl);
+		return chapters.Order().ToArray();
+	}
+
+	private List<Chapter> ParseChaptersFromHtml(Manga manga, string mangaUrl)
+	{
+		// Using HtmlWeb will include the chapters since they are loaded with js 
+		HtmlWeb web = new();
+		HtmlDocument document = web.Load(mangaUrl);
+
+		List<Chapter> ret = new();
+
+		HtmlNode chapterList = document.DocumentNode.SelectSingleNode("//div[contains(@class, 'chapters')]/table/tbody");
+
+		Regex volumeRex = new(@"[0-9a-z\-\.]+\/[0-9a-z\-]*v([0-9\.]+)");
+		Regex chapterNumRex = new(@"[0-9a-z\-\.]+\/[0-9a-z\-]*c([0-9\.]+)");
+		Regex chapterNameRex = new(@"Chapter [0-9\.]+:? (.*)");
+		
+		foreach (HtmlNode chapterInfo in chapterList.Descendants("tr"))
+		{
+			string fullString = chapterInfo.Descendants("a").First().InnerText;
+			string url = chapterInfo.Descendants("a").First()
+				.GetAttributeValue("href", "");
+
+			int? volumeNumber = volumeRex.IsMatch(url) ? int.Parse(volumeRex.Match(url).Groups[1].Value) : null;
+			if(!ChapterNumber.CanParse(chapterNumRex.Match(url).Groups[1].Value))
+				continue;
+			ChapterNumber chapterNumber = new(chapterNumRex.Match(url).Groups[1].Value);
+			string chapterName = chapterNameRex.Match(fullString).Groups[1].Value;
+			try
+			{
+				ret.Add(new Chapter(manga, url, chapterNumber, volumeNumber, chapterName));
+			}
+			catch (Exception e)
+			{
+			}
+		}
+		
+		return ret;
+	}
+
+	internal override string[] GetChapterImageUrls(Chapter chapter)
+	{
+		string requestUrl = chapter.Url;
+		// Leaving this in to check if the page exists
+		RequestResult requestResult =
+			downloadClient.MakeRequest(requestUrl, RequestType.Default);
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+		{
+			return [];
+		}
+
+		string[] imageUrls = ParseImageUrlsFromHtml(requestResult.htmlDocument);
+		return imageUrls;
+	}
+
+	private string[] ParseImageUrlsFromHtml(HtmlDocument document)
+	{
+		// Images are loaded dynamically, but the urls are present in a piece of js code on the page
+		string js = document.DocumentNode.SelectSingleNode("//script[contains(., 'data-src')]").InnerText
+			.Replace("\r", "")
+			.Replace("\n", "")
+			.Replace("\t", "");
+		
+		// ReSharper disable once StringLiteralTypo
+		string regexPat = @"(var thzq=\[')(.*)(,];function)";
+		var group = Regex.Matches(js, regexPat).First().Groups[2].Value.Replace("'", "");
+		var urls = group.Split(',');
+		
+		return urls;
+	}
+}

API/Schema/MangaConnectors/MangaLife.cs

@@ -0,0 +1,188 @@
+using System.Net;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+
+namespace API.Schema.MangaConnectors;
+
+public class MangaLife : MangaConnector
+{
+    public MangaLife() : base("Manga4Life", ["en"], ["manga4life.com"])
+    {
+        this.downloadClient = new ChromiumDownloadClient();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
+    {
+        string sanitizedTitle = WebUtility.UrlEncode(publicationTitle);
+        string requestUrl = $"https://manga4life.com/search/?name={sanitizedTitle}";
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return [];
+
+        if (requestResult.htmlDocument is null)
+            return [];
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
+        return publications;
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+    {
+        return GetMangaFromUrl($"https://manga4life.com/manga/{publicationId}");
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
+    {
+        Regex publicationIdRex = new(@"https:\/\/(www\.)?manga4life.com\/manga\/(.*)(\/.*)*");
+        string publicationId = publicationIdRex.Match(url).Groups[2].Value;
+
+        RequestResult requestResult = this.downloadClient.MakeRequest(url, RequestType.MangaInfo);
+        if(requestResult.htmlDocument is not null)
+            return ParseSinglePublicationFromHtml(requestResult.htmlDocument, publicationId, url);
+        return null;
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(HtmlDocument document)
+    {
+        HtmlNode resultsNode = document.DocumentNode.SelectSingleNode("//div[@class='BoxBody']/div[last()]/div[1]/div");
+        if (resultsNode.Descendants("div").Count() == 1 && resultsNode.Descendants("div").First().HasClass("NoResults"))
+        {
+            return [];
+        }
+
+        List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
+
+        foreach (HtmlNode resultNode in resultsNode.SelectNodes("div"))
+        {
+            string url = resultNode.Descendants().First(d => d.HasClass("SeriesName")).GetAttributeValue("href", "");
+            (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl($"https://manga4life.com{url}");
+            if (manga is { } x)
+                ret.Add(x);
+        }
+        
+        return ret.ToArray();
+    }
+
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    {
+        string originalLanguage = "", status = "";
+        Dictionary<string, string> altTitles = new(), links = new();
+        HashSet<string> tags = new();
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
+
+        HtmlNode posterNode = document.DocumentNode.SelectSingleNode("//div[@class='BoxBody']//div[@class='row']//img");
+        string coverUrl = posterNode.GetAttributeValue("src", "");
+
+        HtmlNode titleNode = document.DocumentNode.SelectSingleNode("//div[@class='BoxBody']//div[@class='row']//h1");
+        string sortName = titleNode.InnerText;
+
+        HtmlNode[] authorsNodes = document.DocumentNode
+            .SelectNodes("//div[@class='BoxBody']//div[@class='row']//span[text()='Author(s):']/..").Descendants("a")
+            .ToArray();
+        List<string> authorNames = new();
+        foreach (HtmlNode authorNode in authorsNodes)
+            authorNames.Add(authorNode.InnerText);
+        List<Author> authors = authorNames.Select(a => new Author(a)).ToList();
+
+        HtmlNode[] genreNodes = document.DocumentNode
+            .SelectNodes("//div[@class='BoxBody']//div[@class='row']//span[text()='Genre(s):']/..").Descendants("a")
+            .ToArray();
+        foreach (HtmlNode genreNode in genreNodes)
+            tags.Add(genreNode.InnerText);
+        List<MangaTag> mangaTags = tags.Select(t => new MangaTag(t)).ToList();
+
+        HtmlNode yearNode = document.DocumentNode
+            .SelectNodes("//div[@class='BoxBody']//div[@class='row']//span[text()='Released:']/..").Descendants("a")
+            .First();
+        uint year = uint.Parse(yearNode.InnerText);
+
+        HtmlNode[] statusNodes = document.DocumentNode
+            .SelectNodes("//div[@class='BoxBody']//div[@class='row']//span[text()='Status:']/..").Descendants("a")
+            .ToArray();
+        foreach (HtmlNode statusNode in statusNodes)
+            if (statusNode.InnerText.Contains("publish", StringComparison.CurrentCultureIgnoreCase))
+                status = statusNode.InnerText.Split(' ')[0];
+        switch (status.ToLower())
+        {
+            case "cancelled": releaseStatus = MangaReleaseStatus.Cancelled; break;
+            case "hiatus": releaseStatus = MangaReleaseStatus.OnHiatus; break;
+            case "discontinued": releaseStatus = MangaReleaseStatus.Cancelled; break;
+            case "complete": releaseStatus = MangaReleaseStatus.Completed; break;
+            case "ongoing": releaseStatus = MangaReleaseStatus.Continuing; break;
+        }
+
+        HtmlNode descriptionNode = document.DocumentNode
+            .SelectNodes("//div[@class='BoxBody']//div[@class='row']//span[text()='Description:']/..")
+            .Descendants("div").First();
+        string description = descriptionNode.InnerText;
+
+        Manga manga = new (publicationId, sortName, description, websiteUrl, coverUrl, null, year,
+            originalLanguage, releaseStatus, -1,
+            this, 
+            authors, 
+            mangaTags, 
+            [],
+            []);
+		
+        return (manga, authors, mangaTags, [], []);
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string language="en")
+    {
+        RequestResult result = downloadClient.MakeRequest($"https://manga4life.com/manga/{manga.MangaId}", RequestType.Default, clickButton:"[class*='ShowAllChapters']");
+        if ((int)result.statusCode < 200 || (int)result.statusCode >= 300 || result.htmlDocument is null)
+        {
+            return Array.Empty<Chapter>();
+        }
+        
+        HtmlNodeCollection chapterNodes = result.htmlDocument.DocumentNode.SelectNodes(
+            "//a[contains(concat(' ',normalize-space(@class),' '),' ChapterLink ')]");
+        string[] urls = chapterNodes.Select(node => node.GetAttributeValue("href", "")).ToArray();
+        Regex urlRex = new (@"-chapter-([0-9\\.]+)(-index-([0-9\\.]+))?");
+        
+        List<Chapter> chapters = new();
+        foreach (string url in urls)
+        {
+            Match rexMatch = urlRex.Match(url);
+
+            int? volumeNumber = rexMatch.Groups[3].Success && rexMatch.Groups[3].Value.Length > 0
+                ? int.Parse(rexMatch.Groups[3].Value)
+                : null;
+            
+            if(!ChapterNumber.CanParse(rexMatch.Groups[1].Value))
+                continue;
+            ChapterNumber chapterNumber = new(rexMatch.Groups[1].Value);
+            string fullUrl = $"https://manga4life.com{url}";
+            fullUrl = fullUrl.Replace(Regex.Match(url,"(-page-[0-9])").Value,"");
+            try
+            {
+                chapters.Add(new Chapter(manga, fullUrl, chapterNumber, volumeNumber, null));
+            }
+            catch (Exception e)
+            {
+            }
+        }
+        //Return Chapters ordered by Chapter-Number
+        return chapters.Order().ToArray();
+    }
+
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        RequestResult requestResult = this.downloadClient.MakeRequest(chapter.Url, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+        {
+            return [];
+        }
+
+        HtmlDocument document = requestResult.htmlDocument;
+        
+        HtmlNode gallery = document.DocumentNode.Descendants("div").First(div => div.HasClass("ImageGallery"));
+        HtmlNode[] images = gallery.Descendants("img").Where(img => img.HasClass("img-fluid")).ToArray();
+        List<string> urls = new();
+        foreach(HtmlNode galleryImage in images)
+            urls.Add(galleryImage.GetAttributeValue("src", ""));
+        return urls.ToArray();
+    }
+}

API/Schema/MangaConnectors/Manganato.cs

@@ -0,0 +1,226 @@
+using System.Globalization;
+using System.Net;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+
+namespace API.Schema.MangaConnectors;
+
+public class Manganato : MangaConnector
+{
+    public Manganato() : base("Manganato", ["en"], ["manganato.com"])
+    {
+        this.downloadClient = new HttpDownloadClient();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
+    {
+        string sanitizedTitle = string.Join('_', Regex.Matches(publicationTitle, "[A-z]*").Where(str => str.Length > 0)).ToLower();
+        string requestUrl = $"https://manganato.com/search/story/{sanitizedTitle}";
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 ||requestResult.htmlDocument is null)
+            return [];
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
+        return publications;
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(HtmlDocument document)
+    {
+        List<HtmlNode> searchResults = document.DocumentNode.Descendants("div").Where(n => n.HasClass("search-story-item")).ToList();
+        List<string> urls = new();
+        foreach (HtmlNode mangaResult in searchResults)
+        {
+            urls.Add(mangaResult.Descendants("a").First(n => n.HasClass("item-title")).GetAttributes()
+                .First(a => a.Name == "href").Value);
+        }
+
+        List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
+        foreach (string url in urls)
+        {
+            (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+            if (manga is { } x)
+                ret.Add(x);
+        }
+
+        return ret.ToArray();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+    {
+        return GetMangaFromUrl($"https://chapmanganato.com/{publicationId}");
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
+    {
+        RequestResult requestResult =
+            downloadClient.MakeRequest(url, RequestType.MangaInfo);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return null;
+        
+        if (requestResult.htmlDocument is null)
+            return null;
+        return ParseSinglePublicationFromHtml(requestResult.htmlDocument, url.Split('/')[^1], url);
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    {
+        Dictionary<string, string> altTitlesDict = new();
+        Dictionary<string, string>? links = null;
+        HashSet<string> tags = new();
+        string[] authorNames = [];
+        string originalLanguage = "";
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
+
+        HtmlNode infoNode = document.DocumentNode.Descendants("div").First(d => d.HasClass("story-info-right"));
+
+        string sortName = infoNode.Descendants("h1").First().InnerText;
+
+        HtmlNode infoTable = infoNode.Descendants().First(d => d.Name == "table");
+        
+        foreach (HtmlNode row in infoTable.Descendants("tr"))
+        {
+            string key = row.SelectNodes("td").First().InnerText.ToLower();
+            string value = row.SelectNodes("td").Last().InnerText;
+            string keySanitized = string.Concat(Regex.Matches(key, "[a-z]"));
+
+            switch (keySanitized)
+            {
+                case "alternative":
+                    string[] alts = value.Split(" ; ");
+                    for(int i = 0; i < alts.Length; i++)
+                        altTitlesDict.Add(i.ToString(), alts[i]);
+                    break;
+                case "authors":
+                    authorNames = value.Split('-');
+                    for (int i = 0; i < authorNames.Length; i++)
+                        authorNames[i] = authorNames[i].Replace("\r\n", "");
+                    break;
+                case "status":
+                    switch (value.ToLower())
+                    {
+                        case "ongoing": releaseStatus = MangaReleaseStatus.Continuing; break;
+                        case "completed": releaseStatus = MangaReleaseStatus.Completed; break;
+                    }
+                    break;
+                case "genres":
+                    string[] genres = value.Split(" - ");
+                    for (int i = 0; i < genres.Length; i++)
+                        genres[i] = genres[i].Replace("\r\n", "");
+                    tags = genres.ToHashSet();
+                    break;
+            }
+        }
+        List<Author> authors = authorNames.Select(n => new Author(n)).ToList();
+        List<MangaTag> mangaTags = tags.Select(n => new MangaTag(n)).ToList();
+        List<MangaAltTitle> mangaAltTitles = altTitlesDict.Select(a => new MangaAltTitle(a.Key, a.Value)).ToList();
+
+        string coverUrl = document.DocumentNode.Descendants("span").First(s => s.HasClass("info-image")).Descendants("img").First()
+            .GetAttributes().First(a => a.Name == "src").Value;
+
+        string description = document.DocumentNode.Descendants("div").First(d => d.HasClass("panel-story-info-description"))
+            .InnerText.Replace("Description :", "");
+        while (description.StartsWith('\n'))
+            description = description.Substring(1);
+        
+        string pattern = "MMM dd,yyyy HH:mm";
+
+        HtmlNode? oldestChapter = document.DocumentNode
+            .SelectNodes("//span[contains(concat(' ',normalize-space(@class),' '),' chapter-time ')]").MaxBy(
+                node => DateTime.ParseExact(node.GetAttributeValue("title", "Dec 31 2400, 23:59"), pattern,
+                    CultureInfo.InvariantCulture).Millisecond);
+
+
+        uint year = (uint)DateTime.ParseExact(oldestChapter?.GetAttributeValue("title", "Dec 31 2400, 23:59")??"Dec 31 2400, 23:59", pattern,
+            CultureInfo.InvariantCulture).Year;
+        
+        Manga manga = new (publicationId, sortName, description, websiteUrl, coverUrl, null, year,
+            originalLanguage, releaseStatus, -1,
+            this, 
+            authors, 
+            mangaTags, 
+            [],
+            mangaAltTitles);
+		
+        return (manga, authors, mangaTags, [], mangaAltTitles);
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string language="en")
+    {
+        string requestUrl = $"https://chapmanganato.com/{manga.MangaId}";
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return [];
+        
+        //Return Chapters ordered by Chapter-Number
+        if (requestResult.htmlDocument is null)
+            return [];
+        List<Chapter> chapters = ParseChaptersFromHtml(manga, requestResult.htmlDocument);
+        return chapters.Order().ToArray();
+    }
+
+
+    private List<Chapter> ParseChaptersFromHtml(Manga manga, HtmlDocument document)
+    {
+        List<Chapter> ret = new();
+
+        HtmlNode chapterList = document.DocumentNode.Descendants("ul").First(l => l.HasClass("row-content-chapter"));
+
+        Regex volRex = new(@"Vol\.([0-9]+).*");
+        Regex chapterRex = new(@"https:\/\/chapmanganato.[A-z]+\/manga-[A-z0-9]+\/chapter-([0-9\.]+)");
+        Regex nameRex = new(@"Chapter ([0-9]+(\.[0-9]+)*){1}:? (.*)");
+
+        foreach (HtmlNode chapterInfo in chapterList.Descendants("li"))
+        {
+            string fullString = chapterInfo.Descendants("a").First(d => d.HasClass("chapter-name")).InnerText;
+
+            string url = chapterInfo.Descendants("a").First(d => d.HasClass("chapter-name"))
+                .GetAttributeValue("href", "");
+            
+            int? volumeNumber = volRex.IsMatch(fullString)
+                ? int.Parse(volRex.Match(fullString).Groups[1].Value)
+                : null;
+            if(!ChapterNumber.CanParse(chapterRex.Match(url).Groups[1].Value))
+                continue;
+            ChapterNumber chapterNumber = new(chapterRex.Match(url).Groups[1].Value);
+            string chapterName = nameRex.Match(fullString).Groups[3].Value;
+            try
+            {
+                ret.Add(new Chapter(manga, url, chapterNumber, volumeNumber, chapterName));
+            }
+            catch (Exception e)
+            {
+            }
+        }
+        ret.Reverse();
+        return ret;
+    }
+    
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        string requestUrl = chapter.Url;
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 ||
+            requestResult.htmlDocument is null)
+        {
+            return [];
+        }
+
+        string[] imageUrls = ParseImageUrlsFromHtml(requestResult.htmlDocument);
+        return imageUrls;
+    }
+
+    private string[] ParseImageUrlsFromHtml(HtmlDocument document)
+    {
+        List<string> ret = new();
+
+        HtmlNode imageContainer =
+            document.DocumentNode.Descendants("div").First(i => i.HasClass("container-chapter-reader"));
+        foreach(HtmlNode imageNode in imageContainer.Descendants("img"))
+            ret.Add(imageNode.GetAttributeValue("src", ""));
+
+        return ret.ToArray();
+    }
+}

API/Schema/MangaConnectors/Mangasee.cs

@@ -0,0 +1,215 @@
+using System.Data;
+using System.Net;
+using System.Text.RegularExpressions;
+using System.Xml.Linq;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+using Newtonsoft.Json;
+using Soenneker.Utils.String.NeedlemanWunsch;
+
+namespace API.Schema.MangaConnectors;
+
+public class Mangasee : MangaConnector
+{
+    public Mangasee() : base("Mangasee", ["en"], ["mangasee123.com"])
+    {
+        this.downloadClient = new ChromiumDownloadClient();
+    }
+
+    private struct SearchResult
+    {
+        public string i { get; set; }
+        public string s { get; set; }
+        public string[] a { get; set; }
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
+    {
+        string requestUrl = "https://mangasee123.com/_search.php";
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+        {
+            return [];
+        }
+        
+        try
+        {
+            SearchResult[] searchResults = JsonConvert.DeserializeObject<SearchResult[]>(requestResult.htmlDocument!.DocumentNode.InnerText) ??
+                                           throw new NoNullAllowedException();
+            SearchResult[] filteredResults = FilteredResults(publicationTitle, searchResults);
+            
+
+            string[] urls = filteredResults.Select(result => $"https://mangasee123.com/manga/{result.i}").ToArray();
+            List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> searchResultManga = new();
+            foreach (string url in urls)
+            {
+                (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? newManga = GetMangaFromUrl(url);
+                if(newManga is { } manga)
+                    searchResultManga.Add(manga);
+            }
+            return searchResultManga.ToArray();
+        }
+        catch (NoNullAllowedException)
+        {
+            return [];
+        }
+    }
+
+    private readonly string[] _filterWords = {"a", "the", "of", "as", "to", "no", "for", "on", "with", "be", "and", "in", "wa", "at", "be", "ni"};
+    private string ToFilteredString(string input) => string.Join(' ', input.ToLower().Split(' ').Where(word => _filterWords.Contains(word) == false));
+    private SearchResult[] FilteredResults(string publicationTitle, SearchResult[] unfilteredSearchResults)
+    {
+        Dictionary<SearchResult, int> similarity = new();
+        foreach (SearchResult sr in unfilteredSearchResults)
+        {
+            List<int> scores = new();
+            string filteredPublicationString = ToFilteredString(publicationTitle);
+            string filteredSString = ToFilteredString(sr.s);
+            scores.Add(NeedlemanWunschStringUtil.CalculateSimilarity(filteredSString, filteredPublicationString));
+            foreach (string srA in sr.a)
+            {
+                string filteredAString = ToFilteredString(srA);
+                scores.Add(NeedlemanWunschStringUtil.CalculateSimilarity(filteredAString, filteredPublicationString));
+            }
+            similarity.Add(sr, scores.Sum() / scores.Count);
+        }
+
+        List<SearchResult> ret = similarity.OrderBy(s => s.Value).Take(10).Select(s => s.Key).ToList();
+        return ret.ToArray();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+    {
+        return GetMangaFromUrl($"https://mangasee123.com/manga/{publicationId}");
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
+    {
+        Regex publicationIdRex = new(@"https:\/\/mangasee123.com\/manga\/(.*)(\/.*)*");
+        string publicationId = publicationIdRex.Match(url).Groups[1].Value;
+
+        RequestResult requestResult = this.downloadClient.MakeRequest(url, RequestType.MangaInfo);
+        if((int)requestResult.statusCode < 300 && (int)requestResult.statusCode >= 200 && requestResult.htmlDocument is not null)
+            return ParseSinglePublicationFromHtml(requestResult.htmlDocument, publicationId, url);
+        return null;
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    {
+        string originalLanguage = "", status = "";
+        Dictionary<string, string> altTitles = new(), links = new();
+        HashSet<string> tags = new();
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
+
+        HtmlNode posterNode = document.DocumentNode.SelectSingleNode("//div[@class='BoxBody']//div[@class='row']//img");
+        string coverUrl = posterNode.GetAttributeValue("src", "");
+
+        HtmlNode titleNode = document.DocumentNode.SelectSingleNode("//div[@class='BoxBody']//div[@class='row']//h1");
+        string sortName = titleNode.InnerText;
+
+        HtmlNode[] authorsNodes = document.DocumentNode
+            .SelectNodes("//div[@class='BoxBody']//div[@class='row']//span[text()='Author(s):']/..").Descendants("a")
+            .ToArray();
+        List<string> authorNames = new();
+        foreach (HtmlNode authorNode in authorsNodes)
+            authorNames.Add(authorNode.InnerText);
+        List<Author> authors = authorNames.Select(a => new Author(a)).ToList();
+
+        HtmlNode[] genreNodes = document.DocumentNode
+            .SelectNodes("//div[@class='BoxBody']//div[@class='row']//span[text()='Genre(s):']/..").Descendants("a")
+            .ToArray();
+        foreach (HtmlNode genreNode in genreNodes)
+            tags.Add(genreNode.InnerText);
+        List<MangaTag> mangaTags = tags.Select(t => new MangaTag(t)).ToList();
+
+        HtmlNode yearNode = document.DocumentNode
+            .SelectNodes("//div[@class='BoxBody']//div[@class='row']//span[text()='Released:']/..").Descendants("a")
+            .First();
+        uint year = uint.Parse(yearNode.InnerText);
+
+        HtmlNode[] statusNodes = document.DocumentNode
+            .SelectNodes("//div[@class='BoxBody']//div[@class='row']//span[text()='Status:']/..").Descendants("a")
+            .ToArray();
+        foreach (HtmlNode statusNode in statusNodes)
+            if (statusNode.InnerText.Contains("publish", StringComparison.CurrentCultureIgnoreCase))
+                status = statusNode.InnerText.Split(' ')[0];
+        switch (status.ToLower())
+        {
+            case "cancelled": releaseStatus = MangaReleaseStatus.Cancelled; break;
+            case "hiatus": releaseStatus = MangaReleaseStatus.OnHiatus; break;
+            case "discontinued": releaseStatus = MangaReleaseStatus.Cancelled; break;
+            case "complete": releaseStatus = MangaReleaseStatus.Completed; break;
+            case "ongoing": releaseStatus = MangaReleaseStatus.Continuing; break;
+        }
+
+        HtmlNode descriptionNode = document.DocumentNode
+            .SelectNodes("//div[@class='BoxBody']//div[@class='row']//span[text()='Description:']/..")
+            .Descendants("div").First();
+        string description = descriptionNode.InnerText;
+
+        Manga manga = new (publicationId, sortName, description, websiteUrl, coverUrl, null, year,
+            originalLanguage, releaseStatus, -1,
+            this, 
+            authors, 
+            mangaTags, 
+            [],
+            []);
+		
+        return (manga, authors, mangaTags, [], []);
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string language="en")
+    {
+        try
+        {
+            XDocument doc = XDocument.Load($"https://mangasee123.com/rss/{manga.MangaId}.xml");
+            XElement[] chapterItems = doc.Descendants("item").ToArray();
+            List<Chapter> chapters = new();
+            Regex chVolRex = new(@".*chapter-([0-9\.]+)(?:-index-([0-9\.]+))?.*");
+            foreach (XElement chapter in chapterItems)
+            {
+                string url = chapter.Descendants("link").First().Value;
+                Match m = chVolRex.Match(url);
+                int? volumeNumber = m.Groups[2].Success ? int.Parse(m.Groups[2].Value) : null;
+                if(!ChapterNumber.CanParse(m.Groups[1].Value))
+                    continue;
+                ChapterNumber chapterNumber = new(m.Groups[1].Value);
+
+                string chapterUrl = Regex.Replace(url, @"-page-[0-9]+(\.html)", ".html");
+                try
+                {
+                    chapters.Add(new Chapter(manga, chapterUrl,chapterNumber, volumeNumber, null));
+                }
+                catch (Exception e)
+                {
+                }
+            }
+
+            //Return Chapters ordered by Chapter-Number
+            return chapters.Order().ToArray();
+        }
+        catch (HttpRequestException e)
+        {
+            return [];
+        }
+    }
+
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        RequestResult requestResult = this.downloadClient.MakeRequest(chapter.Url, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+        {
+            return [];
+        }
+
+        HtmlDocument document = requestResult.htmlDocument;
+        
+        HtmlNode gallery = document.DocumentNode.Descendants("div").First(div => div.HasClass("ImageGallery"));
+        HtmlNode[] images = gallery.Descendants("img").Where(img => img.HasClass("img-fluid")).ToArray();
+        List<string> urls = new();
+        foreach(HtmlNode galleryImage in images)
+            urls.Add(galleryImage.GetAttributeValue("src", ""));
+        return urls.ToArray();
+    }
+}

API/Schema/MangaConnectors/Mangaworld.cs

@@ -0,0 +1,225 @@
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+
+namespace API.Schema.MangaConnectors;
+
+public class Mangaworld : MangaConnector
+{
+    public Mangaworld() : base("Mangaworld", ["it"], ["www.mangaworld.ac"])
+    {
+        this.downloadClient = new ChromiumDownloadClient();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
+    {
+        string sanitizedTitle = string.Join(' ', Regex.Matches(publicationTitle, "[A-z]*").Where(str => str.Length > 0)).ToLower();
+        string requestUrl = $"https://www.mangaworld.ac/archive?keyword={sanitizedTitle}";
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return [];
+
+        if (requestResult.htmlDocument is null)
+            return [];
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
+        return publications;
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(HtmlDocument document)
+    {
+        if (!document.DocumentNode.SelectSingleNode("//div[@class='comics-grid']").ChildNodes
+                .Any(node => node.HasClass("entry")))
+            return [];
+        
+        List<string> urls = document.DocumentNode
+            .SelectNodes(
+                "//div[@class='comics-grid']//div[@class='entry']//a[contains(concat(' ',normalize-space(@class),' '),'thumb')]")
+            .Select(thumb => thumb.GetAttributeValue("href", "")).ToList();
+
+        List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
+        foreach (string url in urls)
+        {
+            (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+            if (manga is { } x)
+                ret.Add(x);
+        }
+
+        return ret.ToArray();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+    {
+        return GetMangaFromUrl($"https://www.mangaworld.ac/manga/{publicationId}");
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
+    {
+        RequestResult requestResult =
+            downloadClient.MakeRequest(url, RequestType.MangaInfo);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return null;
+        
+        if (requestResult.htmlDocument is null)
+            return null;
+        
+        Regex idRex = new (@"https:\/\/www\.mangaworld\.[a-z]{0,63}\/manga\/([0-9]+\/[0-9A-z\-]+).*");
+        string id = idRex.Match(url).Groups[1].Value;
+        return ParseSinglePublicationFromHtml(requestResult.htmlDocument, id, url);
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    {
+        Dictionary<string, string> altTitlesDict = new();
+        string originalLanguage = "";
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
+
+        HtmlNode infoNode = document.DocumentNode.Descendants("div").First(d => d.HasClass("info"));
+
+        string sortName = infoNode.Descendants("h1").First().InnerText;
+
+        HtmlNode metadata = infoNode.Descendants().First(d => d.HasClass("meta-data"));
+
+        HtmlNode altTitlesNode = metadata.SelectSingleNode("//span[text()='Titoli alternativi: ' or text()='Titolo alternativo: ']/..").ChildNodes[1];
+        string[] alts = altTitlesNode.InnerText.Split(", ");
+        for(int i = 0; i < alts.Length; i++)
+            altTitlesDict.Add(i.ToString(), alts[i]);
+        List<MangaAltTitle> altTitles = altTitlesDict.Select(a => new MangaAltTitle(a.Key, a.Value)).ToList();
+
+        HtmlNode genresNode =
+            metadata.SelectSingleNode("//span[text()='Generi: ' or text()='Genero: ']/..");
+        HashSet<string> tags = genresNode.SelectNodes("a").Select(node => node.InnerText).ToHashSet();
+        List<MangaTag> mangaTags = tags.Select(t => new MangaTag(t)).ToList();
+        
+        HtmlNode authorsNode =
+            metadata.SelectSingleNode("//span[text()='Autore: ' or text()='Autori: ']/..");
+        string[] authorNames = authorsNode.SelectNodes("a").Select(node => node.InnerText).ToArray();
+        List<Author> authors = authorNames.Select(n => new Author(n)).ToList();
+
+        string status = metadata.SelectSingleNode("//span[text()='Stato: ']/..").SelectNodes("a").First().InnerText;
+        // ReSharper disable 5 times StringLiteralTypo
+        switch (status.ToLower())
+        {
+            case "cancellato": releaseStatus = MangaReleaseStatus.Cancelled; break;
+            case "in pausa": releaseStatus = MangaReleaseStatus.OnHiatus; break;
+            case "droppato": releaseStatus = MangaReleaseStatus.Cancelled; break;
+            case "finito": releaseStatus = MangaReleaseStatus.Completed; break;
+            case "in corso": releaseStatus = MangaReleaseStatus.Continuing; break;
+        }
+
+        string coverUrl = document.DocumentNode.SelectSingleNode("//img[@class='rounded']").GetAttributeValue("src", "");
+
+        string description = document.DocumentNode.SelectSingleNode("//div[@id='noidungm']").InnerText;
+        
+        string yearString = metadata.SelectSingleNode("//span[text()='Anno di uscita: ']/..").SelectNodes("a").First().InnerText;
+        uint year = uint.Parse(yearString);
+        
+        Manga manga = new (publicationId, sortName, description, websiteUrl, coverUrl, null, year,
+            originalLanguage, releaseStatus, -1,
+            this, 
+            authors, 
+            mangaTags, 
+            [],
+            altTitles);
+		
+        return (manga, authors, mangaTags, [], altTitles);
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string language="en")
+    {
+        string requestUrl = $"https://www.mangaworld.ac/manga/{manga.MangaId}";
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+            return [];
+        
+        List<Chapter> chapters = ParseChaptersFromHtml(manga, requestResult.htmlDocument);
+        return chapters.Order().ToArray();
+    }
+
+    private List<Chapter> ParseChaptersFromHtml(Manga manga, HtmlDocument document)
+    {
+        List<Chapter> ret = new();
+
+        HtmlNode chaptersWrapper =
+            document.DocumentNode.SelectSingleNode(
+                "//div[contains(concat(' ',normalize-space(@class),' '),'chapters-wrapper')]");
+
+        Regex volumeRex = new(@"[Vv]olume ([0-9]+).*");
+        Regex chapterRex = new(@"[Cc]apitolo ([0-9]+(?:\.[0-9]+)?).*");
+        Regex idRex = new(@".*\/read\/([a-z0-9]+)(?:[?\/].*)?");
+        if (chaptersWrapper.Descendants("div").Any(descendant => descendant.HasClass("volume-element")))
+        {
+            foreach (HtmlNode volNode in document.DocumentNode.SelectNodes("//div[contains(concat(' ',normalize-space(@class),' '),'volume-element')]"))
+            {
+                string volumeStr = volumeRex.Match(volNode.SelectNodes("div").First(node => node.HasClass("volume")).SelectSingleNode("p").InnerText).Groups[1].Value;
+                int volume = int.Parse(volumeStr);
+                foreach (HtmlNode chNode in volNode.SelectNodes("div").First(node => node.HasClass("volume-chapters")).SelectNodes("div"))
+                {
+
+                    string numberStr = chapterRex.Match(chNode.SelectSingleNode("a").SelectSingleNode("span").InnerText).Groups[1].Value;
+                    if(!ChapterNumber.CanParse(numberStr))
+                        continue;
+                    ChapterNumber chapterNumber = new(numberStr);
+                    string url = chNode.SelectSingleNode("a").GetAttributeValue("href", "");
+                    string id = idRex.Match(chNode.SelectSingleNode("a").GetAttributeValue("href", "")).Groups[1].Value;
+                    try
+                    {
+                        ret.Add(new Chapter(manga, url, chapterNumber, volume, null));
+                    }
+                    catch (Exception e)
+                    {
+                    }
+                }
+            }
+        }
+        else
+        {
+            foreach (HtmlNode chNode in chaptersWrapper.SelectNodes("div").Where(node => node.HasClass("chapter")))
+            {
+                string numberStr = chapterRex.Match(chNode.SelectSingleNode("a").SelectSingleNode("span").InnerText).Groups[1].Value;
+                if(!ChapterNumber.CanParse(numberStr))
+                    continue;
+                ChapterNumber chapterNumber = new(numberStr);
+                string url = chNode.SelectSingleNode("a").GetAttributeValue("href", "");
+                string id = idRex.Match(chNode.SelectSingleNode("a").GetAttributeValue("href", "")).Groups[1].Value;
+                try
+                {
+                    ret.Add(new Chapter(manga, url, chapterNumber, null, null));
+                }
+                catch (Exception e)
+                {
+                }
+            }
+        }
+
+        ret.Reverse();
+        return ret;
+    }
+
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        string requestUrl = $"{chapter.Url}?style=list";
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+        {
+            return [];
+        }
+
+        string[] imageUrls = ParseImageUrlsFromHtml(requestResult.htmlDocument);
+        return imageUrls;
+    }
+
+    private string[] ParseImageUrlsFromHtml(HtmlDocument document)
+    {
+        List<string> ret = new();
+
+        HtmlNode imageContainer =
+            document.DocumentNode.SelectSingleNode("//div[@id='page']");
+        foreach(HtmlNode imageNode in imageContainer.Descendants("img"))
+            ret.Add(imageNode.GetAttributeValue("src", ""));
+
+        return ret.ToArray();
+    }
+}

API/Schema/MangaConnectors/ManhuaPlus.cs

@@ -0,0 +1,181 @@
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+
+namespace API.Schema.MangaConnectors;
+
+public class ManhuaPlus : MangaConnector
+{
+    public ManhuaPlus() : base("ManhuaPlus", ["en"], ["manhuaplus.org"])
+    {
+        this.downloadClient = new ChromiumDownloadClient();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
+    {
+        string sanitizedTitle = string.Join(' ', Regex.Matches(publicationTitle, "[A-z]*").Where(str => str.Length > 0)).ToLower();
+        string requestUrl = $"https://manhuaplus.org/search?keyword={sanitizedTitle}";
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+            return [];
+        
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
+        return publications;
+    }
+    
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(HtmlDocument document)
+    {
+        if (document.DocumentNode.SelectSingleNode("//h1/../..").ChildNodes//I already want to not.
+                .Any(node => node.InnerText.Contains("No manga found")))
+            return [];
+
+        List<string> urls = document.DocumentNode
+            .SelectNodes("//h1/../..//a[contains(@href, 'https://manhuaplus.org/manga/') and contains(concat(' ',normalize-space(@class),' '),' clamp ') and not(contains(@href, '/chapter'))]")
+                .Select(mangaNode => mangaNode.GetAttributeValue("href", "")).ToList();
+
+        List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
+        foreach (string url in urls)
+        {
+            (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+            if (manga is { } x)
+                ret.Add(x);
+        }
+
+        return ret.ToArray();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+    {
+        return GetMangaFromUrl($"https://manhuaplus.org/manga/{publicationId}");
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
+    {
+        Regex publicationIdRex = new(@"https:\/\/manhuaplus.org\/manga\/(.*)(\/.*)*");
+        string publicationId = publicationIdRex.Match(url).Groups[1].Value;
+
+        RequestResult requestResult = this.downloadClient.MakeRequest(url, RequestType.MangaInfo);
+        if((int)requestResult.statusCode < 300 && (int)requestResult.statusCode >= 200 && requestResult.htmlDocument is not null && requestResult.redirectedToUrl != "https://manhuaplus.org/home") //When manga doesnt exists it redirects to home
+            return ParseSinglePublicationFromHtml(requestResult.htmlDocument, publicationId, url);
+        return null;
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    {
+        string originalLanguage = "", status = "";
+        Dictionary<string, string> altTitles = new(), links = new();
+        HashSet<string> tags = new();
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
+
+        HtmlNode posterNode = document.DocumentNode.SelectSingleNode("/html/body/main/div/div/div[2]/div[1]/figure/a/img");//BRUH
+        Regex posterRex = new(@".*(\/uploads/covers/[a-zA-Z0-9\-\._\~\!\$\&\'\(\)\*\+\,\;\=\:\@]+).*");
+        string coverUrl = $"https://manhuaplus.org/{posterRex.Match(posterNode.GetAttributeValue("src", "")).Groups[1].Value}";
+
+        HtmlNode titleNode = document.DocumentNode.SelectSingleNode("//h1");
+        string sortName = titleNode.InnerText.Replace("\n", "");
+        
+        List<string> authorNames = new();
+        try
+        {
+            HtmlNode[] authorsNodes = document.DocumentNode
+                .SelectNodes("//a[contains(@href, 'https://manhuaplus.org/authors/')]")
+                .ToArray();
+            foreach (HtmlNode authorNode in authorsNodes)
+                authorNames.Add(authorNode.InnerText);
+        }
+        catch (ArgumentNullException e)
+        {
+        }
+        List<Author> authors = authorNames.Select(a => new Author(a)).ToList();
+
+        try
+        {
+            HtmlNode[] genreNodes = document.DocumentNode
+                .SelectNodes("//a[contains(@href, 'https://manhuaplus.org/genres/')]").ToArray();
+            foreach (HtmlNode genreNode in genreNodes)
+                tags.Add(genreNode.InnerText.Replace("\n", ""));
+        }
+        catch (ArgumentNullException e)
+        {
+        }
+        List<MangaTag> mangaTags = tags.Select(t => new MangaTag(t)).ToList();
+
+        Regex yearRex = new(@"(?:[0-9]{1,2}\/){2}([0-9]{2,4}) [0-9]{1,2}:[0-9]{1,2}");
+        HtmlNode yearNode = document.DocumentNode.SelectSingleNode("//aside//i[contains(concat(' ',normalize-space(@class),' '),' fa-clock ')]/../span");
+        Match match = yearRex.Match(yearNode.InnerText);
+        uint year = match.Success && match.Groups[1].Success ? uint.Parse(match.Groups[1].Value) : 0;
+
+        status = document.DocumentNode.SelectSingleNode("//aside//i[contains(concat(' ',normalize-space(@class),' '),' fa-rss ')]/../span").InnerText.Replace("\n", "");
+        switch (status.ToLower())
+        {
+            case "cancelled": releaseStatus = MangaReleaseStatus.Cancelled; break;
+            case "hiatus": releaseStatus = MangaReleaseStatus.OnHiatus; break;
+            case "discontinued": releaseStatus = MangaReleaseStatus.Cancelled; break;
+            case "complete": releaseStatus = MangaReleaseStatus.Completed; break;
+            case "ongoing": releaseStatus = MangaReleaseStatus.Continuing; break;
+        }
+
+        HtmlNode descriptionNode = document.DocumentNode
+            .SelectSingleNode("//div[@id='syn-target']");
+        string description = descriptionNode.InnerText;
+
+        Manga manga = new (publicationId, sortName, description, websiteUrl, coverUrl, null, year,
+            originalLanguage, releaseStatus, -1,
+            this, 
+            authors, 
+            mangaTags, 
+            [],
+            []);
+		
+        return (manga, authors, mangaTags, [], []);
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string language="en")
+    {
+        RequestResult result = downloadClient.MakeRequest($"https://manhuaplus.org/manga/{manga.MangaId}", RequestType.Default);
+        if ((int)result.statusCode < 200 || (int)result.statusCode >= 300 || result.htmlDocument is null)
+        {
+            return Array.Empty<Chapter>();
+        }
+        
+        HtmlNodeCollection chapterNodes = result.htmlDocument.DocumentNode.SelectNodes("//li[contains(concat(' ',normalize-space(@class),' '),' chapter ')]//a");
+        string[] urls = chapterNodes.Select(node => node.GetAttributeValue("href", "")).ToArray();
+        Regex urlRex = new (@".*\/chapter-([0-9\-]+).*");
+        
+        List<Chapter> chapters = new();
+        foreach (string url in urls)
+        {
+            Match rexMatch = urlRex.Match(url);
+
+            if(!ChapterNumber.CanParse(rexMatch.Groups[1].Value))
+                continue;
+            ChapterNumber chapterNumber = new(rexMatch.Groups[1].Value);
+            string fullUrl = url;
+            try
+            {
+                chapters.Add(new Chapter(manga, fullUrl, chapterNumber, null, null));
+            }
+            catch (Exception e)
+            {
+            }
+        }
+        //Return Chapters ordered by Chapter-Number
+        return chapters.Order().ToArray();
+    }
+
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        RequestResult requestResult = this.downloadClient.MakeRequest(chapter.Url, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+        {
+            return [];
+        }
+
+        HtmlDocument document = requestResult.htmlDocument;
+        
+        HtmlNode[] images = document.DocumentNode.SelectNodes("//a[contains(concat(' ',normalize-space(@class),' '),' readImg ')]/img").ToArray();
+        List<string> urls = images.Select(node => node.GetAttributeValue("src", "")).ToList();
+        return urls.ToArray();
+    }
+}

API/Schema/MangaConnectors/WeebCentral.cs

@@ -0,0 +1,228 @@
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+using Soenneker.Utils.String.NeedlemanWunsch;
+
+namespace API.Schema.MangaConnectors;
+
+public class Weebcentral : MangaConnector
+{
+    private readonly string _baseUrl = "https://weebcentral.com";
+
+    private readonly string[] _filterWords =
+        { "a", "the", "of", "as", "to", "no", "for", "on", "with", "be", "and", "in", "wa", "at", "be", "ni" };
+
+    public Weebcentral() : base("Weebcentral", ["en"], ["https://weebcentral.com"])
+    {
+        downloadClient = new ChromiumDownloadClient();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
+    {
+        const int limit = 32; //How many values we want returned at once
+        var offset = 0; //"Page"
+        var requestUrl =
+            $"{_baseUrl}/search/data?limit={limit}&offset={offset}&text={publicationTitle}&sort=Best+Match&order=Ascending&official=Any&display_mode=Minimal%20Display";
+        var requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 ||
+            requestResult.htmlDocument == null)
+        {
+            return [];
+        }
+
+        var publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
+
+        return publications;
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(HtmlDocument document)
+    {
+        if (document.DocumentNode.SelectNodes("//article") == null)
+            return [];
+
+        var urls = document.DocumentNode.SelectNodes("/html/body/article/a[@class='link link-hover']")
+            .Select(elem => elem.GetAttributeValue("href", "")).ToList();
+
+        List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
+        foreach (var url in urls)
+        {
+            var manga = GetMangaFromUrl(url);
+            if (manga is { } x)
+                ret.Add(x);
+        }
+
+        return ret.ToArray();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
+    {
+        Regex publicationIdRex = new(@"https:\/\/weebcentral\.com\/series\/(\w*)\/(.*)");
+        var publicationId = publicationIdRex.Match(url).Groups[1].Value;
+
+        var requestResult = downloadClient.MakeRequest(url, RequestType.MangaInfo);
+        if ((int)requestResult.statusCode < 300 && (int)requestResult.statusCode >= 200 &&
+            requestResult.htmlDocument is not null)
+            return ParseSinglePublicationFromHtml(requestResult.htmlDocument, publicationId, url);
+        return null;
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    {
+        var posterNode =
+            document.DocumentNode.SelectSingleNode("//section[@class='flex items-center justify-center']/picture/img");
+        var coverUrl = posterNode?.GetAttributeValue("src", "") ?? "";
+
+        var titleNode = document.DocumentNode.SelectSingleNode("//section/h1");
+        var sortName = titleNode?.InnerText ?? "Undefined";
+
+        HtmlNode[] authorsNodes =
+            document.DocumentNode.SelectNodes("//ul/li[strong/text() = 'Author(s): ']/span")?.ToArray() ?? [];
+        var authorNames = authorsNodes.Select(n => n.InnerText).ToList();
+        List<Author> authors = authorNames.Select(n => new Author(n)).ToList();
+
+        HtmlNode[] genreNodes =
+            document.DocumentNode.SelectNodes("//ul/li[strong/text() = 'Tags(s): ']/span")?.ToArray() ?? [];
+        HashSet<string> tags = genreNodes.Select(n => n.InnerText).ToHashSet();
+        List<MangaTag> mangaTags = tags.Select(t => new MangaTag(t)).ToList();
+
+        var statusNode = document.DocumentNode.SelectSingleNode("//ul/li[strong/text() = 'Status: ']/a");
+        var status = statusNode?.InnerText ?? "";
+        var releaseStatus = MangaReleaseStatus.Unreleased;
+        switch (status.ToLower())
+        {
+            case "cancelled": releaseStatus = MangaReleaseStatus.Cancelled; break;
+            case "hiatus": releaseStatus = MangaReleaseStatus.OnHiatus; break;
+            case "complete": releaseStatus = MangaReleaseStatus.Completed; break;
+            case "ongoing": releaseStatus = MangaReleaseStatus.Continuing; break;
+        }
+
+        var yearNode = document.DocumentNode.SelectSingleNode("//ul/li[strong/text() = 'Released: ']/span");
+        var year = uint.Parse(yearNode?.InnerText ?? "0");
+
+        var descriptionNode = document.DocumentNode.SelectSingleNode("//ul/li[strong/text() = 'Description']/p");
+        var description = descriptionNode?.InnerText ?? "Undefined";
+
+        HtmlNode[] altTitleNodes = document.DocumentNode
+            .SelectNodes("//ul/li[strong/text() = 'Associated Name(s)']/ul/li")?.ToArray() ?? [];
+        Dictionary<string, string> altTitlesDict = new(), links = new();
+        for (var i = 0; i < altTitleNodes.Length; i++)
+            altTitlesDict.Add(i.ToString(), altTitleNodes[i].InnerText);
+        List<MangaAltTitle> altTitles = altTitlesDict.Select(a => new MangaAltTitle(a.Key, a.Value)).ToList();
+
+        var originalLanguage = "";
+
+        Manga manga = new (publicationId, sortName, description, websiteUrl, coverUrl, null, year,
+            originalLanguage, releaseStatus, -1,
+            this, 
+            authors, 
+            mangaTags, 
+            [],
+            altTitles);
+		
+        return (manga, authors, mangaTags, [], altTitles);
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+    {
+        return GetMangaFromUrl($"https://weebcentral.com/series/{publicationId}");
+    }
+
+    private string ToFilteredString(string input)
+    {
+        return string.Join(' ', input.ToLower().Split(' ').Where(word => _filterWords.Contains(word) == false));
+    }
+
+    private SearchResult[] FilteredResults(string publicationTitle, SearchResult[] unfilteredSearchResults)
+    {
+        Dictionary<SearchResult, int> similarity = new();
+        foreach (var sr in unfilteredSearchResults)
+        {
+            List<int> scores = new();
+            var filteredPublicationString = ToFilteredString(publicationTitle);
+            var filteredSString = ToFilteredString(sr.s);
+            scores.Add(NeedlemanWunschStringUtil.CalculateSimilarity(filteredSString, filteredPublicationString));
+            foreach (var srA in sr.a)
+            {
+                var filteredAString = ToFilteredString(srA);
+                scores.Add(NeedlemanWunschStringUtil.CalculateSimilarity(filteredAString, filteredPublicationString));
+            }
+
+            similarity.Add(sr, scores.Sum() / scores.Count);
+        }
+
+        var ret = similarity.OrderBy(s => s.Value).Take(10).Select(s => s.Key).ToList();
+        return ret.ToArray();
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string language = "en")
+    {
+        var requestUrl = $"{_baseUrl}/series/{manga.MangaId}/full-chapter-list";
+        var requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return Array.Empty<Chapter>();
+
+        //Return Chapters ordered by Chapter-Number
+        if (requestResult.htmlDocument is null)
+            return Array.Empty<Chapter>();
+        var chapters = ParseChaptersFromHtml(manga, requestResult.htmlDocument);
+        return chapters.Order().ToArray();
+    }
+
+    private List<Chapter> ParseChaptersFromHtml(Manga manga, HtmlDocument document)
+    {
+        var chaptersWrapper = document.DocumentNode.SelectSingleNode("/html/body");
+
+        Regex chapterRex = new(@".* (\d+)");
+        Regex idRex = new(@"https:\/\/weebcentral\.com\/chapters\/(\w*)");
+
+        var ret = chaptersWrapper.Descendants("a").Select(elem =>
+        {
+            var url = elem.GetAttributeValue("href", "") ?? "Undefined";
+
+            if (!url.StartsWith("https://") && !url.StartsWith("http://"))
+                return new Chapter(manga, "undefined", new ChapterNumber(-1), null, null);
+
+            var idMatch = idRex.Match(url);
+            var id = idMatch.Success ? idMatch.Groups[1].Value : null;
+
+            var chapterNode = elem.SelectSingleNode("span[@class='grow flex items-center gap-2']/span")?.InnerText ??
+                              "Undefined";
+
+            var chapterNumberMatch = chapterRex.Match(chapterNode);
+
+            if(!chapterNumberMatch.Success || !ChapterNumber.CanParse(chapterNumberMatch.Groups[1].Value))
+                return new Chapter(manga, "undefined", new ChapterNumber(-1), null, null);
+            ChapterNumber chapterNumber = new(chapterNumberMatch.Groups[1].Value);
+            
+            return new Chapter(manga, url, chapterNumber, null, null);
+        }).Where(elem => elem.ChapterNumber < ChapterNumber.Zero && elem.Url != "undefined").ToList();
+
+        ret.Reverse();
+        return ret;
+    }
+
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        var requestResult = downloadClient.MakeRequest(chapter.Url, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 ||requestResult.htmlDocument is null)
+        {
+            return [];
+        }
+
+        var document = requestResult.htmlDocument;
+
+        var imageNodes =
+            document.DocumentNode.SelectNodes($"//section[@hx-get='{chapter.Url}/images']/img")?.ToArray() ?? [];
+        var urls = imageNodes.Select(imgNode => imgNode.GetAttributeValue("src", "")).ToArray();
+        return urls;
+    }
+
+    private struct SearchResult
+    {
+        public string i { get; set; }
+        public string s { get; set; }
+        public string[] a { get; set; }
+    }
+}

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,9 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("Tag")]
+public class MangaTag(string tag)
+{
+    public string Tag { get; init; } = tag;
+}

API/Schema/Notification.cs

@@ -0,0 +1,21 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("NotificationId")]
+public class Notification(string title, string message = "", NotificationUrgency urgency = NotificationUrgency.Normal, DateTime? date = null)
+{
+    [MaxLength(64)]
+    public string NotificationId { get; init; } = TokenGen.CreateToken("Notification", 64);
+
+    public NotificationUrgency Urgency { get; init; } = urgency;
+
+    public string Title { get; init; } = title;
+
+    public string Message { get; init; } = message;
+    
+    public DateTime Date { get; init; } = date ?? DateTime.UtcNow;
+    
+    public Notification() : this("") { }
+}

API/Schema/NotificationConnectors/Gotify.cs

@@ -0,0 +1,42 @@
+using System.Text;
+using Newtonsoft.Json;
+
+namespace API.Schema.NotificationConnectors;
+
+public class Gotify(string endpoint, string appToken)
+    : NotificationConnector(TokenGen.CreateToken(typeof(Gotify), 64), NotificationConnectorType.Gotify)
+{
+    public string Endpoint { get; init; } = endpoint;
+    public string AppToken { get; init; } = appToken;
+    
+    public override void SendNotification(string title, string notificationText)
+    {
+        MessageData message = new(title, notificationText);
+        HttpRequestMessage request = new(HttpMethod.Post, $"{endpoint}/message");
+        request.Headers.Add("X-Gotify-Key", this.AppToken);
+        request.Content = new StringContent(JsonConvert.SerializeObject(message, Formatting.None), Encoding.UTF8, "application/json");
+        HttpResponseMessage response = _client.Send(request);
+        if (!response.IsSuccessStatusCode)
+        {
+            StreamReader sr = new (response.Content.ReadAsStream());
+            //TODO
+        }
+    }
+    
+    private class MessageData
+    {
+        // ReSharper disable four times UnusedAutoPropertyAccessor.Local
+        public string message { get; }
+        public long priority { get; }
+        public string title { get; }
+        public Dictionary<string, object> extras { get; }
+
+        public MessageData(string title, string message)
+        {
+            this.title = title;
+            this.message = message;
+            this.extras = new();
+            this.priority = 4;
+        }
+    }
+}

API/Schema/NotificationConnectors/Lunasea.cs

@@ -0,0 +1,35 @@
+using System.Text;
+using Newtonsoft.Json;
+
+namespace API.Schema.NotificationConnectors;
+
+public class Lunasea(string id)
+    : NotificationConnector(TokenGen.CreateToken(typeof(Lunasea), 64), NotificationConnectorType.LunaSea)
+{
+    public string Id { get; init; } = id;
+    public override void SendNotification(string title, string notificationText)
+    {
+        MessageData message = new(title, notificationText);
+        HttpRequestMessage request = new(HttpMethod.Post, $"https://notify.lunasea.app/v1/custom/{id}");
+        request.Content = new StringContent(JsonConvert.SerializeObject(message, Formatting.None), Encoding.UTF8, "application/json");
+        HttpResponseMessage response = _client.Send(request);
+        if (!response.IsSuccessStatusCode)
+        {
+            StreamReader sr = new (response.Content.ReadAsStream());
+            //TODO
+        }
+    }
+
+    private class MessageData
+    {
+        // ReSharper disable twice UnusedAutoPropertyAccessor.Local
+        public string title { get; }
+        public string body { get; }
+
+        public MessageData(string title, string body)
+        {
+            this.title = title;
+            this.body = body;
+        }
+    }
+}

API/Schema/NotificationConnectors/NotificationConnector.cs

@@ -0,0 +1,20 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+
+namespace API.Schema.NotificationConnectors;
+
+[PrimaryKey("NotificationConnectorId")]
+public abstract class NotificationConnector(string notificationConnectorId, NotificationConnectorType notificationConnectorType)
+{
+    [MaxLength(64)]
+    public string NotificationConnectorId { get; } = notificationConnectorId;
+    public NotificationConnectorType NotificationConnectorType { get; init; } = notificationConnectorType;
+    
+    [JsonIgnore]
+    [NotMapped]
+    protected readonly HttpClient _client = new();
+    
+    public abstract void SendNotification(string title, string notificationText);
+}

API/Schema/NotificationConnectors/NotificationConnectorType.cs

@@ -0,0 +1,9 @@
+namespace API.Schema.NotificationConnectors;
+
+
+public enum NotificationConnectorType : byte
+{
+    Gotify = 0,
+    LunaSea = 1,
+    Ntfy = 2
+}

API/Schema/NotificationConnectors/Ntfy.cs

@@ -0,0 +1,77 @@
+using System.Text;
+using System.Text.RegularExpressions;
+using Newtonsoft.Json;
+
+namespace API.Schema.NotificationConnectors;
+
+public class Ntfy : NotificationConnector
+{
+    private NotificationConnector _notificationConnectorImplementation;
+    public string Endpoint { get; init; }
+    public string Auth { get; init; }
+    public string Topic { get; init; }
+
+    public Ntfy(string endpoint, string auth, string topic): base(TokenGen.CreateToken(typeof(Ntfy), 64), NotificationConnectorType.Ntfy)
+    {
+        Endpoint = endpoint;
+        Auth = auth;
+        Topic = topic;
+    }
+    
+    public Ntfy(string endpoint, string username, string password, string? topic = null) : 
+        this(EndpointAndTopicFromUrl(endpoint)[0], topic??EndpointAndTopicFromUrl(endpoint)[1], AuthFromUsernamePassword(username, password))
+    {
+        
+    }
+
+    private static string AuthFromUsernamePassword(string username, string password)
+    {
+        string authHeader = "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{password}"));
+        string authParam = Convert.ToBase64String(Encoding.UTF8.GetBytes(authHeader)).Replace("=","");
+        return authParam;
+    }
+
+    private static string[] EndpointAndTopicFromUrl(string url)
+    {
+        string[] ret = new string[2];
+        Regex rootUriRex = new(@"(https?:\/\/[a-zA-Z0-9-\.]+\.[a-zA-Z0-9]+)(?:\/([a-zA-Z0-9-\.]+))?.*");
+        Match match = rootUriRex.Match(url);
+        if(!match.Success)
+            throw new ArgumentException($"Error getting URI from provided endpoint-URI: {url}");
+        
+        ret[0] = match.Groups[1].Value;
+        ret[1] = match.Groups[2].Success && match.Groups[2].Value.Length > 0 ? match.Groups[2].Value : "tranga";
+
+        return ret;
+    }
+    
+    public override void SendNotification(string title, string notificationText)
+    {
+        MessageData message = new(title, Topic, notificationText);
+        HttpRequestMessage request = new(HttpMethod.Post, $"{this.Endpoint}?auth={this.Auth}");
+        request.Content = new StringContent(JsonConvert.SerializeObject(message, Formatting.None), Encoding.UTF8, "application/json");
+        HttpResponseMessage response = _client.Send(request);
+        if (!response.IsSuccessStatusCode)
+        {
+            StreamReader sr = new (response.Content.ReadAsStream());
+            //TODO
+        }
+    }
+
+    private class MessageData
+    {
+        // ReSharper disable UnusedAutoPropertyAccessor.Local
+        public string topic { get; }
+        public string title { get; }
+        public string message { get; }
+        public int priority { get; }
+
+        public MessageData(string title, string topic, string message)
+        {
+            this.topic = topic;
+            this.title = title;
+            this.message = message;
+            this.priority = 3;
+        }
+    }
+}

API/Schema/NotificationUrgency.cs

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

API/Schema/PgsqlContext.cs

@@ -0,0 +1,109 @@
+using API.Schema.Jobs;
+using API.Schema.LibraryConnectors;
+using API.Schema.MangaConnectors;
+using API.Schema.NotificationConnectors;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(options)
+{
+    public DbSet<Job> Jobs { get; set; }
+    public DbSet<MangaConnector> MangaConnectors { get; set; }
+    public DbSet<Manga> Manga { get; set; }
+    public DbSet<Chapter> Chapters { get; set; }
+    public DbSet<Author> Authors { get; set; }
+    public DbSet<Link> Link { get; set; }
+    public DbSet<MangaTag> Tags { get; set; }
+    public DbSet<MangaAltTitle> AltTitles { get; set; }
+    public DbSet<LibraryConnector> LibraryConnectors { get; set; }
+    public DbSet<NotificationConnector> NotificationConnectors { get; set; }
+    public DbSet<Notification> Notifications { get; set; }
+    
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.Entity<MangaConnector>()
+            .HasDiscriminator(c => c.Name)
+            .HasValue<AsuraToon>("AsuraToon")
+            .HasValue<Bato>("Bato")
+            .HasValue<MangaHere>("MangaHere")
+            .HasValue<MangaKatana>("MangaKatana")
+            .HasValue<MangaLife>("Manga4Life")
+            .HasValue<Manganato>("Manganato")
+            .HasValue<Mangasee>("Mangasee")
+            .HasValue<Mangaworld>("Mangaworld")
+            .HasValue<ManhuaPlus>("ManhuaPlus")
+            .HasValue<Weebcentral>("Weebcentral")
+            .HasValue<MangaDex>("MangaDex");
+        modelBuilder.Entity<LibraryConnector>()
+            .HasDiscriminator<LibraryType>(l => l.LibraryType)
+            .HasValue<Komga>(LibraryType.Komga)
+            .HasValue<Kavita>(LibraryType.Kavita);
+        modelBuilder.Entity<NotificationConnector>()
+            .HasDiscriminator<NotificationConnectorType>(n => n.NotificationConnectorType)
+            .HasValue<Gotify>(NotificationConnectorType.Gotify)
+            .HasValue<Ntfy>(NotificationConnectorType.Ntfy)
+            .HasValue<Lunasea>(NotificationConnectorType.LunaSea);
+        
+        modelBuilder.Entity<Job>()
+            .HasDiscriminator<JobType>(j => j.JobType)
+            .HasValue<MoveFileOrFolderJob>(JobType.MoveFileOrFolderJob)
+            .HasValue<DownloadNewChaptersJob>(JobType.DownloadNewChaptersJob)
+            .HasValue<DownloadSingleChapterJob>(JobType.DownloadSingleChapterJob)
+            .HasValue<UpdateMetadataJob>(JobType.UpdateMetaDataJob);
+        modelBuilder.Entity<Job>()
+            .HasOne<Job>(j => j.ParentJob)
+            .WithMany()
+            .HasForeignKey(j => j.ParentJobId);
+        modelBuilder.Entity<Job>()
+            .HasMany<Job>(j => j.DependsOnJobs);
+        modelBuilder.Entity<DownloadNewChaptersJob>()
+            .Navigation(dncj => dncj.Manga)
+            .AutoInclude();
+        modelBuilder.Entity<DownloadSingleChapterJob>()
+            .Navigation(dscj => dscj.Chapter)
+            .AutoInclude();
+        modelBuilder.Entity<UpdateMetadataJob>()
+            .Navigation(umj => umj.Manga)
+            .AutoInclude();
+
+        modelBuilder.Entity<Manga>()
+            .HasOne<MangaConnector>(m => m.MangaConnector)
+            .WithMany()
+            .HasForeignKey(m => m.MangaConnectorId);
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.MangaConnector)
+            .AutoInclude();
+        modelBuilder.Entity<Manga>()
+            .HasMany<Author>(m => m.Authors)
+            .WithMany();
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.Authors)
+            .AutoInclude();
+        modelBuilder.Entity<Manga>()
+            .HasMany<MangaTag>(m => m.Tags)
+            .WithMany();
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.Tags)
+            .AutoInclude();
+        modelBuilder.Entity<Manga>()
+            .HasMany<Link>(m => m.Links)
+            .WithOne();
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.Links)
+            .AutoInclude();
+        modelBuilder.Entity<Manga>()
+            .HasMany<MangaAltTitle>(m => m.AltTitles)
+            .WithOne();
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.AltTitles)
+            .AutoInclude();
+        modelBuilder.Entity<Chapter>()
+            .HasOne<Manga>(c => c.ParentManga)
+            .WithMany()
+            .HasForeignKey(c => c.ParentMangaId);
+        modelBuilder.Entity<Chapter>()
+            .Navigation(c => c.ParentManga)
+            .AutoInclude();
+    }
+}

API/TokenGen.cs

@@ -0,0 +1,40 @@
+using System.Security.Cryptography;
+using System.Text;
+
+namespace API;
+
+public static class TokenGen
+{
+    private const uint MinimumLength = 8;
+    private const string Chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+
+    public static string CreateToken(Type t, uint fullLength) => CreateToken(t.Name, fullLength);
+    
+    public static string CreateToken(string prefix, uint fullLength)
+    {
+        if (prefix.Length + 1 >= fullLength - MinimumLength)
+            throw new ArgumentException("Prefix to long to create Token of meaningful length.");
+        long l = fullLength - prefix.Length - 1;
+        byte[] rng = new byte[l];
+        RandomNumberGenerator.Create().GetBytes(rng);
+        string key = new (rng.Select(b => Chars[b % Chars.Length]).ToArray());
+        key = string.Join('-', prefix, key);
+        return key;
+    }
+
+    public static string CreateTokenHash(string prefix, uint fullLength, string[] keys)
+    {
+        if (prefix.Length + 1 >= fullLength - MinimumLength)
+            throw new ArgumentException("Prefix to long to create Token of meaningful length.");
+        int l = (int)(fullLength - prefix.Length - 1);
+        MD5 md5 = MD5.Create();
+        byte[][] hashes = keys.Select(key => md5.ComputeHash(Encoding.UTF8.GetBytes(key))).ToArray();
+        byte[] xOrHash = new byte[l];
+        foreach (byte[] hash in hashes)
+            for(int i = 0; i < hash.Length; i++)
+                xOrHash[i] = (byte)(xOrHash[i] ^ (i >= hash.Length ? 0 : hash[i]));
+        string key = new (xOrHash.Select(b => Chars[b % Chars.Length]).ToArray());
+        key = string.Join('-', prefix, key);
+        return key;
+    }
+}

API/Tranga.cs

@@ -0,0 +1,104 @@
+using API.Schema;
+using API.Schema.Jobs;
+using API.Schema.NotificationConnectors;
+using log4net;
+using log4net.Config;
+
+namespace API;
+
+public static class Tranga
+{
+    public static Thread NotificationSenderThread { get; } = new (NotificationSender);
+    public static Thread JobStarterThread { get; } = new (JobStarter);
+    private static readonly Dictionary<Thread, Job> RunningJobs = new();
+    private static readonly ILog Log = LogManager.GetLogger(typeof(Tranga));
+
+    internal static void StartLogger()
+    {
+        BasicConfigurator.Configure();
+    }
+
+    private static void NotificationSender(object? pgsqlContext)
+    {
+        if(pgsqlContext is null) return;
+        PgsqlContext context = (PgsqlContext)pgsqlContext;
+
+        IQueryable<Notification> staleNotifications = context.Notifications.Where(n => n.Urgency < NotificationUrgency.Normal);
+        context.Notifications.RemoveRange(staleNotifications);
+        context.SaveChanges();
+        while (true)
+        {
+            SendNotifications(context, NotificationUrgency.High);
+            SendNotifications(context, NotificationUrgency.Normal);
+            SendNotifications(context, NotificationUrgency.Low);
+            
+            context.SaveChanges();
+            Thread.Sleep(2000);
+        }
+    }
+
+    private static void SendNotifications(PgsqlContext context, NotificationUrgency urgency)
+    {
+        List<Notification> notifications = context.Notifications.Where(n => n.Urgency == urgency).ToList();
+        if (notifications.Any())
+        {
+            DateTime max = notifications.MaxBy(n => n.Date)!.Date;
+            if (DateTime.Now.Subtract(max) > TrangaSettings.NotificationUrgencyDelay(urgency))
+            {
+                foreach (NotificationConnector notificationConnector in context.NotificationConnectors)
+                {
+                    foreach (Notification notification in notifications)
+                        notificationConnector.SendNotification(notification.Title, notification.Message);
+                }
+                context.Notifications.RemoveRange(notifications);
+            }
+        }
+        context.SaveChanges();
+    }
+
+    private static void JobStarter(object? pgsqlContext)
+    {
+        if(pgsqlContext is null) return;
+        PgsqlContext context = (PgsqlContext)pgsqlContext;
+        
+        string TRANGA = "\n\n _______                                   \n|_     _|.----..---.-..-----..-----..---.-.\n  |   |  |   _||  _  ||     ||  _  ||  _  |\n  |___|  |__|  |___._||__|__||___  ||___._|\n                             |_____|       \n\n";
+        Log.Info(TRANGA);
+        while (true)
+        {
+            List<Job> completedJobs = context.Jobs.Where(j => j.state == JobState.Completed).ToList();
+            foreach (Job job in completedJobs)
+                if(job.RecurrenceMs <= 0)
+                    context.Jobs.Remove(job);
+                else
+                {
+                    job.LastExecution = DateTime.UtcNow;
+                    job.state = JobState.Waiting;
+                    context.Jobs.Update(job);
+                }
+            
+            List<Job> runJobs = context.Jobs.Where(j => j.state <= JobState.Running).ToList().Where(j => j.NextExecution < DateTime.UtcNow).ToList();
+            foreach (Job job in runJobs)
+            {
+                Thread t = new (() =>
+                {
+                    IEnumerable<Job> newJobs = job.Run(context);
+                    context.Jobs.AddRange(newJobs);
+                });
+                RunningJobs.Add(t, job);
+                t.Start();
+                context.Jobs.Update(job);
+            }
+
+            (Thread, Job)[] removeFromThreadsList = RunningJobs.Where(t => !t.Key.IsAlive)
+                .Select(t => (t.Key, t.Value)).ToArray();
+            foreach ((Thread thread, Job job) thread in removeFromThreadsList)
+            {
+                RunningJobs.Remove(thread.thread);
+                context.Jobs.Update(thread.job);
+            }
+            
+            context.SaveChanges();
+            Thread.Sleep(2000);
+        }
+    }
+}

API/TrangaSettings.cs

@@ -0,0 +1,191 @@
+using System.Runtime.InteropServices;
+using API.MangaDownloadClients;
+using API.Schema;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using static System.IO.UnixFileMode;
+
+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");
+    public static int apiPortNumber { get; private set; } = 6531;
+    [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;
+    [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;
+    [JsonIgnore]
+    internal static readonly Dictionary<RequestType, int> DefaultRequestLimits = new ()
+    {
+        {RequestType.MangaInfo, 250},
+        {RequestType.MangaDexFeed, 250},
+        {RequestType.MangaDexImage, 40},
+        {RequestType.MangaImage, 60},
+        {RequestType.MangaCover, 250},
+        {RequestType.Default, 60}
+    };
+    public static Dictionary<RequestType, int> requestLimits { get; 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)
+    };
+
+    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 UpdateDownloadLocation(string newPath, bool moveFiles = true)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            Directory.CreateDirectory(newPath, GroupRead | GroupWrite | None | OtherRead | OtherWrite | UserRead | UserWrite);
+        else
+            Directory.CreateDirectory(newPath);
+        
+        if (moveFiles)
+            MoveContentsOfDirectoryTo(TrangaSettings.downloadLocation, newPath);
+        
+        TrangaSettings.downloadLocation = newPath;
+        ExportSettings();
+    }
+
+    private static void MoveContentsOfDirectoryTo(string oldDir, string newDir)
+    {
+        string[] directoryPaths = Directory.GetDirectories(oldDir);
+        string[] filePaths = Directory.GetFiles(oldDir);
+        foreach (string file in filePaths)
+        {
+            string newPath = Path.Join(newDir, Path.GetFileName(file));
+            File.Move(file, newPath, true);
+        }
+        foreach(string directory in directoryPaths)
+        {
+            string? dirName = Path.GetDirectoryName(directory);
+            if(dirName is null)
+                continue;
+            string newPath = Path.Join(newDir, dirName);
+            if(Directory.Exists(newPath))
+                MoveContentsOfDirectoryTo(directory, newPath);
+            else
+                Directory.Move(directory, newPath);
+        }
+    }
+
+    public static void UpdateUserAgent(string? customUserAgent)
+    {
+        userAgent = customUserAgent ?? DefaultUserAgent;
+        ExportSettings();
+    }
+
+    public static void UpdateRateLimit(RequestType requestType, int newLimit)
+    {
+        requestLimits[requestType] = newLimit;
+        ExportSettings();
+    }
+
+    public static void ResetRateLimits()
+    {
+        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 JObject();
+        jobj.Add("downloadLocation", JToken.FromObject(downloadLocation));
+        jobj.Add("workingDirectory", JToken.FromObject(workingDirectory));
+        jobj.Add("apiPortNumber", JToken.FromObject(apiPortNumber));
+        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));
+        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("apiPortNumber", out JToken? apn))
+            apiPortNumber = apn.Value<int>();
+        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>()!;
+    }
+}

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"]

LICENSE.txt

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -0,0 +1,171 @@
+<!-- PROJECT LOGO -->
+<br />
+<div align="center">
+
+<h3 align="center">Tranga v2</h3>
+
+  <p align="center">
+    Automatic Manga and Metadata downloader 
+  </p>
+  <p align="center">
+    This is the API for <a href="https://github.com/C9Glax/tranga-website">Tranga-Website</a>  
+  </p>
+</div>
+
+<!-- TABLE OF CONTENTS -->
+<details>
+  <summary>Table of Contents</summary>
+  <ol>
+    <li>
+      <a href="#about-the-project">About The Project</a>
+      <ul>
+        <li><a href="#built-with">Built With</a></li>
+      </ul>
+    </li>
+    <li>
+      <a href="#getting-started">Getting Started</a>
+      <ul>
+        <li><a href="#prerequisites">Usage</a></li>
+        <li><a href="#prerequisites">Prerequisites</a></li>
+      </ul>
+    </li>
+    <li><a href="#roadmap">Roadmap</a></li>
+    <li><a href="#contributing">Contributing</a></li>
+    <li><a href="#license">License</a></li>
+    <li><a href="#acknowledgments">Acknowledgments</a></li>
+  </ol>
+</details>
+
+
+
+<!-- ABOUT THE PROJECT -->
+## About The Project
+
+Tranga can download Chapters and Metadata from "Scanlation" sites such as 
+
+- [MangaDex.org](https://mangadex.org/) (Multilingual)
+- [Manganato.com](https://manganato.com/) (en)
+- [Mangasee.com](https://mangasee123.com/) (en)
+- [MangaKatana.com](https://mangakatana.com) (en)
+- [Mangaworld.bz](https://www.mangaworld.bz/) (it)
+- [Bato.to](https://bato.to/v3x) (en)
+- [Manga4Life](https://manga4life.com) (en)
+- [ManhuaPlus](https://manhuaplus.org/) (en)
+- [MangaHere](https://www.mangahere.cc/) (en) (Their covers aren't scrapeable.)
+- [Weebcentral](https://weebcentral.com) (en)
+- ❓ Open an [issue](https://github.com/C9Glax/tranga/issues/new?assignees=&labels=New+Connector&projects=&template=new_connector.yml&title=%5BNew+Connector%5D%3A+)
+
+and trigger a library-scan with [Komga](https://komga.org/) and [Kavita](https://www.kavitareader.com/).  
+Notifications can be sent to your devices using [Gotify](https://gotify.net/), [LunaSea](https://www.lunasea.app/) or [Ntfy](https://ntfy.sh/
+).
+
+### What this does and doesn't do
+
+Tranga (this git-repo) will open a port (standard 6531) and listen for requests to add Jobs to Monitor and/or download specific Manga.
+The configuration is all done through HTTP-Requests. [Documentation](docs/API_Calls_v2.md)
+
+_**For a web-frontend use [tranga-website](https://github.com/C9Glax/tranga-website).**_
+
+This project downloads the images for a Manga from the specified Scanlation-Website and packages them with some metadata - from that same website - in a .cbz-archive (per chapter).  
+It does this on an interval, and checks for any Chapters (.cbz-Archive) not already existing in your specified Download-Location. (If you rename or move files, it will download those again)  
+Tranga can (if configured) trigger a scan in Komga or Kavita, however the directory in which the Manga reside has to be available to both Tranga and Komga/Kavita.
+
+The project doesn't manage metadata, and doesn't curate, change or enhance any information that isn't available on the selected Scanlation-Site.  
+It will blindly use whatever is scrapes (yes this is a glorified Web-scraper).
+
+
+### Inspiration:
+
+Because [Kaizoku](https://github.com/oae/kaizoku) was relying on [mangal](https://github.com/metafates/mangal) and mangal
+hasn't received bugfixes for its issues with Titles not showing up, or throwing errors because of illegal characters,
+there were no alternatives for automatic downloads. However, [Kaizoku](https://github.com/oae/kaizoku) certainly had a great Web-UI.
+
+That is why I wanted to create my own project, in a language I understand, and that I am able to maintain myself.
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+### Built With
+
+- .NET-Core
+- Newtonsoft.JSON
+- [PuppeteerSharp](https://www.puppeteersharp.com/)
+- [Html Agility Pack (HAP)](https://html-agility-pack.net/)
+- [Soenneker.Utils.String.NeedlemanWunsch](https://github.com/soenneker/soenneker.utils.string.needlemanwunsch)
+- [Sixlabors.ImageSharp](https://docs-v2.sixlabors.com/articles/imagesharp/index.html#license)
+- [zstd-wrapper](https://github.com/oleg-st/ZstdSharp) [zstd](https://github.com/facebook/zstd)
+- 💙 Blåhaj 🦈
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+## Star History
+
+<a href="https://star-history.com/#c9glax/tranga&Date">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=c9glax/tranga&type=Date&theme=dark" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=c9glax/tranga&type=Date" />
+   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=c9glax/tranga&type=Date" />
+ </picture>
+</a>
+
+<!-- GETTING STARTED -->
+## Getting Started
+
+### Docker
+
+Download [docker-compose.yaml](https://git.bernloehr.eu/glax/Tranga/src/branch/master/docker-compose.yaml) and configure to your needs.  
+Mount `/Manga` to wherever you want your chapters (`.cbz`-Archives) downloaded (where Komga/Kavita can access them).  
+The `docker-compose` also includes [tranga-website](https://github.com/C9Glax/tranga-website) as frontend. For its configuration refer to the repo README.
+
+For compatibility do not execute the compose as root (which you should not do anyways...) but as user that can
+access the folder.
+
+### Prerequisites
+
+#### To Build
+[.NET-Core 8.0 SDK](https://dotnet.microsoft.com/en-us/download/dotnet/8.0)
+#### To Run
+[.NET-Core 8.0 Runtime](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) scroll down a bit, should be on the right the second item.
+
+See the [open issues](https://github.com/C9Glax/tranga/issues) for a full list of proposed features (and known issues).
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+
+
+<!-- CONTRIBUTING -->
+## Contributing
+
+The following is copy & pasted:
+
+Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
+
+If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
+Don't forget to give the project a star! Thanks again!
+
+1. Fork the Project
+2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the Branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+
+
+<!-- LICENSE -->
+## License
+
+Distributed under the GNU GPLv3  License. See `LICENSE.txt` for more information.
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+
+
+<!-- ACKNOWLEDGMENTS -->
+## Acknowledgments
+
+* [Choose an Open Source License](https://choosealicense.com)
+* [Font Awesome](https://fontawesome.com)
+* [Best-README-Template](https://github.com/othneildrew/Best-README-Template/tree/master)
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>

Tranga-API/Dockerfile

@@ -1,20 +0,0 @@
-FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
-WORKDIR /app
-EXPOSE 80
-EXPOSE 443
-
-FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
-WORKDIR /src
-COPY ["Tranga-API/Tranga-API.csproj", "Tranga-API/"]
-RUN dotnet restore "Tranga-API/Tranga-API.csproj"
-COPY . .
-WORKDIR "/src/Tranga-API"
-RUN dotnet build "Tranga-API.csproj" -c Release -o /app/build
-
-FROM build AS publish
-RUN dotnet publish "Tranga-API.csproj" -c Release -o /app/publish /p:UseAppHost=false
-
-FROM base AS final
-WORKDIR /app
-COPY --from=publish /app/publish .
-ENTRYPOINT ["dotnet", "Tranga-API.dll"]

Tranga-API/Program.cs

@@ -1,51 +0,0 @@
-using System.Text.Json;
-using Tranga;
-using Tranga.Connectors;
-
-TaskManager taskManager = new TaskManager(Directory.GetCurrentDirectory());
-var builder = WebApplication.CreateBuilder(args);
-var app = builder.Build();
-
-app.MapGet("/GetConnectors", () => JsonSerializer.Serialize(taskManager.GetAvailableConnectors().Values.ToArray()));
-
-app.MapGet("/GetPublications", (string connectorName, string? title) =>
-{
-    Connector? connector = taskManager.GetAvailableConnectors().FirstOrDefault(c => c.Key == connectorName).Value;
-    if (connector is null)
-        JsonSerializer.Serialize($"Connector {connectorName} is not a known connector.");
-
-    Publication[] publications;
-    if (title is not null)
-        publications = connector.GetPublications(title);
-    else
-        publications = connector.GetPublications();
-
-    return JsonSerializer.Serialize(publications);
-});
-
-app.MapGet("/ListTasks", () => JsonSerializer.Serialize(taskManager.GetAllTasks()));
-
-app.MapGet("/CreateTask",
-    (TrangaTask.Task task, string connectorName, string? publicationName, TimeSpan reoccurrence, string language) =>
-    {
-        Publication? publication =
-            taskManager.GetAllPublications().FirstOrDefault(pub => pub.downloadUrl == publicationName);
-        if (publication is null)
-            JsonSerializer.Serialize($"Publication {publicationName} is unknown.");
-        
-        taskManager.AddTask(task, connectorName, publication, reoccurrence, language);
-        JsonSerializer.Serialize("Success");
-    });
-
-app.MapGet("/RemoveTask", (TrangaTask.Task task, string connector, string? publicationName) =>
-{
-    Publication? publication =
-        taskManager.GetAllPublications().FirstOrDefault(pub => pub.downloadUrl == publicationName);
-    if (publication is null)
-        JsonSerializer.Serialize($"Publication {publicationName} is unknown.");
-        
-    taskManager.RemoveTask(task, connector, publication);
-    JsonSerializer.Serialize("Success");
-});
-
-app.Run();

Tranga-API/Properties/launchSettings.json

@@ -1,37 +0,0 @@
-{
-  "iisSettings": {
-    "windowsAuthentication": false,
-    "anonymousAuthentication": true,
-    "iisExpress": {
-      "applicationUrl": "http://localhost:14826",
-      "sslPort": 44333
-    }
-  },
-  "profiles": {
-    "http": {
-      "commandName": "Project",
-      "dotnetRunMessages": true,
-      "launchBrowser": true,
-      "applicationUrl": "http://localhost:5119",
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      }
-    },
-    "https": {
-      "commandName": "Project",
-      "dotnetRunMessages": true,
-      "launchBrowser": true,
-      "applicationUrl": "https://localhost:7070;http://localhost:5119",
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      }
-    },
-    "IIS Express": {
-      "commandName": "IISExpress",
-      "launchBrowser": true,
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      }
-    }
-  }
-}

Tranga-API/Tranga-API.csproj

@@ -1,21 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
-
-    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
-        <Nullable>enable</Nullable>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <RootNamespace>Tranga_API</RootNamespace>
-        <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <Content Include="..\.dockerignore">
-        <Link>.dockerignore</Link>
-      </Content>
-    </ItemGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="..\Tranga\Tranga.csproj" />
-    </ItemGroup>
-
-</Project>

Tranga-API/tasks.json

@@ -1 +0,0 @@
-[{"reoccurrence":"00:00:00","lastExecuted":"2023-05-19T17:34:40.5349215+02:00","connectorName":"MangaDex","task":0,"publication":{"sortName":null,"description":null,"tags":null,"posterUrl":null,"year":null,"originalLanguage":null,"status":null,"folderName":null,"downloadUrl":null},"language":"en"}]

Tranga-CLI/Dockerfile

@@ -1,18 +0,0 @@
-FROM mcr.microsoft.com/dotnet/runtime:7.0 AS base
-WORKDIR /app
-
-FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
-WORKDIR /src
-COPY ["Tranga-CLI/Tranga-CLI.csproj", "Tranga-CLI/"]
-RUN dotnet restore "Tranga-CLI/Tranga-CLI.csproj"
-COPY . .
-WORKDIR "/src/Tranga-CLI"
-RUN dotnet build "Tranga-CLI.csproj" -c Release -o /app/build
-
-FROM build AS publish
-RUN dotnet publish "Tranga-CLI.csproj" -c Release -o /app/publish /p:UseAppHost=false
-
-FROM base AS final
-WORKDIR /app
-COPY --from=publish /app/publish .
-ENTRYPOINT ["dotnet", "Tranga-CLI.dll"]

Tranga-CLI/Tranga-CLI.csproj

@@ -1,22 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <OutputType>Exe</OutputType>
-        <TargetFramework>net7.0</TargetFramework>
-        <RootNamespace>Tranga_CLI</RootNamespace>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>enable</Nullable>
-        <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <Content Include="..\.dockerignore">
-        <Link>.dockerignore</Link>
-      </Content>
-    </ItemGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="..\Tranga\Tranga.csproj" />
-    </ItemGroup>
-
-</Project>

Tranga-CLI/Tranga_Cli.cs

@@ -1,254 +0,0 @@
-using System.Globalization;
-using Tranga;
-using Tranga.Connectors;
-
-namespace Tranga_CLI;
-
-public static class Tranga_Cli
-{
-    public static void Main(string[] args)
-    {
-        Console.WriteLine("Output folder path [standard D:]:");
-        string? folderPath = Console.ReadLine();
-        while(folderPath is null )
-            folderPath = Console.ReadLine();
-        if (folderPath.Length < 1)
-            folderPath = "D:";
-        
-        Console.Write("Mode (D: Interactive only, T: TaskManager):");
-        ConsoleKeyInfo mode = Console.ReadKey();
-        while (mode.Key != ConsoleKey.D && mode.Key != ConsoleKey.T)
-            mode = Console.ReadKey();
-        Console.WriteLine();
-        
-        if(mode.Key == ConsoleKey.D)
-            DownloadNow(folderPath);
-        else if (mode.Key == ConsoleKey.T)
-            TaskMode(folderPath);
-    }
-
-    private static void TaskMode(string folderPath)
-    {
-        TaskManager taskManager = new TaskManager(folderPath);
-        ConsoleKey selection = ConsoleKey.NoName;
-        int menu = 0;
-        while (selection != ConsoleKey.Escape && selection != ConsoleKey.Q)
-        {
-            switch (menu)
-            {
-                case 1:
-                    PrintTasks(taskManager);
-                    Console.WriteLine("Press any key.");
-                    Console.ReadKey();
-                    menu = 0;
-                    break;
-                case 2:
-                    Connector connector = SelectConnector(folderPath, taskManager.GetAvailableConnectors().Values.ToArray());
-                    TrangaTask.Task task = SelectTask();
-                    Publication? publication = null;
-                    if(task != TrangaTask.Task.UpdatePublications)
-                        publication = SelectPublication(connector);
-                    TimeSpan reoccurrence = SelectReoccurrence();
-                    taskManager.AddTask(task, connector.name, publication, reoccurrence, "en");
-                    Console.WriteLine($"{task} - {connector.name} - {publication?.sortName}");
-                    Console.WriteLine("Press any key.");
-                    Console.ReadKey();
-                    menu = 0;
-                    break;
-                case 3:
-                    RemoveTask(taskManager);
-                    Console.WriteLine("Press any key.");
-                    Console.ReadKey();
-                    menu = 0;
-                    break;
-                default:
-                    selection = Menu(folderPath);
-                    switch (selection)
-                    {
-                        case ConsoleKey.L:
-                            menu = 1;
-                            break;
-                        case ConsoleKey.C:
-                            menu = 2;
-                            break;
-                        case ConsoleKey.D:
-                            menu = 3;
-                            break;
-                        default:
-                            menu = 0;
-                            break;
-                    }
-                    break;
-            }
-        }
-        taskManager.Shutdown();
-    }
-
-    private static ConsoleKey Menu(string folderPath)
-    {
-        Console.Clear();
-        Console.WriteLine($"Download Folder: {folderPath}");
-        Console.WriteLine("Select Option:");
-        Console.WriteLine("L: List tasks");
-        Console.WriteLine("C: Create Task");
-        Console.WriteLine("D: Delete Task");
-        Console.WriteLine("Q: Exit with saving");
-        ConsoleKey selection = Console.ReadKey().Key;
-        Console.WriteLine();
-        return selection;
-    }
-
-    private static int PrintTasks(TaskManager taskManager)
-    {
-        Console.Clear();
-        TrangaTask[] tasks = taskManager.GetAllTasks();
-        int tIndex = 0;
-        Console.WriteLine("Tasks:");
-        foreach(TrangaTask trangaTask in tasks)
-            Console.WriteLine($"{tIndex++}: {trangaTask.task} - {trangaTask.reoccurrence} - {trangaTask.publication?.sortName} - {trangaTask.connectorName}");
-        return tasks.Length;
-    }
-
-    private static void RemoveTask(TaskManager taskManager)
-    {
-        int length = PrintTasks(taskManager);
-        
-        TrangaTask[] tasks = taskManager.GetAllTasks();
-        Console.WriteLine($"Select Task (0-{length - 1}):");
-
-        string? selectedTask = Console.ReadLine();
-        while(selectedTask is null || selectedTask.Length < 1)
-            selectedTask = Console.ReadLine();
-        int selectedTaskIndex = Convert.ToInt32(selectedTask);
-
-        taskManager.RemoveTask(tasks[selectedTaskIndex].task, tasks[selectedTaskIndex].connectorName, tasks[selectedTaskIndex].publication);
-    }
-
-    private static TrangaTask.Task SelectTask()
-    {
-        Console.Clear();
-        string[] taskNames = Enum.GetNames<TrangaTask.Task>();
-        
-        int tIndex = 0;
-        Console.WriteLine("Available Tasks:");
-        foreach (string taskName in taskNames)
-            Console.WriteLine($"{tIndex++}: {taskName}");
-        Console.WriteLine($"Select Task (0-{taskNames.Length - 1}):");
-
-        string? selectedTask = Console.ReadLine();
-        while(selectedTask is null || selectedTask.Length < 1)
-            selectedTask = Console.ReadLine();
-        int selectedTaskIndex = Convert.ToInt32(selectedTask);
-
-        string selectedTaskName = taskNames[selectedTaskIndex];
-        return Enum.Parse<TrangaTask.Task>(selectedTaskName);
-    }
-
-    private static TimeSpan SelectReoccurrence()
-    {
-        Console.WriteLine("Select reoccurrence Timer (Format hh:mm:ss):");
-        return TimeSpan.Parse(Console.ReadLine()!, new CultureInfo("en-US"));
-    }
-
-    private static void DownloadNow(string folderPath)
-    {
-        Connector connector = SelectConnector(folderPath);
-
-        Publication publication = SelectPublication(connector);
-        
-        Chapter[] downloadChapters = SelectChapters(connector, publication);
-
-        if (downloadChapters.Length > 0)
-        {
-            connector.DownloadCover(publication);
-            connector.SaveSeriesInfo(publication);
-        }
-
-        foreach (Chapter chapter in downloadChapters)
-        {
-            Console.WriteLine($"Downloading {publication.sortName} V{chapter.volumeNumber}C{chapter.chapterNumber}");
-            connector.DownloadChapter(publication, chapter);
-        }
-    }
-
-    private static Connector SelectConnector(string folderPath, Connector[]? availableConnectors = null)
-    {
-        Console.Clear();
-        Connector[] connectors = availableConnectors ?? new Connector[] { new MangaDex(folderPath) };
-        
-        int cIndex = 0;
-        Console.WriteLine("Connectors:");
-        foreach (Connector connector in connectors)
-            Console.WriteLine($"{cIndex++}: {connector.name}");
-        Console.WriteLine($"Select Connector (0-{connectors.Length - 1}):");
-
-        string? selectedConnector = Console.ReadLine();
-        while(selectedConnector is null || selectedConnector.Length < 1)
-            selectedConnector = Console.ReadLine();
-        int selectedConnectorIndex = Convert.ToInt32(selectedConnector);
-        
-        return connectors[selectedConnectorIndex];
-    }
-
-    private static Publication SelectPublication(Connector connector)
-    {
-        Console.Clear();
-        Console.WriteLine($"Connector: {connector.name}");
-        Console.WriteLine("Publication search query (leave empty for all):");
-        string? query = Console.ReadLine();
-
-        Publication[] publications = connector.GetPublications(query ?? "");
-        
-        int pIndex = 0;
-        Console.WriteLine("Publications:");
-        foreach(Publication publication in publications)
-            Console.WriteLine($"{pIndex++}: {publication.sortName}");
-        Console.WriteLine($"Select publication to Download (0-{publications.Length - 1}):");
-        
-        string? selected = Console.ReadLine();
-        while(selected is null || selected.Length < 1)
-            selected = Console.ReadLine();
-        return publications[Convert.ToInt32(selected)];
-    }
-
-    private static Chapter[] SelectChapters(Connector connector, Publication publication)
-    {
-        Console.Clear();
-        Console.WriteLine($"Connector: {connector.name} Publication: {publication.sortName}");
-        Chapter[] chapters = connector.GetChapters(publication, "en");
-        
-        int cIndex = 0;
-        Console.WriteLine("Chapters:");
-        foreach (Chapter ch in chapters)
-        {
-            string name = cIndex.ToString();
-            if (ch.name is not null && ch.name.Length > 0)
-                name = ch.name;
-            else if (ch.chapterNumber is not null && ch.chapterNumber.Length > 0)
-                name = ch.chapterNumber;
-            Console.WriteLine($"{cIndex++}: {name}");
-        }
-        Console.WriteLine($"Select Chapters to download (0-{chapters.Length - 1}) [range x-y or 'a' for all]: ");
-        string? selected = Console.ReadLine();
-        while(selected is null || selected.Length < 1)
-            selected = Console.ReadLine();
-
-        int start = 0;
-        int end = 0;
-        if (selected == "a")
-            end = chapters.Length - 1;
-        else if (selected.Contains('-'))
-        {
-            string[] split = selected.Split('-');
-            start = Convert.ToInt32(split[0]);
-            end = Convert.ToInt32(split[1]);
-        }
-        else
-        {
-            start = Convert.ToInt32(selected);
-            end = Convert.ToInt32(selected);
-        }
-        
-        return chapters.Skip(start).Take((end + 1)-start).ToArray();
-    }
-}

Tranga.sln

@@ -1,10 +1,6 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tranga", ".\Tranga\Tranga.csproj", "{545E81B9-D96B-4C8F-A97F-2C02414DE566}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tranga-CLI", "Tranga-CLI\Tranga-CLI.csproj", "{4899E3B2-B259-479A-B43E-042D043E9501}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tranga-API", "Tranga-API\Tranga-API.csproj", "{6284C936-4E90-486B-BC46-0AFAD85AD8EE}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "API", "API\API.csproj", "{EDB07E7B-351F-4FCC-9AEF-777838E5551E}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -12,17 +8,9 @@ Global
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{545E81B9-D96B-4C8F-A97F-2C02414DE566}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{545E81B9-D96B-4C8F-A97F-2C02414DE566}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{545E81B9-D96B-4C8F-A97F-2C02414DE566}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{545E81B9-D96B-4C8F-A97F-2C02414DE566}.Release|Any CPU.Build.0 = Release|Any CPU
-		{4899E3B2-B259-479A-B43E-042D043E9501}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4899E3B2-B259-479A-B43E-042D043E9501}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{4899E3B2-B259-479A-B43E-042D043E9501}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{4899E3B2-B259-479A-B43E-042D043E9501}.Release|Any CPU.Build.0 = Release|Any CPU
-		{6284C936-4E90-486B-BC46-0AFAD85AD8EE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6284C936-4E90-486B-BC46-0AFAD85AD8EE}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6284C936-4E90-486B-BC46-0AFAD85AD8EE}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{6284C936-4E90-486B-BC46-0AFAD85AD8EE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EDB07E7B-351F-4FCC-9AEF-777838E5551E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EDB07E7B-351F-4FCC-9AEF-777838E5551E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EDB07E7B-351F-4FCC-9AEF-777838E5551E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EDB07E7B-351F-4FCC-9AEF-777838E5551E}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

Tranga.sln.DotSettings

@@ -1,2 +1,14 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=altnames/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=authorsartists/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Gotify/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=jjob/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Komga/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=lunasea/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=mangakatana/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Manganato/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Mangasee/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Mangaworld/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Ntfy/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Taskmanager/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Tranga/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

Tranga/Chapter.cs

@@ -1,27 +0,0 @@
-using System.Globalization;
-
-namespace Tranga;
-
-public struct Chapter
-{
-    public Publication publication { get; }
-    public string? name { get; }
-    public string? volumeNumber { get; }
-    public string? chapterNumber { get; }
-    public string url { get; }
-    
-    public string fileName { get; }
-
-    public Chapter(Publication publication, string? name, string? volumeNumber, string? chapterNumber, string url)
-    {
-        this.publication = publication;
-        this.name = name;
-        this.volumeNumber = volumeNumber;
-        this.chapterNumber = chapterNumber;
-        this.url = url;
-        string chapterName = string.Concat((name ?? "").Split(Path.GetInvalidFileNameChars()));
-        double multiplied = Convert.ToDouble(chapterNumber, new NumberFormatInfo() { NumberDecimalSeparator = "." }) *
-                            Convert.ToInt32(volumeNumber);
-        this.fileName = $"{chapterName} - V{volumeNumber}C{chapterNumber} - {multiplied}";
-    }
-}

Tranga/Connector.cs

@@ -1,88 +0,0 @@
-using System.IO.Compression;
-using System.Net;
-
-namespace Tranga;
-
-public abstract class Connector
-{
-    public Connector(string downloadLocation)
-    {
-        this.downloadLocation = downloadLocation;
-    }
-    
-    internal string downloadLocation { get; }
-    public abstract string name { get; }
-    public abstract Publication[] GetPublications(string publicationTitle = "");
-    public abstract Chapter[] GetChapters(Publication publication, string language = "");
-    public abstract void DownloadChapter(Publication publication, Chapter chapter); //where to?
-    protected abstract void DownloadImage(string url, string savePath);
-    public abstract void DownloadCover(Publication publication);
-
-    protected void DownloadChapter(string[] imageUrls, string saveArchiveFilePath)
-    {
-        string tempFolder = Path.GetTempFileName();
-        File.Delete(tempFolder);
-        Directory.CreateDirectory(tempFolder);
-
-        int chapter = 0;
-        foreach (string imageUrl in imageUrls)
-        {
-            string[] split = imageUrl.Split('.');
-            string extension = split[split.Length - 1];
-            DownloadImage(imageUrl, Path.Join(tempFolder, $"{chapter++}.{extension}"));
-        }
-
-        string[] splitPath = saveArchiveFilePath.Split(Path.DirectorySeparatorChar);
-        string directoryPath = Path.Combine(splitPath.Take(splitPath.Length - 1).ToArray());
-        if (!Directory.Exists(directoryPath))
-            Directory.CreateDirectory(directoryPath);
-
-        string fullPath = $"{saveArchiveFilePath}.cbz";
-        File.Delete(fullPath);
-        ZipFile.CreateFromDirectory(tempFolder, fullPath);
-    }
-
-    public void SaveSeriesInfo(Publication publication)
-    {
-        string seriesInfoPath = Path.Join(downloadLocation, publication.folderName, "series.json");
-        if(!File.Exists(seriesInfoPath))
-            File.WriteAllText(seriesInfoPath,publication.GetSeriesInfo());
-    }
-
-    internal class DownloadClient
-    {
-        private readonly TimeSpan _requestSpeed;
-        private DateTime _lastRequest;
-        private static readonly HttpClient Client = new();
-
-        public DownloadClient(uint delay)
-        {
-            _requestSpeed = TimeSpan.FromMilliseconds(delay);
-            _lastRequest = DateTime.Now.Subtract(_requestSpeed);
-        }
-        
-        public RequestResult MakeRequest(string url)
-        {
-            while((DateTime.Now - _lastRequest) < _requestSpeed)
-                Thread.Sleep(10);
-            _lastRequest = DateTime.Now;
-
-            HttpRequestMessage requestMessage = new(HttpMethod.Get, url);
-            HttpResponseMessage response = Client.Send(requestMessage);
-            Stream resultString = response.IsSuccessStatusCode ? response.Content.ReadAsStream() : Stream.Null;
-            return new RequestResult(response.StatusCode, resultString);
-        }
-
-        public struct RequestResult
-        {
-            public HttpStatusCode statusCode { get; }
-            public Stream result { get; }
-
-            public RequestResult(HttpStatusCode statusCode, Stream result)
-            {
-                this.statusCode = statusCode;
-                this.result = result;
-            }
-        }
-    }
-}

Tranga/Connectors/MangaDex.cs

@@ -1,211 +0,0 @@
-using System.Globalization;
-using System.Text.Json;
-using System.Text.Json.Nodes;
-
-namespace Tranga.Connectors;
-public class MangaDex : Connector
-{
-    public override string name { get; }
-    private readonly DownloadClient _downloadClient = new (750);
-
-    public MangaDex(string downloadLocation) : base(downloadLocation)
-    {
-        name = "MangaDex";
-    }
-
-    public override Publication[] GetPublications(string publicationTitle = "")
-    {
-        const int limit = 100;
-        int offset = 0;
-        int total = int.MaxValue;
-        HashSet<Publication> publications = new();
-        while (offset < total)
-        {
-            DownloadClient.RequestResult requestResult = _downloadClient.MakeRequest($"https://api.mangadex.org/manga?limit={limit}&title={publicationTitle}&offset={offset}");
-            JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
-            offset += limit;
-            if (result is null)
-                break;
-            
-            total = result["total"]!.GetValue<int>();
-            JsonArray mangaInResult = result["data"]!.AsArray();
-            foreach (JsonNode? mangeNode in mangaInResult)
-            {
-                JsonObject manga = (JsonObject)mangeNode!;
-                JsonObject attributes = manga["attributes"]!.AsObject();
-                
-                string title = attributes["title"]!.AsObject().ContainsKey("en") && attributes["title"]!["en"] is not null
-                    ? attributes["title"]!["en"]!.GetValue<string>()
-                    : "";
-                
-                string? description = attributes["description"]!.AsObject().ContainsKey("en") && attributes["description"]!["en"] is not null
-                    ? attributes["description"]!["en"]!.GetValue<string?>()
-                    : null;
-
-                JsonArray altTitlesObject = attributes["altTitles"]!.AsArray();
-                string[,] altTitles = new string[altTitlesObject.Count, 2];
-                int titleIndex = 0;
-                foreach (JsonNode? altTitleNode in altTitlesObject)
-                {
-                    JsonObject altTitleObject = (JsonObject)altTitleNode!;
-                    string key = ((IDictionary<string, JsonNode?>)altTitleObject).Keys.ToArray()[0];
-                    altTitles[titleIndex, 0] = key;
-                    altTitles[titleIndex++, 1] = altTitleObject[key]!.GetValue<string>();
-                }
-
-                JsonArray tagsObject = attributes["tags"]!.AsArray();
-                HashSet<string> tags = new();
-                foreach (JsonNode? tagNode in tagsObject)
-                {
-                    JsonObject tagObject = (JsonObject)tagNode!;
-                    if(tagObject["attributes"]!["name"]!.AsObject().ContainsKey("en"))
-                        tags.Add(tagObject["attributes"]!["name"]!["en"]!.GetValue<string>());
-                }
-
-                string? poster = null;
-                if (manga.ContainsKey("relationships") && manga["relationships"] is not null)
-                {
-                    JsonArray relationships = manga["relationships"]!.AsArray();
-                    poster = relationships.FirstOrDefault(relationship => relationship!["type"]!.GetValue<string>() == "cover_art")!["id"]!.GetValue<string>();
-                }
-
-                string[,]? links = null;
-                if (attributes.ContainsKey("links") && attributes["links"] is not null)
-                {
-                    JsonObject linksObject = attributes["links"]!.AsObject();
-                    links = new string[linksObject.Count, 2];
-                    int linkIndex = 0;
-                    foreach (string key in ((IDictionary<string, JsonNode?>)linksObject).Keys)
-                    {
-                        links[linkIndex, 0] = key;
-                        links[linkIndex++, 1] = linksObject[key]!.GetValue<string>();
-                    }
-                }
-                
-                int? year = attributes.ContainsKey("year") && attributes["year"] is not null
-                    ? attributes["year"]!.GetValue<int?>()
-                    : null;
-
-                string? originalLanguage = attributes.ContainsKey("originalLanguage") && attributes["originalLanguage"] is not null
-                    ? attributes["originalLanguage"]!.GetValue<string?>()
-                    : null;
-                
-                string status = attributes["status"]!.GetValue<string>();
-
-                Publication pub = new Publication(
-                    title,
-                    description,
-                    altTitles,
-                    tags.ToArray(),
-                    poster,
-                    links,
-                    year,
-                    originalLanguage,
-                    status,
-                    manga["id"]!.GetValue<string>()
-                );
-                publications.Add(pub);
-            }
-        }
-
-        return publications.ToArray();
-    }
-
-    public override Chapter[] GetChapters(Publication publication, string language = "")
-    {
-        const int limit = 100;
-        int offset = 0;
-        string id = publication.downloadUrl;
-        int total = int.MaxValue;
-        List<Chapter> chapters = new();
-        while (offset < total)
-        {
-            DownloadClient.RequestResult requestResult =
-                _downloadClient.MakeRequest($"https://api.mangadex.org/manga/{id}/feed?limit={limit}&offset={offset}&translatedLanguage%5B%5D={language}");
-            JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
-            
-            offset += limit;
-            if (result is null)
-                break;
-            
-            total = result["total"]!.GetValue<int>();
-            JsonArray chaptersInResult = result["data"]!.AsArray();
-            foreach (JsonNode? jsonNode in chaptersInResult)
-            {
-                JsonObject chapter = (JsonObject)jsonNode!;
-                JsonObject attributes = chapter["attributes"]!.AsObject();
-                string chapterId = chapter["id"]!.GetValue<string>();
-                
-                string? title = attributes.ContainsKey("title") && attributes["title"] is not null
-                    ? attributes["title"]!.GetValue<string>()
-                    : null;
-                
-                string? volume = attributes.ContainsKey("volume") && attributes["volume"] is not null
-                    ? attributes["volume"]!.GetValue<string>()
-                    : null;
-                
-                string? chapterNum = attributes.ContainsKey("chapter") && attributes["chapter"] is not null
-                    ? attributes["chapter"]!.GetValue<string>()
-                    : null;
-                
-                chapters.Add(new Chapter(publication, title, volume, chapterNum, chapterId));
-            }
-        }
-
-        NumberFormatInfo chapterNumberFormatInfo = new()
-        {
-            NumberDecimalSeparator = "."
-        };
-        return chapters.OrderBy(chapter => Convert.ToSingle(chapter.chapterNumber, chapterNumberFormatInfo)).ToArray();
-    }
-
-    public override void DownloadChapter(Publication publication, Chapter chapter)
-    {
-        DownloadClient.RequestResult requestResult =
-            _downloadClient.MakeRequest($"https://api.mangadex.org/at-home/server/{chapter.url}?forcePort443=false'");
-        JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
-        if (result is null)
-            return;
-
-        string baseUrl = result["baseUrl"]!.GetValue<string>();
-        string hash = result["chapter"]!["hash"]!.GetValue<string>();
-        JsonArray imageFileNames = result["chapter"]!["data"]!.AsArray();
-        HashSet<string> imageUrls = new();
-        foreach (JsonNode? image in imageFileNames)
-            imageUrls.Add($"{baseUrl}/data/{hash}/{image!.GetValue<string>()}");
-
-        DownloadChapter(imageUrls.ToArray(), Path.Join(downloadLocation, publication.folderName, chapter.fileName));
-    }
-
-    protected override void DownloadImage(string url, string savePath)
-    {
-        DownloadClient.RequestResult requestResult = _downloadClient.MakeRequest(url);
-        byte[] buffer = new byte[requestResult.result.Length];
-        requestResult.result.ReadExactly(buffer, 0, buffer.Length);
-        File.WriteAllBytes(savePath, buffer);
-    }
-
-    public override void DownloadCover(Publication publication)
-    {
-        string publicationPath = Path.Join(downloadLocation, publication.folderName);
-        DirectoryInfo dirInfo = new DirectoryInfo(publicationPath);
-        foreach(FileInfo fileInfo in dirInfo.EnumerateFiles())
-            if (fileInfo.Name.Contains("cover."))
-                return;
-        
-        DownloadClient.RequestResult requestResult = _downloadClient.MakeRequest($"https://api.mangadex.org/cover/{publication.posterUrl}");
-        JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
-        if (result is null)
-            return;
-
-        string fileName = result!["data"]!["attributes"]!["fileName"]!.GetValue<string>();
-
-        string coverUrl = $"https://uploads.mangadex.org/covers/{publication.downloadUrl}/{fileName}";
-        string[] split = coverUrl.Split('.');
-        string extension = split[split.Length - 1];
-
-        string outFolderPath = Path.Join(downloadLocation, publication.folderName);
-        Directory.CreateDirectory(outFolderPath);
-        DownloadImage(coverUrl, Path.Join(downloadLocation, publication.folderName, $"cover.{extension}"));
-    }
-}

Tranga/Publication.cs

@@ -1,62 +0,0 @@
-using Newtonsoft.Json;
-
-namespace Tranga;
-
-public struct Publication
-{
-    public string sortName { get; }
-    [JsonIgnore]public string[,] altTitles { get; }
-    public string? description { get; }
-    public string[] tags { get; }
-    public string? posterUrl { get; }
-    [JsonIgnore]public string[,]? links { get; }
-    public int? year { get; }
-    public string? originalLanguage { get; }
-    public string status { get; }
-    public string folderName { get; }
-    public string downloadUrl { get; }
-
-    public Publication(string sortName, string? description, string[,] altTitles, string[] tags, string? posterUrl, string[,]? links, int? year, string? originalLanguage, string status, string downloadUrl)
-    {
-        this.sortName = sortName;
-        this.description = description;
-        this.altTitles = altTitles;
-        this.tags = tags;
-        this.posterUrl = posterUrl;
-        this.links = links;
-        this.year = year;
-        this.originalLanguage = originalLanguage;
-        this.status = status;
-        this.downloadUrl = downloadUrl;
-        this.folderName = string.Concat(sortName.Split(Path.GetInvalidPathChars()));
-    }
-
-    public string GetSeriesInfo()
-    {
-        SeriesInfo si = new (new Metadata(this.sortName, this.year.ToString() ?? string.Empty, this.status, this.description ?? ""));
-        return System.Text.Json.JsonSerializer.Serialize(si);
-    }
-    
-    internal struct SeriesInfo
-    {
-        [JsonRequired]public Metadata metadata { get; }
-        public SeriesInfo(Metadata metadata) => this.metadata = metadata;
-    }
-        
-    internal struct Metadata
-    {
-        [JsonRequired]public string name { get; }
-        [JsonRequired]public string year { get; }
-        [JsonRequired]public string status { get; }
-        // ReSharper disable twice InconsistentNaming
-        [JsonRequired]public string description_text { get; }
-
-        public Metadata(string name, string year, string status, string description_text)
-        {
-            this.name = name;
-            this.year = year;
-            this.status = status;
-            this.description_text = description_text;
-        }
-    }
-}

Tranga/TaskExecutor.cs

@@ -1,55 +0,0 @@
-namespace Tranga;
-
-public static class TaskExecutor
-{
-    public static void Execute(Connector[] connectors, TrangaTask trangaTask, Dictionary<Publication, List<Chapter>> chapterCollection)
-    {
-        Connector? connector = connectors.FirstOrDefault(c => c.name == trangaTask.connectorName);
-        if (connector is null)
-            throw new ArgumentException($"Connector {trangaTask.connectorName} is not a known connector.");
-        trangaTask.lastExecuted = DateTime.Now;
-        
-        switch (trangaTask.task)
-        {
-            case TrangaTask.Task.DownloadNewChapters:
-                DownloadNewChapters(connector, (Publication)trangaTask.publication!, trangaTask.language, chapterCollection);
-                break;
-            case TrangaTask.Task.UpdateChapters:
-                UpdateChapters(connector, (Publication)trangaTask.publication!, trangaTask.language, chapterCollection);
-                break;
-            case TrangaTask.Task.UpdatePublications:
-                UpdatePublications(connector, chapterCollection);
-                break;
-        }
-    }
-
-    private static void UpdatePublications(Connector connector, Dictionary<Publication, List<Chapter>> chapterCollection)
-    {
-        Publication[] publications = connector.GetPublications();
-        foreach (Publication publication in publications)
-            chapterCollection.TryAdd(publication, new List<Chapter>());
-    }
-
-    private static void DownloadNewChapters(Connector connector, Publication publication, string language, Dictionary<Publication, List<Chapter>> chapterCollection)
-    {
-        List<Chapter> newChapters = UpdateChapters(connector, publication, language, chapterCollection);
-        foreach(Chapter newChapter in newChapters)
-            connector.DownloadChapter(publication, newChapter);
-        connector.DownloadCover(publication);
-        connector.SaveSeriesInfo(publication);
-    }
-
-    private static List<Chapter> UpdateChapters(Connector connector, Publication publication, string language, Dictionary<Publication, List<Chapter>> chapterCollection)
-    {
-        List<Chapter> newChaptersList = new();
-        if (!chapterCollection.ContainsKey(publication))
-            return newChaptersList;
-        
-        List<Chapter> currentChapters = chapterCollection[publication];
-        Chapter[] newChapters = connector.GetChapters(publication, language);
-        
-        newChaptersList = newChapters.ToList()
-            .ExceptBy(currentChapters.Select(cChapter => cChapter.url), nChapter => nChapter.url).ToList();
-        return newChaptersList;
-    }
-}

Tranga/TaskManager.cs

@@ -1,105 +0,0 @@
-using Newtonsoft.Json;
-using Tranga.Connectors;
-
-namespace Tranga;
-
-public class TaskManager
-{
-    private readonly Dictionary<Publication, List<Chapter>> _chapterCollection;
-    private readonly HashSet<TrangaTask> _allTasks;
-    private bool _continueRunning = true;
-    private readonly Connector[] connectors;
-    private readonly string folderPath;
-
-    public TaskManager(string folderPath)
-    {
-        this.folderPath = folderPath;
-        this.connectors = new Connector[]{ new MangaDex(folderPath) };
-        _chapterCollection = new();
-        _allTasks = ImportTasks(Directory.GetCurrentDirectory());
-        Thread taskChecker = new(TaskCheckerThread);
-        taskChecker.Start();
-    }
-
-    private void TaskCheckerThread()
-    {
-        while (_continueRunning)
-        {
-            foreach (TrangaTask task in _allTasks)
-            {
-                if(task.ShouldExecute()) 
-                    TaskExecutor.Execute(this.connectors, task, this._chapterCollection);
-            }
-            Thread.Sleep(1000);
-        }
-    }
-
-    public void AddTask(TrangaTask.Task task, string connectorName, Publication? publication, TimeSpan reoccurrence,
-        string language = "")
-    {
-        Connector? connector = connectors.FirstOrDefault(c => c.name == connectorName);
-        if (connector is null)
-            throw new ArgumentException($"Connector {connectorName} is not a known connector.");
-        
-        if (!_allTasks.Any(trangaTask => trangaTask.task != task && trangaTask.connectorName != connector.name &&
-                                         trangaTask.publication?.downloadUrl != publication?.downloadUrl))
-        {
-            _allTasks.Add(new TrangaTask(connector.name, task, publication, reoccurrence, language));
-            ExportTasks(Directory.GetCurrentDirectory());
-        }
-    }
-
-    public void RemoveTask(TrangaTask.Task task, string connectorName, Publication? publication)
-    {
-        _allTasks.RemoveWhere(trangaTask =>
-            trangaTask.task == task && trangaTask.connectorName == connectorName &&
-            trangaTask.publication?.downloadUrl == publication?.downloadUrl);
-        ExportTasks(Directory.GetCurrentDirectory());
-    }
-
-    public Dictionary<string, Connector> GetAvailableConnectors()
-    {
-        return this.connectors.ToDictionary(connector => connector.name, connector => connector);
-    }
-
-    public TrangaTask[] GetAllTasks()
-    {
-        TrangaTask[] ret = new TrangaTask[_allTasks.Count];
-        _allTasks.CopyTo(ret);
-        return ret;
-    }
-
-    public Publication[] GetAllPublications()
-    {
-        return this._chapterCollection.Keys.ToArray();
-    }
-    
-    public void Shutdown()
-    {
-        _continueRunning = false;
-        ExportTasks(Directory.GetCurrentDirectory());
-    }
-
-    public HashSet<TrangaTask> ImportTasks(string importFolderPath)
-    {
-        string filePath = Path.Join(importFolderPath, "tasks.json");
-        if (!File.Exists(filePath))
-            return new HashSet<TrangaTask>();
-
-        string toRead = File.ReadAllText(filePath);
-
-        TrangaTask[] importTasks = JsonConvert.DeserializeObject<TrangaTask[]>(toRead)!;
-        
-        foreach(TrangaTask task in importTasks.Where(task => task.publication is not null))
-            this._chapterCollection.Add((Publication)task.publication!, new List<Chapter>());
-        
-        return importTasks.ToHashSet();
-    }
-
-    public void ExportTasks(string exportFolderPath)
-    {
-        string filePath = Path.Join(exportFolderPath, "tasks.json");
-        string toWrite = JsonConvert.SerializeObject(_allTasks.ToArray());
-        File.WriteAllText(filePath,toWrite);
-    }
-}

Tranga/Tranga.csproj

@@ -1,13 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>enable</Nullable>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    </ItemGroup>
-
-</Project>

Tranga/TrangaTask.cs

@@ -1,35 +0,0 @@
-namespace Tranga;
-
-public class TrangaTask
-{
-    public TimeSpan reoccurrence { get; }
-    public DateTime lastExecuted { get; set; }
-    public string connectorName { get; }
-    public Task task { get; }
-    public Publication? publication { get; }
-    public string language { get; }
-
-    public TrangaTask(string connectorName, Task task, Publication? publication, TimeSpan reoccurrence, string language = "")
-    {
-        if (task != Task.UpdatePublications && publication is null)
-            throw new ArgumentException($"Publication has to be not null for task {task}");
-        this.publication = publication;
-        this.reoccurrence = reoccurrence;
-        this.lastExecuted = DateTime.Now.Subtract(reoccurrence);
-        this.connectorName = connectorName;
-        this.task = task;
-        this.language = language;
-    }
-
-    public bool ShouldExecute()
-    {
-        return DateTime.Now.Subtract(this.lastExecuted) > reoccurrence;
-    }
-
-    public enum Task
-    {
-        UpdatePublications,
-        UpdateChapters,
-        DownloadNewChapters
-    }
-}

docker-compose.local.yaml

@@ -0,0 +1,33 @@
+version: '3'
+services:
+  tranga-api:
+    build:
+      dockerfile: Dockerfile
+      context: .
+    container_name: tranga-api
+    volumes:
+      - ./Manga:/Manga
+      - ./settings:/usr/share/tranga-api
+    ports:
+      - "6531:6531"
+    depends_on:
+      - tranga-pg
+    environment:
+      - POSTGRES_HOST=tranga-pg
+    restart: unless-stopped
+  tranga-website:
+    image: glax/tranga-website:latest
+    container_name: tranga-website
+    ports:
+      - "9555:80"
+    depends_on: 
+      - tranga-api
+    restart: unless-stopped
+  tranga-pg:
+    image: postgres:latest
+    container_name: tranga-pg
+    ports:
+      - "5432:5432"
+    environment:
+      - POSTGRES_PASSWORD=postgres
+    restart: unless-stopped

docker-compose.yaml

@@ -0,0 +1,31 @@
+version: '3'
+services:
+  tranga-api:
+    image: glax/tranga-api:latest
+    container_name: tranga-api
+    volumes:
+      - ./Manga:/Manga
+      - ./settings:/usr/share/tranga-api
+    ports:
+      - "6531:6531"
+    depends_on:
+      - tranga-pg
+    environment:
+      - POSTGRES_HOST=tranga-pg
+    restart: unless-stopped
+  tranga-website:
+    image: glax/tranga-website:latest
+    container_name: tranga-website
+    ports:
+      - "9555:80"
+    depends_on: 
+      - tranga-api
+    restart: unless-stopped
+  tranga-pg:
+    image: postgres:latest
+    container_name: tranga-pg
+    ports:
+      - "5432:5432"
+    environment:
+      - POSTGRES_PASSWORD=postgres
+    restart: unless-stopped