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

@@ -18,4 +18,10 @@ riderModule.iml
 /dataSources.local.xml
 /.idea
 cover.jpg
-cover.png
+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

@@ -1,22 +1,21 @@
-using System.Text.Json.Nodes;
-using Logging;
-using Newtonsoft.Json;
-using JsonSerializer = System.Text.Json.JsonSerializer;
+using System.Text.Json;
+using System.Text.Json.Nodes;
 
-namespace Tranga.LibraryManagers;
+namespace API.Schema.LibraryConnectors;
 
-public class Kavita : LibraryManager
+public class Kavita : LibraryConnector
 {
 
-    public Kavita(string baseUrl, string username, string password, Logger? logger) : base(baseUrl, GetToken(baseUrl, username, password), logger, LibraryType.Kavita)
+    public Kavita(string baseUrl, string auth) : base(TokenGen.CreateToken(typeof(Kavita), 64), LibraryType.Kavita, baseUrl, auth)
     {
     }
     
-    [JsonConstructor]
-    public Kavita(string baseUrl, string auth, Logger? logger) : base(baseUrl, auth, logger, LibraryType.Kavita)
+    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()
@@ -32,48 +31,65 @@ public class Kavita : LibraryManager
             RequestUri = new Uri($"{baseUrl}/api/Account/login"),
             Content = new StringContent($"{{\"username\":\"{username}\",\"password\":\"{password}\"}}", System.Text.Encoding.UTF8, "application/json")
         };
-        
-        HttpResponseMessage response = client.Send(requestMessage);
-        JsonObject? result = JsonSerializer.Deserialize<JsonObject>(response.Content.ReadAsStream());
-        if (result is not null)
-            return result!["token"]!.GetValue<string>();
-        else return "";
+        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 "";
     }
 
-    public override void UpdateLibrary()
+    protected override void UpdateLibraryInternal()
     {
-        logger?.WriteLine(this.GetType().ToString(), $"Updating Libraries");
         foreach (KavitaLibrary lib in GetLibraries())
-            NetClient.MakePost($"{baseUrl}/api/Library/scan?libraryId={lib.id}", "Bearer", auth, logger);
+            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()
     {
-        logger?.WriteLine(this.GetType().ToString(), $"Getting Libraries");
-        Stream data = NetClient.MakeRequest($"{baseUrl}/api/Library", "Bearer", auth, logger);
+        Stream data = NetClient.MakeRequest($"{BaseUrl}/api/Library/libraries", "Bearer", Auth);
         if (data == Stream.Null)
         {
-            logger?.WriteLine(this.GetType().ToString(), $"No libraries returned");
             return Array.Empty<KavitaLibrary>();
         }
         JsonArray? result = JsonSerializer.Deserialize<JsonArray>(data);
         if (result is null)
         {
-            logger?.WriteLine(this.GetType().ToString(), $"No libraries returned");
             return Array.Empty<KavitaLibrary>();
         }
 
-        HashSet<KavitaLibrary> ret = new();
+        List<KavitaLibrary> ret = new();
 
         foreach (JsonNode? jsonNode in result)
         {
-            var jObject = (JsonObject?)jsonNode;
+            JsonObject? jObject = (JsonObject?)jsonNode;
+            if(jObject is null)
+                continue;
             int libraryId = jObject!["id"]!.GetValue<int>();
-            string libraryName = jObject!["name"]!.GetValue<string>();
+            string libraryName = jObject["name"]!.GetValue<string>();
             ret.Add(new KavitaLibrary(libraryId, libraryName));
         }
 
@@ -83,6 +99,7 @@ public class Kavita : LibraryManager
     private struct KavitaLibrary
     {
         public int id { get; }
+        // ReSharper disable once UnusedAutoPropertyAccessor.Local
         public string name { get; }
 
         public KavitaLibrary(int id, string 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

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

Logging/FileLogger.cs

@@ -1,32 +0,0 @@
-using System.Text;
-using System.Text.Json.Serialization;
-
-namespace Logging;
-
-public class FileLogger : LoggerBase
-{
-    private string logFilePath { get; }
-    private const int MaxNumberOfLogFiles = 5;
-
-    public FileLogger(string logFilePath, TextWriter? stdOut, Encoding? encoding = null) : base (stdOut, encoding)
-    {
-        this.logFilePath = logFilePath;
-        
-        //Remove oldest logfile if more than MaxNumberOfLogFiles
-        string parentFolderPath = Path.GetDirectoryName(logFilePath)!;
-        for (int fileCount = new DirectoryInfo(parentFolderPath).EnumerateFiles().Count(); fileCount > MaxNumberOfLogFiles - 1; fileCount--) //-1 because we create own logfile later
-            File.Delete(new DirectoryInfo(parentFolderPath).EnumerateFiles().MinBy(file => file.LastWriteTime)!.FullName);
-    }
-    
-    protected override void Write(LogMessage logMessage)
-    {
-        try
-        {
-            File.AppendAllText(logFilePath, logMessage.ToString());
-        }
-        catch (Exception e)
-        {
-            stdOut?.WriteLine(e);
-        }
-    }
-}

Logging/FormattedConsoleLogger.cs

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

Logging/Logger.cs

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

Logging/LoggerBase.cs

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

Logging/Logging.csproj

@@ -1,9 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>enable</Nullable>
-    </PropertyGroup>
-
-</Project>

Logging/MemoryLogger.cs

@@ -1,57 +0,0 @@
-using System.Text;
-
-namespace Logging;
-
-public class MemoryLogger : LoggerBase
-{
-    private readonly SortedList<DateTime, LogMessage> _logMessages = new();
-    private int _lastLogMessageIndex = 0;
-
-    public MemoryLogger(TextWriter? stdOut, Encoding? encoding = null) : base(stdOut, encoding)
-    {
-        
-    }
-
-    protected override void Write(LogMessage value)
-    {
-        _logMessages.Add(value.logTime, value);
-    }
-
-    public string[] GetLogMessage()
-    {
-        return Tail(Convert.ToUInt32(_logMessages.Count));
-    }
-
-    public string[] Tail(uint? length)
-    {
-        int retLength;
-        if (length is null || length > _logMessages.Count)
-            retLength = _logMessages.Count;
-        else
-            retLength = (int)length;
-        
-        string[] ret = new string[retLength];
-
-        for (int retIndex = 0; retIndex < ret.Length; retIndex++)
-        {
-            ret[retIndex] = _logMessages.GetValueAtIndex(_logMessages.Count - retLength + retIndex).ToString();
-        }
-
-        _lastLogMessageIndex = _logMessages.Count - 1;
-        return ret;
-    }
-
-    public string[] GetNewLines()
-    {
-        int logMessageCount = _logMessages.Count;
-        string[] ret = new string[logMessageCount - _lastLogMessageIndex];
-
-        for (int retIndex = 0; retIndex < ret.Length; retIndex++)
-        {
-            ret[retIndex] = _logMessages.GetValueAtIndex(_lastLogMessageIndex + retIndex).ToString();
-        }
-
-        _lastLogMessageIndex = logMessageCount;
-        return ret;
-    }
-}

README.md

@@ -1,25 +1,17 @@
-<!-- PROJECT SHIELDS -->
-<!--
-*** I'm using markdown "reference style" links for readability.
-*** Reference links are enclosed in brackets [ ] instead of parentheses ( ).
-*** See the bottom of this document for the declaration of the reference variables
-*** for contributors-url, forks-url, etc. This is an optional, concise syntax you may use.
-*** https://www.markdownguide.org/basic-syntax/#reference-style-links
--->
-
 <!-- PROJECT LOGO -->
 <br />
 <div align="center">
 
-<h3 align="center">Tranga</h3>
+<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>
@@ -30,12 +22,10 @@
         <li><a href="#built-with">Built With</a></li>
       </ul>
     </li>
-    <li>
-      <a href="#screenshots">Screenshots</a>
-    </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>
@@ -51,19 +41,44 @@
 <!-- ABOUT THE PROJECT -->
 ## About The Project
 
-Tranga can download Chapters and Metadata from Scanlation sites such as 
+Tranga can download Chapters and Metadata from "Scanlation" sites such as 
 
-- [MangaDex.org](https://mangadex.org/)
-- [Manganato.com](https://manganato.com/)
-- [Mangasee](https://mangasee123.com/)
+- [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).
 
-and automatically start updates in [Komga](https://komga.org/) and [Kavita](https://www.kavitareader.com/) to import them.
 
 ### Inspiration:
 
 Because [Kaizoku](https://github.com/oae/kaizoku) was relying on [mangal](https://github.com/metafates/mangal) and mangal
-hasn't received bugfixes for it's 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.
+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.
 
@@ -75,51 +90,43 @@ That is why I wanted to create my own project, in a language I understand, and t
 - Newtonsoft.JSON
 - [PuppeteerSharp](https://www.puppeteersharp.com/)
 - [Html Agility Pack (HAP)](https://html-agility-pack.net/)
-- Love <3 Blåhaj 🦈
+- [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
 
-## Screenshots
-
-![image](screenshots/overview.png)
-
-![image](screenshots/addtask.png)
-
-| ![image](screenshots/settings.png) | ![image](screenshots/publication-description.png) |
-|-----------------------------------:|:-------------------------------------------------:|
-
-<p align="right">(<a href="#readme-top">back to top</a>)</p>
+<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
 
-There is two release types:
-
-- CLI
-- Docker
-
-### CLI
-
-Head over to [releases](https://git.bernloehr.eu/glax/Tranga/releases) and download. The CLI will guide you through setup.
-
 ### Docker
 
-Download [docker-compose.yaml](https://git.bernloehr.eu/glax/Tranga/src/branch/master/docker-compose.yaml) and configure to your needs.
+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.
 
-Wherever you are mounting `/usr/share/Tranga-API` you also need to mount that same path + `/imageCache` in the webserver container.
+For compatibility do not execute the compose as root (which you should not do anyways...) but as user that can
+access the folder.
 
 ### Prerequisites
 
-[.NET-Core 7.0 SDK](https://dotnet.microsoft.com/en-us/download/dotnet/7.0)
+#### 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.
 
-<!-- ROADMAP -->
-## Roadmap
-
-- [ ] Docker ARM support
-- [ ] ? 
-
-See the [open issues](https://git.bernloehr.eu/glax/Tranga/issues) for a full list of proposed features (and known issues).
+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>
 

Tranga-API/Program.cs

@@ -1,185 +0,0 @@
-using System.Runtime.InteropServices;
-using Logging;
-using Tranga;
-
-string applicationFolderPath = Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "Tranga-API");
-string downloadFolderPath = RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "/Manga" : Path.Join(applicationFolderPath, "Manga");
-string logsFolderPath = RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "/var/logs/Tranga" : Path.Join(applicationFolderPath, "logs");
-string logFilePath = Path.Join(logsFolderPath, $"log-{DateTime.Now:dd-M-yyyy-HH-mm-ss}.txt");
-string settingsFilePath = Path.Join(applicationFolderPath, "settings.json");
-
-Directory.CreateDirectory(logsFolderPath);
-Logger logger = new(new[] { Logger.LoggerType.FileLogger, Logger.LoggerType.ConsoleLogger }, Console.Out, Console.Out.Encoding, logFilePath);
-
-logger.WriteLine("Tranga", "Loading settings.");
-
-TrangaSettings settings;
-if (File.Exists(settingsFilePath))
-    settings = TrangaSettings.LoadSettings(settingsFilePath, logger);
-else
-    settings = new TrangaSettings(downloadFolderPath, applicationFolderPath, new HashSet<LibraryManager>());
-
-Directory.CreateDirectory(settings.workingDirectory);
-Directory.CreateDirectory(settings.downloadLocation);
-Directory.CreateDirectory(settings.coverImageCache);
-
-logger.WriteLine("Tranga",$"Application-Folder: {settings.workingDirectory}");
-logger.WriteLine("Tranga",$"Settings-File-Path: {settings.settingsFilePath}");
-logger.WriteLine("Tranga",$"Download-Folder-Path: {settings.downloadLocation}");
-logger.WriteLine("Tranga",$"Logfile-Path: {logFilePath}");
-logger.WriteLine("Tranga",$"Image-Cache-Path: {settings.coverImageCache}");
-
-logger.WriteLine("Tranga", "Loading Taskmanager.");
-TaskManager taskManager = new (settings, logger);
-
-var builder = WebApplication.CreateBuilder(args);
-builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();
-builder.Services.AddControllers().AddNewtonsoftJson();
-
-string corsHeader = "Tranga";
-builder.Services.AddCors(options =>
-{
-    options.AddPolicy(name: corsHeader,
-        policy  =>
-        {
-            policy.AllowAnyOrigin();
-            policy.WithMethods("GET", "POST", "DELETE");
-        });
-});
-
-var app = builder.Build();
-app.UseSwagger();
-app.UseSwaggerUI();
-
-app.UseCors(corsHeader);
-
-app.MapGet("/Tranga/GetAvailableControllers", () =>  taskManager.GetAvailableConnectors().Keys.ToArray());
-
-app.MapGet("/Tranga/GetKnownPublications", () => taskManager.GetAllPublications());
-
-app.MapGet("/Tranga/GetPublicationsFromConnector", (string connectorName, string title) =>
-{
-    Connector? connector = taskManager.GetAvailableConnectors().FirstOrDefault(con => con.Key == connectorName).Value;
-    if (connector is null)
-        return Array.Empty<Publication>();
-    if(title.Length < 4)
-        return Array.Empty<Publication>();
-    return taskManager.GetPublicationsFromConnector(connector, title);
-});
-
-app.MapGet("/Tasks/GetTaskTypes", () => Enum.GetNames(typeof(TrangaTask.Task)));
-
-
-app.MapPost("/Tasks/Create", (string taskType, string? connectorName, string? publicationId, string reoccurrenceTime, string? language) =>
-{
-    TrangaTask.Task task = Enum.Parse<TrangaTask.Task>(taskType);
-    taskManager.AddTask(task, connectorName, publicationId, TimeSpan.Parse(reoccurrenceTime), language??"");
-});
-
-app.MapDelete("/Tasks/Delete", (string taskType, string? connectorName, string? publicationId) =>
-{
-    TrangaTask.Task task = Enum.Parse<TrangaTask.Task>(taskType);
-    taskManager.DeleteTask(task, connectorName, publicationId);
-});
-
-app.MapGet("/Tasks/Get", (string taskType, string? connectorName, string? searchString) =>
-{
-    try
-    {
-        TrangaTask.Task task = Enum.Parse<TrangaTask.Task>(taskType);
-        return taskManager.GetTasksMatching(task, connectorName:connectorName, searchString:searchString);
-    }
-    catch (ArgumentException)
-    {
-        return Array.Empty<TrangaTask>();
-    }
-});
-
-app.MapGet("/Tasks/GetTaskProgress", (string taskType, string? connectorName, string? publicationId) =>
-{
-    try
-    {
-        TrangaTask.Task pTask = Enum.Parse<TrangaTask.Task>(taskType);
-        TrangaTask? task = taskManager
-            .GetTasksMatching(pTask, connectorName: connectorName, internalId: publicationId)?.First();
-
-        if (task is null)
-            return -1f;
-
-        return task.progress;
-    }
-    catch (ArgumentException)
-    {
-        return -1f;
-    }
-});
-
-app.MapPost("/Tasks/Start", (string taskType, string? connectorName, string? internalId) =>
-{
-    try
-    {
-        TrangaTask.Task pTask = Enum.Parse<TrangaTask.Task>(taskType);
-        TrangaTask? task = taskManager
-            .GetTasksMatching(pTask, connectorName: connectorName, internalId: internalId)?.FirstOrDefault();
-            
-        if (task is null)
-            return;
-        taskManager.ExecuteTaskNow(task);
-    }
-    catch (ArgumentException)
-    {
-        return;
-    }
-
-});
-
-app.MapGet("/Tasks/GetRunningTasks",
-    () => taskManager.GetAllTasks().Where(task => task.state is TrangaTask.ExecutionState.Running));
-
-app.MapGet("/Queue/GetList",
-    () => taskManager.GetAllTasks().Where(task => task.state is TrangaTask.ExecutionState.Enqueued));
-
-app.MapPost("/Queue/Enqueue", (string taskType, string? connectorName, string? publicationId) =>
-{
-    try
-    {
-        TrangaTask.Task pTask = Enum.Parse<TrangaTask.Task>(taskType);
-        TrangaTask? task = taskManager
-            .GetTasksMatching(pTask, connectorName: connectorName, internalId: publicationId)?.First();
-            
-        if (task is null)
-            return;
-        taskManager.AddTaskToQueue(task);
-    }
-    catch (ArgumentException)
-    {
-        return;
-    }
-});
-
-app.MapDelete("/Queue/Dequeue", (string taskType, string? connectorName, string? publicationId) =>
-{
-    try
-    {
-        TrangaTask.Task pTask = Enum.Parse<TrangaTask.Task>(taskType);
-        TrangaTask? task = taskManager
-            .GetTasksMatching(pTask, connectorName: connectorName, internalId: publicationId)?.First();
-            
-        if (task is null)
-            return;
-        taskManager.RemoveTaskFromQueue(task);
-    }
-    catch (ArgumentException)
-    {
-        return;
-    }
-});
-
-app.MapGet("/Settings/Get", () => taskManager.settings);
-
-app.MapPost("/Settings/Update",
-    (string? downloadLocation, string? komgaUrl, string? komgaAuth, string? kavitaUrl, string? kavitaUsername, string? kavitaPassword) =>
-        taskManager.UpdateSettings(downloadLocation, komgaUrl, komgaAuth, kavitaUrl, kavitaUsername, kavitaPassword));
-
-app.Run();

Tranga-API/Properties/launchSettings.json

@@ -1,28 +0,0 @@
-{
-  "iisSettings": {
-    "windowsAuthentication": false,
-    "anonymousAuthentication": true,
-    "iisExpress": {
-      "applicationUrl": "http://localhost:1716",
-      "sslPort": 44391
-    }
-  },
-  "profiles": {
-    "http": {
-      "commandName": "Project",
-      "dotnetRunMessages": true,
-      "launchBrowser": true,
-      "applicationUrl": "http://localhost:5177"
-    },
-    "https": {
-      "commandName": "Project",
-      "dotnetRunMessages": true,
-      "launchBrowser": true,
-      "applicationUrl": "https://localhost:7036;http://localhost:5177"
-    },
-    "IIS Express": {
-      "commandName": "IISExpress",
-      "launchBrowser": true
-    }
-  }
-}

Tranga-API/Tranga-API.csproj

@@ -1,28 +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="..\Logging\Logging.csproj" />
-      <ProjectReference Include="..\Tranga\Tranga.csproj" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="7.0.5" />
-      <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="7.0.6" />
-      <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
-    </ItemGroup>
-
-</Project>

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,622 +0,0 @@
-using System.Globalization;
-using Logging;
-using Tranga;
-using Tranga.LibraryManagers;
-using Tranga.TrangaTasks;
-
-namespace Tranga_CLI;
-
-/*
- * This is written with pure hatred for readability.
- * At some point do this properly.
- * Read at own risk.
- */
-
-public static class Tranga_Cli
-{
-    public static void Main(string[] args)
-    {
-        string applicationFolderPath =  Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "Tranga");
-        string logsFolderPath = Path.Join(applicationFolderPath, "logs");
-        string logFilePath = Path.Join(logsFolderPath, $"log-{DateTime.Now:dd-M-yyyy-HH-mm-ss}.txt");
-        string settingsFilePath = Path.Join(applicationFolderPath, "settings.json");
-
-        Directory.CreateDirectory(applicationFolderPath);
-        Directory.CreateDirectory(logsFolderPath);
-        
-        Console.WriteLine($"Logfile-Path: {logFilePath}");
-        Console.WriteLine($"Settings-File-Path: {settingsFilePath}");
-
-        Logger logger = new(new[] { Logger.LoggerType.FileLogger }, null, Console.Out.Encoding, logFilePath);
-        
-        logger.WriteLine("Tranga_CLI", "Loading Taskmanager.");
-        TrangaSettings settings = File.Exists(settingsFilePath) ? TrangaSettings.LoadSettings(settingsFilePath, logger) : new TrangaSettings(Directory.GetCurrentDirectory(), applicationFolderPath, new HashSet<LibraryManager>());
-
-            
-        logger.WriteLine("Tranga_CLI", "User Input");
-        Console.WriteLine($"Output folder path [{settings.downloadLocation}]:");
-        string? tmpPath = Console.ReadLine();
-        while(tmpPath is null)
-            tmpPath = Console.ReadLine();
-        if (tmpPath.Length > 0)
-            settings.downloadLocation = tmpPath;
-
-        Console.WriteLine($"Komga BaseURL [{settings.libraryManagers.FirstOrDefault(lm => lm.GetType() == typeof(Komga))?.baseUrl}]:");
-        string? tmpUrlKomga = Console.ReadLine();
-        while (tmpUrlKomga is null)
-            tmpUrlKomga = Console.ReadLine();
-        if (tmpUrlKomga.Length > 0)
-        {
-            Console.WriteLine("Username:");
-            string? tmpKomgaUser = Console.ReadLine();
-            while (tmpKomgaUser is null || tmpKomgaUser.Length < 1)
-                tmpKomgaUser = Console.ReadLine();
-            
-            Console.WriteLine("Password:");
-            string tmpKomgaPass = string.Empty;
-            ConsoleKey key;
-            do
-            {
-                var keyInfo = Console.ReadKey(intercept: true);
-                key = keyInfo.Key;
-
-                if (key == ConsoleKey.Backspace && tmpKomgaPass.Length > 0)
-                {
-                    Console.Write("\b \b");
-                    tmpKomgaPass = tmpKomgaPass[0..^1];
-                }
-                else if (!char.IsControl(keyInfo.KeyChar))
-                {
-                    Console.Write("*");
-                    tmpKomgaPass += keyInfo.KeyChar;
-                }
-            } while (key != ConsoleKey.Enter);
-
-            settings.libraryManagers.RemoveWhere(lm => lm.GetType() == typeof(Komga));
-            settings.libraryManagers.Add(new Komga(tmpUrlKomga, tmpKomgaUser, tmpKomgaPass, logger));
-        }
-        
-        Console.WriteLine($"Kavita BaseURL [{settings.libraryManagers.FirstOrDefault(lm => lm.GetType() == typeof(Kavita))?.baseUrl}]:");
-        string? tmpUrlKavita = Console.ReadLine();
-        while (tmpUrlKavita is null)
-            tmpUrlKavita = Console.ReadLine();
-        if (tmpUrlKavita.Length > 0)
-        {
-            Console.WriteLine("Username:");
-            string? tmpKavitaUser = Console.ReadLine();
-            while (tmpKavitaUser is null || tmpKavitaUser.Length < 1)
-                tmpKavitaUser = Console.ReadLine();
-            
-            Console.WriteLine("Password:");
-            string tmpKavitaPass = string.Empty;
-            ConsoleKey key;
-            do
-            {
-                var keyInfo = Console.ReadKey(intercept: true);
-                key = keyInfo.Key;
-
-                if (key == ConsoleKey.Backspace && tmpKavitaPass.Length > 0)
-                {
-                    Console.Write("\b \b");
-                    tmpKavitaPass = tmpKavitaPass[0..^1];
-                }
-                else if (!char.IsControl(keyInfo.KeyChar))
-                {
-                    Console.Write("*");
-                    tmpKavitaPass += keyInfo.KeyChar;
-                }
-            } while (key != ConsoleKey.Enter);
-
-            settings.libraryManagers.RemoveWhere(lm => lm.GetType() == typeof(Kavita));
-            settings.libraryManagers.Add(new Kavita(tmpUrlKavita, tmpKavitaUser, tmpKavitaPass, logger));
-        }
-        
-        logger.WriteLine("Tranga_CLI", "Loaded.");
-        TaskMode(settings, logger);
-    }
-
-    private static void TaskMode(TrangaSettings settings, Logger logger)
-    {
-        TaskManager taskManager = new (settings, logger);
-        ConsoleKey selection = ConsoleKey.EraseEndOfFile;
-        PrintMenu(taskManager, taskManager.settings.downloadLocation);
-        while (selection != ConsoleKey.Q)
-        {
-            int taskCount = taskManager.GetAllTasks().Length;
-            int taskRunningCount = taskManager.GetAllTasks().Count(task => task.state == TrangaTask.ExecutionState.Running);
-            int taskEnqueuedCount =
-                taskManager.GetAllTasks().Count(task => task.state == TrangaTask.ExecutionState.Enqueued);
-            Console.SetCursorPosition(0,1);
-            Console.WriteLine($"Tasks (Running/Queue/Total)): {taskRunningCount}/{taskEnqueuedCount}/{taskCount}");
-
-            if (Console.KeyAvailable)
-            {
-                selection = Console.ReadKey().Key;
-                switch (selection)
-                {
-                    case ConsoleKey.L:
-                        while (!Console.KeyAvailable)
-                        {
-                            PrintTasks(taskManager.GetAllTasks(), logger);
-                            Console.WriteLine("Press any key.");
-                            Thread.Sleep(500);
-                        }
-                        Console.ReadKey();
-                        break;
-                    case ConsoleKey.C:
-                        CreateTask(taskManager, logger);
-                        Console.WriteLine("Press any key.");
-                        Console.ReadKey();
-                        break;
-                    case ConsoleKey.D:
-                        DeleteTask(taskManager, logger);
-                        Console.WriteLine("Press any key.");
-                        Console.ReadKey();
-                        break;
-                    case ConsoleKey.E:
-                        ExecuteTaskNow(taskManager, logger);
-                        Console.WriteLine("Press any key.");
-                        Console.ReadKey();
-                        break;
-                    case ConsoleKey.S:
-                        SearchTasks(taskManager, logger);
-                        Console.WriteLine("Press any key.");
-                        Console.ReadKey();
-                        break;
-                    case ConsoleKey.R:
-                        while (!Console.KeyAvailable)
-                        {
-                            PrintTasks(
-                                taskManager.GetAllTasks().Where(eTask => eTask.state == TrangaTask.ExecutionState.Running)
-                                    .ToArray(), logger);
-                            Console.WriteLine("Press any key.");
-                            Thread.Sleep(500);
-                        }
-                        Console.ReadKey();
-                        break;
-                    case ConsoleKey.K:
-                        while (!Console.KeyAvailable)
-                        {
-                            PrintTasks(
-                                taskManager.GetAllTasks()
-                                    .Where(qTask => qTask.state is TrangaTask.ExecutionState.Enqueued)
-                                    .ToArray(), logger);
-                            Console.WriteLine("Press any key.");
-                            Thread.Sleep(500);
-                        }
-                        Console.ReadKey();
-                        break;
-                    case ConsoleKey.F:
-                        TailLog(logger);
-                        Console.ReadKey();
-                        break;
-                    case ConsoleKey.G:
-                        RemoveTaskFromQueue(taskManager, logger);
-                        Console.WriteLine("Press any key.");
-                        Console.ReadKey();
-                        break;
-                    case ConsoleKey.B:
-                        AddTaskToQueue(taskManager, logger);
-                        Console.WriteLine("Press any key.");
-                        Console.ReadKey();
-                        break;
-                    case ConsoleKey.M:
-                        AddMangaTaskToQueue(taskManager, logger);
-                        Console.WriteLine("Press any key.");
-                        Console.ReadKey();
-                        break; 
-                }
-                PrintMenu(taskManager, taskManager.settings.downloadLocation);
-            }
-            Thread.Sleep(200);
-        }
-
-        logger.WriteLine("Tranga_CLI", "Exiting.");
-        Console.Clear();
-        Console.WriteLine("Exiting.");
-        if (taskManager.GetAllTasks().Any(task => task.state == TrangaTask.ExecutionState.Running))
-        {
-            Console.WriteLine("Force quit (Even with running tasks?) y/N");
-            selection = Console.ReadKey().Key;
-            while(selection != ConsoleKey.Y && selection != ConsoleKey.N)
-                selection = Console.ReadKey().Key;
-            taskManager.Shutdown(selection == ConsoleKey.Y);
-        }else
-            // ReSharper disable once RedundantArgumentDefaultValue Better readability
-            taskManager.Shutdown(false);
-    }
-
-    private static void PrintMenu(TaskManager taskManager, string folderPath)
-    {
-        int taskCount = taskManager.GetAllTasks().Length;
-        int taskRunningCount = taskManager.GetAllTasks().Count(task => task.state == TrangaTask.ExecutionState.Running);
-        int taskEnqueuedCount =
-            taskManager.GetAllTasks().Count(task => task.state == TrangaTask.ExecutionState.Enqueued);
-        Console.Clear();
-        Console.WriteLine($"Download Folder: {folderPath}");
-        Console.WriteLine($"Tasks (Running/Queue/Total)): {taskRunningCount}/{taskEnqueuedCount}/{taskCount}");
-        Console.WriteLine();
-        Console.WriteLine($"{"C: Create Task",-30}{"L: List tasks",-30}{"B: Enqueue Task", -30}");
-        Console.WriteLine($"{"D: Delete Task",-30}{"S: Search Tasks", -30}{"K: List Task Queue", -30}");
-        Console.WriteLine($"{"E: Execute Task now",-30}{"R: List Running Tasks", -30}{"G: Remove Task from Queue", -30}");
-        Console.WriteLine($"{"M: New Download Manga Task",-30}{"", -30}{"", -30}");
-        Console.WriteLine($"{"",-30}{"F: Show Log",-30}{"Q: Exit",-30}");
-    }
-
-    private static void PrintTasks(TrangaTask[] tasks, Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Printing Tasks");
-        int taskCount = tasks.Length;
-        int taskRunningCount = tasks.Count(task => task.state == TrangaTask.ExecutionState.Running);
-        int taskEnqueuedCount = tasks.Count(task => task.state == TrangaTask.ExecutionState.Enqueued);
-        Console.Clear();
-        int tIndex = 0;
-        Console.WriteLine($"Tasks (Running/Queue/Total): {taskRunningCount}/{taskEnqueuedCount}/{taskCount}");
-        string header =
-            $"{"",-5}{"Task",-20} | {"Last Executed",-20} | {"Reoccurrence",-12} | {"State",-10} | {"Progress",-9} | {"Finished",-20} | {"Remaining",-12} | {"Connector",-15} | Publication/Manga ";
-        Console.WriteLine(header);
-        Console.WriteLine(new string('-', header.Length));
-        foreach (TrangaTask trangaTask in tasks)
-        {
-            string[] taskSplit = trangaTask.ToString().Split(", ");
-            Console.WriteLine($"{tIndex++:000}: {taskSplit[0],-20} | {taskSplit[1],-20} | {taskSplit[2],-12} | {taskSplit[3],-10} | {taskSplit[4],-9} | {taskSplit[5],-20} | {taskSplit[6][..12],-12} | {(taskSplit.Length > 7 ? taskSplit[7] : ""),-15} | {(taskSplit.Length > 8 ? taskSplit[8] : "")} {(taskSplit.Length > 9 ? taskSplit[9] : "")} {(taskSplit.Length > 10 ? taskSplit[10] : "")}");
-        }
-            
-    }
-
-    private static TrangaTask[] SelectTasks(TrangaTask[] tasks, Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Menu: Select task");
-        if (tasks.Length < 1)
-        {
-            Console.Clear();
-            Console.WriteLine("There are no available Tasks.");
-            logger.WriteLine("Tranga_CLI", "No available Tasks.");
-            return Array.Empty<TrangaTask>();
-        }
-        PrintTasks(tasks, logger);
-        
-        logger.WriteLine("Tranga_CLI", "Selecting Task to Remove (from queue)");
-        Console.WriteLine("Enter q to abort");
-        Console.WriteLine($"Select Task(s) (0-{tasks.Length - 1}):");
-
-        string? selectedTask = Console.ReadLine();
-        while(selectedTask is null || selectedTask.Length < 1)
-            selectedTask = Console.ReadLine();
-        
-        if (selectedTask.Length == 1 && selectedTask.ToLower() == "q")
-        {
-            Console.Clear();
-            Console.WriteLine("aborted.");
-            logger.WriteLine("Tranga_CLI", "aborted");
-            return Array.Empty<TrangaTask>();
-        }
-
-        if (selectedTask.Contains('-'))
-        {
-            int start = Convert.ToInt32(selectedTask.Split('-')[0]);
-            int end = Convert.ToInt32(selectedTask.Split('-')[1]);
-            return tasks[start..end];
-        }
-        else
-        {
-            int selectedTaskIndex = Convert.ToInt32(selectedTask);
-            return new[] { tasks[selectedTaskIndex] };
-        }
-    }
-    
-    private static void AddMangaTaskToQueue(TaskManager taskManager, Logger logger)
-    {
-        Console.Clear();
-        logger.WriteLine("Tranga_CLI", "Menu: Add Manga Download to queue");
-        
-        Connector? connector = SelectConnector(taskManager.GetAvailableConnectors().Values.ToArray(), logger);
-        if (connector is null)
-            return;
-                    
-        Publication? publication = SelectPublication(taskManager, connector, logger);
-        if (publication is null)
-            return;
-        
-        TimeSpan reoccurrence = SelectReoccurrence(logger);
-        logger.WriteLine("Tranga_CLI", "Sending Task to TaskManager");
-        TrangaTask? newTask = taskManager.AddTask(TrangaTask.Task.DownloadNewChapters, connector.name, publication.Value.publicationId, reoccurrence, "en");
-        Console.WriteLine(newTask);
-    }
-
-    private static void AddTaskToQueue(TaskManager taskManager, Logger logger)
-    {
-        Console.Clear();
-        logger.WriteLine("Tranga_CLI", "Menu: Add Task to queue");
-
-        TrangaTask[] tasks = taskManager.GetAllTasks().Where(rTask =>
-            rTask.state is not TrangaTask.ExecutionState.Enqueued and not TrangaTask.ExecutionState.Running).ToArray();
-        
-        TrangaTask[] selectedTasks = SelectTasks(tasks, logger);
-        logger.WriteLine("Tranga_CLI", $"Sending {selectedTasks.Length} Tasks to TaskManager");
-        foreach(TrangaTask task in selectedTasks)
-            taskManager.AddTaskToQueue(task);
-    }
-
-    private static void RemoveTaskFromQueue(TaskManager taskManager, Logger logger)
-    {
-        Console.Clear();
-        logger.WriteLine("Tranga_CLI", "Menu: Remove Task from queue");
-        
-        TrangaTask[] tasks = taskManager.GetAllTasks().Where(rTask => rTask.state is TrangaTask.ExecutionState.Enqueued).ToArray();
-
-        TrangaTask[] selectedTasks = SelectTasks(tasks, logger);
-        logger.WriteLine("Tranga_CLI", $"Sending {selectedTasks.Length} Tasks to TaskManager");
-        foreach(TrangaTask task in selectedTasks)
-            taskManager.RemoveTaskFromQueue(task);
-    }
-
-    private static void TailLog(Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Menu: Show Log-lines");
-        Console.Clear();
-        
-        string[] lines = logger.Tail(20);
-        foreach (string message in lines)
-            Console.Write(message);
-
-        while (!Console.KeyAvailable)
-        {
-            string[] newLines = logger.GetNewLines();
-            foreach(string message in newLines)
-                Console.Write(message);
-            Thread.Sleep(40);
-        }
-    }
-
-    private static void CreateTask(TaskManager taskManager, Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Menu: Creating Task");
-        TrangaTask.Task? tmpTask = SelectTaskType(logger);
-        if (tmpTask is null)
-            return;
-        TrangaTask.Task task = (TrangaTask.Task)tmpTask;
-        
-        Connector? connector = null;
-        if (task != TrangaTask.Task.UpdateLibraries)
-        {
-            connector = SelectConnector(taskManager.GetAvailableConnectors().Values.ToArray(), logger);
-            if (connector is null)
-                return;
-        }
-                    
-        Publication? publication = null;
-        if (task != TrangaTask.Task.UpdateLibraries)
-        {
-            publication = SelectPublication(taskManager, connector!, logger);
-            if (publication is null)
-                return;
-        }
-
-        if (task is TrangaTask.Task.DownloadNewChapters)
-        {
-            TimeSpan reoccurrence = SelectReoccurrence(logger);
-            logger.WriteLine("Tranga_CLI", "Sending Task to TaskManager");
-
-            TrangaTask newTask = new DownloadNewChaptersTask(TrangaTask.Task.DownloadNewChapters, connector!.name, (Publication)publication!, reoccurrence, "en");
-            taskManager.AddTask(newTask);
-            Console.WriteLine(newTask);
-        }else if (task is TrangaTask.Task.DownloadChapter)
-        {
-            foreach (Chapter chapter in SelectChapters(connector!, (Publication)publication!, logger))
-            {
-                TrangaTask newTask = new DownloadChapterTask(TrangaTask.Task.DownloadChapter, connector!.name,
-                    (Publication)publication!, chapter, "en");
-                taskManager.AddTask(newTask);
-                Console.WriteLine(newTask);
-            }
-        }
-    }
-
-    private static void ExecuteTaskNow(TaskManager taskManager, Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Menu: Executing Task");
-        TrangaTask[] tasks = taskManager.GetAllTasks().Where(nTask => nTask.state is not TrangaTask.ExecutionState.Running).ToArray();
-        
-        TrangaTask[] selectedTasks = SelectTasks(tasks, logger);
-        logger.WriteLine("Tranga_CLI", $"Sending {selectedTasks.Length} Tasks to TaskManager");
-        foreach(TrangaTask task in selectedTasks)
-            taskManager.ExecuteTaskNow(task);
-    }
-
-    private static void DeleteTask(TaskManager taskManager, Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Menu: Delete Task");
-        TrangaTask[] tasks = taskManager.GetAllTasks();
-        
-        TrangaTask[] selectedTasks = SelectTasks(tasks, logger);
-        logger.WriteLine("Tranga_CLI", $"Sending {selectedTasks.Length} Tasks to TaskManager");
-        foreach(TrangaTask task in selectedTasks)
-            taskManager.DeleteTask(task);
-    }
-
-    private static TrangaTask.Task? SelectTaskType(Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Menu: Select TaskType");
-        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("Enter q to abort");
-        Console.WriteLine($"Select Task (0-{taskNames.Length - 1}):");
-
-        string? selectedTask = Console.ReadLine();
-        while(selectedTask is null || selectedTask.Length < 1)
-            selectedTask = Console.ReadLine();
-
-        if (selectedTask.Length == 1 && selectedTask.ToLower() == "q")
-        {
-            Console.Clear();
-            Console.WriteLine("aborted.");
-            logger.WriteLine("Tranga_CLI", "aborted.");
-            return null;
-        }
-        
-        try
-        {
-            int selectedTaskIndex = Convert.ToInt32(selectedTask);
-            string selectedTaskName = taskNames[selectedTaskIndex];
-            return Enum.Parse<TrangaTask.Task>(selectedTaskName);
-        }
-        catch (Exception e)
-        {
-            Console.WriteLine($"Exception: {e.Message}");
-            logger.WriteLine("Tranga_CLI", e.Message);
-        }
-
-        return null;
-    }
-
-    private static TimeSpan SelectReoccurrence(Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Menu: Select Reoccurrence");
-        Console.WriteLine("Select reoccurrence Timer (Format hh:mm:ss):");
-        return TimeSpan.Parse(Console.ReadLine()!, new CultureInfo("en-US"));
-    }
-
-    private static Chapter[] SelectChapters(Connector connector, Publication publication, Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Menu: Select Chapters");
-        Chapter[] availableChapters = connector.GetChapters(publication, "en");
-        int cIndex = 0;
-        Console.WriteLine("Chapters:");
-        foreach(Chapter chapter in availableChapters)
-            Console.WriteLine($"{cIndex++}: Vol.{chapter.volumeNumber} Ch.{chapter.chapterNumber} - {chapter.name}");
-        
-        Console.WriteLine("Enter q to abort");
-        Console.WriteLine($"Select Chapter(s):");
-
-        string? selectedChapters = Console.ReadLine();
-        while(selectedChapters is null || selectedChapters.Length < 1)
-            selectedChapters = Console.ReadLine();
-
-        if (selectedChapters.Length == 1 && selectedChapters.ToLower() == "q")
-        {
-            Console.Clear();
-            Console.WriteLine("aborted.");
-            logger.WriteLine("Tranga_CLI", "aborted.");
-            return Array.Empty<Chapter>();
-        }
-        
-        if (selectedChapters.Contains('-'))
-        {
-            int start = Convert.ToInt32(selectedChapters.Split('-')[0]);
-            int end = Convert.ToInt32(selectedChapters.Split('-')[1]);
-            return availableChapters[start..end];
-        }
-        else
-            return new Chapter[] { availableChapters[Convert.ToInt32(selectedChapters)] };
-    }
-
-    private static Connector? SelectConnector(Connector[] connectors, Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Menu: Select Connector");
-        Console.Clear();
-        
-        int cIndex = 0;
-        Console.WriteLine("Connectors:");
-        foreach (Connector connector in connectors)
-            Console.WriteLine($"{cIndex++}: {connector.name}");
-        
-        Console.WriteLine("Enter q to abort");
-        Console.WriteLine($"Select Connector (0-{connectors.Length - 1}):");
-
-        string? selectedConnector = Console.ReadLine();
-        while(selectedConnector is null || selectedConnector.Length < 1)
-            selectedConnector = Console.ReadLine();
-
-        if (selectedConnector.Length == 1 && selectedConnector.ToLower() == "q")
-        {
-            Console.Clear();
-            Console.WriteLine("aborted.");
-            logger.WriteLine("Tranga_CLI", "aborted.");
-            return null;
-        }
-        
-        try
-        {
-            int selectedConnectorIndex = Convert.ToInt32(selectedConnector);
-            return connectors[selectedConnectorIndex];
-        }
-        catch (Exception e)
-        {
-            Console.WriteLine($"Exception: {e.Message}");
-            logger.WriteLine("Tranga_CLI", e.Message);
-        }
-
-        return null;
-    }
-
-    private static Publication? SelectPublication(TaskManager taskManager, Connector connector, Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Menu: Select Publication");
-        
-        Console.Clear();
-        Console.WriteLine($"Connector: {connector.name}");
-        Console.WriteLine("Publication search query (leave empty for all):");
-        string? query = Console.ReadLine();
-
-        Publication[] publications = taskManager.GetPublicationsFromConnector(connector, query ?? "");
-
-        if (publications.Length < 1)
-        {
-            logger.WriteLine("Tranga_CLI", "No publications returned");
-            Console.WriteLine($"No publications for query '{query}' returned;");
-            return null;
-        }
-        
-        int pIndex = 0;
-        Console.WriteLine("Publications:");
-        foreach(Publication publication in publications)
-            Console.WriteLine($"{pIndex++}: {publication.sortName}");
-        
-        Console.WriteLine("Enter q to abort");
-        Console.WriteLine($"Select publication to Download (0-{publications.Length - 1}):");
-
-        string? selectedPublication = Console.ReadLine();
-        while(selectedPublication is null || selectedPublication.Length < 1)
-            selectedPublication = Console.ReadLine();
-
-        if (selectedPublication.Length == 1 && selectedPublication.ToLower() == "q")
-        {
-            Console.Clear();
-            Console.WriteLine("aborted.");
-            logger.WriteLine("Tranga_CLI", "aborted.");
-            return null;
-        }
-        
-        try
-        {
-            int selectedPublicationIndex = Convert.ToInt32(selectedPublication);
-            return publications[selectedPublicationIndex];
-        }
-        catch (Exception e)
-        {
-            Console.WriteLine($"Exception: {e.Message}");
-            logger.WriteLine("Tranga_CLI", e.Message);
-        }
-
-        return null;
-    }
-
-    private static void SearchTasks(TaskManager taskManager, Logger logger)
-    {
-        logger.WriteLine("Tranga_CLI", "Menu: Search task");
-        Console.Clear();
-        Console.WriteLine("Enter search query:");
-        string? query = Console.ReadLine();
-        while (query is null || query.Length < 4)
-            query = Console.ReadLine();
-        PrintTasks(taskManager.GetAllTasks().Where(qTask =>
-            qTask.ToString().ToLower().Contains(query, StringComparison.OrdinalIgnoreCase)).ToArray(), logger);
-    }
-}

Tranga.sln

@@ -1,12 +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}") = "Logging", "Logging\Logging.csproj", "{415BE889-BB7D-426F-976F-8D977876A462}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tranga-API", "Tranga-API\Tranga-API.csproj", "{48F4E495-75BC-4402-8E03-DEC5B79D7E83}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "API", "API\API.csproj", "{EDB07E7B-351F-4FCC-9AEF-777838E5551E}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -14,21 +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
-		{415BE889-BB7D-426F-976F-8D977876A462}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{415BE889-BB7D-426F-976F-8D977876A462}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{415BE889-BB7D-426F-976F-8D977876A462}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{415BE889-BB7D-426F-976F-8D977876A462}.Release|Any CPU.Build.0 = Release|Any CPU
-		{48F4E495-75BC-4402-8E03-DEC5B79D7E83}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{48F4E495-75BC-4402-8E03-DEC5B79D7E83}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{48F4E495-75BC-4402-8E03-DEC5B79D7E83}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{48F4E495-75BC-4402-8E03-DEC5B79D7E83}.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,6 +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,40 +0,0 @@
-using System.Globalization;
-using System.Text.RegularExpressions;
-
-namespace Tranga;
-
-/// <summary>
-/// Has to be Part of a publication
-/// Includes the Chapter-Name, -VolumeNumber, -ChapterNumber, the location of the chapter on the internet and the saveName of the local file.
-/// </summary>
-public struct Chapter
-{
-    public string? name { get; }
-    public string? volumeNumber { get; }
-    public string? chapterNumber { get; }
-    public string url { get; }
-    public string fileName { get; }
-    public string sortNumber { get; }
-    
-    private static readonly Regex LegalCharacters = new Regex(@"([A-z]*[0-9]* *\.*-*,*\]*\[*'*\'*\)*\(*~*!*)*");
-    public Chapter(string? name, string? volumeNumber, string? chapterNumber, string url)
-    {
-        this.name = name;
-        this.volumeNumber = volumeNumber;
-        this.chapterNumber = chapterNumber;
-        this.url = url;
-        NumberFormatInfo nfi = new NumberFormatInfo()
-        {
-            NumberDecimalSeparator = "."
-        };
-        sortNumber = decimal.Round(Convert.ToDecimal(this.volumeNumber ?? "1") * Convert.ToDecimal(this.chapterNumber, nfi), 1)
-            .ToString(nfi);
-
-        string chapterName = string.Concat(LegalCharacters.Matches(name ?? ""));
-        string volStr = this.volumeNumber is not null ? $"Vol.{this.volumeNumber} " : "";
-        string chNumberStr = this.chapterNumber is not null ? $"Ch.{chapterNumber} " : "";
-        string chNameStr = chapterName.Length > 0 ? $"- {chapterName}" : "";
-        chNameStr = chNameStr.Replace("Volume", "").Replace("volume", "");
-        this.fileName = $"{volStr}{chNumberStr}{chNameStr}";
-    }
-}

Tranga/Connector.cs

@@ -1,298 +0,0 @@
-using System.IO.Compression;
-using System.Net;
-using System.Runtime.InteropServices;
-using System.Text.RegularExpressions;
-using System.Xml.Linq;
-using Logging;
-using Tranga.TrangaTasks;
-using static System.IO.UnixFileMode;
-
-namespace Tranga;
-
-/// <summary>
-/// Base-Class for all Connectors
-/// Provides some methods to be used by all Connectors, as well as a DownloadClient
-/// </summary>
-public abstract class Connector
-{
-    internal string downloadLocation { get; }  //Location of local files
-    protected DownloadClient downloadClient { get; init; }
-
-    protected readonly Logger? logger;
-
-    protected readonly string imageCachePath;
-
-    protected Connector(string downloadLocation, string imageCachePath, Logger? logger)
-    {
-        this.downloadLocation = downloadLocation;
-        this.logger = logger;
-        this.downloadClient = new DownloadClient(new Dictionary<byte, int>()
-        {
-            //RequestTypes for RateLimits
-        }, logger);
-        this.imageCachePath = imageCachePath;
-        if (!Directory.Exists(imageCachePath))
-            Directory.CreateDirectory(this.imageCachePath);
-    }
-    
-    public abstract string name { get; } //Name of the Connector (e.g. Website)
-    
-    /// <summary>
-    /// Returns all Publications with the given string.
-    /// If the string is empty or null, returns all Publication of the Connector
-    /// </summary>
-    /// <param name="publicationTitle">Search-Query</param>
-    /// <returns>Publications matching the query</returns>
-    public abstract Publication[] GetPublications(string publicationTitle = "");
-    
-    /// <summary>
-    /// Returns all Chapters of the publication in the provided language.
-    /// If the language is empty or null, returns all Chapters in all Languages.
-    /// </summary>
-    /// <param name="publication">Publication to get Chapters for</param>
-    /// <param name="language">Language of the Chapters</param>
-    /// <returns>Array of Chapters matching Publication and Language</returns>
-    public abstract Chapter[] GetChapters(Publication publication, string language = "");
-    
-    /// <summary>
-    /// Retrieves the Chapter (+Images) from the website.
-    /// Should later call DownloadChapterImages to retrieve the individual Images of the Chapter and create .cbz archive.
-    /// </summary>
-    /// <param name="publication">Publication that contains Chapter</param>
-    /// <param name="chapter">Chapter with Images to retrieve</param>
-    /// <param name="parentTask">Will be used for progress-tracking</param>
-    public abstract void DownloadChapter(Publication publication, Chapter chapter, DownloadChapterTask parentTask);
-
-    /// <summary>
-    /// Copies the already downloaded cover from cache to downloadLocation
-    /// </summary>
-    /// <param name="publication">Publication to retrieve Cover for</param>
-    /// <param name="settings">TrangaSettings</param>
-    public void CopyCoverFromCacheToDownloadLocation(Publication publication, TrangaSettings settings)
-    {
-        logger?.WriteLine(this.GetType().ToString(), $"Cloning cover {publication.sortName} {publication.internalId}");
-        //Check if Publication already has a Folder and cover
-        string publicationFolder = publication.CreatePublicationFolder(downloadLocation);
-        DirectoryInfo dirInfo = new (publicationFolder);
-        if (dirInfo.EnumerateFiles().Any(info => info.Name.Contains("cover.")))
-        {
-            logger?.WriteLine(this.GetType().ToString(), $"Cover exists {publication.sortName}");
-            return;
-        }
-
-        string fileInCache = Path.Join(settings.coverImageCache, publication.coverFileNameInCache);
-        string newFilePath = Path.Join(publicationFolder, $"cover.{Path.GetFileName(fileInCache).Split('.')[^1]}" );
-        logger?.WriteLine(this.GetType().ToString(), $"Cloning cover {fileInCache} -> {newFilePath}");
-        File.Copy(fileInCache, newFilePath, true);
-        if(RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-            File.SetUnixFileMode(newFilePath, GroupRead | GroupWrite | OtherRead | OtherWrite | UserRead | UserWrite);
-    }
-
-    /// <summary>
-    /// Creates a string containing XML of publication and chapter.
-    /// See ComicInfo.xml
-    /// </summary>
-    /// <returns>XML-string</returns>
-    protected static string GetComicInfoXmlString(Publication publication, Chapter chapter, Logger? logger)
-    {
-        logger?.WriteLine("Connector", $"Creating ComicInfo.Xml for {publication.sortName} {publication.internalId} {chapter.volumeNumber}-{chapter.chapterNumber}");
-        XElement comicInfo = new XElement("ComicInfo",
-            new XElement("Tags", string.Join(',',publication.tags)),
-            new XElement("LanguageISO", publication.originalLanguage),
-            new XElement("Title", chapter.name),
-            new XElement("Writer", publication.author),
-            new XElement("Volume", chapter.volumeNumber),
-            new XElement("Number", chapter.chapterNumber)
-        );
-        return comicInfo.ToString();
-    }
-
-    /// <summary>
-    /// Checks if a chapter-archive is already present
-    /// </summary>
-    /// <returns>true if chapter is present</returns>
-    public bool CheckChapterIsDownloaded(Publication publication, Chapter chapter)
-    {
-        Regex legalCharacters = new Regex(@"([A-z]*[0-9]* *\.*-*,*\]*\[*'*\'*\)*\(*~*!*)*");
-        string oldFilePath = Path.Join(downloadLocation, publication.folderName, $"{string.Concat(legalCharacters.Matches(chapter.name ?? ""))} - V{chapter.volumeNumber}C{chapter.chapterNumber} - {chapter.sortNumber}.cbz");
-        string oldFilePath2 = Path.Join(downloadLocation, publication.folderName, $"{string.Concat(legalCharacters.Matches(chapter.name ?? ""))} - VC{chapter.chapterNumber} - {chapter.chapterNumber}.cbz");
-        string newFilePath = GetArchiveFilePath(publication, chapter);
-        if (File.Exists(oldFilePath))
-            File.Move(oldFilePath, newFilePath);
-        else if (File.Exists(oldFilePath2))
-            File.Move(oldFilePath2, newFilePath);
-        return File.Exists(newFilePath);
-    }
-
-    /// <summary>
-    /// Creates full file path of chapter-archive
-    /// </summary>
-    /// <returns>Filepath</returns>
-    protected string GetArchiveFilePath(Publication publication, Chapter chapter)
-    {
-        return Path.Join(downloadLocation, publication.folderName, $"{publication.folderName} - {chapter.fileName}.cbz");
-    }
-
-    /// <summary>
-    /// Downloads Image from URL and saves it to the given path(incl. fileName)
-    /// </summary>
-    /// <param name="imageUrl"></param>
-    /// <param name="fullPath"></param>
-    /// <param name="requestType">RequestType for Rate-Limit</param>
-    /// <param name="referrer">referrer used in html request header</param>
-    private void DownloadImage(string imageUrl, string fullPath, byte requestType, string? referrer = null)
-    {
-        DownloadClient.RequestResult requestResult = downloadClient.MakeRequest(imageUrl, requestType, referrer);
-        if (requestResult.result != Stream.Null)
-        {
-            byte[] buffer = new byte[requestResult.result.Length];
-            requestResult.result.ReadExactly(buffer, 0, buffer.Length);
-            File.WriteAllBytes(fullPath, buffer);
-        }else
-            logger?.WriteLine(this.GetType().ToString(), "No Stream-Content in result.");
-    }
-
-    /// <summary>
-    /// Downloads all Images from URLs, Compresses to zip(cbz) and saves.
-    /// </summary>
-    /// <param name="imageUrls">List of URLs to download Images from</param>
-    /// <param name="saveArchiveFilePath">Full path to save archive to (without file ending .cbz)</param>
-    /// <param name="parentTask">Used for progress tracking</param>
-    /// <param name="comicInfoPath">Path of the generate Chapter ComicInfo.xml, if it was generated</param>
-    /// <param name="requestType">RequestType for RateLimits</param>
-    /// <param name="referrer">Used in http request header</param>
-    protected void DownloadChapterImages(string[] imageUrls, string saveArchiveFilePath, byte requestType, DownloadChapterTask parentTask, string? comicInfoPath = null, string? referrer = null)
-    {
-        logger?.WriteLine("Connector", $"Downloading Images for {saveArchiveFilePath}");
-        //Check if Publication Directory already exists
-        string directoryPath = Path.GetDirectoryName(saveArchiveFilePath)!;
-        if (!Directory.Exists(directoryPath))
-            Directory.CreateDirectory(directoryPath);
-
-        if (File.Exists(saveArchiveFilePath)) //Don't download twice.
-            return;
-        
-        //Create a temporary folder to store images
-        string tempFolder = Directory.CreateTempSubdirectory().FullName;
-
-        int chapter = 0;
-        //Download all Images to temporary Folder
-        foreach (string imageUrl in imageUrls)
-        {
-            string[] split = imageUrl.Split('.');
-            string extension = split[^1];
-            logger?.WriteLine("Connector", $"Downloading Image {chapter + 1:000}/{imageUrls.Length:000} {parentTask.publication.sortName} {parentTask.publication.internalId} Vol.{parentTask.chapter.volumeNumber} Ch.{parentTask.chapter.chapterNumber} {parentTask.progress:P2}");
-            DownloadImage(imageUrl, Path.Join(tempFolder, $"{chapter++}.{extension}"), requestType, referrer);
-            parentTask.IncrementProgress(1f / imageUrls.Length);
-        }
-        
-        if(comicInfoPath is not null)
-            File.Copy(comicInfoPath, Path.Join(tempFolder, "ComicInfo.xml"));
-        
-        logger?.WriteLine("Connector", $"Creating archive {saveArchiveFilePath}");
-        //ZIP-it and ship-it
-        ZipFile.CreateFromDirectory(tempFolder, saveArchiveFilePath);
-        if(RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-            File.SetUnixFileMode(saveArchiveFilePath, GroupRead | GroupWrite | OtherRead | OtherWrite | UserRead | UserWrite);
-        Directory.Delete(tempFolder, true); //Cleanup
-    }
-    
-    protected string SaveCoverImageToCache(string url, byte requestType)
-    {
-        string[] split = url.Split('/');
-        string filename = split[^1];
-        string saveImagePath = Path.Join(imageCachePath, filename);
-
-        if (File.Exists(saveImagePath))
-            return filename;
-        
-        DownloadClient.RequestResult coverResult = downloadClient.MakeRequest(url, requestType);
-        using MemoryStream ms = new();
-        coverResult.result.CopyTo(ms);
-        File.WriteAllBytes(saveImagePath, ms.ToArray());
-        logger?.WriteLine(this.GetType().ToString(), $"Saving image to {saveImagePath}");
-        return filename;
-    }
-    
-    protected class DownloadClient
-    {
-        private static readonly HttpClient Client = new();
-
-        private readonly Dictionary<byte, DateTime> _lastExecutedRateLimit;
-        private readonly Dictionary<byte, TimeSpan> _rateLimit;
-        private Logger? logger;
-
-        /// <summary>
-        /// Creates a httpClient
-        /// </summary>
-        /// <param name="rateLimitRequestsPerMinute">Rate limits for requests. byte is RequestType, int maximum requests per minute for RequestType</param>
-        /// <param name="logger"></param>
-        public DownloadClient(Dictionary<byte, int> rateLimitRequestsPerMinute, Logger? logger)
-        {
-            this.logger = logger;
-            _lastExecutedRateLimit = new();
-            _rateLimit = new();
-            foreach(KeyValuePair<byte, int> limit in rateLimitRequestsPerMinute)
-                _rateLimit.Add(limit.Key, TimeSpan.FromMinutes(1).Divide(limit.Value));
-        }
-
-        /// <summary>
-        /// Request Webpage
-        /// </summary>
-        /// <param name="url"></param>
-        /// <param name="requestType">For RateLimits: Same Endpoints use same type</param>
-        /// <param name="referrer">Used in http request header</param>
-        /// <returns>RequestResult with StatusCode and Stream of received data</returns>
-        public RequestResult MakeRequest(string url, byte requestType, string? referrer = null)
-        {
-            if (_rateLimit.TryGetValue(requestType, out TimeSpan value))
-                _lastExecutedRateLimit.TryAdd(requestType, DateTime.Now.Subtract(value));
-            else
-            {
-                logger?.WriteLine(this.GetType().ToString(), "RequestType not configured for rate-limit.");
-                return new RequestResult(HttpStatusCode.NotAcceptable, Stream.Null);
-            }
-
-            TimeSpan rateLimitTimeout = _rateLimit[requestType]
-                .Subtract(DateTime.Now.Subtract(_lastExecutedRateLimit[requestType]));
-            
-            if(rateLimitTimeout > TimeSpan.Zero)
-                Thread.Sleep(rateLimitTimeout);
-
-            HttpResponseMessage? response = null;
-            while (response is null)
-            {
-                try
-                {
-                    HttpRequestMessage requestMessage = new(HttpMethod.Get, url);
-                    if(referrer is not null)
-                        requestMessage.Headers.Referrer = new Uri(referrer);
-                    _lastExecutedRateLimit[requestType] = DateTime.Now;
-                    response = Client.Send(requestMessage);
-                }
-                catch (HttpRequestException e)
-                {
-                    logger?.WriteLine(this.GetType().ToString(), e.Message);
-                    logger?.WriteLine(this.GetType().ToString(), $"Waiting {_rateLimit[requestType] * 2}... Retrying.");
-                    Thread.Sleep(_rateLimit[requestType] * 2);
-                }
-            }
-            Stream resultString = response.IsSuccessStatusCode ? response.Content.ReadAsStream() : Stream.Null;
-            if (!response.IsSuccessStatusCode)
-                logger?.WriteLine(this.GetType().ToString(), $"Request-Error {response.StatusCode}: {response.ReasonPhrase}");
-            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,277 +0,0 @@
-using System.Globalization;
-using System.Net;
-using System.Text.Json;
-using System.Text.Json.Nodes;
-using Logging;
-using Tranga.TrangaTasks;
-
-namespace Tranga.Connectors;
-public class MangaDex : Connector
-{
-    public override string name { get; }
-
-    private enum RequestType : byte
-    {
-        Manga,
-        Feed,
-        AtHomeServer,
-        CoverUrl,
-        Author,
-    }
-
-    public MangaDex(string downloadLocation, string imageCachePath, Logger? logger) : base(downloadLocation, imageCachePath, logger)
-    {
-        name = "MangaDex";
-        this.downloadClient = new DownloadClient(new Dictionary<byte, int>()
-        {
-            {(byte)RequestType.Manga, 250},
-            {(byte)RequestType.Feed, 250},
-            {(byte)RequestType.AtHomeServer, 40},
-            {(byte)RequestType.CoverUrl, 250},
-            {(byte)RequestType.Author, 250}
-        }, logger);
-    }
-
-    public override Publication[] GetPublications(string publicationTitle = "")
-    {
-        logger?.WriteLine(this.GetType().ToString(), $"Getting Publications (title={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<Publication> publications = new();
-        int loadedPublicationData = 0;
-        while (offset < total) //As long as we haven't requested all "Pages"
-        {
-            //Request next Page
-            DownloadClient.RequestResult requestResult =
-                downloadClient.MakeRequest(
-                    $"https://api.mangadex.org/manga?limit={limit}&title={publicationTitle}&offset={offset}", (byte)RequestType.Manga);
-            if (requestResult.statusCode != HttpStatusCode.OK)
-                break;
-            JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
-            
-            offset += limit;
-            if (result is null)
-                break;
-            
-            total = result["total"]!.GetValue<int>(); //Update the total number of Publications
-            
-            JsonArray mangaInResult = result["data"]!.AsArray(); //Manga-data-Array
-            //Loop each Manga and extract information from JSON
-            foreach (JsonNode? mangeNode in mangaInResult)
-            {
-                logger?.WriteLine(this.GetType().ToString(), $"Getting publication data. {++loadedPublicationData}/{total}");
-                JsonObject manga = (JsonObject)mangeNode!;
-                JsonObject attributes = manga["attributes"]!.AsObject();
-                
-                string publicationId = manga["id"]!.GetValue<string>();
-                
-                string title = attributes["title"]!.AsObject().ContainsKey("en") && attributes["title"]!["en"] is not null
-                    ? attributes["title"]!["en"]!.GetValue<string>()
-                    : attributes["title"]![((IDictionary<string, JsonNode?>)attributes["title"]!.AsObject()).Keys.First()]!.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();
-                Dictionary<string, string> altTitlesDict = new();
-                foreach (JsonNode? altTitleNode in altTitlesObject)
-                {
-                    JsonObject altTitleObject = (JsonObject)altTitleNode!;
-                    string key = ((IDictionary<string, JsonNode?>)altTitleObject).Keys.ToArray()[0];
-                    altTitlesDict.TryAdd(key, 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? posterId = null;
-                string? authorId = null;
-                if (manga.ContainsKey("relationships") && manga["relationships"] is not null)
-                {
-                    JsonArray relationships = manga["relationships"]!.AsArray();
-                    posterId = relationships.FirstOrDefault(relationship => relationship!["type"]!.GetValue<string>() == "cover_art")!["id"]!.GetValue<string>();
-                    authorId = relationships.FirstOrDefault(relationship => relationship!["type"]!.GetValue<string>() == "author")!["id"]!.GetValue<string>();
-                }
-                string? coverUrl = GetCoverUrl(publicationId, posterId);
-                string? coverCacheName = null;
-                if (coverUrl is not null)
-                    coverCacheName = SaveCoverImageToCache(coverUrl, (byte)RequestType.AtHomeServer);
-                
-                string? author = GetAuthor(authorId);
-
-                Dictionary<string, string> linksDict = new();
-                if (attributes.ContainsKey("links") && attributes["links"] is not null)
-                {
-                    JsonObject linksObject = attributes["links"]!.AsObject();
-                    foreach (string key in ((IDictionary<string, JsonNode?>)linksObject).Keys)
-                    {
-                        linksDict.Add(key, 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 (
-                    title,
-                    author,
-                    description,
-                    altTitlesDict,
-                    tags.ToArray(),
-                    coverUrl,
-                    coverCacheName,
-                    linksDict,
-                    year,
-                    originalLanguage,
-                    status,
-                    publicationId
-                );
-                publications.Add(pub); //Add Publication (Manga) to result
-            }
-        }
-
-        logger?.WriteLine(this.GetType().ToString(), $"Done getting publications (title={publicationTitle})");
-        return publications.ToArray();
-    }
-
-    public override Chapter[] GetChapters(Publication publication, string language = "")
-    {
-        logger?.WriteLine(this.GetType().ToString(), $"Getting Chapters for {publication.sortName} {publication.internalId} (language={language})");
-        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"
-            DownloadClient.RequestResult requestResult =
-                downloadClient.MakeRequest(
-                    $"https://api.mangadex.org/manga/{publication.publicationId}/feed?limit={limit}&offset={offset}&translatedLanguage%5B%5D={language}", (byte)RequestType.Feed);
-            if (requestResult.statusCode != HttpStatusCode.OK)
-                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? 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(title, volume, chapterNum, chapterId));
-            }
-        }
-
-        //Return Chapters ordered by Chapter-Number
-        NumberFormatInfo chapterNumberFormatInfo = new()
-        {
-            NumberDecimalSeparator = "."
-        };
-        logger?.WriteLine(this.GetType().ToString(), $"Done getting Chapters for {publication.internalId}");
-        return chapters.OrderBy(chapter => Convert.ToSingle(chapter.chapterNumber, chapterNumberFormatInfo)).ToArray();
-    }
-
-    public override void DownloadChapter(Publication publication, Chapter chapter, DownloadChapterTask parentTask)
-    {
-        logger?.WriteLine(this.GetType().ToString(), $"Downloading Chapter-Info {publication.sortName} {publication.internalId} {chapter.volumeNumber}-{chapter.chapterNumber}");
-        //Request URLs for Chapter-Images
-        DownloadClient.RequestResult requestResult =
-            downloadClient.MakeRequest($"https://api.mangadex.org/at-home/server/{chapter.url}?forcePort443=false'", (byte)RequestType.AtHomeServer);
-        if (requestResult.statusCode != HttpStatusCode.OK)
-            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)
-        HashSet<string> imageUrls = new();
-        foreach (JsonNode? image in imageFileNames)
-            imageUrls.Add($"{baseUrl}/data/{hash}/{image!.GetValue<string>()}");
-
-        string comicInfoPath = Path.GetTempFileName();
-        File.WriteAllText(comicInfoPath, GetComicInfoXmlString(publication, chapter, logger));
-        
-        //Download Chapter-Images
-        DownloadChapterImages(imageUrls.ToArray(), GetArchiveFilePath(publication, chapter), (byte)RequestType.AtHomeServer, parentTask, comicInfoPath);
-    }
-
-    private string? GetCoverUrl(string publicationId, string? posterId)
-    {
-        logger?.WriteLine(this.GetType().ToString(), $"Getting CoverUrl for {publicationId}");
-        if (posterId is null)
-        {
-            logger?.WriteLine(this.GetType().ToString(), $"No posterId, aborting");
-            return null;
-        }
-        
-        //Request information where to download Cover
-        DownloadClient.RequestResult requestResult =
-            downloadClient.MakeRequest($"https://api.mangadex.org/cover/{posterId}", (byte)RequestType.CoverUrl);
-        if (requestResult.statusCode != HttpStatusCode.OK)
-            return null;
-        JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
-        if (result is null)
-            return null;
-
-        string fileName = result["data"]!["attributes"]!["fileName"]!.GetValue<string>();
-
-        string coverUrl = $"https://uploads.mangadex.org/covers/{publicationId}/{fileName}";
-        logger?.WriteLine(this.GetType().ToString(), $"Got Cover-Url for {publicationId} -> {coverUrl}");
-        return coverUrl;
-    }
-
-    private string? GetAuthor(string? authorId)
-    {
-        if (authorId is null)
-            return null;
-        
-        DownloadClient.RequestResult requestResult =
-            downloadClient.MakeRequest($"https://api.mangadex.org/author/{authorId}", (byte)RequestType.Author);
-        if (requestResult.statusCode != HttpStatusCode.OK)
-            return null;
-        JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
-        if (result is null)
-            return null;
-
-        string author = result["data"]!["attributes"]!["name"]!.GetValue<string>();
-        logger?.WriteLine(this.GetType().ToString(), $"Got author {authorId} -> {author}");
-        return author;
-    }
-}

Tranga/Connectors/Manganato.cs

@@ -1,196 +0,0 @@
-using System.Net;
-using System.Text.RegularExpressions;
-using HtmlAgilityPack;
-using Logging;
-using Tranga.TrangaTasks;
-
-namespace Tranga.Connectors;
-
-public class Manganato : Connector
-{
-    public override string name { get; }
-    
-    public Manganato(string downloadLocation, string imageCachePath, Logger? logger) : base(downloadLocation, imageCachePath, logger)
-    {
-        this.name = "Manganato";
-        this.downloadClient = new DownloadClient(new Dictionary<byte, int>()
-        {
-            {(byte)1, 60}
-        }, logger);
-    }
-
-    public override Publication[] GetPublications(string publicationTitle = "")
-    {
-        logger?.WriteLine(this.GetType().ToString(), $"Getting Publications (title={publicationTitle})");
-        string sanitizedTitle = string.Concat(Regex.Matches(publicationTitle, "[A-z]* *")).ToLower().Replace(' ', '_');
-        string requestUrl = $"https://manganato.com/search/story/{sanitizedTitle}";
-        DownloadClient.RequestResult requestResult =
-            downloadClient.MakeRequest(requestUrl, (byte)1);
-        if (requestResult.statusCode != HttpStatusCode.OK)
-            return Array.Empty<Publication>();
-
-        return ParsePublicationsFromHtml(requestResult.result);
-    }
-
-    private Publication[] ParsePublicationsFromHtml(Stream html)
-    {
-        StreamReader reader = new (html);
-        string htmlString = reader.ReadToEnd();
-        HtmlDocument document = new ();
-        document.LoadHtml(htmlString);
-        IEnumerable<HtmlNode> searchResults = document.DocumentNode.Descendants("div").Where(n => n.HasClass("search-story-item"));
-        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);
-        }
-
-        HashSet<Publication> ret = new();
-        foreach (string url in urls)
-        {
-            DownloadClient.RequestResult requestResult =
-                downloadClient.MakeRequest(url, (byte)1);
-            if (requestResult.statusCode != HttpStatusCode.OK)
-                return Array.Empty<Publication>();
-
-            ret.Add(ParseSinglePublicationFromHtml(requestResult.result, url.Split('/')[^1]));
-        }
-
-        return ret.ToArray();
-    }
-
-    private Publication ParseSinglePublicationFromHtml(Stream html, string publicationId)
-    {
-        StreamReader reader = new (html);
-        string htmlString = reader.ReadToEnd();
-        HtmlDocument document = new ();
-        document.LoadHtml(htmlString);
-        string status = "";
-        Dictionary<string, string> altTitles = new();
-        Dictionary<string, string>? links = null;
-        HashSet<string> tags = new();
-        string? author = null, originalLanguage = null;
-        int? year = DateTime.Now.Year;
-
-        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++)
-                        altTitles.Add(i.ToString(), alts[i]);
-                    break;
-                case "authors":
-                    author = value;
-                    break;
-                case "status":
-                    status = value;
-                    break;
-                case "genres":
-                    string[] genres = value.Split(" - ");
-                    tags = genres.ToHashSet();
-                    break;
-                default: break;
-            }
-        }
-
-        string posterUrl = document.DocumentNode.Descendants("span").First(s => s.HasClass("info-image")).Descendants("img").First()
-            .GetAttributes().First(a => a.Name == "src").Value;
-
-        string coverFileNameInCache = SaveCoverImageToCache(posterUrl, 1);
-
-        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 yearString = document.DocumentNode.Descendants("li").Last(li => li.HasClass("a-h")).Descendants("span")
-            .First(s => s.HasClass("chapter-time")).InnerText;
-        year = Convert.ToInt32(yearString.Split(',')[^1]) + 2000;
-        
-        return new Publication(sortName, author, description, altTitles, tags.ToArray(), posterUrl, coverFileNameInCache, links,
-            year, originalLanguage, status, publicationId);
-    }
-
-    public override Chapter[] GetChapters(Publication publication, string language = "")
-    {
-        logger?.WriteLine(this.GetType().ToString(), $"Getting Chapters for {publication.sortName} {publication.internalId} (language={language})");
-        string requestUrl = $"https://chapmanganato.com/{publication.publicationId}";
-        DownloadClient.RequestResult requestResult =
-            downloadClient.MakeRequest(requestUrl, (byte)1);
-        if (requestResult.statusCode != HttpStatusCode.OK)
-            return Array.Empty<Chapter>();
-
-        return ParseChaptersFromHtml(requestResult.result);
-    }
-
-    private Chapter[] ParseChaptersFromHtml(Stream html)
-    {
-        StreamReader reader = new (html);
-        string htmlString = reader.ReadToEnd();
-        HtmlDocument document = new ();
-        document.LoadHtml(htmlString);
-        List<Chapter> ret = new();
-
-        HtmlNode chapterList = document.DocumentNode.Descendants("ul").First(l => l.HasClass("row-content-chapter"));
-
-        foreach (HtmlNode chapterInfo in chapterList.Descendants("li"))
-        {
-            string fullString = chapterInfo.Descendants("a").First(d => d.HasClass("chapter-name")).InnerText;
-
-            string? volumeNumber = fullString.Contains("Vol.") ? fullString.Replace("Vol.", "").Split(' ')[0] : null;
-            string? chapterNumber = fullString.Split(':')[0].Split("Chapter ")[1].Replace('-','.');
-            string chapterName = string.Concat(fullString.Split(':')[1..]);
-            string url = chapterInfo.Descendants("a").First(d => d.HasClass("chapter-name"))
-                .GetAttributeValue("href", "");
-            ret.Add(new Chapter(chapterName, volumeNumber, chapterNumber, url));
-        }
-        ret.Reverse();
-        return ret.ToArray();
-    }
-
-    public override void DownloadChapter(Publication publication, Chapter chapter, DownloadChapterTask parentTask)
-    {
-        logger?.WriteLine(this.GetType().ToString(), $"Downloading Chapter-Info {publication.sortName} {publication.internalId} {chapter.volumeNumber}-{chapter.chapterNumber}");
-        string requestUrl = chapter.url;
-        DownloadClient.RequestResult requestResult =
-            downloadClient.MakeRequest(requestUrl, (byte)1);
-        if (requestResult.statusCode != HttpStatusCode.OK)
-            return;
-
-        string[] imageUrls = ParseImageUrlsFromHtml(requestResult.result);
-        
-        string comicInfoPath = Path.GetTempFileName();
-        File.WriteAllText(comicInfoPath, GetComicInfoXmlString(publication, chapter, logger));
-        
-        DownloadChapterImages(imageUrls, GetArchiveFilePath(publication, chapter), (byte)1, parentTask, comicInfoPath, "https://chapmanganato.com/");
-    }
-
-    private string[] ParseImageUrlsFromHtml(Stream html)
-    {
-        StreamReader reader = new (html);
-        string htmlString = reader.ReadToEnd();
-        HtmlDocument document = new ();
-        document.LoadHtml(htmlString);
-        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();
-    }
-}

Tranga/Connectors/Mangasee.cs

@@ -1,235 +0,0 @@
-using System.Net;
-using System.Text.RegularExpressions;
-using System.Xml.Linq;
-using HtmlAgilityPack;
-using Logging;
-using Newtonsoft.Json;
-using PuppeteerSharp;
-using Tranga.TrangaTasks;
-
-namespace Tranga.Connectors;
-
-public class Mangasee : Connector
-{
-    public override string name { get; }
-    private IBrowser? _browser = null;
-    private const string ChromiumVersion = "1153303";
-
-    public Mangasee(string downloadLocation, string imageCachePath, Logger? logger) : base(downloadLocation,
-        imageCachePath, logger)
-    {
-        this.name = "Mangasee";
-        this.downloadClient = new DownloadClient(new Dictionary<byte, int>()
-        {
-            { (byte)1, 60 }
-        }, logger);
-
-        Task d = new Task(DownloadBrowser);
-        d.Start();
-    }
-
-    private async void DownloadBrowser()
-    {
-        BrowserFetcher browserFetcher = new BrowserFetcher();
-        foreach(string rev in browserFetcher.LocalRevisions().Where(rev => rev != ChromiumVersion))
-            browserFetcher.Remove(rev);
-        if (!browserFetcher.LocalRevisions().Contains(ChromiumVersion))
-        {
-            logger?.WriteLine(this.GetType().ToString(), "Downloading headless browser");
-            DateTime last = DateTime.Now.Subtract(TimeSpan.FromSeconds(5));
-            browserFetcher.DownloadProgressChanged += (sender, args) =>
-            {
-                double currentBytes = Convert.ToDouble(args.BytesReceived) / Convert.ToDouble(args.TotalBytesToReceive);
-                if (args.TotalBytesToReceive == args.BytesReceived)
-                {
-                    logger?.WriteLine(this.GetType().ToString(), "Browser downloaded.");
-                }
-                else if (DateTime.Now > last.AddSeconds(5))
-                {
-                    logger?.WriteLine(this.GetType().ToString(), $"Browser download progress: {currentBytes:P2}");
-                    last = DateTime.Now;
-                }
-
-            };
-            if (!browserFetcher.CanDownloadAsync(ChromiumVersion).Result)
-            {
-                logger?.WriteLine(this.GetType().ToString(), $"Can't download browser version {ChromiumVersion}");
-                return;
-            }
-            await browserFetcher.DownloadAsync(ChromiumVersion);
-        }
-        
-        logger?.WriteLine(this.GetType().ToString(), "Starting browser.");
-        this._browser = await Puppeteer.LaunchAsync(new LaunchOptions
-        {
-            Headless = true,
-            ExecutablePath = browserFetcher.GetExecutablePath(ChromiumVersion),
-            Args = new [] {
-                "--disable-gpu",
-                "--disable-dev-shm-usage",
-                "--disable-setuid-sandbox",
-                "--no-sandbox"}
-        });
-    }
-
-    public override Publication[] GetPublications(string publicationTitle = "")
-    {
-        logger?.WriteLine(this.GetType().ToString(), $"Getting Publications (title={publicationTitle})");
-        string sanitizedTitle = string.Concat(Regex.Matches(publicationTitle, "[A-z]* *")).ToLower().Replace(' ', '+');
-        string requestUrl = $"https://mangasee123.com/_search.php";
-        DownloadClient.RequestResult requestResult =
-            downloadClient.MakeRequest(requestUrl, (byte)1);
-        if (requestResult.statusCode != HttpStatusCode.OK)
-            return Array.Empty<Publication>();
-
-        return ParsePublicationsFromHtml(requestResult.result, publicationTitle);
-    }
-
-    private Publication[] ParsePublicationsFromHtml(Stream html, string publicationTitle)
-    {
-        string jsonString = new StreamReader(html).ReadToEnd();
-        List<SearchResultItem> result = JsonConvert.DeserializeObject<List<SearchResultItem>>(jsonString)!;
-        Dictionary<SearchResultItem, int> queryFiltered = new();
-        foreach (SearchResultItem resultItem in result)
-        {
-            foreach (string term in publicationTitle.Split(' '))
-                if (resultItem.i.Contains(term, StringComparison.CurrentCultureIgnoreCase))
-                    if (!queryFiltered.TryAdd(resultItem, 0))
-                        queryFiltered[resultItem]++;
-        }
-
-        queryFiltered = queryFiltered.Where(item => item.Value >= publicationTitle.Split(' ').Length - 1)
-            .ToDictionary(item => item.Key, item => item.Value);
-
-        HashSet<Publication> ret = new();
-        List<SearchResultItem> orderedFiltered =
-            queryFiltered.OrderBy(item => item.Value).ToDictionary(item => item.Key, item => item.Value).Keys.ToList();
-
-        foreach (SearchResultItem orderedItem in orderedFiltered)
-        {
-            DownloadClient.RequestResult requestResult =
-                downloadClient.MakeRequest($"https://mangasee123.com/manga/{orderedItem.i}", (byte)1);
-            if (requestResult.statusCode != HttpStatusCode.OK)
-                return Array.Empty<Publication>();
-            ret.Add(ParseSinglePublicationFromHtml(requestResult.result, orderedItem.s, orderedItem.i, orderedItem.a));
-        }
-        return ret.ToArray();
-    }
-
-    
-    private Publication ParseSinglePublicationFromHtml(Stream html, string sortName, string publicationId, string[] a)
-    {
-        StreamReader reader = new (html);
-        string htmlString = reader.ReadToEnd();
-        HtmlDocument document = new ();
-        document.LoadHtml(htmlString);
-
-        string originalLanguage = "", status = "";
-        Dictionary<string, string> altTitles = new(), links = new();
-        HashSet<string> tags = new();
-
-        HtmlNode posterNode =
-            document.DocumentNode.Descendants("img").First(img => img.HasClass("img-fluid") && img.HasClass("bottom-5"));
-        string posterUrl = posterNode.GetAttributeValue("src", "");
-        string coverFileNameInCache = SaveCoverImageToCache(posterUrl, 1);
-
-        HtmlNode attributes = document.DocumentNode.Descendants("div")
-            .First(div => div.HasClass("col-md-9") && div.HasClass("col-sm-8") && div.HasClass("top-5"))
-            .Descendants("ul").First();
-
-        HtmlNode[] authorsNodes = attributes.Descendants("li")
-            .First(node => node.InnerText.Contains("author(s):", StringComparison.CurrentCultureIgnoreCase))
-            .Descendants("a").ToArray();
-        string[] authors = new string[authorsNodes.Length];
-        for (int j = 0; j < authors.Length; j++)
-            authors[j] = authorsNodes[j].InnerText;
-        string author = string.Join(" - ", authors);
-
-        HtmlNode[] genreNodes = attributes.Descendants("li")
-            .First(node => node.InnerText.Contains("genre(s):", StringComparison.CurrentCultureIgnoreCase))
-            .Descendants("a").ToArray();
-        foreach (HtmlNode genreNode in genreNodes)
-            tags.Add(genreNode.InnerText);
-
-        HtmlNode yearNode = attributes.Descendants("li")
-            .First(node => node.InnerText.Contains("released:", StringComparison.CurrentCultureIgnoreCase))
-            .Descendants("a").First();
-        int year = Convert.ToInt32(yearNode.InnerText);
-
-        HtmlNode[] statusNodes = attributes.Descendants("li")
-            .First(node => node.InnerText.Contains("status:", StringComparison.CurrentCultureIgnoreCase))
-            .Descendants("a").ToArray();
-        foreach(HtmlNode statusNode in statusNodes)
-            if (statusNode.InnerText.Contains("publish", StringComparison.CurrentCultureIgnoreCase))
-                status = statusNode.InnerText.Split(' ')[0];
-        
-        HtmlNode descriptionNode = attributes.Descendants("li").First(node => node.InnerText.Contains("description:", StringComparison.CurrentCultureIgnoreCase)).Descendants("div").First();
-        string description = descriptionNode.InnerText;
-        
-        int i = 0;
-        foreach(string at in a)
-            altTitles.Add((i++).ToString(), at);
-        
-        return new Publication(sortName, author, description, altTitles, tags.ToArray(), posterUrl, coverFileNameInCache, links,
-            year, originalLanguage, status, publicationId);
-    }
-    
-    // ReSharper disable once ClassNeverInstantiated.Local Will be instantiated during deserialization
-    private class SearchResultItem
-    {
-#pragma warning disable CS8618 //Will always be set
-        public string i { get; set; }
-        public string s { get; set; }
-        public string[] a { get; set; }
-#pragma warning restore CS8618
-    }
-
-    public override Chapter[] GetChapters(Publication publication, string language = "")
-    {
-        XDocument doc = XDocument.Load($"https://mangasee123.com/rss/{publication.publicationId}.xml");
-        XElement[] chapterItems = doc.Descendants("item").ToArray();
-        List<Chapter> ret = new();
-        foreach (XElement chapter in chapterItems)
-        {
-            string? volumeNumber = "1";
-            string chapterName = chapter.Descendants("title").First().Value;
-            string chapterNumber = Regex.Matches(chapterName, "[0-9]+")[^1].ToString();
-
-            string url = chapter.Descendants("link").First().Value;
-            url = url.Replace(Regex.Matches(url,"(-page-[0-9])")[0].ToString(),"");
-            ret.Add(new Chapter("", volumeNumber, chapterNumber, url));
-        }
-
-        ret.Reverse();
-        return ret.ToArray();
-    }
-
-    public override void DownloadChapter(Publication publication, Chapter chapter, DownloadChapterTask parentTask)
-    {
-        while (this._browser is null)
-        {
-            logger?.WriteLine(this.GetType().ToString(), "Waiting for headless browser to download...");
-            Thread.Sleep(1000);
-        }
-        
-        logger?.WriteLine(this.GetType().ToString(), $"Downloading Chapter-Info {publication.sortName} {publication.internalId} {chapter.volumeNumber}-{chapter.chapterNumber}");
-        IPage page = _browser.NewPageAsync().Result;
-        IResponse response = page.GoToAsync(chapter.url).Result;
-        if (response.Ok)
-        {
-            HtmlDocument document = new ();
-            document.LoadHtml(page.GetContentAsync().Result);
-
-            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", ""));
-            
-            string comicInfoPath = Path.GetTempFileName();
-            File.WriteAllText(comicInfoPath, GetComicInfoXmlString(publication, chapter, logger));
-        
-            DownloadChapterImages(urls.ToArray(), GetArchiveFilePath(publication, chapter), (byte)1, parentTask, comicInfoPath);
-        }
-    }
-}

Tranga/LibraryManager.cs

@@ -1,121 +0,0 @@
-using System.Net;
-using System.Net.Http.Headers;
-using Logging;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using Tranga.LibraryManagers;
-
-namespace Tranga;
-
-public abstract class LibraryManager
-{
-    public enum LibraryType : byte
-    {
-        Komga = 0,
-        Kavita = 1
-    }
-
-    public LibraryType libraryType { get; }
-    public string baseUrl { get; }
-    public string auth { get; } //Base64 encoded, if you use your password everywhere, you have problems
-    protected Logger? logger;
-    
-    /// <param name="baseUrl">Base-URL of Komga instance, no trailing slashes(/)</param>
-    /// <param name="auth">Base64 string of username and password (username):(password)</param>
-    /// <param name="logger"></param>
-    protected LibraryManager(string baseUrl, string auth, Logger? logger, LibraryType libraryType)
-    {
-        this.baseUrl = baseUrl;
-        this.auth = auth;
-        this.logger = logger;
-        this.libraryType = libraryType;
-    }
-    public abstract void UpdateLibrary();
-
-    public void AddLogger(Logger newLogger)
-    {
-        this.logger = newLogger;
-    }
-
-    protected static class NetClient
-    {
-        public static Stream MakeRequest(string url, string authScheme, string auth, Logger? logger)
-        {
-            HttpClient client = new();
-            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(authScheme, auth);
-            
-            HttpRequestMessage requestMessage = new ()
-            {
-                Method = HttpMethod.Get,
-                RequestUri = new Uri(url)
-            };
-            logger?.WriteLine("LibraryManager", $"GET {url}");
-            HttpResponseMessage response = client.Send(requestMessage);
-            logger?.WriteLine("LibraryManager", $"{(int)response.StatusCode} {response.StatusCode}: {response.ReasonPhrase}");
-            
-            if(response.StatusCode is HttpStatusCode.Unauthorized && response.RequestMessage!.RequestUri!.AbsoluteUri != url)
-                return MakeRequest(response.RequestMessage!.RequestUri!.AbsoluteUri, authScheme, auth, logger);
-            else if (response.IsSuccessStatusCode)
-                return response.Content.ReadAsStream();
-            else
-                return Stream.Null;
-        }
-
-        public static bool MakePost(string url, string authScheme, string auth, Logger? logger)
-        {
-            HttpClient client = new()
-            {
-                DefaultRequestHeaders =
-                {
-                    { "Accept", "application/json" },
-                    { "Authorization", new AuthenticationHeaderValue(authScheme, auth).ToString() }
-                }
-            };
-            HttpRequestMessage requestMessage = new ()
-            {
-                Method = HttpMethod.Post,
-                RequestUri = new Uri(url)
-            };
-            logger?.WriteLine("LibraryManager", $"POST {url}");
-            HttpResponseMessage response = client.Send(requestMessage);
-            logger?.WriteLine("LibraryManager", $"{(int)response.StatusCode} {response.StatusCode}: {response.ReasonPhrase}");
-            
-            if(response.StatusCode is HttpStatusCode.Unauthorized && response.RequestMessage!.RequestUri!.AbsoluteUri != url)
-                return MakePost(response.RequestMessage!.RequestUri!.AbsoluteUri, authScheme, auth, logger);
-            else if (response.IsSuccessStatusCode)
-                return true;
-            else 
-                return false;
-        }
-    }
-    
-    public class LibraryManagerJsonConverter : JsonConverter
-    {
-        public override bool CanConvert(Type objectType)
-        {
-            return (objectType == typeof(LibraryManager));
-        }
-
-        public override object ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
-        {
-            JObject jo = JObject.Load(reader);
-            if (jo["libraryType"]!.Value<Int64>() == (Int64)LibraryType.Komga)
-                return jo.ToObject<Komga>(serializer)!;
-
-            if (jo["libraryType"]!.Value<Int64>() == (Int64)LibraryType.Kavita)
-                return jo.ToObject<Kavita>(serializer)!;
-
-            throw new Exception();
-        }
-
-        public override bool CanWrite => false;
-
-        /// <summary>
-        /// Don't call this
-        /// </summary>
-        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
-        {
-            throw new Exception("Dont call this");
-        }
-    }
-}

Tranga/LibraryManagers/Komga.cs

@@ -1,75 +0,0 @@
-using System.Text.Json.Nodes;
-using Logging;
-using Newtonsoft.Json;
-using JsonSerializer = System.Text.Json.JsonSerializer;
-
-namespace Tranga.LibraryManagers;
-
-/// <summary>
-/// Provides connectivity to Komga-API
-/// Can fetch and update libraries
-/// </summary>
-public class Komga : LibraryManager
-{
-    public Komga(string baseUrl, string username, string password, Logger? logger)
-        : base(baseUrl, Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes($"{username}:{password}")), logger, LibraryType.Komga)
-    {
-    }
-
-    [JsonConstructor]
-    public Komga(string baseUrl, string auth, Logger? logger) : base(baseUrl, auth, logger, LibraryType.Komga)
-    {
-    }
-
-    public override void UpdateLibrary()
-    {
-        logger?.WriteLine(this.GetType().ToString(), $"Updating Libraries");
-        foreach (KomgaLibrary lib in GetLibraries())
-            NetClient.MakePost($"{baseUrl}/api/v1/libraries/{lib.id}/scan", "Basic", auth, logger);
-    }
-
-    /// <summary>
-    /// Fetches all libraries available to the user
-    /// </summary>
-    /// <returns>Array of KomgaLibraries</returns>
-    private IEnumerable<KomgaLibrary> GetLibraries()
-    {
-        logger?.WriteLine(this.GetType().ToString(), $"Getting Libraries");
-        Stream data = NetClient.MakeRequest($"{baseUrl}/api/v1/libraries", "Basic", auth, logger);
-        if (data == Stream.Null)
-        {
-            logger?.WriteLine(this.GetType().ToString(), $"No libraries returned");
-            return Array.Empty<KomgaLibrary>();
-        }
-        JsonArray? result = JsonSerializer.Deserialize<JsonArray>(data);
-        if (result is null)
-        {
-            logger?.WriteLine(this.GetType().ToString(), $"No libraries returned");
-            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; }
-        public string name { get; }
-
-        public KomgaLibrary(string id, string name)
-        {
-            this.id = id;
-            this.name = name;
-        }
-    }
-}

Tranga/Publication.cs

@@ -1,128 +0,0 @@
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Text.RegularExpressions;
-using Newtonsoft.Json;
-using static System.IO.UnixFileMode;
-
-namespace Tranga;
-
-/// <summary>
-/// Contains information on a Publication (Manga)
-/// </summary>
-public readonly struct Publication
-{
-    public string sortName { get; }
-    public string? author { get; }
-    public Dictionary<string,string> altTitles { get; }
-    // ReSharper disable trice MemberCanBePrivate.Global, trust
-    public string? description { get; }
-    public string[] tags { get; }
-    public string? posterUrl { get; }
-    public string? coverFileNameInCache { get; }
-    public Dictionary<string,string> links { get; }
-    public int? year { get; }
-    public string? originalLanguage { get; }
-    public string status { get; }
-    public string folderName { get; }
-    public string publicationId { get; }
-    public string internalId { get; }
-
-    private static readonly Regex LegalCharacters = new Regex(@"[A-Z]*[a-z]*[0-9]* *\.*-*,*'*\'*\)*\(*~*!*");
-
-    public Publication(string sortName, string? author, string? description, Dictionary<string,string> altTitles, string[] tags, string? posterUrl, string? coverFileNameInCache, Dictionary<string,string>? links, int? year, string? originalLanguage, string status, string publicationId)
-    {
-        this.sortName = sortName;
-        this.author = author;
-        this.description = description;
-        this.altTitles = altTitles;
-        this.tags = tags;
-        this.coverFileNameInCache = coverFileNameInCache;
-        this.posterUrl = posterUrl;
-        this.links = links ?? new Dictionary<string, string>();
-        this.year = year;
-        this.originalLanguage = originalLanguage;
-        this.status = status;
-        this.publicationId = publicationId;
-        this.folderName = string.Concat(LegalCharacters.Matches(sortName));
-        while (this.folderName.EndsWith('.'))
-            this.folderName = this.folderName.Substring(0, this.folderName.Length - 1);
-        string onlyLowerLetters = string.Concat(this.sortName.ToLower().Where(Char.IsLetter));
-        this.internalId = Convert.ToBase64String(Encoding.ASCII.GetBytes($"{onlyLowerLetters}{this.year}"));
-    }
-
-    public string CreatePublicationFolder(string downloadDirectory)
-    {
-        string publicationFolder = Path.Join(downloadDirectory, 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;
-    }
-
-    public void SaveSeriesInfoJson(string downloadDirectory)
-    {
-        string publicationFolder = CreatePublicationFolder(downloadDirectory);
-        string seriesInfoPath = Path.Join(publicationFolder, "series.json");
-        if(!File.Exists(seriesInfoPath))
-            File.WriteAllText(seriesInfoPath,this.GetSeriesInfoJson());
-        if(RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-            File.SetUnixFileMode(seriesInfoPath, GroupRead | GroupWrite | OtherRead | OtherWrite | UserRead | UserWrite);
-    }
-    
-    /// <returns>Serialized JSON String for series.json</returns>
-    public string GetSeriesInfoJson()
-    {
-        SeriesInfo si = new (new Metadata(this.sortName, this.year.ToString() ?? string.Empty, this.status, this.description ?? ""));
-        return System.Text.Json.JsonSerializer.Serialize(si);
-    }
-
-    //Only for series.json
-    private struct SeriesInfo
-    {
-        // ReSharper disable once UnusedAutoPropertyAccessor.Local we need it, trust
-        [JsonRequired]public Metadata metadata { get; }
-        public SeriesInfo(Metadata metadata) => this.metadata = metadata;
-    }
-
-    //Only for series.json what an abomination, why are all the fields not-null????
-    private struct Metadata
-    {
-        // ReSharper disable UnusedAutoPropertyAccessor.Local we need them all, trust me
-        [JsonRequired] public string type { get; }
-        [JsonRequired] public string publisher { get; }
-        // ReSharper disable twice IdentifierTypo
-        [JsonRequired] public int comicid  { get; }
-        [JsonRequired] public string booktype { get; }
-        // ReSharper disable InconsistentNaming This one property is capitalized. Why?
-        [JsonRequired] public string ComicImage { get; }
-        [JsonRequired] public int total_issues { get; }
-        [JsonRequired] public string publication_run { get; }
-        [JsonRequired]public string name { get; }
-        [JsonRequired]public string year { get; }
-        [JsonRequired]public string status { get; }
-        [JsonRequired]public string description_text { get; }
-
-        public Metadata(string name, string year, string status, string description_text)
-        {
-            this.name = name;
-            this.year = year;
-            if(status.ToLower() == "ongoing" || status.ToLower() == "hiatus")
-                this.status = "Continuing";
-            else if (status.ToLower() == "completed" || status.ToLower() == "cancelled" || status.ToLower() == "discontinued")
-                this.status = "Ended";
-            else
-                this.status = status;
-            this.description_text = description_text;
-            
-            //kill it with fire, but otherwise Komga will not parse
-            type = "Manga";
-            publisher = "";
-            comicid = 0;
-            booktype = "";
-            ComicImage = "";
-            total_issues = 0;
-            publication_run = "";
-        }
-    }
-}