Pushover Notifications https://github.com/C9Glax/tranga/issues/246

https://github.com/C9Glax/tranga/issues/92

.dockerignore

@@ -1,27 +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
-Manga
-settings

.gitignore

@@ -20,6 +20,8 @@ riderModule.iml
 cover.jpg
 cover.png
 /.vscode
+/.vs/
+Tranga/Properties/launchSettings.json
 /Manga
 /settings
 *.DotSettings.user

API/API.csproj

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

API/API.http

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

API/APIEndpointRecords/DownloadAvailableJobsRecord.cs

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

API/APIEndpointRecords/GotifyRecord.cs

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

API/APIEndpointRecords/LunaseaRecord.cs

@@ -0,0 +1,16 @@
+using System.Text.RegularExpressions;
+
+namespace API.APIEndpointRecords;
+
+public record LunaseaRecord(string id)
+{
+    private static Regex validateRex = new(@"(?:device|user)\/[0-9a-zA-Z\-]+");
+    public bool Validate()
+    {
+        if (id == string.Empty)
+            return false;
+        if (!validateRex.IsMatch(id))
+            return false;
+        return true;
+    }
+}

API/APIEndpointRecords/ModifyJobRecord.cs

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

API/APIEndpointRecords/NewLibraryRecord.cs

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

API/APIEndpointRecords/NtfyRecord.cs

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

API/APIEndpointRecords/PushoverRecord.cs

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

API/Controllers/JobController.cs

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

API/Controllers/LibraryConnectorController.cs

@@ -0,0 +1,96 @@
+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]
+[Route("v{v:apiVersion}/[controller]")]
+public class LibraryConnectorController(PgsqlContext context) : Controller
+{
+    /// <summary>
+    /// Gets all configured Library-Connectors
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet]
+    [ProducesResponseType<LibraryConnector[]>(Status200OK, "application/json")]
+    public IActionResult GetAllConnectors()
+    {
+        LibraryConnector[] connectors = context.LibraryConnectors.ToArray();
+        return Ok(connectors);
+    }
+    
+    /// <summary>
+    /// Returns Library-Connector with requested ID
+    /// </summary>
+    /// <param name="LibraryControllerId">Library-Connector-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">Connector with ID not found.</response>
+    [HttpGet("{LibraryControllerId}")]
+    [ProducesResponseType<LibraryConnector>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetConnector(string LibraryControllerId)
+    {
+        LibraryConnector? ret = context.LibraryConnectors.Find(LibraryControllerId);
+        return (ret is not null) switch
+        {
+            true => Ok(ret),
+            false => NotFound()
+        };
+    }
+    
+    /// <summary>
+    /// Creates a new Library-Connector
+    /// </summary>
+    /// <param name="libraryConnector">Library-Connector</param>
+    /// <response code="201"></response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut]
+    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateConnector([FromBody]LibraryConnector libraryConnector)
+    {
+        try
+        {
+            context.LibraryConnectors.Add(libraryConnector);
+            context.SaveChanges();
+            return Created();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+    
+    /// <summary>
+    /// Deletes the Library-Connector with the requested ID
+    /// </summary>
+    /// <param name="LibraryControllerId">Library-Connector-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">Connector with ID not found.</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpDelete("{LibraryControllerId}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult DeleteConnector(string LibraryControllerId)
+    {
+        try
+        {
+            LibraryConnector? ret = context.LibraryConnectors.Find(LibraryControllerId);
+            if (ret is null)
+                return NotFound();
+            
+            context.Remove(ret);
+            context.SaveChanges();
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+}

API/Controllers/LocalLibrariesController.cs

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

API/Controllers/MangaConnectorController.cs

@@ -0,0 +1,80 @@
+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]
+[Route("v{v:apiVersion}/[controller]")]
+public class MangaConnectorController(PgsqlContext context) : Controller
+{
+    /// <summary>
+    /// Get all available Connectors (Scanlation-Sites)
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet]
+    [ProducesResponseType<MangaConnector[]>(Status200OK, "application/json")]
+    public IActionResult GetConnectors()
+    {
+        MangaConnector[] connectors = context.MangaConnectors.ToArray();
+        return Ok(connectors);
+    }
+    
+    /// <summary>
+    /// Get all enabled Connectors (Scanlation-Sites)
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet("enabled")]
+    [ProducesResponseType<MangaConnector[]>(Status200OK, "application/json")]
+    public IActionResult GetEnabledConnectors()
+    {
+        MangaConnector[] connectors = context.MangaConnectors.Where(c => c.Enabled == true).ToArray();
+        return Ok(connectors);
+    }
+    
+    /// <summary>
+    /// Get all disabled Connectors (Scanlation-Sites)
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet("disabled")]
+    [ProducesResponseType<MangaConnector[]>(Status200OK, "application/json")]
+    public IActionResult GetDisabledConnectors()
+    {
+        MangaConnector[] connectors = context.MangaConnectors.Where(c => c.Enabled == false).ToArray();
+        return Ok(connectors);
+    }
+
+    /// <summary>
+    /// Enabled or disables a Connector
+    /// </summary>
+    /// <param name="MangaConnectorName">ID of the connector</param>
+    /// <param name="enabled">Set true to enable</param>
+    /// <response code="200"></response>
+    /// <response code="404">Connector with ID not found.</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPatch("{MangaConnectorName}/SetEnabled/{enabled}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult SetEnabled(string MangaConnectorName, bool enabled)
+    {
+        try
+        {
+            MangaConnector? connector = context.MangaConnectors.Find(MangaConnectorName);
+            if (connector is null)
+                return NotFound();
+            
+            connector.Enabled = enabled;
+            context.SaveChanges();
+
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+}

API/Controllers/MangaController.cs

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

API/Controllers/NotificationConnectorController.cs

@@ -0,0 +1,215 @@
+using System.Text;
+using API.APIEndpointRecords;
+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>
+    /// <response code="200"></response>
+    [HttpGet]
+    [ProducesResponseType<NotificationConnector[]>(Status200OK, "application/json")]
+    public IActionResult GetAllConnectors()
+    {
+        NotificationConnector[] ret = context.NotificationConnectors.ToArray();
+        return Ok(ret);
+    }
+    
+    /// <summary>
+    /// Returns Notification-Connector with requested ID
+    /// </summary>
+    /// <param name="NotificationConnectorId">Notification-Connector-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">NotificationConnector with ID not found</response>
+    [HttpGet("{NotificationConnectorId}")]
+    [ProducesResponseType<NotificationConnector>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetConnector(string NotificationConnectorId)
+    {
+        NotificationConnector? ret = context.NotificationConnectors.Find(NotificationConnectorId);
+        return (ret is not null) switch
+        {
+            true => Ok(ret),
+            false => NotFound()
+        };
+    }
+    
+    /// <summary>
+    /// Creates a new REST-Notification-Connector
+    /// </summary>
+    /// <remarks>Formatting placeholders: "%title" and "%text" can be placed in url, header-values and body and will be replaced when notifications are sent</remarks>
+    /// <param name="notificationConnector">Notification-Connector</param>
+    /// <response code="201">ID of new connector</response>
+    /// <response code="409">A NotificationConnector with name already exists</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
+    [ProducesResponseType(Status409Conflict)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateConnector([FromBody]NotificationConnector notificationConnector)
+    {
+        if (context.NotificationConnectors.Find(notificationConnector.Name) is not null)
+            return Conflict();
+        try
+        {
+            context.NotificationConnectors.Add(notificationConnector);
+            context.SaveChanges();
+            return Created(notificationConnector.Name, notificationConnector);
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+    
+    /// <summary>
+    /// Creates a new Gotify-Notification-Connector
+    /// </summary>
+    /// <remarks>Priority needs to be between 0 and 10</remarks>
+    /// <response code="201">ID of new connector</response>
+    /// <response code="400"></response>
+    /// <response code="409">A NotificationConnector with name already exists</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("Gotify")]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status409Conflict)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateGotifyConnector([FromBody]GotifyRecord gotifyData)
+    {
+        if(!gotifyData.Validate())
+            return BadRequest();
+        
+        NotificationConnector gotifyConnector = new NotificationConnector(TokenGen.CreateToken("Gotify"),
+            gotifyData.endpoint, 
+            new Dictionary<string, string>() { { "X-Gotify-Key", gotifyData.appToken } }, 
+            "POST", 
+            $"{{\"message\": \"%text\", \"title\": \"%title\", \"priority\": {gotifyData.priority}}}");
+        return CreateConnector(gotifyConnector);
+    }
+    
+    /// <summary>
+    /// Creates a new Ntfy-Notification-Connector
+    /// </summary>
+    /// <remarks>Priority needs to be between 1 and 5</remarks>
+    /// <response code="201">ID of new connector</response>
+    /// <response code="400"></response>
+    /// <response code="409">A NotificationConnector with name already exists</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("Ntfy")]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status409Conflict)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateNtfyConnector([FromBody]NtfyRecord ntfyRecord)
+    {
+        if(!ntfyRecord.Validate())
+            return BadRequest();
+        
+        string authHeader = "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes($"{ntfyRecord.username}:{ntfyRecord.password}"));
+        string auth = Convert.ToBase64String(Encoding.UTF8.GetBytes(authHeader)).Replace("=","");
+        
+        NotificationConnector ntfyConnector = new (TokenGen.CreateToken("Ntfy"),
+            $"{ntfyRecord.endpoint}?auth={auth}", 
+            new Dictionary<string, string>()
+            {
+                {"Title", "%title"},
+                {"Priority", ntfyRecord.priority.ToString()},
+            }, 
+            "POST", 
+            "%text");
+        return CreateConnector(ntfyConnector);
+    }
+    
+    /// <summary>
+    /// Creates a new Lunasea-Notification-Connector
+    /// </summary>
+    /// <remarks>https://docs.lunasea.app/lunasea/notifications/custom-notifications for id. Either device/:device_id or user/:user_id</remarks>
+    /// <response code="201">ID of new connector</response>
+    /// <response code="400"></response>
+    /// <response code="409">A NotificationConnector with name already exists</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("Lunasea")]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status409Conflict)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateLunaseaConnector([FromBody]LunaseaRecord lunaseaRecord)
+    {
+        if(!lunaseaRecord.Validate())
+            return BadRequest();
+        
+        NotificationConnector lunaseaConnector = new (TokenGen.CreateToken("Lunasea"),
+            $"https://notify.lunasea.app/v1/custom/{lunaseaRecord.id}", 
+            new Dictionary<string, string>(),
+            "POST", 
+            "{\"title\": \"%title\", \"body\": \"%text\"}");
+        return CreateConnector(lunaseaConnector);
+    }
+    
+    /// <summary>
+    /// Creates a new Pushover-Notification-Connector
+    /// </summary>
+    /// <remarks>https://pushover.net/api</remarks>
+    /// <response code="201">ID of new connector</response>
+    /// <response code="400"></response>
+    /// <response code="409">A NotificationConnector with name already exists</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("Pushover")]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status409Conflict)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreatePushoverConnector([FromBody]PushoverRecord pushoverRecord)
+    {
+        if(!pushoverRecord.Validate())
+            return BadRequest();
+        
+        NotificationConnector pushoverConnector = new  (TokenGen.CreateToken("Pushover"),
+            $"https://api.pushover.net/1/messages.json", 
+            new Dictionary<string, string>(),
+            "POST", 
+            $"{{\"token\": \"{pushoverRecord.apptoken}\", \"user\": \"{pushoverRecord.user}\", \"message:\":\"%text\", \"%title\" }}");
+        return CreateConnector(pushoverConnector);
+    }
+    
+    /// <summary>
+    /// Deletes the Notification-Connector with the requested ID
+    /// </summary>
+    /// <param name="NotificationConnectorId">Notification-Connector-ID</param>
+    /// <response code="200"></response>
+    /// <response code="404">NotificationConnector with ID not found</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpDelete("{NotificationConnectorId}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult DeleteConnector(string NotificationConnectorId)
+    {
+        try
+        {
+            NotificationConnector? ret = context.NotificationConnectors.Find(NotificationConnectorId);
+            if(ret is null)
+                return NotFound();
+            
+            context.Remove(ret);
+            context.SaveChanges();
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+}

API/Controllers/QueryController.cs

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

API/Controllers/SearchController.cs

@@ -0,0 +1,200 @@
+using API.Schema;
+using API.Schema.Jobs;
+using API.Schema.MangaConnectors;
+using Asp.Versioning;
+using Microsoft.AspNetCore.Mvc;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[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>
+    /// <response code="200"></response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("Name")]
+    [ProducesResponseType<Manga[]>(Status200OK, "application/json")]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult SearchMangaGlobal([FromBody]string name)
+    {
+        List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> allManga = new();
+        foreach (MangaConnector contextMangaConnector in context.MangaConnectors.Where(connector => connector.Enabled))
+            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 (Exception e)
+            {
+                return StatusCode(500, e);
+            }
+        }
+        return Ok(retMangas.ToArray());
+    }
+    
+    /// <summary>
+    /// Initiate a search for a Manga on a specific Connector
+    /// </summary>
+    /// <param name="MangaConnectorName">Manga-Connector-ID</param>
+    /// <param name="name">Name/Title of the Manga</param>
+    /// <response code="200"></response>
+    /// <response code="404">MangaConnector with ID not found</response>
+    /// <response code="406">MangaConnector with ID is disabled</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("{MangaConnectorName}")]
+    [ProducesResponseType<Manga[]>(Status200OK, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType(Status406NotAcceptable)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult SearchManga(string MangaConnectorName, [FromBody]string name)
+    {
+        MangaConnector? connector = context.MangaConnectors.Find(MangaConnectorName);
+        if (connector is null)
+            return NotFound();
+        else if (connector.Enabled is false)
+            return StatusCode(406);
+        
+        (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 (Exception e)
+            {
+                return StatusCode(500, e.Message);
+            }
+        }
+
+        return Ok(retMangas.ToArray());
+    }
+
+    /// <summary>
+    /// Returns Manga from MangaConnector associated with URL
+    /// </summary>
+    /// <param name="url">Manga-Page URL</param>
+    /// <response code="200"></response>
+    /// <response code="300">Multiple connectors found for URL</response>
+    /// <response code="400">No Manga at URL</response>
+    /// <response code="404">No connector found for URL</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("Url")]
+    [ProducesResponseType<Manga>(Status200OK, "application/json")]
+    [ProducesResponseType(Status300MultipleChoices)]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult GetMangaFromUrl([FromBody]string url)
+    {
+        List<MangaConnector> connectors = context.MangaConnectors.AsEnumerable().Where(c => c.ValidateUrl(url)).ToList();
+        if (connectors.Count == 0)
+            return NotFound();
+        else if (connectors.Count > 1)
+            return StatusCode(Status300MultipleChoices);
+
+        (Manga manga, List<Author>? authors, List<MangaTag>? tags, List<Link>? links, List<MangaAltTitle>? altTitles)? x = connectors.First().GetMangaFromUrl(url);
+        if (x is null)
+            return BadRequest();
+        try
+        {
+            Manga? add = AddMangaToContext(x.Value.manga, x.Value.authors, x.Value.tags, x.Value.links, x.Value.altTitles);
+            if (add is not null)
+                return Ok(add);
+            return StatusCode(500);
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
+    }
+    
+    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.Mangas.Find(manga.MangaId);
+        
+        if (tags is not null)
+        {
+            IEnumerable<MangaTag> mergedTags = tags.Select(mt =>
+            {
+                MangaTag? inDb = context.Tags.Find(mt.Tag);
+                return inDb ?? mt;
+            });
+            manga.MangaTags = mergedTags.ToList();
+            IEnumerable<MangaTag> newTags = manga.MangaTags
+                .Where(mt => !context.Tags.Select(t => t.Tag).Contains(mt.Tag));
+            context.Tags.AddRange(newTags);
+        }
+
+        if (authors is not null)
+        {
+            IEnumerable<Author> mergedAuthors = authors.Select(ma =>
+            {
+                Author? inDb = context.Authors.Find(ma.AuthorId);
+                return inDb ?? ma;
+            });
+            manga.Authors = mergedAuthors.ToList();
+            IEnumerable<Author> newAuthors = manga.Authors
+                .Where(ma => !context.Authors.Select(a => a.AuthorId).Contains(ma.AuthorId));
+            context.Authors.AddRange(newAuthors);
+        }
+
+        if (links is not null)
+        {
+            IEnumerable<Link> mergedLinks = links.Select(ml =>
+            {
+                Link? inDb = context.Links.Find(ml.LinkId);
+                return inDb ?? ml;
+            });
+            manga.Links = mergedLinks.ToList();
+            IEnumerable<Link> newLinks = manga.Links
+                .Where(ml => !context.Links.Select(l => l.LinkId).Contains(ml.LinkId));
+            context.Links.AddRange(newLinks);
+        }
+
+        if (altTitles is not null)
+        {
+            IEnumerable<MangaAltTitle> mergedAltTitles = altTitles.Select(mat =>
+            {
+                MangaAltTitle? inDb = context.AltTitles.Find(mat.AltTitleId);
+                return inDb ?? mat;
+            });
+            manga.AltTitles = mergedAltTitles.ToList();
+            IEnumerable<MangaAltTitle> newAltTitles = manga.AltTitles
+                .Where(mat => !context.AltTitles.Select(at => at.AltTitleId).Contains(mat.AltTitleId));
+            context.AltTitles.AddRange(newAltTitles);
+        }
+        
+        existing?.UpdateWithInfo(manga);
+        if(existing is not null)
+            context.Mangas.Update(existing);
+        else
+            context.Mangas.Add(manga);
+
+        context.Jobs.Add(new DownloadMangaCoverJob(manga.MangaId));
+        context.Jobs.Add(new RetrieveChaptersJob(0, manga.MangaId));
+
+        context.SaveChanges();
+        return existing ?? manga;
+    }
+}

API/Controllers/SettingsController.cs

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

API/HttpRequestTimeFeature.cs

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

API/MangaDownloadClients/ChromiumDownloadClient.cs

@@ -2,19 +2,19 @@
 using System.Text;
 using System.Text.RegularExpressions;
 using HtmlAgilityPack;
-using Microsoft.Extensions.Logging;
 using PuppeteerSharp;
 
-namespace Tranga.MangaConnectors;
+namespace API.MangaDownloadClients;
 
 internal class ChromiumDownloadClient : DownloadClient
 {
     private static IBrowser? _browser;
     private readonly HttpDownloadClient _httpDownloadClient;
+    private readonly Thread _closeStalePagesThread;
+    private readonly List<KeyValuePair<IPage, DateTime>> _openPages = new ();
     
-    private static async Task<IBrowser> StartBrowser(Logging.Logger? logger = null)
+    private static async Task<IBrowser> StartBrowser()
     {
-        logger?.WriteLine("Starting ChromiumDownloadClient Puppeteer");
         return await Puppeteer.LaunchAsync(new LaunchOptions
         {
             Headless = true,
@@ -23,40 +23,29 @@ internal class ChromiumDownloadClient : DownloadClient
                 "--disable-dev-shm-usage",
                 "--disable-setuid-sandbox",
                 "--no-sandbox"},
-            Timeout = TrangaSettings.ChromiumStartupTimeoutMs
-        }, new LoggerFactory([new LogProvider(logger)]));
+            Timeout = 30000
+        });
     }
 
-    private class LogProvider : GlobalBase, ILoggerProvider
+    public ChromiumDownloadClient()
     {
-        public LogProvider(Logging.Logger? logger) : base(logger) { }
-
-        public void Dispose() { }
-
-        public ILogger CreateLogger(string categoryName) => new Logger(logger);
-    }
-
-    private class Logger : GlobalBase, ILogger
-    {
-        public Logger(Logging.Logger? logger) : base(logger) { }
-
-        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
-        {
-            if (logLevel <= LogLevel.Information)
-                return;
-            logger?.WriteLine("Puppeteer", formatter.Invoke(state, exception));
-        }
-
-        public bool IsEnabled(LogLevel logLevel) => true;
-
-        public IDisposable? BeginScope<TState>(TState state) where TState : notnull => null;
-    }
-
-    public ChromiumDownloadClient(GlobalBase clone) : base(clone)
-    {
-        _httpDownloadClient = new(this);
+        _httpDownloadClient = new();
         if(_browser is null)
-            _browser = StartBrowser(this.logger).Result;
+            _browser = StartBrowser().Result;
+        _closeStalePagesThread = new Thread(CheckStalePages);
+        _closeStalePagesThread.Start();
+    }
+
+    private void CheckStalePages()
+    {
+        while (true)
+        {
+            Thread.Sleep(TimeSpan.FromHours(1));
+            foreach ((IPage? key, DateTime value) in _openPages.Where(kv => kv.Value.Subtract(DateTime.Now) > TimeSpan.FromHours(1)))
+            {
+                key.CloseAsync().Wait();
+            }
+        }
     }
 
     private readonly Regex _imageUrlRex = new(@"https?:\/\/.*\.(?:p?jpe?g|gif|a?png|bmp|avif|webp)(\?.*)?");
@@ -72,18 +61,20 @@ internal class ChromiumDownloadClient : DownloadClient
         if (_browser is null)
             return new RequestResult(HttpStatusCode.InternalServerError, null, Stream.Null);
         IPage page = _browser.NewPageAsync().Result;
-        page.DefaultTimeout = TrangaSettings.ChromiumPageTimeoutMs;
+        _openPages.Add(new(page, DateTime.Now));
         page.SetExtraHttpHeadersAsync(new() { { "Referer", referrer } });
+        page.DefaultTimeout = 30000;
         IResponse response;
         try
         {
             response = page.GoToAsync(url, WaitUntilNavigation.Networkidle0).Result;
-            Log($"Page loaded. {url}");
+            //Log($"Page loaded. {url}");
         }
         catch (Exception e)
         {
-            Log($"Could not load Page {url}\n{e.Message}");
+            //Log($"Could not load Page {url}\n{e.Message}");
             page.CloseAsync();
+            _openPages.Remove(_openPages.Find(i => i.Key == page));
             return new RequestResult(HttpStatusCode.InternalServerError, null, Stream.Null);
         }
 
@@ -107,11 +98,13 @@ internal class ChromiumDownloadClient : DownloadClient
         }
         else
         {
-            page.CloseAsync();
+            page.CloseAsync().Wait();
+            _openPages.Remove(_openPages.Find(i => i.Key == page));
             return new RequestResult(HttpStatusCode.InternalServerError, null, Stream.Null);
         }
         
-        page.CloseAsync();
+        page.CloseAsync().Wait();
+        _openPages.Remove(_openPages.Find(i => i.Key == page));
         return new RequestResult(response.Status, document, stream, false, "");
     }
 }

API/MangaDownloadClients/DownloadClient.cs

@@ -1,13 +1,13 @@
 using System.Net;
-using HtmlAgilityPack;
+using API.Schema;
 
-namespace Tranga.MangaConnectors;
+namespace API.MangaDownloadClients;
 
-internal abstract class DownloadClient : GlobalBase
+internal abstract class DownloadClient
 {
     private readonly Dictionary<RequestType, DateTime> _lastExecutedRateLimit;
 
-    protected DownloadClient(GlobalBase clone) : base(clone)
+    protected DownloadClient()
     {
         this._lastExecutedRateLimit = new();
     }
@@ -16,7 +16,6 @@ internal abstract class DownloadClient : GlobalBase
     {
         if (!TrangaSettings.requestLimits.ContainsKey(requestType))
         {
-            Log("RequestType not configured for rate-limit.");
             return new RequestResult(HttpStatusCode.NotAcceptable, null, Stream.Null);
         }
 
@@ -25,18 +24,17 @@ internal abstract class DownloadClient : GlobalBase
             : TrangaSettings.requestLimits[requestType];
         
         TimeSpan timeBetweenRequests = TimeSpan.FromMinutes(1).Divide(rateLimit);
-        _lastExecutedRateLimit.TryAdd(requestType, DateTime.Now.Subtract(timeBetweenRequests));
+        _lastExecutedRateLimit.TryAdd(requestType, DateTime.UtcNow.Subtract(timeBetweenRequests));
 
-        TimeSpan rateLimitTimeout = timeBetweenRequests.Subtract(DateTime.Now.Subtract(_lastExecutedRateLimit[requestType]));
+        TimeSpan rateLimitTimeout = timeBetweenRequests.Subtract(DateTime.UtcNow.Subtract(_lastExecutedRateLimit[requestType]));
 
         if (rateLimitTimeout > TimeSpan.Zero)
         {
-            Log($"Waiting {rateLimitTimeout.TotalSeconds} seconds");
             Thread.Sleep(rateLimitTimeout);
         }
 
         RequestResult result = MakeRequestInternal(url, referrer, clickButton);
-        _lastExecutedRateLimit[requestType] = DateTime.Now;
+        _lastExecutedRateLimit[requestType] = DateTime.UtcNow;
         return result;
     }
 

API/MangaDownloadClients/HttpDownloadClient.cs

@@ -1,8 +1,8 @@
 using System.Net;
-using System.Net.Http.Headers;
+using API.Schema;
 using HtmlAgilityPack;
 
-namespace Tranga.MangaConnectors;
+namespace API.MangaDownloadClients;
 
 internal class HttpDownloadClient : DownloadClient
 {
@@ -11,15 +11,16 @@ internal class HttpDownloadClient : DownloadClient
         Timeout = TimeSpan.FromSeconds(10)
     };
 
-    public HttpDownloadClient(GlobalBase clone) : base(clone)
+    public HttpDownloadClient()
     {
         Client.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", TrangaSettings.userAgent);
     }
     
     internal override RequestResult MakeRequestInternal(string url, string? referrer = null, string? clickButton = null)
     {
-        if(clickButton is not null)
-            Log("Can not click button on static site.");
+        //TODO
+        //if (clickButton is not null)
+            //Log("Can not click button on static site.");
         HttpResponseMessage? response = null;
         while (response is null)
         {
@@ -36,10 +37,8 @@ internal class HttpDownloadClient : DownloadClient
                 switch (e)
                 {
                     case TaskCanceledException:
-                        Log($"Request timed out {url}.\n\r{e}");
                         return new RequestResult(HttpStatusCode.RequestTimeout, null, Stream.Null);
                     case HttpRequestException:
-                        Log($"Request failed {url}\n\r{e}");
                         return new RequestResult(HttpStatusCode.BadRequest, null, Stream.Null);
                 }
             }
@@ -47,7 +46,6 @@ internal class HttpDownloadClient : DownloadClient
 
         if (!response.IsSuccessStatusCode)
         {
-            Log($"Request-Error {response.StatusCode}: {url}");
             return new RequestResult(response.StatusCode,  null, Stream.Null);
         }
         

API/MangaDownloadClients/RequestResult.cs

@@ -1,7 +1,7 @@
 using System.Net;
 using HtmlAgilityPack;
 
-namespace Tranga.MangaConnectors;
+namespace API.MangaDownloadClients;
 
 public struct RequestResult
 {

API/MangaDownloadClients/RequestType.cs

@@ -1,4 +1,4 @@
-namespace Tranga.MangaConnectors;
+namespace API.MangaDownloadClients;
 
 public enum RequestType : byte
 {

API/Migrations/20250316143014_dev-160325-Initial.Designer.cs

@@ -0,0 +1,821 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+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("20250316143014_dev-160325-Initial")]
+    partial class dev160325Initial
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Links");
+                });
+
+            modelBuilder.Entity("API.Schema.LocalLibrary", b =>
+                {
+                    b.Property<string>("LocalLibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("BasePath")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LibraryName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("LocalLibraryId");
+
+                    b.ToTable("LocalLibraries");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DirectoryName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LibraryLocalLibraryId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LibraryLocalLibraryId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Mangas");
+                });
+
+            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()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    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()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            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("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", 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("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.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.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            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.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", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.LocalLibrary", "Library")
+                        .WithMany()
+                        .HasForeignKey("LibraryLocalLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Library");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            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("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            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.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250316143014_dev-160325-Initial.cs

@@ -0,0 +1,478 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev160325Initial : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterDatabase()
+                .Annotation("Npgsql:PostgresExtension:hstore", ",,");
+
+            migrationBuilder.CreateTable(
+                name: "Authors",
+                columns: table => new
+                {
+                    AuthorId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    AuthorName = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Authors", x => x.AuthorId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "LibraryConnectors",
+                columns: table => new
+                {
+                    LibraryConnectorId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    LibraryType = table.Column<byte>(type: "smallint", nullable: false),
+                    BaseUrl = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Auth = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LibraryConnectors", x => x.LibraryConnectorId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "LocalLibraries",
+                columns: table => new
+                {
+                    LocalLibraryId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    BasePath = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    LibraryName = table.Column<string>(type: "character varying(512)", maxLength: 512, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LocalLibraries", x => x.LocalLibraryId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "MangaConnectors",
+                columns: table => new
+                {
+                    Name = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: false),
+                    SupportedLanguages = table.Column<string[]>(type: "text[]", maxLength: 8, nullable: false),
+                    IconUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    BaseUris = table.Column<string[]>(type: "text[]", maxLength: 256, nullable: false),
+                    Enabled = table.Column<bool>(type: "boolean", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MangaConnectors", x => x.Name);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "NotificationConnectors",
+                columns: table => new
+                {
+                    Name = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    Url = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    Headers = table.Column<Dictionary<string, string>>(type: "hstore", nullable: false),
+                    HttpMethod = table.Column<string>(type: "character varying(8)", maxLength: 8, nullable: false),
+                    Body = table.Column<string>(type: "character varying(4096)", maxLength: 4096, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_NotificationConnectors", x => x.Name);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Notifications",
+                columns: table => new
+                {
+                    NotificationId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    Urgency = table.Column<byte>(type: "smallint", nullable: false),
+                    Title = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
+                    Message = table.Column<string>(type: "character varying(512)", maxLength: 512, nullable: false),
+                    Date = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Notifications", x => x.NotificationId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Tags",
+                columns: table => new
+                {
+                    Tag = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Tags", x => x.Tag);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Mangas",
+                columns: table => new
+                {
+                    MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    IdOnConnectorSite = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
+                    Name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Description = table.Column<string>(type: "text", nullable: false),
+                    WebsiteUrl = table.Column<string>(type: "character varying(256)", maxLength: 256, 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: "character varying(8)", maxLength: 8, nullable: false),
+                    ReleaseStatus = table.Column<byte>(type: "smallint", nullable: false),
+                    DirectoryName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    LibraryLocalLibraryId = table.Column<string>(type: "character varying(64)", nullable: true),
+                    IgnoreChapterBefore = table.Column<float>(type: "real", nullable: false),
+                    MangaConnectorId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Mangas", x => x.MangaId);
+                    table.ForeignKey(
+                        name: "FK_Mangas_LocalLibraries_LibraryLocalLibraryId",
+                        column: x => x.LibraryLocalLibraryId,
+                        principalTable: "LocalLibraries",
+                        principalColumn: "LocalLibraryId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Mangas_MangaConnectors_MangaConnectorId",
+                        column: x => x.MangaConnectorId,
+                        principalTable: "MangaConnectors",
+                        principalColumn: "Name",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            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: "character varying(256)", maxLength: 256, nullable: false),
+                    MangaId = table.Column<string>(type: "character varying(64)", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AltTitles", x => x.AltTitleId);
+                    table.ForeignKey(
+                        name: "FK_AltTitles_Mangas_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AuthorManga",
+                columns: table => new
+                {
+                    AuthorsAuthorId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    MangaId = table.Column<string>(type: "character varying(64)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AuthorManga", x => new { x.AuthorsAuthorId, x.MangaId });
+                    table.ForeignKey(
+                        name: "FK_AuthorManga_Authors_AuthorsAuthorId",
+                        column: x => x.AuthorsAuthorId,
+                        principalTable: "Authors",
+                        principalColumn: "AuthorId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_AuthorManga_Mangas_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Chapters",
+                columns: table => new
+                {
+                    ChapterId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    VolumeNumber = table.Column<int>(type: "integer", nullable: true),
+                    ChapterNumber = table.Column<string>(type: "character varying(10)", maxLength: 10, nullable: false),
+                    Url = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    Title = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    FileName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    Downloaded = table.Column<bool>(type: "boolean", nullable: false),
+                    ParentMangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Chapters", x => x.ChapterId);
+                    table.ForeignKey(
+                        name: "FK_Chapters_Mangas_ParentMangaId",
+                        column: x => x.ParentMangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Links",
+                columns: table => new
+                {
+                    LinkId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    LinkProvider = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    LinkUrl = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    MangaId = table.Column<string>(type: "character varying(64)", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Links", x => x.LinkId);
+                    table.ForeignKey(
+                        name: "FK_Links_Mangas_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "MangaMangaTag",
+                columns: table => new
+                {
+                    MangaId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    MangaTagsTag = table.Column<string>(type: "character varying(64)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MangaMangaTag", x => new { x.MangaId, x.MangaTagsTag });
+                    table.ForeignKey(
+                        name: "FK_MangaMangaTag_Mangas_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_MangaMangaTag_Tags_MangaTagsTag",
+                        column: x => x.MangaTagsTag,
+                        principalTable: "Tags",
+                        principalColumn: "Tag",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Jobs",
+                columns: table => new
+                {
+                    JobId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    ParentJobId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    DependsOnJobsIds = 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),
+                    state = table.Column<byte>(type: "smallint", nullable: false),
+                    Enabled = table.Column<bool>(type: "boolean", nullable: false),
+                    DownloadAvailableChaptersJob_MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    ChapterId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    FromLocation = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    ToLocation = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    RetrieveChaptersJob_MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    UpdateFilesDownloadedJob_MangaId = table.Column<string>(type: "character varying(64)", maxLength: 64, 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_Jobs_ParentJobId",
+                        column: x => x.ParentJobId,
+                        principalTable: "Jobs",
+                        principalColumn: "JobId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Mangas_DownloadAvailableChaptersJob_MangaId",
+                        column: x => x.DownloadAvailableChaptersJob_MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Mangas_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Mangas_RetrieveChaptersJob_MangaId",
+                        column: x => x.RetrieveChaptersJob_MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Mangas_UpdateFilesDownloadedJob_MangaId",
+                        column: x => x.UpdateFilesDownloadedJob_MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Jobs_Mangas_UpdateMetadataJob_MangaId",
+                        column: x => x.UpdateMetadataJob_MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "JobJob",
+                columns: table => new
+                {
+                    DependsOnJobsJobId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    JobId = table.Column<string>(type: "character varying(64)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_JobJob", x => new { x.DependsOnJobsJobId, x.JobId });
+                    table.ForeignKey(
+                        name: "FK_JobJob_Jobs_DependsOnJobsJobId",
+                        column: x => x.DependsOnJobsJobId,
+                        principalTable: "Jobs",
+                        principalColumn: "JobId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_JobJob_Jobs_JobId",
+                        column: x => x.JobId,
+                        principalTable: "Jobs",
+                        principalColumn: "JobId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AltTitles_MangaId",
+                table: "AltTitles",
+                column: "MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AuthorManga_MangaId",
+                table: "AuthorManga",
+                column: "MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Chapters_ParentMangaId",
+                table: "Chapters",
+                column: "ParentMangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_JobJob_JobId",
+                table: "JobJob",
+                column: "JobId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_ChapterId",
+                table: "Jobs",
+                column: "ChapterId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_DownloadAvailableChaptersJob_MangaId",
+                table: "Jobs",
+                column: "DownloadAvailableChaptersJob_MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_MangaId",
+                table: "Jobs",
+                column: "MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_ParentJobId",
+                table: "Jobs",
+                column: "ParentJobId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_RetrieveChaptersJob_MangaId",
+                table: "Jobs",
+                column: "RetrieveChaptersJob_MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_UpdateFilesDownloadedJob_MangaId",
+                table: "Jobs",
+                column: "UpdateFilesDownloadedJob_MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_UpdateMetadataJob_MangaId",
+                table: "Jobs",
+                column: "UpdateMetadataJob_MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Links_MangaId",
+                table: "Links",
+                column: "MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MangaMangaTag_MangaTagsTag",
+                table: "MangaMangaTag",
+                column: "MangaTagsTag");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Mangas_LibraryLocalLibraryId",
+                table: "Mangas",
+                column: "LibraryLocalLibraryId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Mangas_MangaConnectorId",
+                table: "Mangas",
+                column: "MangaConnectorId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "AltTitles");
+
+            migrationBuilder.DropTable(
+                name: "AuthorManga");
+
+            migrationBuilder.DropTable(
+                name: "JobJob");
+
+            migrationBuilder.DropTable(
+                name: "LibraryConnectors");
+
+            migrationBuilder.DropTable(
+                name: "Links");
+
+            migrationBuilder.DropTable(
+                name: "MangaMangaTag");
+
+            migrationBuilder.DropTable(
+                name: "NotificationConnectors");
+
+            migrationBuilder.DropTable(
+                name: "Notifications");
+
+            migrationBuilder.DropTable(
+                name: "Authors");
+
+            migrationBuilder.DropTable(
+                name: "Jobs");
+
+            migrationBuilder.DropTable(
+                name: "Tags");
+
+            migrationBuilder.DropTable(
+                name: "Chapters");
+
+            migrationBuilder.DropTable(
+                name: "Mangas");
+
+            migrationBuilder.DropTable(
+                name: "LocalLibraries");
+
+            migrationBuilder.DropTable(
+                name: "MangaConnectors");
+        }
+    }
+}

API/Migrations/20250316150158_dev-160325-2.Designer.cs

@@ -0,0 +1,821 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+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("20250316150158_dev-160325-2")]
+    partial class dev1603252
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Links");
+                });
+
+            modelBuilder.Entity("API.Schema.LocalLibrary", b =>
+                {
+                    b.Property<string>("LocalLibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("BasePath")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LibraryName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("LocalLibraryId");
+
+                    b.ToTable("LocalLibraries");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DirectoryName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LibraryLocalLibraryId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LibraryLocalLibraryId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Mangas");
+                });
+
+            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()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    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()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            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("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", 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("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.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.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            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.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", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.LocalLibrary", "Library")
+                        .WithMany()
+                        .HasForeignKey("LibraryLocalLibraryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Library");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            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("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            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.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250316150158_dev-160325-2.cs

@@ -0,0 +1,42 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev1603252 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Mangas_LocalLibraries_LibraryLocalLibraryId",
+                table: "Mangas");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Mangas_LocalLibraries_LibraryLocalLibraryId",
+                table: "Mangas",
+                column: "LibraryLocalLibraryId",
+                principalTable: "LocalLibraries",
+                principalColumn: "LocalLibraryId",
+                onDelete: ReferentialAction.Restrict);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Mangas_LocalLibraries_LibraryLocalLibraryId",
+                table: "Mangas");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Mangas_LocalLibraries_LibraryLocalLibraryId",
+                table: "Mangas",
+                column: "LibraryLocalLibraryId",
+                principalTable: "LocalLibraries",
+                principalColumn: "LocalLibraryId",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

API/Migrations/PgsqlContextModelSnapshot.cs

@@ -0,0 +1,818 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+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.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Links");
+                });
+
+            modelBuilder.Entity("API.Schema.LocalLibrary", b =>
+                {
+                    b.Property<string>("LocalLibraryId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("BasePath")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LibraryName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("LocalLibraryId");
+
+                    b.ToTable("LocalLibraries");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DirectoryName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("LibraryLocalLibraryId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("LibraryLocalLibraryId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Mangas");
+                });
+
+            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()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    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()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            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("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", 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("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.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.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            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.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", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.LocalLibrary", "Library")
+                        .WithMany()
+                        .HasForeignKey("LibraryLocalLibraryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Library");
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            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("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            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.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/Program.cs

@@ -0,0 +1,147 @@
+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;
+using Newtonsoft.Json.Converters;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddCors(options =>
+{
+    options.AddPolicy("AllowAll",
+        policy =>
+        {
+            policy
+                .AllowAnyOrigin()
+                .AllowAnyMethod()
+                .AllowAnyHeader();
+        });
+});
+
+builder.Services.AddApiVersioning(option =>
+    {
+        option.AssumeDefaultVersionWhenUnspecified = true;
+        option.DefaultApiVersion = new ApiVersion(2);
+        option.ReportApiVersions = true;
+        option.ApiVersionReader = ApiVersionReader.Combine(
+            new UrlSegmentApiVersionReader(),
+            new QueryStringApiVersionReader("api-version"),
+            new HeaderApiVersionReader("X-Version"),
+            new MediaTypeApiVersionReader("x-version"));
+    })
+    .AddMvc(options =>
+    {
+        options.Conventions.Add(new VersionByNamespaceConvention());
+    })
+    .AddApiExplorer(options =>
+    {
+        options.GroupNameFormat = "'v'V";
+        options.SubstituteApiVersionInUrl = true;
+    });
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGenNewtonsoftSupport();
+builder.Services.AddSwaggerGen(opt =>
+{
+    var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
+    opt.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, xmlFilename));
+});
+builder.Services.ConfigureOptions<NamedSwaggerGenOptions>();
+
+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(options =>
+{
+    options.AllowEmptyInputInBodyModelBinding = true;
+});
+builder.Services.AddControllers().AddNewtonsoftJson(opts =>
+{
+    opts.SerializerSettings.Converters.Add(new StringEnumConverter());
+    opts.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
+});
+
+builder.WebHost.UseUrls("http://*:6531");
+
+var app = builder.Build();
+
+ApiVersionSet apiVersionSet = app.NewApiVersionSet()
+    .HasApiVersion(new ApiVersion(2))
+    .ReportApiVersions()
+    .Build();
+
+
+app.UseCors("AllowAll");
+
+app.MapControllers()
+    .WithApiVersionSet(apiVersionSet)
+    .MapToApiVersion(2);
+
+app.UseSwagger();
+app.UseSwaggerUI(options =>
+{
+    options.SwaggerEndpoint(
+            $"/swagger/v2/swagger.json", "v2"); 
+});
+
+app.UseHttpsRedirection();
+
+//app.UseMiddleware<RequestTimeMiddleware>();
+
+using (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 Mangaworld(),
+            new ManhuaPlus(),
+            new Weebcentral(),
+            new Manganato(),
+            new Global(scope.ServiceProvider.GetService<PgsqlContext>()!)
+        ];
+    MangaConnector[] newConnectors = connectors.Where(c => !context.MangaConnectors.Contains(c)).ToArray();
+    context.MangaConnectors.AddRange(newConnectors);
+
+    context.Jobs.AddRange(context.Mangas.AsEnumerable().Select(m => new UpdateFilesDownloadedJob(0, m.MangaId)));
+    
+    context.Jobs.RemoveRange(context.Jobs.Where(j => j.state == JobState.Completed && j.RecurrenceMs < 1));
+
+    if (!context.LocalLibraries.Any())
+        context.LocalLibraries.Add(new LocalLibrary(TrangaSettings.downloadLocation, "Default Library"));
+    
+    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);
+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,15 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("AuthorId")]
+public class Author(string authorName)
+{
+    [StringLength(64)]
+    [Required]
+    public string AuthorId { get; init; } = TokenGen.CreateToken(typeof(Author), authorName);
+    [StringLength(128)]
+    [Required]
+    public string AuthorName { get; init; } = authorName;
+}

API/Schema/Chapter.cs

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

API/Schema/Jobs/DownloadAvailableChaptersJob.cs

@@ -0,0 +1,21 @@
+using System.ComponentModel.DataAnnotations;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class DownloadAvailableChaptersJob(ulong recurrenceMs, string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(DownloadAvailableChaptersJob)), JobType.DownloadAvailableChaptersJob, recurrenceMs, parentJobId, dependsOnJobsIds)
+{
+    [StringLength(64)]
+    [Required]
+    public string MangaId { get; init; } = mangaId;
+    
+    [JsonIgnore]
+    public Manga? Manga { get; init; }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        return context.Chapters.Where(c => c.ParentMangaId == MangaId).AsEnumerable()
+            .Select(chapter => new DownloadSingleChapterJob(chapter.ChapterId, this.JobId));
+    }
+}

API/Schema/Jobs/DownloadMangaCoverJob.cs

@@ -0,0 +1,25 @@
+using System.ComponentModel.DataAnnotations;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class DownloadMangaCoverJob(string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(DownloadMangaCoverJob)), JobType.DownloadMangaCoverJob, 0, parentJobId, dependsOnJobsIds)
+{
+    [StringLength(64)]
+    [Required]
+    public string MangaId { get; init; } = mangaId;
+    [JsonIgnore]
+    public Manga? Manga { get; init; }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        Manga? manga = Manga ?? context.Mangas.Find(this.MangaId);
+        if (manga is null)
+            return [];
+        
+        manga.CoverFileNameInCache = manga.SaveCoverImageToCache();
+        context.SaveChanges();
+        return [];
+    }
+}

API/Schema/Jobs/DownloadSingleChapterJob.cs

@@ -0,0 +1,131 @@
+using System.ComponentModel.DataAnnotations;
+using System.IO.Compression;
+using System.Runtime.InteropServices;
+using API.MangaDownloadClients;
+using API.Schema.MangaConnectors;
+using Newtonsoft.Json;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Formats.Jpeg;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors.Binarization;
+using static System.IO.UnixFileMode;
+
+namespace API.Schema.Jobs;
+
+public class DownloadSingleChapterJob(string chapterId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(DownloadSingleChapterJob)), JobType.DownloadSingleChapterJob, 0, parentJobId, dependsOnJobsIds)
+{
+    [StringLength(64)]
+    [Required]
+    public string ChapterId { get; init; } = chapterId;
+    
+    [JsonIgnore]
+    public Chapter? Chapter { get; init; }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        Chapter chapter = Chapter ?? context.Chapters.Find(ChapterId)!;
+        Manga manga = chapter.ParentManga ?? context.Mangas.Find(chapter.ParentMangaId)!;
+        MangaConnector connector = manga.MangaConnector ?? context.MangaConnectors.Find(manga.MangaConnectorId)!;
+        string[] imageUrls = connector.GetChapterImageUrls(chapter);
+        string saveArchiveFilePath = chapter.FullArchiveFilePath;
+        
+        //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 [];
+        }
+        
+        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 [];
+        }
+
+        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
+        
+        chapter.Downloaded = true;
+        context.SaveChanges();
+
+        return [new UpdateFilesDownloadedJob(0, manga.MangaId, this.JobId)];
+    }
+    
+    private void ProcessImage(string imagePath)
+    {
+        if (!TrangaSettings.bwImages && TrangaSettings.compression == 100)
+            return;
+        using Image image = Image.Load(imagePath);
+        File.Delete(imagePath);
+        if(TrangaSettings.bwImages) 
+            image.Mutate(i => i.ApplyProcessor(new AdaptiveThresholdProcessor()));
+        image.SaveAsJpeg(imagePath, new JpegEncoder()
+        {
+            Quality = TrangaSettings.compression
+        });
+    }
+    
+    private void CopyCoverFromCacheToDownloadLocation(Manga manga)
+    {
+        //Check if Publication already has a Folder and cover
+        string publicationFolder = manga.CreatePublicationFolder();
+        DirectoryInfo dirInfo = new (publicationFolder);
+        if (dirInfo.EnumerateFiles().Any(info => info.Name.Contains("cover", StringComparison.InvariantCultureIgnoreCase)))
+        {
+            return;
+        }
+
+        string? fileInCache = manga.CoverFileNameInCache ?? manga.SaveCoverImageToCache();
+        if (fileInCache is null)
+            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, FileAccess.Write, FileShare.None);
+        requestResult.result.CopyTo(fs);
+        fs.Close();
+        ProcessImage(savePath);
+        return true;
+    }
+}

API/Schema/Jobs/Job.cs

@@ -0,0 +1,69 @@
+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 
+{
+    [StringLength(64)]
+    [Required]
+    public string JobId { get; init; }
+    [StringLength(64)]
+    public string? ParentJobId { get; init; }
+    [JsonIgnore]
+    public Job? ParentJob { get; init; }
+    [StringLength(64)]
+    public ICollection<string>? DependsOnJobsIds { get; init; }
+    [JsonIgnore]
+    public ICollection<Job>? DependsOnJobs { get; init; }
+    
+    [Required]
+    public JobType JobType { get; init; }
+    [Required]
+    public ulong RecurrenceMs { get; set; }
+    [Required]
+    public DateTime LastExecution { get; internal set; } = DateTime.UnixEpoch;
+    
+    [NotMapped]
+    [Required]
+    public DateTime NextExecution => LastExecution.AddMilliseconds(RecurrenceMs);
+    [Required]
+    public JobState state { get; internal set; } = JobState.Waiting;
+    [Required]
+    public bool Enabled { get; internal set; } = true;
+
+    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(IServiceProvider serviceProvider)
+    {
+        using IServiceScope scope = serviceProvider.CreateScope();
+        PgsqlContext context = scope.ServiceProvider.GetRequiredService<PgsqlContext>();
+        
+        this.state = JobState.Running;
+        context.SaveChanges();
+        Job[] newJobs = RunInternal(context).ToArray();
+        this.state = JobState.Completed;
+        context.Jobs.AddRange(newJobs);
+        context.SaveChanges();
+        return newJobs;
+    }
+    
+    protected abstract IEnumerable<Job> RunInternal(PgsqlContext context);
+}

API/Schema/Jobs/JobState.cs

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

API/Schema/Jobs/JobType.cs

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

API/Schema/Jobs/MoveFileOrFolderJob.cs

@@ -0,0 +1,46 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace API.Schema.Jobs;
+
+public class MoveFileOrFolderJob(string fromLocation, string toLocation, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(MoveFileOrFolderJob)), JobType.MoveFileOrFolderJob, 0, parentJobId, dependsOnJobsIds)
+{
+    [StringLength(256)]
+    [Required]
+    public string FromLocation { get; init; } = fromLocation;
+    [StringLength(256)]
+    [Required]
+    public string ToLocation { get; init; } = toLocation;
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        try
+        {
+            FileInfo fi = new FileInfo(FromLocation);
+            if (!fi.Exists)
+                return [];
+            if (File.Exists(ToLocation))//Do not override existing
+                return [];
+            if(fi.Attributes.HasFlag(FileAttributes.Directory))
+                MoveDirectory(fi, ToLocation);
+            else
+                MoveFile(fi, ToLocation);
+        }
+        catch (Exception e)
+        {
+            
+        }
+
+        return [];
+    }
+
+    private void MoveDirectory(FileInfo from, string toLocation)
+    {
+        Directory.Move(from.FullName, toLocation);        
+    }
+
+    private void MoveFile(FileInfo from, string toLocation)
+    {
+        File.Move(from.FullName, toLocation);
+    }
+}

API/Schema/Jobs/MoveMangaLibraryJob.cs

@@ -0,0 +1,30 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace API.Schema.Jobs;
+
+public class MoveMangaLibraryJob(string mangaId, string toLibraryId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(MoveMangaLibraryJob)), JobType.MoveMangaLibraryJob, 0, parentJobId, dependsOnJobsIds)
+{
+    [StringLength(64)]
+    [Required]
+    public string MangaId { get; init; } = mangaId;
+    [StringLength(64)]
+    [Required]
+    public string ToLibraryId { get; init; } = toLibraryId;
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        Manga? manga = context.Mangas.Find(MangaId);
+        if(manga is null)
+            throw new KeyNotFoundException();
+        LocalLibrary? library = context.LocalLibraries.Find(ToLibraryId);
+        if(library is null)
+            throw new KeyNotFoundException();
+        Chapter[] chapters = context.Chapters.Where(c => c.ParentMangaId == MangaId).ToArray();
+        Dictionary<Chapter, string> oldPath = chapters.ToDictionary(c => c, c => c.FullArchiveFilePath!);
+        manga.Library = library;
+        context.SaveChanges();
+
+        return chapters.Select(c => new MoveFileOrFolderJob(oldPath[c], c.FullArchiveFilePath!));
+    }
+}

API/Schema/Jobs/RetrieveChaptersJob.cs

@@ -0,0 +1,37 @@
+using System.ComponentModel.DataAnnotations;
+using API.Schema.MangaConnectors;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class RetrieveChaptersJob(ulong recurrenceMs, string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(RetrieveChaptersJob)), JobType.RetrieveChaptersJob, recurrenceMs, parentJobId, dependsOnJobsIds)
+{
+    [StringLength(64)]
+    [Required]
+    public string MangaId { get; init; } = mangaId;
+    
+    [JsonIgnore]
+    public Manga? Manga { get; init; }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        /*
+         * For some reason, directly using Manga from above instead of finding it again causes DBContext to consider
+         * Manga as a new entity and Postgres throws a Duplicate PK exception.
+         * m.MangaConnector does not have this issue (IDK why).
+         */ 
+        Manga m = context.Mangas.Find(MangaId)!; 
+        MangaConnector connector = context.MangaConnectors.Find(m.MangaConnectorId)!;
+        // This gets all chapters that are not downloaded
+        Chapter[] allNewChapters = connector.GetNewChapters(m).DistinctBy(c => c.ChapterId).ToArray();
+        
+        // This filters out chapters that are not downloaded but already exist in the DB
+        string[] chapterIds = context.Chapters.Where(chapter => chapter.ParentMangaId == m.MangaId).Select(chapter => chapter.ChapterId).ToArray();
+        Chapter[] newChapters = allNewChapters.Where(chapter => !chapterIds.Contains(chapter.ChapterId)).ToArray();
+        context.Chapters.AddRange(newChapters);
+        context.SaveChanges();
+
+        return [];
+    }
+}

API/Schema/Jobs/UpdateFilesDownloadedJob.cs

@@ -0,0 +1,25 @@
+using System.ComponentModel.DataAnnotations;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class UpdateFilesDownloadedJob(ulong recurrenceMs, string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(UpdateFilesDownloadedJob)), JobType.UpdateFilesDownloadedJob, recurrenceMs, parentJobId, dependsOnJobsIds)
+{
+    [StringLength(64)]
+    [Required]
+    public string MangaId { get; init; } = mangaId;
+    
+    [JsonIgnore]
+    public virtual Manga? Manga { get; init; }
+    
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        IQueryable<Chapter> chapters = context.Chapters.Where(c => c.ParentMangaId == MangaId);
+        foreach (Chapter chapter in chapters)
+            chapter.Downloaded = chapter.IsDownloaded();
+
+        context.SaveChanges();
+        return [];
+    }
+}

API/Schema/Jobs/UpdateMetadataJob.cs

@@ -0,0 +1,26 @@
+using System.ComponentModel.DataAnnotations;
+using Newtonsoft.Json;
+
+namespace API.Schema.Jobs;
+
+public class UpdateMetadataJob(ulong recurrenceMs, string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
+    : Job(TokenGen.CreateToken(typeof(UpdateMetadataJob)), JobType.UpdateMetaDataJob, recurrenceMs, parentJobId, dependsOnJobsIds)
+{
+    [StringLength(64)]
+    [Required]
+    public string MangaId { get; init; } = mangaId;
+    
+    [JsonIgnore]
+    public virtual Manga? Manga { get; init; }
+    
+    /// <summary>
+    /// Updates all data related to Manga.
+    /// Retrieves data from Mangaconnector
+    /// Updates Chapter-info
+    /// </summary>
+    /// <param name="context"></param>
+    protected override IEnumerable<Job> RunInternal(PgsqlContext context)
+    {
+        return [];//TODO
+    }
+}

API/Schema/LibraryConnectors/Kavita.cs

@@ -1,29 +1,22 @@
-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.LibraryConnectors;
+namespace API.Schema.LibraryConnectors;
 
 public class Kavita : LibraryConnector
 {
 
-    public Kavita(GlobalBase clone, string baseUrl, string username, string password) : 
-        base(clone, baseUrl, GetToken(baseUrl, username, password, clone.logger), LibraryType.Kavita)
+    public Kavita(string baseUrl, string auth) : base(TokenGen.CreateToken(typeof(Kavita), baseUrl), LibraryType.Kavita, baseUrl, auth)
     {
     }
     
-    [JsonConstructor]
-    public Kavita(GlobalBase clone, string baseUrl, string auth) : base(clone, baseUrl, auth, LibraryType.Kavita)
+    public Kavita(string baseUrl, string username, string password) : 
+        this(baseUrl, GetToken(baseUrl, username, password))
     {
     }
     
-    public override string ToString()
-    {
-        return $"Kavita {baseUrl}";
-    }
     
-    private static string GetToken(string baseUrl, string username, string password, Logger? logger = null)
+    private static string GetToken(string baseUrl, string username, string password)
     {
         HttpClient client = new()
         {
@@ -41,7 +34,6 @@ public class Kavita : LibraryConnector
         try
         {
             HttpResponseMessage response = client.Send(requestMessage);
-            logger?.WriteLine($"Kavita | GetToken {requestMessage.RequestUri} -> {response.StatusCode}");
             if (response.IsSuccessStatusCode)
             {
                 JsonObject? result = JsonSerializer.Deserialize<JsonObject>(response.Content.ReadAsStream());
@@ -50,28 +42,24 @@ public class Kavita : LibraryConnector
             }
             else
             {
-                logger?.WriteLine($"Kavita | {response.Content}");
             }
         }
         catch (HttpRequestException e)
         {
-            logger?.WriteLine($"Kavita | Unable to retrieve token:\n\r{e}");
         }
-        logger?.WriteLine("Kavita | Did not receive token.");
         return "";
     }
 
     protected override void UpdateLibraryInternal()
     {
-        Log("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, logger))
+            if (NetClient.MakePost($"{BaseUrl}/api/Library/scan?libraryId={lib.id}", "Bearer", Auth))
                 return true;
         return false;
     }
@@ -82,17 +70,14 @@ public class Kavita : LibraryConnector
     /// <returns>Array of KavitaLibrary</returns>
     private IEnumerable<KavitaLibrary> GetLibraries()
     {
-        Log("Getting libraries.");
-        Stream data = NetClient.MakeRequest($"{baseUrl}/api/Library/libraries", "Bearer", auth, logger);
+        Stream data = NetClient.MakeRequest($"{BaseUrl}/api/Library/libraries", "Bearer", Auth);
         if (data == Stream.Null)
         {
-            Log("No libraries returned");
             return Array.Empty<KavitaLibrary>();
         }
         JsonArray? result = JsonSerializer.Deserialize<JsonArray>(data);
         if (result is null)
         {
-            Log("No libraries returned");
             return Array.Empty<KavitaLibrary>();
         }
 

API/Schema/LibraryConnectors/Komga.cs

@@ -1,41 +1,30 @@
-using System.Text.Json.Nodes;
-using Newtonsoft.Json;
-using JsonSerializer = System.Text.Json.JsonSerializer;
+using System.Text.Json;
+using System.Text.Json.Nodes;
 
-namespace Tranga.LibraryConnectors;
+namespace API.Schema.LibraryConnectors;
 
-/// <summary>
-/// Provides connectivity to Komga-API
-/// Can fetch and update libraries
-/// </summary>
 public class Komga : LibraryConnector
 {
-    public Komga(GlobalBase clone, string baseUrl, string username, string password)
-        : base(clone, baseUrl, Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes($"{username}:{password}")), LibraryType.Komga)
+    public Komga(string baseUrl, string auth) : base(TokenGen.CreateToken(typeof(Komga), baseUrl), LibraryType.Komga,
+        baseUrl, auth)
     {
     }
     
-    [JsonConstructor]
-    public Komga(GlobalBase clone, string baseUrl, string auth) : base(clone, baseUrl, auth, LibraryType.Komga)
+    public Komga(string baseUrl, string username, string password)
+        : this(baseUrl, Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes($"{username}:{password}")))
     {
     }
     
-    public override string ToString()
-    {
-        return $"Komga {baseUrl}";
-    }
-
     protected override void UpdateLibraryInternal()
     {
-        Log("Updating libraries.");
         foreach (KomgaLibrary lib in GetLibraries())
-            NetClient.MakePost($"{baseUrl}/api/v1/libraries/{lib.id}/scan", "Basic", auth, logger);
+            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, logger))
+            if (NetClient.MakePost($"{BaseUrl}/api/v1/libraries/{lib.id}/scan", "Basic", Auth))
                 return true;
         return false;
     }
@@ -46,17 +35,14 @@ public class Komga : LibraryConnector
     /// <returns>Array of KomgaLibraries</returns>
     private IEnumerable<KomgaLibrary> GetLibraries()
     {
-        Log("Getting Libraries");
-        Stream data = NetClient.MakeRequest($"{baseUrl}/api/v1/libraries", "Basic", auth, logger);
+        Stream data = NetClient.MakeRequest($"{BaseUrl}/api/v1/libraries", "Basic", Auth);
         if (data == Stream.Null)
         {
-            Log("No libraries returned");
             return Array.Empty<KomgaLibrary>();
         }
         JsonArray? result = JsonSerializer.Deserialize<JsonArray>(data);
         if (result is null)
         {
-            Log("No libraries returned");
             return Array.Empty<KomgaLibrary>();
         }
 

API/Schema/LibraryConnectors/LibraryConnector.cs

@@ -0,0 +1,25 @@
+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)
+{
+    [StringLength(64)]
+    [Required]
+    public string LibraryConnectorId { get; } = libraryConnectorId;
+
+    [Required]
+    public LibraryType LibraryType { get; init; } = libraryType;
+    [StringLength(256)]
+    [Required]
+    [Url]
+    public string BaseUrl { get; init; } = baseUrl;
+    [StringLength(256)]
+    [Required]
+    public string Auth { get; init; } = auth;
+    
+    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,19 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("LinkId")]
+public class Link(string linkProvider, string linkUrl)
+{
+    [StringLength(64)]
+    [Required]
+    public string LinkId { get; init; } = TokenGen.CreateToken(typeof(Link), linkProvider, linkUrl);
+    [StringLength(64)]
+    [Required]
+    public string LinkProvider { get; init; } = linkProvider;
+    [StringLength(2048)]
+    [Required]
+    [Url]
+    public string LinkUrl { get; init; } = linkUrl;
+}

API/Schema/LocalLibrary.cs

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

API/Schema/Manga.cs

@@ -0,0 +1,186 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Diagnostics.CodeAnalysis;
+using System.Net;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using API.Schema.Jobs;
+using API.Schema.MangaConnectors;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using static System.IO.UnixFileMode;
+
+namespace API.Schema;
+
+[PrimaryKey("MangaId")]
+public class Manga
+{
+    [StringLength(64)]
+    [Required]
+    public string MangaId { get; init; }
+    [StringLength(128)]
+    [Required]
+    public string IdOnConnectorSite { get; init; }
+    [StringLength(256)]
+    [Required]
+    public string Name { get; internal set; }
+    [Required]
+    public string Description { get; internal set; }
+    [Url]
+    [StringLength(256)]
+    [Required]
+    public string WebsiteUrl { get; internal set; }
+    [JsonIgnore]
+    [Url]
+    public string CoverUrl { get; internal set; }
+    [JsonIgnore]
+    public string? CoverFileNameInCache { get; internal set; }
+    [Required]
+    public uint Year { get; internal set; }
+    [StringLength(8)]
+    [Required]
+    public string? OriginalLanguage { get; internal set; }
+    [Required]
+    public MangaReleaseStatus ReleaseStatus { get; internal set; }
+    [StringLength(256)]
+    [Required]
+    public string DirectoryName { get; private set; }
+    public LocalLibrary? Library { get; internal set; }
+    [JsonIgnore]
+    [NotMapped]
+    public string LibraryPath => Library is null ? TrangaSettings.downloadLocation : Library.BasePath;
+    [JsonIgnore]
+    [NotMapped]
+    public string FullDirectoryPath => Path.Join(LibraryPath, DirectoryName);
+    [Required]
+    public float IgnoreChapterBefore { get; internal set; }
+    [StringLength(64)]
+    [Required]
+    public string MangaConnectorId { get; private set; }
+    [JsonIgnore] public MangaConnector? MangaConnector { get; private set; }
+    
+    [JsonIgnore] public ICollection<Author>? Authors { get; internal set; }
+    [NotMapped]
+    [StringLength(64)]
+    [Required]
+    public IEnumerable<string> AuthorIds => Authors?.Select(a => a.AuthorId) ?? [];
+    
+    [JsonIgnore] public ICollection<MangaTag>? MangaTags { get; internal set; }
+    [NotMapped]
+    [StringLength(64)]
+    [Required]
+    public IEnumerable<string> Tags => MangaTags?.Select(t => t.Tag) ?? [];
+    
+    
+    [JsonIgnore] public ICollection<Link>? Links { get; internal set; }
+    [NotMapped]
+    [StringLength(64)]
+    [Required]
+    public IEnumerable<string> LinkIds => Links?.Select(l => l.LinkId) ?? [];
+    
+    [JsonIgnore] public ICollection<MangaAltTitle>? AltTitles { get; internal set; }
+    [NotMapped]
+    [StringLength(64)]
+    [Required]
+    public IEnumerable<string> AltTitleIds => AltTitles?.Select(a => a.AltTitleId) ?? [];
+
+    public Manga(string idOnConnectorSite, 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> mangaTags, ICollection<Link> links, ICollection<MangaAltTitle> altTitles,
+        LocalLibrary? library = null)
+        : this(idOnConnectorSite, name, description, websiteUrl, coverUrl, coverFileNameInCache, year, originalLanguage,
+            releaseStatus, ignoreChapterBefore, mangaConnector.Name)
+    {
+        this.Authors = authors;
+        this.MangaTags = mangaTags;
+        this.Links = links;
+        this.AltTitles = altTitles;
+        this.Library = library;
+    }
+    
+    public Manga(string idOnConnectorSite, string name, string description, string websiteUrl, string coverUrl,
+        string? coverFileNameInCache, uint year, string? originalLanguage, MangaReleaseStatus releaseStatus,
+        float ignoreChapterBefore, string mangaConnectorId)
+    {
+        MangaId = TokenGen.CreateToken(typeof(Manga), mangaConnectorId, idOnConnectorSite);
+        IdOnConnectorSite = idOnConnectorSite;
+        Name = name;
+        Description = description;
+        WebsiteUrl = websiteUrl;
+        CoverUrl = coverUrl;
+        CoverFileNameInCache = coverFileNameInCache;
+        Year = year;
+        OriginalLanguage = originalLanguage;
+        ReleaseStatus = releaseStatus;
+        IgnoreChapterBefore = ignoreChapterBefore;
+        MangaConnectorId = mangaConnectorId;
+        DirectoryName = BuildFolderName(name);
+    }
+
+    public MoveFileOrFolderJob UpdateFolderName(string downloadLocation, string newName)
+    {
+        string oldName = this.DirectoryName;
+        this.DirectoryName = newName;
+        return new MoveFileOrFolderJob(Path.Join(downloadLocation, oldName), Path.Join(downloadLocation, this.DirectoryName));
+    }
+
+    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.MangaTags = other.MangaTags;
+        this.AltTitles = other.AltTitles;
+        this.ReleaseStatus = other.ReleaseStatus;
+    }
+
+    private static string BuildFolderName(string mangaName)
+    {
+        return mangaName;
+    }
+    
+    internal string? SaveCoverImageToCache(int retries = 3)
+    {
+        if(retries < 0)
+            return null;
+        
+        Regex urlRex = new (@"https?:\/\/((?:[a-zA-Z0-9-]+\.)+[a-zA-Z0-9]+)\/(?:.+\/)*(.+\.([a-zA-Z]+))");
+        //https?:\/\/[a-zA-Z0-9-]+\.([a-zA-Z0-9-]+\.[a-zA-Z0-9]+)\/(?:.+\/)*(.+\.([a-zA-Z]+)) for only second level domains
+        Match match = urlRex.Match(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, $"https://{match.Groups[1].Value}");
+        if (coverResult.statusCode is < HttpStatusCode.OK or >= HttpStatusCode.Ambiguous)
+            return SaveCoverImageToCache(--retries);
+            
+        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(LibraryPath, this.DirectoryName);
+        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,19 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema;
+
+[PrimaryKey("AltTitleId")]
+public class MangaAltTitle(string language, string title)
+{
+    [StringLength(64)]
+    [Required]
+    public string AltTitleId { get; init; } = TokenGen.CreateToken("AltTitle", language, title);
+    [StringLength(8)]
+    [Required]
+    public string Language { get; init; } = language;
+    [StringLength(256)]
+    [Required]
+    public string Title { get; set; } = title;
+}

API/Schema/MangaConnectors/AsuraToon.cs

@@ -1,58 +1,53 @@
-using System.Net;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
 using HtmlAgilityPack;
-using Tranga.Jobs;
 
-namespace Tranga.MangaConnectors;
+namespace API.Schema.MangaConnectors;
 
 public class AsuraToon : MangaConnector
 {
 	
-	public AsuraToon(GlobalBase clone) : base(clone, "AsuraToon", ["en"])
+	public AsuraToon() : base("AsuraToon", ["en"], ["asuracomic.net"], "https://asuracomic.net/images/logo.webp")
 	{
-		this.downloadClient = new ChromiumDownloadClient(clone);
+		this.downloadClient = new ChromiumDownloadClient();
 	}
 
-	public override Manga[] GetManga(string publicationTitle = "")
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
 	{
-		Log($"Searching Publications. Term=\"{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 Array.Empty<Manga>();
+			return [];
 
 		if (requestResult.htmlDocument is null)
 		{
-			Log($"Failed to retrieve site");
-			return Array.Empty<Manga>();
+			return [];
 		}
 			
-		Manga[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
-		Log($"Retrieved {publications.Length} publications. Term=\"{publicationTitle}\"");
+		(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
 		return publications;
 	}
 
-	public override Manga? GetMangaFromId(string publicationId)
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
 	{
 		return GetMangaFromUrl($"https://asuracomic.net/series/{publicationId}");
 	}
 
-	public override Manga? GetMangaFromUrl(string url)
+	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)
 		{
-			Log($"Failed to retrieve site");
 			return null;
 		}
 		return ParseSinglePublicationFromHtml(requestResult.htmlDocument, url.Split('/')[^1], url);
 	}
 
-	private Manga[] ParsePublicationsFromHtml(HtmlDocument document)
+	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)
@@ -60,41 +55,41 @@ public class AsuraToon : MangaConnector
 
 		IEnumerable<string> urls = mangaList.Select(a => $"https://asuracomic.net/{a.GetAttributeValue("href", "")}");
 		
-		List<Manga> ret = new();
+		List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
 		foreach (string url in urls)
 		{
-			Manga? manga = GetMangaFromUrl(url);
-			if (manga is not null)
-				ret.Add((Manga)manga);
+			(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+			if (manga is { } x)
+				ret.Add(x);
 		}
 
 		return ret.ToArray();
 	}
 
-	private Manga ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+	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]");
-		Manga.ReleaseStatusByte releaseStatus = statusNode.InnerText.ToLower() switch
+		MangaReleaseStatus releaseStatus = statusNode.InnerText.ToLower() switch
 		{
-			"ongoing" => Manga.ReleaseStatusByte.Continuing,
-			"hiatus" => Manga.ReleaseStatusByte.OnHiatus,
-			"completed" => Manga.ReleaseStatusByte.Completed,
-			"dropped" => Manga.ReleaseStatusByte.Cancelled,
-			"season end" => Manga.ReleaseStatusByte.Continuing,
-			"coming soon" => Manga.ReleaseStatusByte.Unreleased,
-			_ => Manga.ReleaseStatusByte.Unreleased
+			"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", "");
-		string coverFileNameInCache = SaveCoverImageToCache(coverUrl, publicationId, RequestType.MangaCover);
 		
 		HtmlNode titleNode = 
 			document.DocumentNode.SelectSingleNode("//title");
@@ -108,30 +103,34 @@ public class AsuraToon : MangaConnector
 		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> authors = authorNames.Concat(artistNames).ToList();
+		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");
-		int? year = int.Parse(firstChapterNode?.InnerText.Split(' ')[^1] ?? "2000");
+		uint year = uint.Parse(firstChapterNode?.InnerText.Split(' ')[^1] ?? "2000");
 
-		Manga manga = new (sortName, authors, description, altTitles, tags, coverUrl, coverFileNameInCache, links,
-			year, originalLanguage, publicationId, releaseStatus, websiteUrl);
-		AddMangaToCache(manga);
-		return manga;
+		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")
 	{
-		Log($"Getting chapters {manga}");
-		string requestUrl = $"https://asuracomic.net/series/{manga.publicationId}";
+		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 Array.Empty<Chapter>();
+			return [];
 
 		//Return Chapters ordered by Chapter-Number
 		List<Chapter> chapters = ParseChaptersFromHtml(manga, requestUrl);
-		Log($"Got {chapters.Count} chapters. {manga}");
 		return chapters.Order().ToArray();
 	}
 
@@ -140,7 +139,6 @@ public class AsuraToon : MangaConnector
 		RequestResult result = downloadClient.MakeRequest(mangaUrl, RequestType.Default);
 		if ((int)result.statusCode < 200 || (int)result.statusCode >= 300 || result.htmlDocument is null)
 		{
-			Log("Failed to load site");
 			return new List<Chapter>();
 		}
 
@@ -154,63 +152,38 @@ public class AsuraToon : MangaConnector
 			string chapterUrl = chapterInfo.GetAttributeValue("href", "");
 
 			Match match = infoRex.Match(chapterInfo.InnerText);
-			string chapterNumber = match.Groups[1].Value;
+			string 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, chapterName, null, chapterNumber, url));
+				ret.Add(new Chapter(manga, url, chapterNumber, null, chapterName));
 			}
 			catch (Exception e)
 			{
-				Log($"Failed to load chapter {chapterNumber}: {e.Message}");
 			}
 		}
 		
 		return ret;
 	}
 
-	public override HttpStatusCode DownloadChapter(Chapter chapter, ProgressToken? progressToken = null)
+	internal override string[] GetChapterImageUrls(Chapter chapter)
 	{
-		if (progressToken?.cancellationRequested ?? false)
-		{
-			progressToken.Cancel();
-			return HttpStatusCode.RequestTimeout;
-		}
-
-		Manga chapterParentManga = chapter.parentManga;
-		Log($"Retrieving chapter-info {chapter} {chapterParentManga}");
-		string requestUrl = chapter.url;
+		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)
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
 		{
-			progressToken?.Cancel();
-			return requestResult.statusCode;
+			return [];
 		}
-
-		string[] imageUrls = ParseImageUrlsFromHtml(requestUrl);
-		
-		return DownloadChapterImages(imageUrls, chapter, RequestType.MangaImage, progressToken:progressToken);
+		string[] imageUrls = ParseImageUrlsFromHtml(requestResult.htmlDocument);
+		return imageUrls;
 	}
 
-	private string[] ParseImageUrlsFromHtml(string mangaUrl)
+	private string[] ParseImageUrlsFromHtml(HtmlDocument document)
 	{
-		RequestResult requestResult =
-			downloadClient.MakeRequest(mangaUrl, RequestType.Default);
-		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
-		{
-			return Array.Empty<string>();
-		}
-		if (requestResult.htmlDocument is null)
-		{
-			Log($"Failed to retrieve site");
-			return Array.Empty<string>();
-		}
-
-		HtmlNodeCollection images =
-			requestResult.htmlDocument.DocumentNode.SelectNodes("//img[contains(@alt, 'chapter page')]");
+		HtmlNodeCollection images = document.DocumentNode.SelectNodes("//img[contains(@alt, 'chapter page')]");
 
 		return images.Select(i => i.GetAttributeValue("src", "")).ToArray();
 	}

API/Schema/MangaConnectors/Bato.cs

@@ -1,78 +1,74 @@
 using System.Net;
 using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
 using HtmlAgilityPack;
-using Tranga.Jobs;
 
-namespace Tranga.MangaConnectors;
+namespace API.Schema.MangaConnectors;
 
 public class Bato : MangaConnector
 {
 	
-	public Bato(GlobalBase clone) : base(clone, "Bato", ["en"])
+	public Bato() : base("Bato", ["en"], ["bato.to"], "https://bato.to/amsta/img/batoto/favicon.ico")
 	{
-		this.downloadClient = new HttpDownloadClient(clone);
+		this.downloadClient = new HttpDownloadClient();
 	}
 
-	public override Manga[] GetManga(string publicationTitle = "")
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
 	{
-		Log($"Searching Publications. Term=\"{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 Array.Empty<Manga>();
+			return [];
 
 		if (requestResult.htmlDocument is null)
 		{
-			Log($"Failed to retrieve site");
-			return Array.Empty<Manga>();
+			return [];
 		}
 			
-		Manga[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
-		Log($"Retrieved {publications.Length} publications. Term=\"{publicationTitle}\"");
+		(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
 		return publications;
 	}
 
-	public override Manga? GetMangaFromId(string publicationId)
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
 	{
 		return GetMangaFromUrl($"https://bato.to/title/{publicationId}");
 	}
 
-	public override Manga? GetMangaFromUrl(string url)
+	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)
 		{
-			Log($"Failed to retrieve site");
 			return null;
 		}
 		return ParseSinglePublicationFromHtml(requestResult.htmlDocument, url.Split('/')[^1], url);
 	}
 
-	private Manga[] ParsePublicationsFromHtml(HtmlDocument document)
+	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 Array.Empty<Manga>();
+			return [];
 
 		List<string> urls = mangaList.ChildNodes
 			.Select(node => $"https://bato.to{node.Descendants("div").First().FirstChild.GetAttributeValue("href", "")}").ToList();
 		
-		HashSet<Manga> ret = new();
+		HashSet<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
 		foreach (string url in urls)
 		{
-			Manga? manga = GetMangaFromUrl(url);
-			if (manga is not null)
-				ret.Add((Manga)manga);
+			(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+			if (manga is { } x)
+				ret.Add(x);
 		}
 
 		return ret.ToArray();
 	}
 
-	private Manga ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+	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]");
 
@@ -82,57 +78,61 @@ public class Bato : MangaConnector
 
 		string[] altTitlesList = infoNode.ChildNodes[1].ChildNodes[2].InnerText.Split('/');
 		int i = 0;
-		Dictionary<string, string> altTitles = altTitlesList.ToDictionary(s => i++.ToString(), s => s);
+		List<MangaAltTitle> altTitles = altTitlesList.Select(a => new MangaAltTitle(i++.ToString(), a)).ToList();
 
-		string posterUrl = document.DocumentNode.SelectNodes("//img")
+		string coverUrl = document.DocumentNode.SelectNodes("//img")
 			.First(child => child.GetAttributeValue("data-hk", "") == "0-1-0").GetAttributeValue("src", "").Replace("&amp;", "&");
-		string coverFileNameInCache = SaveCoverImageToCache(posterUrl, publicationId, RequestType.MangaCover);
 
 		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> authors = authorsNodes.Select(node => node.InnerText.Replace("amp;", "")).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 (!int.TryParse(
+		if (!uint.TryParse(
 			    document.DocumentNode.SelectSingleNode("//span[text()='Original Publication:']/..").LastChild.InnerText.Split('-')[0],
-			    out int year))
-			year = DateTime.Now.Year;
+			    out uint year))
+			year = (uint)DateTime.UtcNow.Year;
 
 		string status = document.DocumentNode.SelectSingleNode("//span[text()='Original Publication:']/..")
 			.ChildNodes[2].InnerText;
-		Manga.ReleaseStatusByte releaseStatus = Manga.ReleaseStatusByte.Unreleased;
+		MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
 		switch (status.ToLower())
 		{
-			case "ongoing": releaseStatus = Manga.ReleaseStatusByte.Continuing; break;
-			case "completed": releaseStatus = Manga.ReleaseStatusByte.Completed; break;
-			case "hiatus": releaseStatus = Manga.ReleaseStatusByte.OnHiatus; break;
-			case "cancelled": releaseStatus = Manga.ReleaseStatusByte.Cancelled; break;
-			case "pending": releaseStatus = Manga.ReleaseStatusByte.Unreleased; break;
+			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 (sortName, authors, description, altTitles, tags, posterUrl, coverFileNameInCache, new Dictionary<string, string>(),
-			year, originalLanguage, publicationId, releaseStatus, websiteUrl: websiteUrl);
-		AddMangaToCache(manga);
-		return manga;
+		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")
 	{
-		Log($"Getting chapters {manga}");
-		string requestUrl = $"https://bato.to/title/{manga.publicationId}";
+		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 Array.Empty<Chapter>();
+			return [];
 
 		//Return Chapters ordered by Chapter-Number
 		List<Chapter> chapters = ParseChaptersFromHtml(manga, requestUrl);
-		Log($"Got {chapters.Count} chapters. {manga}");
 		return chapters.Order().ToArray();
 	}
 
@@ -141,7 +141,6 @@ public class Bato : MangaConnector
 		RequestResult result = downloadClient.MakeRequest(mangaUrl, RequestType.Default);
 		if ((int)result.statusCode < 200 || (int)result.statusCode >= 300 || result.htmlDocument is null)
 		{
-			Log("Failed to load site");
 			return new List<Chapter>();
 		}
 
@@ -159,64 +158,38 @@ public class Bato : MangaConnector
 
 			Match match = numberRex.Match(chapterUrl);
 			string id = match.Groups[1].Value;
-			string? volumeNumber = match.Groups[2].Success ? match.Groups[2].Value : null;
-			string chapterNumber = match.Groups[3].Value;
-			string chapterName = chapterNumber;
+			int? volumeNumber = match.Groups[2].Success ? int.Parse(match.Groups[2].Value) : null;
+			string chapterNumber = new(match.Groups[3].Value);
 			string url = $"https://bato.to{chapterUrl}?load=2";
 			try
 			{
-				ret.Add(new Chapter(manga, chapterName, volumeNumber, chapterNumber, url));
+				ret.Add(new Chapter(manga, url, chapterNumber, volumeNumber, null));
 			}
 			catch (Exception e)
 			{
-				Log($"Failed to load chapter {chapterNumber}: {e.Message}");
 			}
 		}
 		
 		return ret;
 	}
 
-	public override HttpStatusCode DownloadChapter(Chapter chapter, ProgressToken? progressToken = null)
+	internal override string[] GetChapterImageUrls(Chapter chapter)
 	{
-		if (progressToken?.cancellationRequested ?? false)
-		{
-			progressToken.Cancel();
-			return HttpStatusCode.RequestTimeout;
-		}
-
-		Manga chapterParentManga = chapter.parentManga;
-		Log($"Retrieving chapter-info {chapter} {chapterParentManga}");
-		string requestUrl = chapter.url;
+		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)
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
 		{
-			progressToken?.Cancel();
-			return requestResult.statusCode;
+			return [];
 		}
 
-		string[] imageUrls = ParseImageUrlsFromHtml(requestUrl);
-		
-		return DownloadChapterImages(imageUrls, chapter, RequestType.MangaImage, progressToken:progressToken);
+		string[] imageUrls = ParseImageUrlsFromHtml(requestResult.htmlDocument);
+		return imageUrls;
 	}
 
-	private string[] ParseImageUrlsFromHtml(string mangaUrl)
+	private string[] ParseImageUrlsFromHtml(HtmlDocument document)
 	{
-		RequestResult requestResult =
-			downloadClient.MakeRequest(mangaUrl, RequestType.Default);
-		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
-		{
-			return Array.Empty<string>();
-		}
-		if (requestResult.htmlDocument is null)
-		{
-			Log($"Failed to retrieve site");
-			return Array.Empty<string>();
-		}
-
-		HtmlDocument document = requestResult.htmlDocument;
-
 		HtmlNode images = document.DocumentNode.SelectNodes("//astro-island").First(node =>
 			node.GetAttributeValue("component-url", "").Contains("/_astro/ImageList."));
 

API/Schema/MangaConnectors/Global.cs

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

API/Schema/MangaConnectors/MangaConnector.cs

@@ -0,0 +1,52 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Text.RegularExpressions;
+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, string iconUrl)
+{
+    [StringLength(32)]
+    [Required]
+    public string Name { get; init; } = name;
+    [StringLength(8)]
+    [Required]
+    public string[] SupportedLanguages { get; init; } = supportedLanguages;
+    [StringLength(2048)]
+    [Required]
+    public string IconUrl { get; init; } = iconUrl;
+    [StringLength(256)]
+    [Required]
+    public string[] BaseUris { get; init; } = baseUris;
+    [Required]
+    public bool Enabled { get; internal set; } = true;
+    
+    public abstract (Manga, 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);
+
+    public bool ValidateUrl(string url) => BaseUris.Any(baseUri => Regex.IsMatch(url, "https?://" + baseUri + "/.*"));
+}

API/Schema/MangaConnectors/MangaDex.cs

@@ -1,27 +1,27 @@
 using System.Net;
 using System.Text.Json.Nodes;
 using System.Text.RegularExpressions;
-using Tranga.Jobs;
+using API.MangaDownloadClients;
 using JsonSerializer = System.Text.Json.JsonSerializer;
 
-namespace Tranga.MangaConnectors;
+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(GlobalBase clone) : base(clone, "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"])
+    public MangaDex() : base("MangaDex", ["en","pt","pt-br","it","de","ru","aa","ab","ae","af","ak","am","an","ar-ae","ar-bh","ar-dz","ar-eg","ar-iq","ar-jo","ar-kw","ar-lb","ar-ly","ar-ma","ar-om","ar-qa","ar-sa","ar-sy","ar-tn","ar-ye","ar","as","av","ay","az","ba","be","bg","bh","bi","bm","bn","bo","br","bs","ca","ce","ch","co","cr","cs","cu","cv","cy","da","de-at","de-ch","de-de","de-li","de-lu","div","dv","dz","ee","el","en-au","en-bz","en-ca","en-cb","en-gb","en-ie","en-jm","en-nz","en-ph","en-tt","en-us","en-za","en-zw","eo","es-ar","es-bo","es-cl","es-co","es-cr","es-do","es-ec","es-es","es-gt","es-hn","es-la","es-mx","es-ni","es-pa","es-pe","es-pr","es-py","es-sv","es-us","es-uy","es-ve","es","et","eu","fa","ff","fi","fj","fo","fr-be","fr-ca","fr-ch","fr-fr","fr-lu","fr-mc","fr","fy","ga","gd","gl","gn","gu","gv","ha","he","hi","ho","hr-ba","hr-hr","hr","ht","hu","hy","hz","ia","id","ie","ig","ii","ik","in","io","is","it-ch","it-it","iu","iw","ja","ja-ro","ji","jv","jw","ka","kg","ki","kj","kk","kl","km","kn","ko","ko-ro","kr","ks","ku","kv","kw","ky","kz","la","lb","lg","li","ln","lo","ls","lt","lu","lv","mg","mh","mi","mk","ml","mn","mo","mr","ms-bn","ms-my","ms","mt","my","na","nb","nd","ne","ng","nl-be","nl-nl","nl","nn","no","nr","ns","nv","ny","oc","oj","om","or","os","pa","pi","pl","ps","pt-pt","qu-bo","qu-ec","qu-pe","qu","rm","rn","ro","rw","sa","sb","sc","sd","se-fi","se-no","se-se","se","sg","sh","si","sk","sl","sm","sn","so","sq","sr-ba","sr-sp","sr","ss","st","su","sv-fi","sv-se","sv","sw","sx","syr","ta","te","tg","th","ti","tk","tl","tn","to","tr","ts","tt","tw","ty","ug","uk","ur","us","uz","ve","vi","vo","wa","wo","xh","yi","yo","za","zh-cn","zh-hk","zh-mo","zh-ro","zh-sg","zh-tw","zh","zu"], ["mangadex.org"], "https://mangadex.org/favicon.ico")
     {
-        this.downloadClient = new HttpDownloadClient(clone);
+        this.downloadClient = new HttpDownloadClient();
     }
 
-    public override Manga[] GetManga(string publicationTitle = "")
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
     {
-        Log($"Searching Publications. Term={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> retManga = new();
+        HashSet<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> retManga = new();
         int loadedPublicationData = 0;
         List<JsonNode> results = new();
         
@@ -53,15 +53,13 @@ public class MangaDex : MangaConnector
         
         foreach (JsonNode mangaNode in results)
         {
-            Log($"Getting publication data. {++loadedPublicationData}/{total}");
             if(MangaFromJsonObject(mangaNode.AsObject()) is { } manga)
                 retManga.Add(manga); //Add Publication (Manga) to result
         }
-        Log($"Retrieved {retManga.Count} publications. Term={publicationTitle}");
         return retManga.ToArray();
     }
 
-    public override Manga? GetMangaFromId(string publicationId)
+    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);
@@ -73,15 +71,14 @@ public class MangaDex : MangaConnector
         return null;
     }
 
-    public override Manga? GetMangaFromUrl(string url)
+    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;
-        Log($"Got id {id} from {url}");
         return GetMangaFromId(id);
     }
 
-    private Manga? MangaFromJsonObject(JsonObject manga)
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? MangaFromJsonObject(JsonObject manga)
     {
         if (!manga.TryGetPropertyValue("id", out JsonNode? idNode))
             return null;
@@ -93,7 +90,7 @@ public class MangaDex : MangaConnector
 
         if (!attributes.TryGetPropertyValue("title", out JsonNode? titleNode))
             return null;
-        string title = titleNode!.AsObject().ContainsKey("en") switch
+        string sortName = titleNode!.AsObject().ContainsKey("en") switch
         {
             true => titleNode.AsObject()["en"]!.GetValue<string>(),
             false => titleNode.AsObject().First().Value!.GetValue<string>()
@@ -108,6 +105,7 @@ public class MangaDex : MangaConnector
                 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;
@@ -121,6 +119,7 @@ public class MangaDex : MangaConnector
         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
@@ -129,30 +128,30 @@ public class MangaDex : MangaConnector
                 false => null
             };
         
-        Manga.ReleaseStatusByte status = Manga.ReleaseStatusByte.Unreleased;
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
         if (attributes.TryGetPropertyValue("status", out JsonNode? statusNode))
         {
-            status = statusNode?.GetValue<string>().ToLower() switch
+            releaseStatus = statusNode?.GetValue<string>().ToLower() switch
             {
-                "ongoing" => Manga.ReleaseStatusByte.Continuing,
-                "completed" => Manga.ReleaseStatusByte.Completed,
-                "hiatus" => Manga.ReleaseStatusByte.OnHiatus,
-                "cancelled" => Manga.ReleaseStatusByte.Cancelled,
-                _ => Manga.ReleaseStatusByte.Unreleased
+                "ongoing" => MangaReleaseStatus.Continuing,
+                "completed" => MangaReleaseStatus.Completed,
+                "hiatus" => MangaReleaseStatus.OnHiatus,
+                "cancelled" => MangaReleaseStatus.Cancelled,
+                _ => MangaReleaseStatus.Unreleased
             };
         }
 
-        int? year = attributes.TryGetPropertyValue("year", out JsonNode? yearNode) switch
+        uint year = attributes.TryGetPropertyValue("year", out JsonNode? yearNode) switch
         {
-            true => yearNode?.GetValue<int>(),
-            false => null
+            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;
@@ -163,40 +162,31 @@ public class MangaDex : MangaConnector
             return null;
         string fileName = coverNode["attributes"]!["fileName"]!.GetValue<string>();
         string coverUrl = $"https://uploads.mangadex.org/covers/{publicationId}/{fileName}";
-        string coverCacheName = SaveCoverImageToCache(coverUrl, publicationId, RequestType.MangaCover);
         
-        List<string> authors = new();
+        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(!authors.Contains(authorName))
-               authors.Add(authorName);
+            if(!authorNames.Contains(authorName))
+               authorNames.Add(authorName);
         }
+        List<Author> authors = authorNames.Select(a => new Author(a)).ToList();
 
-        Manga pub = new(
-            title,
+        Manga pub = new (publicationId, sortName, description, $"https://mangadex.org/title/{publicationId}", coverUrl, null, year,
+            originalLanguage, releaseStatus, -1,
+            this, 
             authors, 
-            description,
-            altTitlesDict,
-            tags.ToArray(),
-            coverUrl,
-            coverCacheName,
-            linksDict,
-            year,
-            originalLanguage,
-            publicationId,
-            status,
-            websiteUrl: $"https://mangadex.org/title/{publicationId}"
-        );
-        AddMangaToCache(pub);
-        return pub;
+            mangaTags, 
+            links,
+            altTitles);
+		
+        return (pub, authors, mangaTags, links, altTitles);
     }
 
     public override Chapter[] GetChapters(Manga manga, string language="en")
     {
-        Log($"Getting chapters {manga}");
         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
@@ -207,7 +197,7 @@ public class MangaDex : MangaConnector
             //Request next "Page"
             RequestResult requestResult =
                 downloadClient.MakeRequest(
-                    $"https://api.mangadex.org/manga/{manga.publicationId}/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);
+                    $"https://api.mangadex.org/manga/{manga.IdOnConnectorSite}/feed?limit={limit}&offset={offset}&translatedLanguage%5B%5D={language}&contentRating%5B%5D=safe&contentRating%5B%5D=suggestive&contentRating%5B%5D=erotica&contentRating%5B%5D=pornographic", RequestType.MangaDexFeed);
             if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
                 break;
             JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
@@ -225,80 +215,68 @@ public class MangaDex : MangaConnector
                 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;
                 
-                string? volume = attributes.ContainsKey("volume") && attributes["volume"] is not null
-                    ? attributes["volume"]!.GetValue<string>()
+                int? volume = attributes.ContainsKey("volume") && attributes["volume"] is not null
+                    ? int.Parse(attributes["volume"]!.GetValue<string>())
                     : null;
                 
-                string chapterNum = attributes.ContainsKey("chapter") && attributes["chapter"] is not null
+                string? chapterNumStr = attributes.ContainsKey("chapter") && attributes["chapter"] is not null
                     ? attributes["chapter"]!.GetValue<string>()
-                    : "null";
+                    : null;
+                
+                string chapterNumber = new(chapterNumStr);
                 
                 
                 if (attributes.ContainsKey("pages") && attributes["pages"] is not null &&
                     attributes["pages"]!.GetValue<int>() < 1)
                 {
-                    Log($"Skipping {chapterId} Vol.{volume} Ch.{chapterNum} {title} because it has no pages or is externally linked.");
                     continue;
                 }
                 
                 try
                 {
-                    if(!chapters.Any(chp =>
-                           chp.volumeNumber.Equals(float.Parse(volume??"0", numberFormatDecimalPoint)) &&
-                           chp.chapterNumber.Equals(float.Parse(chapterNum, numberFormatDecimalPoint))))
-                    chapters.Add(new Chapter(manga, title, volume, chapterNum, chapterId, chapterId));
+                    Chapter newChapter = new Chapter(manga, url, chapterNumber, volume, title);
+                    if(!chapters.Contains(newChapter))
+                        chapters.Add(newChapter);
                 }
                 catch (Exception e)
                 {
-                    Log($"Failed to load chapter {chapterNum}: {e.Message}");
                 }
             }
         }
 
         //Return Chapters ordered by Chapter-Number
-        Log($"Got {chapters.Count} chapters. {manga}");
         return chapters.Order().ToArray();
     }
 
-    public override HttpStatusCode DownloadChapter(Chapter chapter, ProgressToken? progressToken = null)
-    {
-        if (progressToken?.cancellationRequested ?? false)
-        {
-            progressToken.Cancel();
-            return HttpStatusCode.RequestTimeout;
-        }
-
-        Manga chapterParentManga = chapter.parentManga;
-        Log($"Retrieving chapter-info {chapter} {chapterParentManga}");
-        //Request URLs for Chapter-Images
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {//Request URLs for Chapter-Images
+        Match m = Regex.Match(chapter.Url, @"https?:\/\/mangadex.org\/chapter\/([0-9\-a-z]+)");
+        if (!m.Success)
+            return [];
         RequestResult requestResult =
-            downloadClient.MakeRequest($"https://api.mangadex.org/at-home/server/{chapter.url}?forcePort443=false", RequestType.MangaDexImage);
+            downloadClient.MakeRequest($"https://api.mangadex.org/at-home/server/{m.Groups[1].Value}?forcePort443=false", RequestType.MangaDexImage);
         if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
         {
-            progressToken?.Cancel();
-            return requestResult.statusCode;
+            return [];
         }
         JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
         if (result is null)
         {
-            progressToken?.Cancel();
-            return HttpStatusCode.NoContent;
+            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();
+        List<string> imageUrls = new();
         foreach (JsonNode? image in imageFileNames)
             imageUrls.Add($"{baseUrl}/data/{hash}/{image!.GetValue<string>()}");
-        
-        //Download Chapter-Images
-        return DownloadChapterImages(imageUrls.ToArray(), chapter, RequestType.MangaImage, progressToken:progressToken);
+        return imageUrls.ToArray();
     }
 }

API/Schema/MangaConnectors/MangaHere.cs

@@ -1,58 +1,55 @@
-using System.Net;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
 using HtmlAgilityPack;
-using Tranga.Jobs;
 
-namespace Tranga.MangaConnectors;
+namespace API.Schema.MangaConnectors;
 
 public class MangaHere : MangaConnector
 {
-    public MangaHere(GlobalBase clone) : base(clone, "MangaHere", ["en"])
+    public MangaHere() : base("MangaHere", ["en"], ["www.mangahere.cc"], "http://www.mangahere.cc/favicon.ico")
     {
-        this.downloadClient = new ChromiumDownloadClient(clone);
+        this.downloadClient = new ChromiumDownloadClient();
     }
 
-    public override Manga[] GetManga(string publicationTitle = "")
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
     {
-        Log($"Searching Publications. Term=\"{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 Array.Empty<Manga>();
+            return [];
         
-        Manga[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
-        Log($"Retrieved {publications.Length} publications. Term=\"{publicationTitle}\"");
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
         return publications;
     }
 
-    private Manga[] ParsePublicationsFromHtml(HtmlDocument document)
+    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 Array.Empty<Manga>();
+            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> ret = new();
+        HashSet<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
         foreach (string url in urls)
         {
-            Manga? manga = GetMangaFromUrl(url);
-            if (manga is not null)
-                ret.Add((Manga)manga);
+            (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? GetMangaFromId(string publicationId)
+    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? GetMangaFromUrl(string url)
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
     {
         RequestResult requestResult =
             downloadClient.MakeRequest(url, RequestType.MangaInfo);
@@ -64,54 +61,58 @@ public class MangaHere : MangaConnector
         return ParseSinglePublicationFromHtml(requestResult.htmlDocument, id, url);
     }
 
-    private Manga ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    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();
-        Manga.ReleaseStatusByte releaseStatus = Manga.ReleaseStatusByte.Unreleased;
+        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 posterUrl = "http://static.mangahere.cc/v20230914/mangahere/images/nopicture.jpg";
-        string coverFileNameInCache = SaveCoverImageToCache(posterUrl, publicationId, RequestType.MangaCover);
+        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> authors = document.DocumentNode
+        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 = Manga.ReleaseStatusByte.Cancelled; break;
-            case "hiatus": releaseStatus = Manga.ReleaseStatusByte.OnHiatus; break;
-            case "discontinued": releaseStatus = Manga.ReleaseStatusByte.Cancelled; break;
-            case "complete": releaseStatus = Manga.ReleaseStatusByte.Completed; break;
-            case "ongoing": releaseStatus = Manga.ReleaseStatusByte.Continuing; break;
+            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(sortName, authors.ToList(), description, altTitles, tags.ToArray(), posterUrl,
-            coverFileNameInCache, links,
-            null, originalLanguage, publicationId, releaseStatus, websiteUrl: websiteUrl);
-        AddMangaToCache(manga);
-        return manga;
+        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")
     {
-        Log($"Getting chapters {manga}");
-        string requestUrl = $"https://www.mangahere.cc/manga/{manga.publicationId}";
+        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)
@@ -126,54 +127,36 @@ public class MangaHere : MangaConnector
         {
             Match rexMatch = chapterRex.Match(url);
 
-            string volumeNumber = rexMatch.Groups[1].Value == "TBD" ? "0" : rexMatch.Groups[1].Value;
-            string chapterNumber = rexMatch.Groups[2].Value;
+            int? volumeNumber = rexMatch.Groups[1].Value == "TBD" ? null : int.Parse(rexMatch.Groups[1].Value);
+            string chapterNumber = new(rexMatch.Groups[2].Value);
             string fullUrl = $"https://www.mangahere.cc{url}";
                 
             try
             {
-                chapters.Add(new Chapter(manga, "", volumeNumber, chapterNumber, fullUrl));
+                chapters.Add(new Chapter(manga, fullUrl, chapterNumber, volumeNumber, null));
             }
             catch (Exception e)
             {
-                Log($"Failed to load chapter {chapterNumber}: {e.Message}");
             }
         }
         //Return Chapters ordered by Chapter-Number
-        Log($"Got {chapters.Count} chapters. {manga}");
         return chapters.Order().ToArray();
     }
 
-    public override HttpStatusCode DownloadChapter(Chapter chapter, ProgressToken? progressToken = null)
+    internal override string[] GetChapterImageUrls(Chapter chapter)
     {
-        if (progressToken?.cancellationRequested ?? false)
-        {
-            progressToken.Cancel();
-            return HttpStatusCode.RequestTimeout;
-        }
-
-        Manga chapterParentManga = chapter.parentManga;
-        Log($"Retrieving chapter-info {chapter} {chapterParentManga}");
-
         List<string> imageUrls = new();
 
         int downloaded = 1;
         int images = 1;
-        string url = string.Join('/', chapter.url.Split('/')[..^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)
+            if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
             {
-                progressToken?.Cancel();
-                return requestResult.statusCode;
-            }
-
-            if (requestResult.htmlDocument is null)
-            {
-                progressToken?.Cancel();
-                return HttpStatusCode.InternalServerError;
+                return [];
             }
             
             imageUrls.AddRange(ParseImageUrlsFromHtml(requestResult.htmlDocument));
@@ -181,17 +164,9 @@ public class MangaHere : MangaConnector
             images = requestResult.htmlDocument.DocumentNode
                 .SelectNodes("//a[contains(@href, '/manga/')]")
                 .MaxBy(node => node.GetAttributeValue("data-page", 0))!.GetAttributeValue("data-page", 0);
-            logger?.WriteLine($"MangaHere speciality: Get Image-url {downloaded}/{images}");
-            if (progressToken is not null)
-            {
-                progressToken.increments = images * 2;//we also have to download the images later
-                progressToken.Increment();
-            }
         } while (downloaded++ <= images);
         
-        if (progressToken is not null)
-            progressToken.increments = images;//we blip to normal length, in downloadchapterimages it is increasaed by the amount of urls again
-        return DownloadChapterImages(imageUrls.ToArray(), chapter, RequestType.MangaImage, progressToken:progressToken);
+        return imageUrls.ToArray();
     }
 
     private string[] ParseImageUrlsFromHtml(HtmlDocument document)

API/Schema/MangaConnectors/MangaKatana.cs

@@ -1,26 +1,24 @@
-using System.Net;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
 using HtmlAgilityPack;
-using Tranga.Jobs;
 
-namespace Tranga.MangaConnectors;
+namespace API.Schema.MangaConnectors;
 
 public class MangaKatana : MangaConnector
 {
-	public MangaKatana(GlobalBase clone) : base(clone, "MangaKatana", ["en"])
+	public MangaKatana() : base("MangaKatana", ["en"], ["mangakatana.com"], "https://mangakatana.com/static/img/fav.png")
 	{
-		this.downloadClient = new HttpDownloadClient(clone);
+		this.downloadClient = new HttpDownloadClient();
 	}
 
-	public override Manga[] GetManga(string publicationTitle = "")
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
 	{
-		Log($"Searching Publications. Term=\"{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 Array.Empty<Manga>();
+			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
@@ -31,17 +29,16 @@ public class MangaKatana : MangaConnector
 			return new [] { ParseSinglePublicationFromHtml(requestResult.result, requestResult.redirectedToUrl.Split('/')[^1], requestResult.redirectedToUrl) };
 		}
 
-		Manga[] publications = ParsePublicationsFromHtml(requestResult.result);
-		Log($"Retrieved {publications.Length} publications. Term=\"{publicationTitle}\"");
+		(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.result);
 		return publications;
 	}
 
-	public override Manga? GetMangaFromId(string publicationId)
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
 	{
 		return GetMangaFromUrl($"https://mangakatana.com/manga/{publicationId}");
 	}
 
-	public override Manga? GetMangaFromUrl(string url)
+	public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
 	{
 		RequestResult requestResult =
 			downloadClient.MakeRequest(url, RequestType.MangaInfo);
@@ -50,7 +47,7 @@ public class MangaKatana : MangaConnector
 		return ParseSinglePublicationFromHtml(requestResult.result, url.Split('/')[^1], url);
 	}
 
-	private Manga[] ParsePublicationsFromHtml(Stream html)
+	private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(Stream html)
 	{
 		StreamReader reader = new(html);
 		string htmlString = reader.ReadToEnd();
@@ -58,7 +55,7 @@ public class MangaKatana : MangaConnector
 		document.LoadHtml(htmlString);
 		IEnumerable<HtmlNode> searchResults = document.DocumentNode.SelectNodes("//*[@id='book_list']/div");
 		if (searchResults is null || !searchResults.Any())
-			return Array.Empty<Manga>();
+			return [];
 		List<string> urls = new();
 		foreach (HtmlNode mangaResult in searchResults)
 		{
@@ -66,29 +63,29 @@ public class MangaKatana : MangaConnector
 				.First(a => a.Name == "href").Value);
 		}
 
-		HashSet<Manga> ret = new();
+		HashSet<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
 		foreach (string url in urls)
 		{
-			Manga? manga = GetMangaFromUrl(url);
-			if (manga is not null)
-				ret.Add((Manga)manga);
+			(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+			if (manga is { } x)
+				ret.Add(x);
 		}
 
 		return ret.ToArray();
 	}
 
-	private Manga ParseSinglePublicationFromHtml(Stream html, string publicationId, string websiteUrl)
+	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> altTitles = new();
+		Dictionary<string, string> altTitlesDict = new();
 		Dictionary<string, string>? links = null;
 		HashSet<string> tags = new();
-		string[] authors = Array.Empty<string>();
+		string[] authorNames = [];
 		string originalLanguage = "";
-		Manga.ReleaseStatusByte releaseStatus = Manga.ReleaseStatusByte.Unreleased;
+		MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
 
 		HtmlNode infoNode = document.DocumentNode.SelectSingleNode("//*[@id='single_book']");
 		string sortName = infoNode.Descendants("h1").First(n => n.HasClass("heading")).InnerText;
@@ -105,16 +102,16 @@ public class MangaKatana : MangaConnector
 				case "altnames":
 					string[] alts = value.Split(" ; ");
 					for (int i = 0; i < alts.Length; i++)
-						altTitles.Add(i.ToString(), alts[i]);
+						altTitlesDict.Add(i.ToString(), alts[i]);
 					break;
 				case "authorsartists":
-					authors = value.Split(',');
+					authorNames = value.Split(',');
 					break;
 				case "status":
 					switch (value.ToLower())
 					{
-						case "ongoing": releaseStatus = Manga.ReleaseStatusByte.Continuing; break;
-						case "completed": releaseStatus = Manga.ReleaseStatusByte.Completed; break;
+						case "ongoing": releaseStatus = MangaReleaseStatus.Continuing; break;
+						case "completed": releaseStatus = MangaReleaseStatus.Completed; break;
 					}
 					break;
 				case "genres":
@@ -123,34 +120,39 @@ public class MangaKatana : MangaConnector
 			}
 		}
 
-		string posterUrl = document.DocumentNode.SelectSingleNode("//*[@id='single_book']/div[1]/div").Descendants("img").First()
+		string coverUrl = document.DocumentNode.SelectSingleNode("//*[@id='single_book']/div[1]/div").Descendants("img").First()
 			.GetAttributes().First(a => a.Name == "src").Value;
 
-		string coverFileNameInCache = SaveCoverImageToCache(posterUrl, publicationId, RequestType.MangaCover);
-
 		string description = document.DocumentNode.SelectSingleNode("//*[@id='single_book']/div[3]/p").InnerText;
 		while (description.StartsWith('\n'))
 			description = description.Substring(1);
 
-		int year = DateTime.Now.Year;
+		uint year = (uint)DateTime.UtcNow.Year;
 		string yearString = infoTable.Descendants("div").First(d => d.HasClass("updateAt"))
 			.InnerText.Split('-')[^1];
 
 		if(yearString.Contains("ago") == false)
 		{
-			year = Convert.ToInt32(yearString);
+			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 (sortName, authors.ToList(), description, altTitles, tags.ToArray(), posterUrl, coverFileNameInCache, links,
-			year, originalLanguage, publicationId, releaseStatus, websiteUrl: websiteUrl);
-		AddMangaToCache(manga);
-		return manga;
+		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")
 	{
-		Log($"Getting chapters {manga}");
-		string requestUrl = $"https://mangakatana.com/manga/{manga.publicationId}";
+		string requestUrl = $"https://mangakatana.com/manga/{manga.MangaId}";
 		// Leaving this in for verification if the page exists
 		RequestResult requestResult =
 			downloadClient.MakeRequest(requestUrl, RequestType.Default);
@@ -159,7 +161,6 @@ public class MangaKatana : MangaConnector
 
 		//Return Chapters ordered by Chapter-Number
 		List<Chapter> chapters = ParseChaptersFromHtml(manga, requestUrl);
-		Log($"Got {chapters.Count} chapters. {manga}");
 		return chapters.Order().ToArray();
 	}
 
@@ -183,52 +184,39 @@ public class MangaKatana : MangaConnector
 			string url = chapterInfo.Descendants("a").First()
 				.GetAttributeValue("href", "");
 
-			string? volumeNumber = volumeRex.IsMatch(url) ? volumeRex.Match(url).Groups[1].Value : null;
-			string chapterNumber = chapterNumRex.Match(url).Groups[1].Value;
+			int? volumeNumber = volumeRex.IsMatch(url) ? int.Parse(volumeRex.Match(url).Groups[1].Value) : null;
+			
+			string chapterNumber = new(chapterNumRex.Match(url).Groups[1].Value);
 			string chapterName = chapterNameRex.Match(fullString).Groups[1].Value;
 			try
 			{
-				ret.Add(new Chapter(manga, chapterName, volumeNumber, chapterNumber, url));
+				ret.Add(new Chapter(manga, url, chapterNumber, volumeNumber, chapterName));
 			}
 			catch (Exception e)
 			{
-				Log($"Failed to load chapter {chapterNumber}: {e.Message}");
 			}
 		}
 		
 		return ret;
 	}
 
-	public override HttpStatusCode DownloadChapter(Chapter chapter, ProgressToken? progressToken = null)
+	internal override string[] GetChapterImageUrls(Chapter chapter)
 	{
-		if (progressToken?.cancellationRequested ?? false)
-		{
-			progressToken.Cancel();
-			return HttpStatusCode.RequestTimeout;
-		}
-
-		Manga chapterParentManga = chapter.parentManga;
-		Log($"Retrieving chapter-info {chapter} {chapterParentManga}");
-		string requestUrl = chapter.url;
+		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)
+		if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
 		{
-			progressToken?.Cancel();
-			return requestResult.statusCode;
+			return [];
 		}
 
-		string[] imageUrls = ParseImageUrlsFromHtml(requestUrl);
-		
-		return DownloadChapterImages(imageUrls, chapter, RequestType.MangaImage, progressToken:progressToken);
+		string[] imageUrls = ParseImageUrlsFromHtml(requestResult.htmlDocument);
+		return imageUrls;
 	}
 
-	private string[] ParseImageUrlsFromHtml(string mangaUrl)
+	private string[] ParseImageUrlsFromHtml(HtmlDocument document)
 	{
-		HtmlWeb web = new();
-		HtmlDocument document = web.Load(mangaUrl);
-
 		// 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", "")

API/Schema/MangaConnectors/Manganato.cs

@@ -1,69 +1,76 @@
 using System.Globalization;
 using System.Net;
 using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
 using HtmlAgilityPack;
-using Tranga.Jobs;
 
-namespace Tranga.MangaConnectors;
+namespace API.Schema.MangaConnectors;
 
 public class Manganato : MangaConnector
 {
-    public Manganato(GlobalBase clone) : base(clone, "Manganato", ["en"])
+    public Manganato() : base("Manganato", ["en"],
+        ["natomanga.com", "manganato.gg", "mangakakalot.gg", "nelomanga.com"],
+        "https://www.manganato.gg/images/favicon-manganato.webp")
     {
-        this.downloadClient = new HttpDownloadClient(clone);
+        this.downloadClient = new HttpDownloadClient();
     }
 
-    public override Manga[] GetManga(string publicationTitle = "")
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(
+        string publicationTitle = "")
     {
-        Log($"Searching Publications. Term=\"{publicationTitle}\"");
-        string sanitizedTitle = string.Join('_', Regex.Matches(publicationTitle, "[A-z]*").Where(str => str.Length > 0)).ToLower();
+        string sanitizedTitle = string.Join('_', Regex.Matches(publicationTitle, "[A-z]*").Where(str => str.Length > 0))
+            .ToLower();
         string requestUrl = $"https://manganato.gg/search/story/{sanitizedTitle}";
         RequestResult requestResult =
             downloadClient.MakeRequest(requestUrl, RequestType.Default);
         if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
-            return Array.Empty<Manga>();
+            return [];
 
         if (requestResult.htmlDocument is null)
-            return Array.Empty<Manga>();
-        Manga[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
-        Log($"Retrieved {publications.Length} publications. Term=\"{publicationTitle}\"");
+            return [];
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications =
+            ParsePublicationsFromHtml(requestResult.htmlDocument);
         return publications;
     }
 
-    private Manga[] ParsePublicationsFromHtml(HtmlDocument document)
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(
+        HtmlDocument document)
     {
-        List<HtmlNode> searchResults = document.DocumentNode.Descendants("div").Where(n => n.HasClass("story_item")).ToList();
-        Log($"{searchResults.Count} items.");
+        List<HtmlNode> searchResults =
+            document.DocumentNode.Descendants("div").Where(n => n.HasClass("story_item")).ToList();
         List<string> urls = new();
         foreach (HtmlNode mangaResult in searchResults)
         {
             try
             {
-            urls.Add(mangaResult.Descendants("h3").First(n => n.HasClass("story_name"))
-                .Descendants("a").First().GetAttributeValue("href", ""));
-            } catch
+                urls.Add(mangaResult.Descendants("h3").First(n => n.HasClass("story_name"))
+                    .Descendants("a").First().GetAttributeValue("href", ""));
+            }
+            catch
             {
                 //failed to get a url, send it to the void
             }
         }
 
-        HashSet<Manga> ret = new();
+        List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
         foreach (string url in urls)
         {
-            Manga? manga = GetMangaFromUrl(url);
-            if (manga is not null)
-                ret.Add((Manga)manga);
+            (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+            if (manga is { } m)
+                ret.Add(m);
         }
 
         return ret.ToArray();
     }
 
-    public override Manga? GetMangaFromId(string publicationId)
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(
+        string publicationId)
     {
         return GetMangaFromUrl($"https://chapmanganato.com/{publicationId}");
     }
 
-    public override Manga? GetMangaFromUrl(string url)
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)?
+        GetMangaFromUrl(string url)
     {
         RequestResult requestResult =
             downloadClient.MakeRequest(url, RequestType.MangaInfo);
@@ -75,14 +82,13 @@ public class Manganato : MangaConnector
         return ParseSinglePublicationFromHtml(requestResult.htmlDocument, url.Split('/')[^1], url);
     }
 
-    private Manga ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(
+        HtmlDocument document, string publicationId, string websiteUrl)
     {
         Dictionary<string, string> altTitles = new();
-        Dictionary<string, string>? links = null;
-        HashSet<string> tags = new();
-        string[] authors = Array.Empty<string>();
-        string originalLanguage = "";
-        Manga.ReleaseStatusByte releaseStatus = Manga.ReleaseStatusByte.Unreleased;
+        List<MangaTag> tags = new();
+        List<Author> authors = new();
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
 
         HtmlNode infoNode = document.DocumentNode.Descendants("ul").First(d => d.HasClass("manga-info-text"));
 
@@ -94,29 +100,28 @@ public class Manganato : MangaConnector
 
             if (text.StartsWith("author(s) :"))
             {
-                authors = li.Descendants("a").Select(a => a.InnerText.Trim()).ToArray();
+                authors = li.Descendants("a").Select(a => a.InnerText.Trim()).Select(a => new Author(a)).ToList();
             }
             else if (text.StartsWith("status :"))
             {
                 string status = text.Replace("status :", "").Trim().ToLower();
                 if (string.IsNullOrWhiteSpace(status))
-                    releaseStatus = Manga.ReleaseStatusByte.Continuing;
+                    releaseStatus = MangaReleaseStatus.Continuing;
                 else if (status == "ongoing")
-                    releaseStatus = Manga.ReleaseStatusByte.Continuing;
+                    releaseStatus = MangaReleaseStatus.Continuing;
                 else
-                    releaseStatus = Enum.Parse<Manga.ReleaseStatusByte>(status, true);
+                    releaseStatus = Enum.Parse<MangaReleaseStatus>(status, true);
             }
             else if (li.HasClass("genres"))
             {
-                tags = li.Descendants("a").Select(a => a.InnerText.Trim()).ToHashSet();
+                tags = li.Descendants("a").Select(a => new MangaTag(a.InnerText.Trim())).ToList();
             }
         }
 
-        string posterUrl = document.DocumentNode.Descendants("div").First(s => s.HasClass("manga-info-pic")).Descendants("img").First()
+        string posterUrl = document.DocumentNode.Descendants("div").First(s => s.HasClass("manga-info-pic"))
+            .Descendants("img").First()
             .GetAttributes().First(a => a.Name == "src").Value;
 
-        string coverFileNameInCache = SaveCoverImageToCache(posterUrl, publicationId, RequestType.MangaCover, "https://www.manganato.gg/");
-
         string description = document.DocumentNode.SelectSingleNode("//div[@id='contentBox']")
             .InnerText.Replace("Description :", "");
         while (description.StartsWith('\n'))
@@ -130,19 +135,18 @@ public class Manganato : MangaConnector
                     CultureInfo.InvariantCulture).Millisecond);
 
 
-        int year = DateTime.ParseExact(oldestChapter?.GetAttributeValue("title", "Dec 31 2400, 23:59")??"Dec 31 2400, 23:59", pattern,
-            CultureInfo.InvariantCulture).Year;
+        uint year = Convert.ToUInt32(DateTime.ParseExact(
+            oldestChapter?.GetAttributeValue("title", "Dec 31 2400, 23:59") ?? "Dec 31 2400, 23:59", pattern,
+            CultureInfo.InvariantCulture).Year);
 
-        Manga manga = new (sortName, authors.ToList(), description, altTitles, tags.ToArray(), posterUrl, coverFileNameInCache, links,
-            year, originalLanguage, publicationId, releaseStatus, websiteUrl: websiteUrl);
-        AddMangaToCache(manga);
-        return manga;
+        Manga manga = new(publicationId, sortName, description, websiteUrl, posterUrl, null, year, null, releaseStatus,
+            -1, this, authors, tags, [], []);
+        return (manga, authors, tags, [], []);
     }
 
-    public override Chapter[] GetChapters(Manga manga, string language="en")
+    public override Chapter[] GetChapters(Manga manga, string language = "en")
     {
-        Log($"Getting chapters {manga}");
-        string requestUrl = manga.websiteUrl;
+        string requestUrl = manga.WebsiteUrl;
         RequestResult requestResult =
             downloadClient.MakeRequest(requestUrl, RequestType.Default);
         if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
@@ -152,10 +156,23 @@ public class Manganato : MangaConnector
         if (requestResult.htmlDocument is null)
             return Array.Empty<Chapter>();
         List<Chapter> chapters = ParseChaptersFromHtml(manga, requestResult.htmlDocument);
-        Log($"Got {chapters.Count} chapters. {manga}");
         return chapters.Order().ToArray();
     }
 
+    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 List<Chapter> ParseChaptersFromHtml(Manga manga, HtmlDocument document)
     {
         List<Chapter> ret = new();
@@ -177,54 +194,24 @@ public class Manganato : MangaConnector
                 volumeNumber = "0";
             try
             {
-                ret.Add(new Chapter(manga, chapterName, volumeNumber, chapterNumber, url));
+                ret.Add(new Chapter(manga, url, chapterNumber, int.Parse(volumeNumber), chapterName));
             }
             catch (Exception e)
             {
-                Log($"Failed to load chapter {chapterNumber}: {e.Message}");
             }
         }
+
         ret.Reverse();
         return ret;
     }
 
-    public override HttpStatusCode DownloadChapter(Chapter chapter, ProgressToken? progressToken = null)
-    {
-        if (progressToken?.cancellationRequested ?? false)
-        {
-            progressToken.Cancel();
-            return HttpStatusCode.RequestTimeout;
-        }
-
-        Manga chapterParentManga = chapter.parentManga;
-        Log($"Retrieving chapter-info {chapter} {chapterParentManga}");
-        string requestUrl = chapter.url;
-        RequestResult requestResult =
-            downloadClient.MakeRequest(requestUrl, RequestType.Default);
-        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
-        {
-            progressToken?.Cancel();
-            return requestResult.statusCode;
-        }
-
-        if (requestResult.htmlDocument is null)
-        {
-            progressToken?.Cancel();
-            return HttpStatusCode.InternalServerError;
-        }
-
-        string[] imageUrls = ParseImageUrlsFromHtml(requestResult.htmlDocument);
-        
-        return DownloadChapterImages(imageUrls, chapter, RequestType.MangaImage, "https://www.manganato.gg", progressToken:progressToken);
-    }
-
     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"))
+        foreach (HtmlNode imageNode in imageContainer.Descendants("img"))
             ret.Add(imageNode.GetAttributeValue("src", ""));
 
         return ret.ToArray();

API/Schema/MangaConnectors/Mangaworld.cs

@@ -1,62 +1,59 @@
-using System.Net;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
 using HtmlAgilityPack;
-using Tranga.Jobs;
 
-namespace Tranga.MangaConnectors;
+namespace API.Schema.MangaConnectors;
 
-public class Mangaworld: MangaConnector
+public class Mangaworld : MangaConnector
 {
-    public Mangaworld(GlobalBase clone) : base(clone, "Mangaworld", ["it"])
+    public Mangaworld() : base("Mangaworld", ["it"], ["www.mangaworld.ac", "www.mangaworld.nz"], "https://www.mangaworld.nz/public/assets/seo/android-icon-192x192.png")
     {
-        this.downloadClient = new ChromiumDownloadClient(clone);
+        this.downloadClient = new ChromiumDownloadClient();
     }
 
-    public override Manga[] GetManga(string publicationTitle = "")
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
     {
-        Log($"Searching Publications. Term=\"{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 Array.Empty<Manga>();
+            return [];
 
         if (requestResult.htmlDocument is null)
-            return Array.Empty<Manga>();
-        Manga[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
-        Log($"Retrieved {publications.Length} publications. Term=\"{publicationTitle}\"");
+            return [];
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
         return publications;
     }
 
-    private Manga[] ParsePublicationsFromHtml(HtmlDocument document)
+    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 Array.Empty<Manga>();
+            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();
 
-        HashSet<Manga> ret = new();
+        List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
         foreach (string url in urls)
         {
-            Manga? manga = GetMangaFromUrl(url);
-            if (manga is not null)
-                ret.Add((Manga)manga);
+            (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? GetMangaFromId(string publicationId)
+    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? GetMangaFromUrl(string url)
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromUrl(string url)
     {
         RequestResult requestResult =
             downloadClient.MakeRequest(url, RequestType.MangaInfo);
@@ -71,12 +68,11 @@ public class Mangaworld: MangaConnector
         return ParseSinglePublicationFromHtml(requestResult.htmlDocument, id, url);
     }
 
-    private Manga ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
     {
-        Dictionary<string, string> altTitles = new();
-        Dictionary<string, string>? links = null;
+        Dictionary<string, string> altTitlesDict = new();
         string originalLanguage = "";
-        Manga.ReleaseStatusByte releaseStatus = Manga.ReleaseStatusByte.Unreleased;
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
 
         HtmlNode infoNode = document.DocumentNode.Descendants("div").First(d => d.HasClass("info"));
 
@@ -85,59 +81,59 @@ public class Mangaworld: MangaConnector
         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++)
-            altTitles.Add(i.ToString(), alts[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[] authors = authorsNode.SelectNodes("a").Select(node => node.InnerText).ToArray();
+        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 = Manga.ReleaseStatusByte.Cancelled; break;
-            case "in pausa": releaseStatus = Manga.ReleaseStatusByte.OnHiatus; break;
-            case "droppato": releaseStatus = Manga.ReleaseStatusByte.Cancelled; break;
-            case "finito": releaseStatus = Manga.ReleaseStatusByte.Completed; break;
-            case "in corso": releaseStatus = Manga.ReleaseStatusByte.Continuing; break;
+            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 posterUrl = document.DocumentNode.SelectSingleNode("//img[@class='rounded']").GetAttributeValue("src", "");
-
-        string coverFileNameInCache = SaveCoverImageToCache(posterUrl, publicationId.Replace('/', '-'), RequestType.MangaCover);
+        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;
-        int year = Convert.ToInt32(yearString);
+        uint year = uint.Parse(yearString);
         
-        Manga manga = new (sortName, authors.ToList(), description, altTitles, tags.ToArray(), posterUrl, coverFileNameInCache, links,
-            year, originalLanguage, publicationId, releaseStatus, websiteUrl: websiteUrl);
-        AddMangaToCache(manga);
-        return manga;
+        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")
     {
-        Log($"Getting chapters {manga}");
-        string requestUrl = $"https://www.mangaworld.ac/manga/{manga.publicationId}";
+        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)
-            return Array.Empty<Chapter>();
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+            return [];
         
-        //Return Chapters ordered by Chapter-Number
-        if (requestResult.htmlDocument is null)
-            return Array.Empty<Chapter>();
         List<Chapter> chapters = ParseChaptersFromHtml(manga, requestResult.htmlDocument);
-        Log($"Got {chapters.Count} chapters. {manga}");
         return chapters.Order().ToArray();
     }
 
@@ -156,20 +152,22 @@ public class Mangaworld: MangaConnector
         {
             foreach (HtmlNode volNode in document.DocumentNode.SelectNodes("//div[contains(concat(' ',normalize-space(@class),' '),'volume-element')]"))
             {
-                string volume = volumeRex.Match(volNode.SelectNodes("div").First(node => node.HasClass("volume")).SelectSingleNode("p").InnerText).Groups[1].Value;
+                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 number = chapterRex.Match(chNode.SelectSingleNode("a").SelectSingleNode("span").InnerText).Groups[1].Value;
+                    string numberStr = chapterRex.Match(chNode.SelectSingleNode("a").SelectSingleNode("span").InnerText).Groups[1].Value;
+                    
+                    string 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, null, volume, number, url, id));
+                        ret.Add(new Chapter(manga, url, chapterNumber, volume, null));
                     }
                     catch (Exception e)
                     {
-                        Log($"Failed to load chapter {number}: {e.Message}");
                     }
                 }
             }
@@ -178,16 +176,17 @@ public class Mangaworld: MangaConnector
         {
             foreach (HtmlNode chNode in chaptersWrapper.SelectNodes("div").Where(node => node.HasClass("chapter")))
             {
-                string number = chapterRex.Match(chNode.SelectSingleNode("a").SelectSingleNode("span").InnerText).Groups[1].Value;
+                string numberStr = chapterRex.Match(chNode.SelectSingleNode("a").SelectSingleNode("span").InnerText).Groups[1].Value;
+                
+                string 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, null, null, number, url, id));
+                    ret.Add(new Chapter(manga, url, chapterNumber, null, null));
                 }
                 catch (Exception e)
                 {
-                    Log($"Failed to load chapter {number}: {e.Message}");
                 }
             }
         }
@@ -196,34 +195,18 @@ public class Mangaworld: MangaConnector
         return ret;
     }
 
-    public override HttpStatusCode DownloadChapter(Chapter chapter, ProgressToken? progressToken = null)
+    internal override string[] GetChapterImageUrls(Chapter chapter)
     {
-        if (progressToken?.cancellationRequested ?? false)
-        {
-            progressToken.Cancel();
-            return HttpStatusCode.RequestTimeout;
-        }
-
-        Manga chapterParentManga = chapter.parentManga;
-        Log($"Retrieving chapter-info {chapter} {chapterParentManga}");
-        string requestUrl = $"{chapter.url}?style=list";
+        string requestUrl = $"{chapter.Url}?style=list";
         RequestResult requestResult =
             downloadClient.MakeRequest(requestUrl, RequestType.Default);
-        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
         {
-            progressToken?.Cancel();
-            return requestResult.statusCode;
-        }
-
-        if (requestResult.htmlDocument is null)
-        {
-            progressToken?.Cancel();
-            return HttpStatusCode.InternalServerError;
+            return [];
         }
 
         string[] imageUrls = ParseImageUrlsFromHtml(requestResult.htmlDocument);
-        
-        return DownloadChapterImages(imageUrls, chapter, RequestType.MangaImage,"https://www.mangaworld.bz/", progressToken:progressToken);
+        return imageUrls;
     }
 
     private string[] ParseImageUrlsFromHtml(HtmlDocument document)

API/Schema/MangaConnectors/ManhuaPlus.cs

@@ -1,62 +1,56 @@
-using System.Net;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
 using HtmlAgilityPack;
-using Tranga.Jobs;
 
-namespace Tranga.MangaConnectors;
+namespace API.Schema.MangaConnectors;
 
 public class ManhuaPlus : MangaConnector
 {
-    public ManhuaPlus(GlobalBase clone) : base(clone, "ManhuaPlus", ["en"])
+    public ManhuaPlus() : base("ManhuaPlus", ["en"], ["manhuaplus.org"], "https://manhuaplus.org/uploads/images/favicon.png")
     {
-        this.downloadClient = new ChromiumDownloadClient(clone);
+        this.downloadClient = new ChromiumDownloadClient();
     }
 
-    public override Manga[] GetManga(string publicationTitle = "")
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "")
     {
-        Log($"Searching Publications. Term=\"{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)
-            return Array.Empty<Manga>();
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
+            return [];
         
-        if (requestResult.htmlDocument is null)
-            return Array.Empty<Manga>();
-        Manga[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
-        Log($"Retrieved {publications.Length} publications. Term=\"{publicationTitle}\"");
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
         return publications;
     }
     
-    private Manga[] ParsePublicationsFromHtml(HtmlDocument document)
+    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 Array.Empty<Manga>();
+            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();
-        logger?.WriteLine($"Got {urls.Count} urls.");
 
-        HashSet<Manga> ret = new();
+        List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
         foreach (string url in urls)
         {
-            Manga? manga = GetMangaFromUrl(url);
-            if (manga is not null)
-                ret.Add((Manga)manga);
+            (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? GetMangaFromId(string publicationId)
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
     {
         return GetMangaFromUrl($"https://manhuaplus.org/manga/{publicationId}");
     }
 
-    public override Manga? GetMangaFromUrl(string url)
+    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;
@@ -67,34 +61,33 @@ public class ManhuaPlus : MangaConnector
         return null;
     }
 
-    private Manga ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    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();
-        Manga.ReleaseStatusByte releaseStatus = Manga.ReleaseStatusByte.Unreleased;
+        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 posterUrl = $"https://manhuaplus.org/{posterRex.Match(posterNode.GetAttributeValue("src", "")).Groups[1].Value}";
-        string coverFileNameInCache = SaveCoverImageToCache(posterUrl, publicationId, RequestType.MangaCover);
+        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> authors = new();
+        List<string> authorNames = new();
         try
         {
             HtmlNode[] authorsNodes = document.DocumentNode
                 .SelectNodes("//a[contains(@href, 'https://manhuaplus.org/authors/')]")
                 .ToArray();
             foreach (HtmlNode authorNode in authorsNodes)
-                authors.Add(authorNode.InnerText);
+                authorNames.Add(authorNode.InnerText);
         }
         catch (ArgumentNullException e)
         {
-            Log("No authors found.");
         }
+        List<Author> authors = authorNames.Select(a => new Author(a)).ToList();
 
         try
         {
@@ -105,39 +98,42 @@ public class ManhuaPlus : MangaConnector
         }
         catch (ArgumentNullException e)
         {
-            Log("No genres found");
         }
+        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);
-        int year = match.Success && match.Groups[1].Success ? int.Parse(match.Groups[1].Value) : 1960;
+        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 = Manga.ReleaseStatusByte.Cancelled; break;
-            case "hiatus": releaseStatus = Manga.ReleaseStatusByte.OnHiatus; break;
-            case "discontinued": releaseStatus = Manga.ReleaseStatusByte.Cancelled; break;
-            case "complete": releaseStatus = Manga.ReleaseStatusByte.Completed; break;
-            case "ongoing": releaseStatus = Manga.ReleaseStatusByte.Continuing; break;
+            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(sortName, authors.ToList(), description, altTitles, tags.ToArray(), posterUrl,
-            coverFileNameInCache, links,
-            year, originalLanguage, publicationId, releaseStatus, websiteUrl: websiteUrl);
-        AddMangaToCache(manga);
-        return manga;
+        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")
     {
-        Log($"Getting chapters {manga}");
-        RequestResult result = downloadClient.MakeRequest($"https://manhuaplus.org/manga/{manga.publicationId}", RequestType.Default);
+        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>();
@@ -152,52 +148,32 @@ public class ManhuaPlus : MangaConnector
         {
             Match rexMatch = urlRex.Match(url);
 
-            string volumeNumber = "1";
-            string chapterNumber = rexMatch.Groups[1].Value;
+           string chapterNumber = new(rexMatch.Groups[1].Value);
             string fullUrl = url;
             try
             {
-                chapters.Add(new Chapter(manga, "", volumeNumber, chapterNumber, fullUrl));
+                chapters.Add(new Chapter(manga, fullUrl, chapterNumber, null, null));
             }
             catch (Exception e)
             {
-                Log($"Failed to load chapter {chapterNumber}: {e.Message}");
             }
         }
         //Return Chapters ordered by Chapter-Number
-        Log($"Got {chapters.Count} chapters. {manga}");
         return chapters.Order().ToArray();
     }
 
-    public override HttpStatusCode DownloadChapter(Chapter chapter, ProgressToken? progressToken = null)
+    internal override string[] GetChapterImageUrls(Chapter chapter)
     {
-        if (progressToken?.cancellationRequested ?? false)
+        RequestResult requestResult = this.downloadClient.MakeRequest(chapter.Url, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 || requestResult.htmlDocument is null)
         {
-            progressToken.Cancel();
-            return HttpStatusCode.RequestTimeout;
-        }
-
-        Manga chapterParentManga = chapter.parentManga;
-        if (progressToken?.cancellationRequested ?? false)
-        {
-            progressToken.Cancel();
-            return HttpStatusCode.RequestTimeout;
-        }
-
-        Log($"Retrieving chapter-info {chapter} {chapterParentManga}");
-
-        RequestResult requestResult = this.downloadClient.MakeRequest(chapter.url, RequestType.Default);
-        if (requestResult.htmlDocument is null)
-        {
-            progressToken?.Cancel();
-            return HttpStatusCode.RequestTimeout;
+            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 DownloadChapterImages(urls.ToArray(), chapter, RequestType.MangaImage, progressToken:progressToken);
+        return urls.ToArray();
     }
 }

API/Schema/MangaConnectors/Webtoons.cs

@@ -1,51 +1,48 @@
 using System.Net;
 using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
 using HtmlAgilityPack;
-using Tranga.Jobs;
 
-namespace Tranga.MangaConnectors;
+namespace API.Schema.MangaConnectors;
 
 public class Webtoons : MangaConnector
 {
 
-    public Webtoons(GlobalBase clone) : base(clone, "Webtoons", ["en"])
+    public Webtoons() : base("Webtoons", ["en"], ["www.webtoons.com"], "https://webtoons-static.pstatic.net/image/favicon/favicon.ico")
     {
-        this.downloadClient = new HttpDownloadClient(clone);
+        this.downloadClient = new HttpDownloadClient();
     }
 
     // Done
-    public override Manga[] GetManga(string publicationTitle = "")
+    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();
-        Log($"Searching Publications. Term=\"{publicationTitle}\"");
         string requestUrl = $"https://www.webtoons.com/en/search?keyword={sanitizedTitle}&searchType=WEBTOON";
         RequestResult requestResult =
             downloadClient.MakeRequest(requestUrl, RequestType.Default);
         if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300) {
-            Log($"Failed to retrieve site");
-            return Array.Empty<Manga>();
+            return [];
         }
 
         if (requestResult.htmlDocument is null)
         {
-            Log($"Failed to retrieve site");
-            return Array.Empty<Manga>();
+            return [];
         }
 
-        Manga[] publications = ParsePublicationsFromHtml(requestResult.htmlDocument);
-        Log($"Retrieved {publications.Length} publications. Term=\"{publicationTitle}\"");
+        (Manga, List<Author>, List<MangaTag>, List<Link>, List<MangaAltTitle>)[] publications =
+            ParsePublicationsFromHtml(requestResult.htmlDocument);
         return publications;
     }
 
     // Done
-    public override Manga? GetMangaFromId(string publicationId)
+    public override (Manga, List<Author>, List<MangaTag>, List<Link>, List<MangaAltTitle>)? GetMangaFromId(string publicationId)
     {
         PublicationManager pb = new PublicationManager(publicationId);
         return GetMangaFromUrl($"https://www.webtoons.com/en/{pb.Category}/{pb.Title}/list?title_no={pb.Id}");
     }
 
     // Done
-    public override Manga? GetMangaFromUrl(string url)
+    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) {
@@ -53,7 +50,6 @@ public class Webtoons : MangaConnector
         }
         if (requestResult.htmlDocument is null)
         {
-            Log($"Failed to retrieve site");
             return null;
         }
         Regex regex = new Regex(@".*webtoons\.com/en/(?<category>[^/]+)/(?<title>[^/]+)/list\?title_no=(?<id>\d+).*");
@@ -63,17 +59,15 @@ public class Webtoons : MangaConnector
             PublicationManager pm = new PublicationManager(match.Groups["title"].Value, match.Groups["category"].Value, match.Groups["id"].Value);
             return ParseSinglePublicationFromHtml(requestResult.htmlDocument, pm.getPublicationId(), url);
         }
-        Log($"Failed match Regex ID");
         return null;
     }
 
     // Done
-    private Manga[] ParsePublicationsFromHtml(HtmlDocument document)
+    private (Manga, List<Author>, List<MangaTag>, List<Link>, List<MangaAltTitle>)[] ParsePublicationsFromHtml(HtmlDocument document)
     {
         HtmlNode mangaList = document.DocumentNode.SelectSingleNode("//ul[contains(@class, 'card_lst')]");
         if (!mangaList.ChildNodes.Any(node => node.Name == "li")) {
-            Log($"Failed to parse publication");
-            return Array.Empty<Manga>();
+            return [];
         }
 
         List<string> urls = document.DocumentNode
@@ -81,12 +75,12 @@ public class Webtoons : MangaConnector
                             .Select(node => node.GetAttributeValue("href", "https://www.webtoons.com"))
                             .ToList();
 
-        HashSet<Manga> ret = new();
+        List<(Manga, List<Author>, List<MangaTag>, List<Link>, List<MangaAltTitle>)> ret = new();
         foreach (string url in urls)
         {
-            Manga? manga = GetMangaFromUrl(url);
-            if (manga is not null)
-                ret.Add((Manga)manga);
+            (Manga, List<Author>, List<MangaTag>, List<Link>, List<MangaAltTitle>)? manga = GetMangaFromUrl(url);
+            if(manga is { } m)
+                ret.Add(m);
         }
 
         return ret.ToArray();
@@ -99,7 +93,7 @@ public class Webtoons : MangaConnector
     }
 
     // Done
-    private Manga ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
+    private (Manga, List<Author>, List<MangaTag>, List<Link>, List<MangaAltTitle>) ParseSinglePublicationFromHtml(HtmlDocument document, string publicationId, string websiteUrl)
     {
         HtmlNode infoNode1 = document.DocumentNode.SelectSingleNode("//*[@id='content']/div[2]/div[1]/div[1]");
         HtmlNode infoNode2 = document.DocumentNode.SelectSingleNode("//*[@id='content']/div[2]/div[2]/div[2]");
@@ -113,39 +107,43 @@ public class Webtoons : MangaConnector
         Regex regex = new Regex(@"url\((?<url>.*?)\)");
         Match match = regex.Match(posterNode.GetAttributeValue("style", ""));
 
-        string posterUrl = match.Groups["url"].Value;
-        string coverFileNameInCache = SaveCoverImageToCache(posterUrl, publicationId, RequestType.MangaCover, websiteUrl);
+        string coverUrl = match.Groups["url"].Value;
 
         string genre = infoNode1.SelectSingleNode(".//h2[contains(@class, 'genre')]")
                             .InnerText.Trim();
-        string[] tags = [ genre ];
+        List<MangaTag> mangaTags = [new MangaTag(genre)];
 
         List<HtmlNode> authorsNodes = infoNode1.SelectSingleNode(".//div[contains(@class, 'author_area')]").Descendants("a").ToList();
-        List<string> authors = authorsNodes.Select(node => node.InnerText.Trim()).ToList();
+        List<Author> authors = authorsNodes.Select(node => new Author(node.InnerText.Trim())).ToList();
 
         string originalLanguage = "";
 
-        int year = DateTime.Now.Year;
+        uint year = 0;
 
         string status1 = infoNode2.SelectSingleNode(".//p").InnerText;
         string status2 = infoNode2.SelectSingleNode(".//p/span").InnerText;
-        Manga.ReleaseStatusByte releaseStatus = Manga.ReleaseStatusByte.Unreleased;
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
         if(status2.Length == 0 || status1.ToLower() == "completed") {
-            releaseStatus = Manga.ReleaseStatusByte.Completed;
+            releaseStatus = MangaReleaseStatus.Completed;
         } else if(status2.ToLower() == "up") {
-            releaseStatus = Manga.ReleaseStatusByte.Continuing;
+            releaseStatus = MangaReleaseStatus.Continuing;
         }
 
-        Manga manga = new(sortName, authors, description, new Dictionary<string, string>(), tags, posterUrl, coverFileNameInCache, new Dictionary<string, string>(),
-            year, originalLanguage, publicationId, releaseStatus, websiteUrl: websiteUrl);
-        AddMangaToCache(manga);
-        return manga;
+        Manga manga = new (publicationId, sortName, description, websiteUrl, coverUrl, null, year,
+            originalLanguage, releaseStatus, -1,
+            this, 
+            authors, 
+            mangaTags, 
+            [],
+            []);
+		
+        return (manga, authors, mangaTags, [], []);
     }
 
     // Done
     public override Chapter[] GetChapters(Manga manga, string language = "en")
     {
-        PublicationManager pm = new PublicationManager(manga.publicationId);
+        PublicationManager pm = new(manga.MangaId);
         string requestUrl = $"https://www.webtoons.com/en/{pm.Category}/{pm.Title}/list?title_no={pm.Id}";
         // Leaving this in for verification if the page exists
         RequestResult requestResult =
@@ -164,7 +162,7 @@ public class Webtoons : MangaConnector
             string pageRequestUrl = $"{requestUrl}&page={page}";
             chapters.AddRange(ParseChaptersFromHtml(manga, pageRequestUrl));
         }
-        Log($"Got {chapters.Count} chapters. {manga}");
+
         return chapters.Order().ToArray();
     }
 
@@ -174,7 +172,6 @@ public class Webtoons : MangaConnector
         RequestResult result = downloadClient.MakeRequest(mangaUrl, RequestType.Default);
         if ((int)result.statusCode < 200 || (int)result.statusCode >= 300 || result.htmlDocument is null)
         {
-            Log("Failed to load site");
             return new List<Chapter>();
         }
 
@@ -187,38 +184,28 @@ public class Webtoons : MangaConnector
 
             string id = chapterInfo.GetAttributeValue("id", "");
             if(id == "") continue;
-            string? volumeNumber = null;
             string chapterNumber = chapterInfo.GetAttributeValue("data-episode-no", "");
             if(chapterNumber == "") continue;
             string chapterName = infoNode.SelectSingleNode(".//span[contains(@class, 'subj')]/span").InnerText.Trim();
-            ret.Add(new Chapter(manga, chapterName, volumeNumber, chapterNumber, url));
+            ret.Add(new Chapter(manga, url, chapterNumber, null, chapterName));
         }
 
         return ret;
     }
 
-    public override HttpStatusCode DownloadChapter(Chapter chapter, ProgressToken? progressToken = null)
+    internal override string[] GetChapterImageUrls(Chapter chapter)
     {
-        if (progressToken?.cancellationRequested ?? false)
-        {
-            progressToken.Cancel();
-            return HttpStatusCode.RequestTimeout;
-        }
-
-        Manga chapterParentManga = chapter.parentManga;
-        Log($"Retrieving chapter-info {chapter} {chapterParentManga}");
-        string requestUrl = chapter.url;
+        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)
         {
-            progressToken?.Cancel();
-            return requestResult.statusCode;
+            return [];
         }
 
         string[] imageUrls = ParseImageUrlsFromHtml(requestUrl);
-		return DownloadChapterImages(imageUrls, chapter, RequestType.MangaImage, progressToken:progressToken, referrer: requestUrl);
+        return imageUrls;
     }
 
     private string[] ParseImageUrlsFromHtml(string mangaUrl)
@@ -227,12 +214,11 @@ public class Webtoons : MangaConnector
             downloadClient.MakeRequest(mangaUrl, RequestType.Default);
         if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
         {
-            return Array.Empty<string>();
+            return [];
         }
         if (requestResult.htmlDocument is null)
         {
-            Log($"Failed to retrieve site");
-            return Array.Empty<string>();
+            return [];
         }
 
         return requestResult.htmlDocument.DocumentNode

API/Schema/MangaConnectors/WeebCentral.cs

@@ -0,0 +1,175 @@
+using System.Net;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+
+namespace API.Schema.MangaConnectors;
+
+public class Weebcentral : MangaConnector
+{
+    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"], ["weebcentral.com"], "https://weebcentral.com/favicon.ico")
+    {
+        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 =
+            $"https://{BaseUris[0]}/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)
+        {
+            (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+            if (manga is { })
+                ret.Add(((Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?))manga);
+        }
+
+        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)
+    {
+        HtmlNode posterNode =
+            document.DocumentNode.SelectSingleNode("//section[@class='flex items-center justify-center']/picture/img");
+        string posterUrl = posterNode?.GetAttributeValue("src", "") ?? "";
+
+        HtmlNode titleNode = document.DocumentNode.SelectSingleNode("//section/h1");
+        string sortName = titleNode?.InnerText ?? "Undefined";
+
+        HtmlNode[] authorsNodes =
+            document.DocumentNode.SelectNodes("//ul/li[strong/text() = 'Author(s): ']/span")?.ToArray() ?? [];
+        List<Author> authors = authorsNodes.Select(n => new Author(n.InnerText)).ToList();
+
+        HtmlNode[] genreNodes =
+            document.DocumentNode.SelectNodes("//ul/li[strong/text() = 'Tags(s): ']/span")?.ToArray() ?? [];
+        List<MangaTag> tags = genreNodes.Select(n => new MangaTag(n.InnerText)).ToList();
+
+        HtmlNode statusNode = document.DocumentNode.SelectSingleNode("//ul/li[strong/text() = 'Status: ']/a");
+        string statusText = statusNode?.InnerText ?? "";
+        MangaReleaseStatus releaseStatus = statusText.ToLower() switch
+        {
+            "cancelled" => MangaReleaseStatus.Cancelled,
+            "hiatus" => MangaReleaseStatus.OnHiatus,
+            "complete" => MangaReleaseStatus.Completed,
+            "ongoing" => MangaReleaseStatus.Continuing,
+            _ => MangaReleaseStatus.Unreleased
+        };
+
+        HtmlNode yearNode = document.DocumentNode.SelectSingleNode("//ul/li[strong/text() = 'Released: ']/span");
+        uint year = Convert.ToUInt32(yearNode?.InnerText ?? "0");
+
+        HtmlNode descriptionNode = document.DocumentNode.SelectSingleNode("//ul/li[strong/text() = 'Description']/p");
+        string description = descriptionNode?.InnerText ?? "Undefined";
+
+        HtmlNode[] altTitleNodes = document.DocumentNode
+            .SelectNodes("//ul/li[strong/text() = 'Associated Name(s)']/ul/li")?.ToArray() ?? [];
+        List<MangaAltTitle> altTitles = altTitleNodes.Select(n => new MangaAltTitle("", n.InnerText)).ToList();
+
+        Manga m = new(publicationId, sortName, description, websiteUrl, posterUrl, null, year, null, releaseStatus, -1,
+            this, authors, tags, [], altTitles);
+        return (m, authors, tags, [], altTitles);
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
+    {
+        return GetMangaFromUrl($"https://{BaseUris[0]}/series/{publicationId}");
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string language = "en")
+    {
+                var requestUrl = $"https://{BaseUris[0]}/series/{manga.MangaConnectorId}/full-chapter-list";
+        var 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 [];
+        var chapters = ParseChaptersFromHtml(manga, requestResult.htmlDocument);
+                return chapters.Order().ToArray();
+    }
+
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        var requestResult = downloadClient.MakeRequest(chapter.Url, RequestType.Default);
+        if (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 List<Chapter> ParseChaptersFromHtml(Manga manga, HtmlDocument document)
+    {
+        var chaptersWrapper = document.DocumentNode.SelectSingleNode("/html/body");
+
+        Regex chapterRex = new(@"(\d+(?:\.\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, "", "");
+
+            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);
+            var chapterNumber = chapterNumberMatch.Success ? chapterNumberMatch.Groups[1].Value : "-1";
+
+            return new Chapter(manga, url, chapterNumber);
+        }).Where(elem => elem.ChapterNumber != String.Empty && elem.Url != string.Empty).ToList();
+
+        ret.Reverse();
+        return ret;
+    }
+}

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

API/Schema/Notification.cs

@@ -0,0 +1,28 @@
+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)
+{
+    [StringLength(64)]
+    [Required]
+    public string NotificationId { get; init; } = TokenGen.CreateToken("Notification");
+
+    [Required]
+    public NotificationUrgency Urgency { get; init; } = urgency;
+
+    [StringLength(128)]
+    [Required]
+    public string Title { get; init; } = title;
+
+    [StringLength(512)]
+    [Required]
+    public string Message { get; init; } = message;
+    
+    [Required]
+    public DateTime Date { get; init; } = date ?? DateTime.UtcNow;
+    
+    public Notification() : this("") { }
+}

API/Schema/NotificationConnectors/NotificationConnector.cs

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

API/Schema/NotificationUrgency.cs

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

API/Schema/PgsqlContext.cs

@@ -0,0 +1,120 @@
+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> Mangas { get; set; }
+    public DbSet<LocalLibrary> LocalLibraries { get; set; }
+    public DbSet<Chapter> Chapters { get; set; }
+    public DbSet<Author> Authors { get; set; }
+    public DbSet<Link> Links { 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<Global>("Global")
+            .HasValue<AsuraToon>("AsuraToon")
+            .HasValue<Bato>("Bato")
+            .HasValue<MangaHere>("MangaHere")
+            .HasValue<MangaKatana>("MangaKatana")
+            .HasValue<Mangaworld>("Mangaworld")
+            .HasValue<ManhuaPlus>("ManhuaPlus")
+            .HasValue<Weebcentral>("Weebcentral")
+            .HasValue<Manganato>("Manganato")
+            .HasValue<MangaDex>("MangaDex");
+        modelBuilder.Entity<LibraryConnector>()
+            .HasDiscriminator<LibraryType>(l => l.LibraryType)
+            .HasValue<Komga>(LibraryType.Komga)
+            .HasValue<Kavita>(LibraryType.Kavita);
+
+        modelBuilder.Entity<Job>()
+            .HasDiscriminator<JobType>(j => j.JobType)
+            .HasValue<MoveFileOrFolderJob>(JobType.MoveFileOrFolderJob)
+            .HasValue<DownloadAvailableChaptersJob>(JobType.DownloadAvailableChaptersJob)
+            .HasValue<DownloadSingleChapterJob>(JobType.DownloadSingleChapterJob)
+            .HasValue<DownloadMangaCoverJob>(JobType.DownloadMangaCoverJob)
+            .HasValue<UpdateMetadataJob>(JobType.UpdateMetaDataJob)
+            .HasValue<RetrieveChaptersJob>(JobType.RetrieveChaptersJob)
+            .HasValue<UpdateFilesDownloadedJob>(JobType.UpdateFilesDownloadedJob);
+        modelBuilder.Entity<Job>()
+            .HasOne<Job>(j => j.ParentJob)
+            .WithMany()
+            .HasForeignKey(j => j.ParentJobId)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<Job>()
+            .HasMany<Job>(j => j.DependsOnJobs)
+            .WithMany();
+        modelBuilder.Entity<DownloadAvailableChaptersJob>()
+            .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)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.MangaConnector)
+            .AutoInclude();
+        modelBuilder.Entity<Manga>()
+            .HasOne<LocalLibrary>(m => m.Library)
+            .WithMany()
+            .OnDelete(DeleteBehavior.Restrict);
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.Library)
+            .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.MangaTags)
+            .WithMany();
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.MangaTags)
+            .AutoInclude();
+        modelBuilder.Entity<Manga>()
+            .HasMany<Link>(m => m.Links)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.Links)
+            .AutoInclude();
+        modelBuilder.Entity<Manga>()
+            .HasMany<MangaAltTitle>(m => m.AltTitles)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<Manga>()
+            .Navigation(m => m.AltTitles)
+            .AutoInclude();
+        modelBuilder.Entity<Chapter>()
+            .HasOne<Manga>(c => c.ParentManga)
+            .WithMany()
+            .HasForeignKey(c => c.ParentMangaId)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<Chapter>()
+            .Navigation(c => c.ParentManga)
+            .AutoInclude();
+    }
+}

API/TokenGen.cs

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

API/Tranga.cs

@@ -0,0 +1,218 @@
+using API.Schema;
+using API.Schema.Jobs;
+using API.Schema.MangaConnectors;
+using API.Schema.NotificationConnectors;
+using log4net;
+using log4net.Config;
+using Microsoft.EntityFrameworkCore;
+
+namespace API;
+
+public static class Tranga
+{
+    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.UtcNow.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? serviceProviderObj)
+    {
+        if(serviceProviderObj is null) return;
+        IServiceProvider serviceProvider = (IServiceProvider)serviceProviderObj;
+        using IServiceScope scope = serviceProvider.CreateScope();
+        PgsqlContext? context = scope.ServiceProvider.GetService<PgsqlContext>();
+        if (context is null) return;
+
+        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
+                {
+                    if (job.state >= JobState.Failed)
+                        job.Enabled = false;
+                    else
+                        job.state = JobState.Waiting;
+                    job.LastExecution = DateTime.UtcNow;
+                    context.Jobs.Update(job);
+                }
+
+            List<Job> runJobs = context.Jobs.Where(j => j.state <= JobState.Running && j.Enabled == true).ToList()
+                .Where(j => j.NextExecution < DateTime.UtcNow).ToList();
+            foreach (Job job in OrderJobs(runJobs, context))
+            {
+                // If the job is already running, skip it
+                if (RunningJobs.Values.Any(j => j.JobId == job.JobId)) continue;
+
+                if (job is DownloadAvailableChaptersJob dncj)
+                {
+                    if (RunningJobs.Values.Any(j =>
+                            j is DownloadAvailableChaptersJob rdncj &&
+                            rdncj.Manga?.MangaConnector == dncj.Manga?.MangaConnector))
+                    {
+                        continue;
+                    }
+                }
+                else if (job is DownloadSingleChapterJob dscj)
+                {
+                    if (RunningJobs.Values.Any(j =>
+                            j is DownloadSingleChapterJob rdscj && rdscj.Chapter?.ParentManga?.MangaConnector ==
+                            dscj.Chapter?.ParentManga?.MangaConnector))
+                    {
+                        continue;
+                    }
+                }
+
+                Thread t = new(() =>
+                {
+                    IEnumerable<Job> newJobs = job.Run(serviceProvider);
+                });
+                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);
+                if(context.Jobs.Find(thread.job.JobId) is not null)
+                    context.Jobs.Update(thread.job);
+            }
+
+            try
+            {
+                context.SaveChanges();
+            }
+            catch (DbUpdateException e)
+            {
+                
+            }
+            Thread.Sleep(TrangaSettings.startNewJobTimeoutMs);
+        }
+    }
+
+    private static IEnumerable<Job> OrderJobs(List<Job> jobs, PgsqlContext context)
+    {
+        Dictionary<JobType, List<Job>> jobsByType = new();
+        foreach (Job job in jobs)
+            if(!jobsByType.TryAdd(job.JobType, [job]))
+                jobsByType[job.JobType].Add(job);
+
+        IEnumerable<Job> ret = new List<Job>();
+        if(jobsByType.ContainsKey(JobType.MoveMangaLibraryJob))
+            ret = ret.Concat(jobsByType[JobType.MoveMangaLibraryJob]);
+        if(jobsByType.ContainsKey(JobType.MoveFileOrFolderJob))
+            ret = ret.Concat(jobsByType[JobType.MoveFileOrFolderJob]);
+        if(jobsByType.ContainsKey(JobType.DownloadMangaCoverJob)) 
+            ret = ret.Concat(jobsByType[JobType.DownloadMangaCoverJob]);
+        if(jobsByType.ContainsKey(JobType.UpdateFilesDownloadedJob))
+            ret = ret.Concat(jobsByType[JobType.UpdateFilesDownloadedJob]);
+
+        Dictionary<MangaConnector, List<Job>> metadataJobsByConnector = new();
+        if (jobsByType.ContainsKey(JobType.DownloadAvailableChaptersJob))
+        {
+            foreach (DownloadAvailableChaptersJob job in jobsByType[JobType.DownloadAvailableChaptersJob])
+            {
+                Manga manga = job.Manga ?? context.Mangas.Find(job.MangaId)!;
+                MangaConnector connector = manga.MangaConnector ?? context.MangaConnectors.Find(manga.MangaConnectorId)!;
+                if(!metadataJobsByConnector.TryAdd(connector, [job]))
+                    metadataJobsByConnector[connector].Add(job);
+            }
+        }
+        if (jobsByType.ContainsKey(JobType.UpdateMetaDataJob))
+        {
+            foreach (UpdateMetadataJob job in jobsByType[JobType.UpdateMetaDataJob])
+            {
+                Manga manga = job.Manga ?? context.Mangas.Find(job.MangaId)!;
+                MangaConnector connector = manga.MangaConnector ?? context.MangaConnectors.Find(manga.MangaConnectorId)!;
+                if(!metadataJobsByConnector.TryAdd(connector, [job]))
+                    metadataJobsByConnector[connector].Add(job);
+            }
+        }
+        if (jobsByType.ContainsKey(JobType.RetrieveChaptersJob))
+        {
+            foreach (RetrieveChaptersJob job in jobsByType[JobType.RetrieveChaptersJob])
+            {
+                Manga manga = job.Manga ?? context.Mangas.Find(job.MangaId)!;
+                MangaConnector connector = manga.MangaConnector ?? context.MangaConnectors.Find(manga.MangaConnectorId)!;
+                if(!metadataJobsByConnector.TryAdd(connector, [job]))
+                    metadataJobsByConnector[connector].Add(job);
+            }
+        }
+        foreach (List<Job> metadataJobs in metadataJobsByConnector.Values)
+            ret = ret.Append(metadataJobs.MinBy(j => j.NextExecution))!;
+
+        if (jobsByType.ContainsKey(JobType.DownloadSingleChapterJob))
+        {
+            
+            Dictionary<MangaConnector, List<DownloadSingleChapterJob>> downloadJobsByConnector = new();
+            foreach (DownloadSingleChapterJob job in jobsByType[JobType.DownloadSingleChapterJob])
+            {
+                Chapter chapter = job.Chapter ?? context.Chapters.Find(job.ChapterId)!;
+                Manga manga = chapter.ParentManga ?? context.Mangas.Find(chapter.ParentMangaId)!;
+                MangaConnector connector = manga.MangaConnector ?? context.MangaConnectors.Find(manga.MangaConnectorId)!;
+            
+                if(!downloadJobsByConnector.TryAdd(connector, [job]))
+                    downloadJobsByConnector[connector].Add(job);
+            }
+            //From all jobs select those that are supposed to be executed soonest, then select the minimum chapternumber
+            foreach (List<DownloadSingleChapterJob> downloadJobs in downloadJobsByConnector.Values)
+                ret = ret.Append(
+                    downloadJobs.Where(j => j.NextExecution == downloadJobs
+                            .MinBy(mj => mj.NextExecution)!.NextExecution)
+                        .MinBy(j => j.Chapter ?? context.Chapters.Find(j.ChapterId)!))!;
+        }
+        
+        return ret;
+    }
+}

API/TrangaSettings.cs

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

API/appsettings.Development.json

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

API/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Error",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}

CLI/CLI.csproj

@@ -1,19 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <OutputType>Exe</OutputType>
-        <TargetFramework>net8.0</TargetFramework>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>enable</Nullable>
-        <LangVersion>12</LangVersion>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <PackageReference Include="Spectre.Console.Cli" Version="0.49.1" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="..\Tranga\Tranga.csproj" />
-    </ItemGroup>
-
-</Project>

CLI/Program.cs

@@ -1,157 +0,0 @@
-using System.ComponentModel;
-using System.Diagnostics.CodeAnalysis;
-using Logging;
-using Spectre.Console;
-using Spectre.Console.Cli;
-using Tranga;
-
-var app = new CommandApp<TrangaCli>();
-return app.Run(args);
-
-internal sealed class TrangaCli : Command<TrangaCli.Settings>
-{
-    public sealed class Settings : CommandSettings
-    {
-        [Description("Directory to which downloaded Manga are saved")]
-        [CommandOption("-d|--downloadLocation")]
-        [DefaultValue(null)]
-        public string? downloadLocation { get; init; }
-        
-        [Description("Directory in which application-data is saved")]
-        [CommandOption("-w|--workingDirectory")]
-        [DefaultValue(null)]
-        public string? workingDirectory { get; init; }
-        
-        [Description("Enables the file-logger")]
-        [CommandOption("-f")]
-        [DefaultValue(null)]
-        public bool? fileLogger { get; init; }
-        
-        [Description("Path to save logfile to")]
-        [CommandOption("-l|--fPath")]
-        [DefaultValue(null)]
-        public string? fileLoggerPath { get; init; }
-        
-        [Description("Port on which to run API on")]
-        [CommandOption("-p|--port")]
-        [DefaultValue(null)]
-        public int? apiPort { get; init; }
-    }
-
-    public override int Execute([NotNull] CommandContext context, [NotNull] Settings settings)
-    {
-        List<Logger.LoggerType> enabledLoggers = new();
-        if(settings.fileLogger is true)
-            enabledLoggers.Add(Logger.LoggerType.FileLogger);
-        
-        string? logFolderPath = settings.fileLoggerPath ?? "";
-        Logger logger = new(enabledLoggers.ToArray(), Console.Out, Console.OutputEncoding, logFolderPath);
-        
-        if(settings.workingDirectory is not null)
-            TrangaSettings.LoadFromWorkingDirectory(settings.workingDirectory);
-        else
-            TrangaSettings.CreateOrUpdate();
-        if(settings.downloadLocation is not null)
-            TrangaSettings.CreateOrUpdate(downloadDirectory: settings.downloadLocation);
-
-        Tranga.Tranga? api = null;
-
-        Thread trangaApi = new Thread(() =>
-        {
-            api = new(logger);
-        });
-        trangaApi.Start();
-        
-        HttpClient client = new();
-        
-        bool exit = false;
-        while (!exit)
-        {
-            string menuSelect = AnsiConsole.Prompt(
-                new SelectionPrompt<string>()
-                    .Title("Menu")
-                    .PageSize(10)
-                    .MoreChoicesText("Up/Down")
-                    .AddChoices(new[]
-                    {
-                        "CustomRequest",
-                        "Log",
-                        "Exit"
-                    }));
-
-            switch (menuSelect)
-            {
-                case "CustomRequest":
-                    HttpMethod requestMethod = AnsiConsole.Prompt(
-                        new SelectionPrompt<HttpMethod>()
-                            .Title("Request Type")
-                            .AddChoices(new[]
-                            {
-                                HttpMethod.Get,
-                                HttpMethod.Delete, 
-                                HttpMethod.Post
-                            }));
-                    string requestPath = AnsiConsole.Prompt(
-                        new TextPrompt<string>("Request Path:"));
-                    List<ValueTuple<string, string>> parameters = new();
-                    while (AnsiConsole.Confirm("Add Parameter?"))
-                    {
-                        string name = AnsiConsole.Ask<string>("Parameter Name:");
-                        string value = AnsiConsole.Ask<string>("Parameter Value:");
-                        parameters.Add(new ValueTuple<string, string>(name, value));
-                    }
-
-                    string requestString = $"http://localhost:{TrangaSettings.apiPortNumber}/{requestPath}";
-                    if (parameters.Any())
-                    {
-                        requestString += "?";
-                        foreach (ValueTuple<string, string> parameter in parameters)
-                            requestString += $"{parameter.Item1}={parameter.Item2}&";
-                    }
-
-                    HttpRequestMessage request = new (requestMethod, requestString);
-                    AnsiConsole.WriteLine($"Request: {request.Method} {request.RequestUri}");
-                    HttpResponseMessage response;
-                    if (AnsiConsole.Confirm("Send Request?"))
-                        response = client.Send(request);
-                    else break;
-                    AnsiConsole.WriteLine($"Response: {(int)response.StatusCode} {response.StatusCode}");
-                    AnsiConsole.WriteLine(response.Content.ReadAsStringAsync().Result);
-                    break;
-                case "Log":
-                    List<string> lines = logger.Tail(10).ToList();
-                    Rows rows = new Rows(lines.Select(line => new Text(line)));
-                    
-                    AnsiConsole.Live(rows).Start(context =>
-                    {
-                        bool running = true;
-                        while (running)
-                        {
-                            string[] newLines = logger.GetNewLines();
-                            if (newLines.Length > 0)
-                            {
-                                lines.AddRange(newLines);
-                                rows = new Rows(lines.Select(line => new Text(line)));
-                                context.UpdateTarget(rows);
-                            }
-                            Thread.Sleep(100);
-                            if (AnsiConsole.Console.Input.IsKeyAvailable())
-                            {
-                                AnsiConsole.Console.Input.ReadKey(true); //Do not process input
-                                running = false;
-                            }
-                        }
-                    });
-                    break;
-                case "Exit":
-                    exit = true;
-                    break;
-            }
-        }
-
-        if (api is not null)
-            api.keepRunning = false;
-        
-        return 0;
-    }
-}

Dockerfile

@@ -1,7 +1,7 @@
 # syntax=docker/dockerfile:1
-ARG DOTNET=8.0
+ARG DOTNET=9.0
 
-FROM --platform=$TARGETPLATFORM mcr.microsoft.com/dotnet/runtime:$DOTNET AS base
+FROM --platform=$TARGETPLATFORM mcr.microsoft.com/dotnet/aspnet:$DOTNET AS base
 WORKDIR /publish
 ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true
 ENV PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium
@@ -16,9 +16,7 @@ FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:$DOTNET AS build-env
 WORKDIR /src
 
 COPY Tranga.sln /src
-COPY CLI/CLI.csproj /src/CLI/CLI.csproj
-COPY Logging/Logging.csproj /src/Logging/Logging.csproj 
-COPY Tranga/Tranga.csproj /src/Tranga/Tranga.csproj
+COPY API/API.csproj /src/API/API.csproj
 RUN dotnet restore /src/Tranga.sln
 
 COPY . /src/
@@ -40,5 +38,5 @@ USER $UNAME
 WORKDIR /publish
 COPY --chown=1000:1000 --from=build-env /publish .
 USER 0
-ENTRYPOINT ["dotnet", "/publish/Tranga.dll"]
+ENTRYPOINT ["dotnet", "/publish/API.dll"]
 CMD ["-f", "-c", "-l", "/usr/share/tranga-api/logs"]

Logging/FileLogger.cs

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

Logging/FormattedConsoleLogger.cs

@@ -1,17 +0,0 @@
-using System.Text;
-
-namespace Logging;
-
-public class FormattedConsoleLogger : LoggerBase
-{
-    private readonly TextWriter _stdOut;
-    public FormattedConsoleLogger(TextWriter stdOut, Encoding? encoding = null) : base(encoding)
-    {
-        this._stdOut = stdOut;
-    }
-
-    protected override void Write(LogMessage message)
-    {
-        this._stdOut.Write(message.formattedMessage);
-    }
-}

Logging/LogMessage.cs

@@ -1,23 +0,0 @@
-namespace Logging;
-
-public readonly struct LogMessage
-{
-    public DateTime logTime { get; }
-    public string caller { get; }
-    public string value { get; }
-    public string formattedMessage => ToString();
-
-    public LogMessage(DateTime messageTime, string caller, string value)
-    {
-        this.logTime = messageTime;
-        this.caller = caller;
-        this.value = value;
-    }
-
-    public override string ToString()
-    {
-        string dateTimeString = $"{logTime.ToShortDateString()} {logTime.ToLongTimeString()}.{logTime.Millisecond,-3}";
-        string name = caller.Split(new char[] { '.', '+' }).Last();
-        return $"[{dateTimeString}] {name.Substring(0, name.Length >= 13 ? 13 : name.Length),13} | {value}";
-    }
-}

Logging/Logger.cs

@@ -1,80 +0,0 @@
-using System.Runtime.InteropServices;
-using System.Text;
-
-namespace Logging;
-
-public class Logger : TextWriter
-{
-    private static readonly string LogDirectoryPath = RuntimeInformation.IsOSPlatform(OSPlatform.Linux)
-        ? "/var/log/tranga-api"
-        : Path.Join(Directory.GetCurrentDirectory(), "logs");
-    public string? logFilePath => _fileLogger?.logFilePath;
-    public override Encoding Encoding { get; }
-    public enum LoggerType
-    {
-        FileLogger,
-        ConsoleLogger
-    }
-
-    private readonly FileLogger? _fileLogger;
-    private readonly FormattedConsoleLogger? _formattedConsoleLogger;
-    private readonly MemoryLogger _memoryLogger;
-
-    public Logger(LoggerType[] enabledLoggers, TextWriter? stdOut, Encoding? encoding, string? logFolderPath)
-    {
-        this.Encoding = encoding ?? Encoding.UTF8;
-        DateTime now = DateTime.Now;
-        if(enabledLoggers.Contains(LoggerType.FileLogger) && (logFolderPath is null || logFolderPath == ""))
-        {
-            string filePath = Path.Join(LogDirectoryPath,
-                $"{now.ToShortDateString()}_{now.Hour}-{now.Minute}-{now.Second}.log");
-            _fileLogger = new FileLogger(filePath, encoding);
-        }else if (enabledLoggers.Contains(LoggerType.FileLogger) && logFolderPath is not null)
-            _fileLogger = new FileLogger(Path.Join(logFolderPath, $"{now.ToShortDateString()}_{now.Hour}-{now.Minute}-{now.Second}.log") , encoding);
-        
-
-        if (enabledLoggers.Contains(LoggerType.ConsoleLogger) && stdOut is not null)
-        {
-            _formattedConsoleLogger = new FormattedConsoleLogger(stdOut, encoding);
-        }
-        else if (enabledLoggers.Contains(LoggerType.ConsoleLogger) && stdOut is null)
-        {
-            _formattedConsoleLogger = null;
-            throw new ArgumentException($"stdOut can not be null for LoggerType {LoggerType.ConsoleLogger}");
-        }
-        _memoryLogger = new MemoryLogger(encoding);
-        WriteLine(GetType().ToString(), $"Logfile: {logFilePath}");
-    }
-
-    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);
-    }
-
-    public string[] Tail(uint? lines)
-    {
-        return _memoryLogger.Tail(lines);
-    }
-
-    public string[] GetNewLines()
-    {
-        return _memoryLogger.GetNewLines();
-    }
-
-    public string[] GetLog()
-    {
-        return _memoryLogger.GetLogMessages();
-    }
-}

Logging/LoggerBase.cs

@@ -1,25 +0,0 @@
-using System.Text;
-
-namespace Logging;
-
-public abstract class LoggerBase : TextWriter
-{
-    public override Encoding Encoding { get; }
-
-    public LoggerBase(Encoding? encoding = null)
-    {
-        this.Encoding = encoding ?? Encoding.ASCII;
-    }
-
-    public void Write(string caller, string? value)
-    {
-        if (value is null)
-            return;
-
-        LogMessage message = new (DateTime.Now, caller, value);
-        
-        Write(message);
-    }
-
-    protected abstract void Write(LogMessage message);
-}

Logging/Logging.csproj

@@ -1,10 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <TargetFramework>net8.0</TargetFramework>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>enable</Nullable>
-        <LangVersion>12</LangVersion>
-    </PropertyGroup>
-
-</Project>

Logging/MemoryLogger.cs

@@ -1,74 +0,0 @@
-using System.Text;
-
-namespace Logging;
-
-public class MemoryLogger : LoggerBase
-{
-    private readonly SortedList<DateTime, LogMessage> _logMessages = new();
-    private int _lastLogMessageIndex = 0;
-
-    public MemoryLogger(Encoding? encoding = null) : base(encoding)
-    {
-        
-    }
-
-    protected override void Write(LogMessage value)
-    {
-        lock (_logMessages)
-        {
-            _logMessages.Add(DateTime.Now, value);
-        }
-    }
-
-    public string[] GetLogMessages()
-    {
-        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++)
-        {
-            lock (_logMessages)
-            {
-                ret[retIndex] = _logMessages.GetValueAtIndex(_logMessages.Count - retLength + retIndex).ToString();
-            }
-        }
-
-        _lastLogMessageIndex = _logMessages.Count - 1;
-        return ret;
-    }
-
-    public string[] GetNewLines()
-    {
-        int logMessageCount = _logMessages.Count;
-        List<string> ret = new();
-
-        int retIndex = 0;
-        for (; retIndex < logMessageCount - _lastLogMessageIndex; retIndex++)
-        {
-            try
-            {
-                lock(_logMessages)
-                {
-                    ret.Add(_logMessages.GetValueAtIndex(_lastLogMessageIndex + retIndex).ToString());
-                }
-            }
-            catch (NullReferenceException)//Called when LogMessage has not finished writing
-            {
-                break;
-            }
-        }
-
-        _lastLogMessageIndex = _lastLogMessageIndex + retIndex;
-        return ret.ToArray();
-    }
-}

README.md

@@ -1,78 +1,77 @@
-<!-- PROJECT LOGO -->
-<br />
+<span id="readme-top"></span>
 <div align="center">
 
-<h3 align="center">Tranga</h3>
-
+  <h1 align="center">Tranga v2</h1>
   <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>
+  
+  ![GitHub License](https://img.shields.io/github/license/C9glax/tranga)
+  
+  <table>
+    <tr>
+      <th><img alt="GitHub branch check runs" src="https://img.shields.io/github/check-runs/c9glax/tranga/master?label=master"></th>
+      <td><img alt="Last Run" src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.github.com%2Frepos%2Fc9glax%2Ftranga%2Factions%2Fworkflows%2Fdocker-image-master.yml%2Fruns%3Fper_page%3D1&query=workflow_runs%5B0%5D.created_at&label=Last%20Run"></td>
+    </tr>
+    <tr>
+      <th><img alt="GitHub branch check runs" src="https://img.shields.io/github/check-runs/c9glax/tranga/cuttingedge?label=cuttingedge"></th>
+      <td><img alt="Last Run" src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.github.com%2Frepos%2Fc9glax%2Ftranga%2Factions%2Fworkflows%2Fdocker-image-cuttingedge.yml%2Fruns%3Fper_page%3D1&query=workflow_runs%5B0%5D.created_at&label=Last%20Run"></td>
+    </tr>
+    <tr>
+      <th><img alt="GitHub branch check runs" src="https://img.shields.io/github/check-runs/c9glax/tranga/postgres-Server-V2?label=postgres-Server-V2"></th>
+      <td><img alt="Last Run" src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.github.com%2Frepos%2Fc9glax%2Ftranga%2Factions%2Fworkflows%2Fdocker-image-serverv2.yml%2Fruns%3Fper_page%3D1&query=workflow_runs%5B0%5D.created_at&label=Last%20Run"></td>
+    </tr>
+  </table>
+
 </div>
 
-<!-- TABLE OF CONTENTS -->
-<details>
-  <summary>Table of Contents</summary>
-  <ol>
-    <li>
-      <a href="#about-the-project">About The Project</a>
-      <ul>
-        <li><a href="#built-with">Built With</a></li>
-      </ul>
-    </li>
-    <li>
-      <a href="#getting-started">Getting Started</a>
-      <ul>
-        <li><a href="#prerequisites">Usage</a></li>
-        <li><a href="#prerequisites">Prerequisites</a></li>
-      </ul>
-    </li>
-    <li><a href="#roadmap">Roadmap</a></li>
-    <li><a href="#contributing">Contributing</a></li>
-    <li><a href="#license">License</a></li>
-    <li><a href="#acknowledgments">Acknowledgments</a></li>
-  </ol>
-</details>
-
-
-
 <!-- ABOUT THE PROJECT -->
 ## About The Project
 
 Tranga can download Chapters and Metadata from "Scanlation" sites such as 
 
 - [MangaDex.org](https://mangadex.org/) (Multilingual)
-- [Manganato.com](https://manganato.com/) (en)
+- [Manganato.gg](https://manganato.com/) (en) (or natomanga.com, mangakakalot, nelomanga, ...)
 - [MangaKatana.com](https://mangakatana.com) (en)
 - [Mangaworld.bz](https://www.mangaworld.bz/) (it)
 - [Bato.to](https://bato.to/v3x) (en)
 - [ManhuaPlus](https://manhuaplus.org/) (en)
-- [MangaHere](https://www.mangahere.cc/) (en) (Their covers aren't scrapeable.)
+- [MangaHere](https://www.mangahere.cc/) (en)
 - [Weebcentral](https://weebcentral.com) (en)
-- [Webtoons](https://www.webtoons.com/en/)
+- [Webtoons](https://www.webtoons.com/en/) (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/
+), or any other service that can use REST Webhooks.
+
+## What this program does and does *not* do
+
+Tranga (the program in this repository) is a REST-API and worker in one. Meaning it will open a network-port
+to listen for requests, and then work through these. Requests include searches for Manga, starting "Jobs" such
+as downloading available chapters, creating a monitoring job (that will periodically do the aforementioned),
+update metadata, and more.
+
+This repository *does not* include a frontend. A frontend can take many forms, such as a website:
+
+[tranga-website](https://github.com/C9Glax/tranga-website)
+
+When downloading a chapter (meaning the images that make-up the manga) from a Scanlation-Website, Tranga will
+additionally try and scrape Metadata from the same website ~~or enhance it from third-party sources~~
+(tbd https://github.com/C9Glax/tranga/issues/280).
+Downloaded images can be jpeg-compressed and/or made black and white to save on diskspace
+(measured at least a 50% reduction in size, without a significant loss of quality).
+
+Tranga will then package the contents of each chapter in a `.cbz`-archive and place it in a common folder per Manga.
+If specified, Tranga will then notify library-Managers such as [Komga](https://komga.org/) and [Kavita](https://www.kavitareader.com/) to trigger a scan for new
+chapters. Tranga can also send notifications to your devices via third-party services such as [Gotify](https://gotify.net/), [LunaSea](https://www.lunasea.app/) or [Ntfy](https://ntfy.sh/
 ).
 
-### What this does and doesn't do
+## Screenshots
 
-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.
-_**For a web-frontend use [tranga-website](https://github.com/C9Glax/tranga-website).**_
+This repository has no frontend, however checkout [tranga-website](https://github.com/C9Glax/tranga-website) for a default!
 
-This project downloads the images for a Manga from the specified Scanlation-Website and packages them with some metadata - from that same website - in a .cbz-archive (per chapter).  
-It does this on an interval, and checks for any Chapters (.cbz-Archive) not already existing in your specified Download-Location. (If you rename or move files, it will download those again)  
-Tranga can (if configured) trigger a scan in Komga or Kavita, however the directory in which the Manga reside has to be available to both Tranga and Komga/Kavita.
-
-The project doesn't manage metadata, and doesn't curate, change or enhance any information that isn't available on the selected Scanlation-Site.  
-It will blindly use whatever is scrapes (yes this is a glorified Web-scraper).
-
-
-### Inspiration:
+## Inspiration:
 
 Because [Kaizoku](https://github.com/oae/kaizoku) was relying on [mangal](https://github.com/metafates/mangal) and mangal
 hasn't received bugfixes for its issues with Titles not showing up, or throwing errors because of illegal characters,
@@ -82,13 +81,23 @@ That is why I wanted to create my own project, in a language I understand, and t
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>
 
-### Built With
+## Endpoint Documentation
 
-- .NET-Core
-- Newtonsoft.JSON
-- [PuppeteerSharp](https://www.puppeteersharp.com/)
-- [Html Agility Pack (HAP)](https://html-agility-pack.net/)
-- [Soenneker.Utils.String.NeedlemanWunsch](https://github.com/soenneker/soenneker.utils.string.needlemanwunsch)
+Endpoints are documented in Swagger. Just spin up an instance, and go to `http://<url>/swagger`.
+
+## Built With
+
+- .NET
+  - ASP.NET
+  - Entity Framework
+- [PostgreSQL](https://www.postgresql.org/about/licence/)
+- [Swagger](https://github.com/domaindrivendev/Swashbuckle.AspNetCore/blob/master/LICENSE)
+- [Ngpsql](https://github.com/npgsql/npgsql/blob/main/LICENSE)
+- [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json/blob/master/LICENSE.md)
+- [PuppeteerSharp](https://github.com/hardkoded/puppeteer-sharp/blob/master/LICENSE)
+- [Html Agility Pack (HAP)](https://github.com/zzzprojects/html-agility-pack/blob/master/LICENSE)
+- [Soenneker.Utils.String.NeedlemanWunsch](https://github.com/soenneker/soenneker.utils.string.needlemanwunsch/blob/main/LICENSE)
+- [Sixlabors.ImageSharp](https://docs-v2.sixlabors.com/articles/imagesharp/index.html#license)
 - 💙 Blåhaj 🦈
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>
@@ -108,60 +117,72 @@ That is why I wanted to create my own project, in a language I understand, and t
 
 ### Docker
 
-Download [docker-compose.yaml](https://git.bernloehr.eu/glax/Tranga/src/branch/master/docker-compose.yaml) and configure to your needs.  
-Mount `/Manga` to wherever you want your chapters (`.cbz`-Archives) downloaded (where Komga/Kavita can access them).  
-The `docker-compose` also includes [tranga-website](https://github.com/C9Glax/tranga-website) as frontend. For its configuration refer to the repo README.
+An example `docker-compose.yaml` is provided. Mount `/Manga` to wherever you want your chapters (`.cbz`-Archives)
+downloaded (where Komga/Kavita can access them for example).  
+The file also includes [tranga-website](https://github.com/C9Glax/tranga-website) as frontend. For its configuration refer to the
+[Tranga-Website Repository](https://github.com/C9Glax/tranga-website) README.
 
 For compatibility do not execute the compose as root (which you should not do anyways...) but as user that can
-access the folder.
+access the folder. Permission conflicts with Komga and Kavita should thus be limited.
 
-### Prerequisites
+### Bare-Metal
 
-#### 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.
+While not supported/currently built, Tranga will also run Bare-Metal without issue.
 
-See the [open issues](https://github.com/C9Glax/tranga/issues) for a full list of proposed features (and known issues).
+Configuration-Files will be stored per OS:
+- Linux `/usr/share/tranga-api`
+- Windows `%appdata%/tranga-api`
 
-<p align="right">(<a href="#readme-top">back to top</a>)</p>
+Downloads (default) are stored in - but this can be configured in `settings.json`:
+- Linux `/Manga`
+- Windows `%currentDirectory%/Downloads`
 
+#### Prerequisits
 
+[.NET-Core 9.0](https://dotnet.microsoft.com/en-us/download/dotnet/9.0)
 
 <!-- CONTRIBUTING -->
 ## Contributing
 
-The following is copy & pasted:
+If you want to contribute, please feel free to fork and create a Pull-Request!
 
-Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
+General rules:
+- Strongly-type your variables. This improves readability.
+```csharp
+var xyz = Object.GetSomething(); //Do not do this. What type is xyz?
+Manga[] zyx = Object.GetAnotherThing(); //I can now easily see that zyx is an Array.
+```
 
-If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
-Don't forget to give the project a star! Thanks again!
-
-1. Fork the Project
-2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
-3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
-4. Push to the Branch (`git push origin feature/AmazingFeature`)
-5. Open a Pull Request
-
-<p align="right">(<a href="#readme-top">back to top</a>)</p>
+**A broad overview of where is what:**<br />
 
+- `Program.cs` Configuration for ASP.NET, Swagger (also in `NamedSwaggerGenOptions.cs`, Npgsql
+- `Tranga.cs` Job(worker)-Logic
+- `Schema/` Entity-Framework
+  - `Schema/Jobs/` + Logic for Jobs
+  - `Schema/**/` + Logic for **
+  - `Schema/PgsqlContext.cs` EF configuration
+- `MangaDownloadClients/` Networking-Clients for Scraping
+- `Controllers/` ASP.NET Controllers (Endpoints)
+- `APIEndpointRecords/` Records for API-Requests with specific Request-Types (Body)
 
+If you want to add a new Scanlationsite-Connector: <br />
+1. Copy one of the existing connectors, or start from scratch and inherit from `API.Schema.MangaConnectors.MangaConnector`.
+2. Add the new Connector as Object-Instance in `Program.cs` to the MangaConnector-Array `connectors`.
+3. In `Schema/PgsqlContext.cs` add the Discriminator for the Connector (the value is the name of the connector, as defined
+in the constructor).
 
 <!-- LICENSE -->
 ## License
 
-Distributed under the GNU GPLv3  License. See `LICENSE.txt` for more information.
+Distributed under the GNU GPLv3  License. See [LICENSE.txt](https://github.com/C9Glax/tranga/blob/master/LICENSE.txt) for more information.
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>
 
-
-
 <!-- ACKNOWLEDGMENTS -->
 ## Acknowledgments
 
 * [Choose an Open Source License](https://choosealicense.com)
-* [Font Awesome](https://fontawesome.com)
 * [Best-README-Template](https://github.com/othneildrew/Best-README-Template/tree/master)
+* [Shields.io](https://shields.io/)
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>

Tranga.sln

@@ -1,10 +1,6 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tranga", ".\Tranga\Tranga.csproj", "{545E81B9-D96B-4C8F-A97F-2C02414DE566}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Logging", "Logging\Logging.csproj", "{415BE889-BB7D-426F-976F-8D977876A462}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CLI", "CLI\CLI.csproj", "{4324C816-F9D2-468F-8ED6-397FE2F0DCB3}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "API", "API\API.csproj", "{EDB07E7B-351F-4FCC-9AEF-777838E5551E}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -12,17 +8,9 @@ Global
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{545E81B9-D96B-4C8F-A97F-2C02414DE566}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{545E81B9-D96B-4C8F-A97F-2C02414DE566}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{545E81B9-D96B-4C8F-A97F-2C02414DE566}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{545E81B9-D96B-4C8F-A97F-2C02414DE566}.Release|Any CPU.Build.0 = Release|Any CPU
-		{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
-		{4324C816-F9D2-468F-8ED6-397FE2F0DCB3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4324C816-F9D2-468F-8ED6-397FE2F0DCB3}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{4324C816-F9D2-468F-8ED6-397FE2F0DCB3}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{4324C816-F9D2-468F-8ED6-397FE2F0DCB3}.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/Chapter.cs

@@ -1,159 +0,0 @@
-using System.Runtime.InteropServices;
-using System.Text.RegularExpressions;
-using System.Xml.Linq;
-using static System.IO.UnixFileMode;
-
-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 readonly struct Chapter : IComparable
-{
-    // ReSharper disable once MemberCanBePrivate.Global
-    public Manga parentManga { get; }
-    public string? name { get; }
-    public float volumeNumber { get; }
-    public float chapterNumber { get; }
-    public string url { get; }
-    // ReSharper disable once MemberCanBePrivate.Global
-    public string fileName { get; }
-    public string? id { get; }
-    
-    private static readonly Regex LegalCharacters = new (@"([A-z]*[0-9]* *\.*-*,*\]*\[*'*\'*\)*\(*~*!*)*");
-    private static readonly Regex IllegalStrings = new(@"(Vol(ume)?|Ch(apter)?)\.?", RegexOptions.IgnoreCase);
-
-    public Chapter(Manga parentManga, string? name, string? volumeNumber, string chapterNumber, string url, string? id = null)
-        : this(parentManga, name, float.Parse(volumeNumber??"0", GlobalBase.numberFormatDecimalPoint),
-            float.Parse(chapterNumber, GlobalBase.numberFormatDecimalPoint), url, id)
-    {
-    }
-    
-    public Chapter(Manga parentManga, string? name, float? volumeNumber, float chapterNumber, string url, string? id = null)
-    {
-        this.parentManga = parentManga;
-        this.name = name;
-        this.volumeNumber = volumeNumber??0;
-        this.chapterNumber = chapterNumber;
-        this.url = url;
-        this.id = id;
-        
-        string chapterVolNumStr = $"Vol.{this.volumeNumber} Ch.{chapterNumber}";
-
-        if (name is not null && name.Length > 0)
-        {
-            string chapterName = IllegalStrings.Replace(string.Concat(LegalCharacters.Matches(name)), "");
-            this.fileName = chapterName.Length > 0 ? $"{chapterVolNumStr} - {chapterName}" : chapterVolNumStr;
-        }
-        else
-            this.fileName = chapterVolNumStr;
-    }
-
-    public override string ToString()
-    {
-        return $"Chapter {parentManga.sortName} {parentManga.internalId} {chapterNumber} {name}";
-    }
-
-    public override bool Equals(object? obj)
-    {
-        if (obj is not Chapter)
-            return false;
-        return CompareTo(obj) == 0;
-    }
-
-    public int CompareTo(object? obj)
-    {
-        if(obj is not Chapter otherChapter)
-            throw new ArgumentException($"{obj} can not be compared to {this}");
-        return volumeNumber.CompareTo(otherChapter.volumeNumber) switch
-        {
-            <0 => -1,
-            >0 => 1,
-            _ => chapterNumber.CompareTo(otherChapter.chapterNumber)
-        };
-    }
-
-    /// <summary>
-    /// Checks if a chapter-archive is already present
-    /// </summary>
-    /// <returns>true if chapter is present</returns>
-    internal bool CheckChapterIsDownloaded()
-    {
-        string mangaDirectory = Path.Join(TrangaSettings.downloadLocation, parentManga.folderName);
-        if (!Directory.Exists(mangaDirectory))
-            return false;
-        FileInfo? mangaArchive = null;
-        string markerPath = Path.Join(mangaDirectory, $".{id}");
-        if (this.id is not null && File.Exists(markerPath))
-        {
-            if(File.Exists(File.ReadAllText(markerPath)))
-                mangaArchive = new FileInfo(File.ReadAllText(markerPath));
-            else
-                File.Delete(markerPath);
-        }
-        
-        if(mangaArchive is null)
-        {
-            FileInfo[] archives = new DirectoryInfo(mangaDirectory).GetFiles("*.cbz");
-            Regex volChRex = new(@"(?:Vol(?:ume)?\.([0-9]+)\D*)?Ch(?:apter)?\.([0-9]+(?:\.[0-9]+)*)(?: - (.*))?.cbz");
-
-            Chapter t = this;
-            mangaArchive = archives.FirstOrDefault(archive =>
-            {
-                Match m = volChRex.Match(archive.Name);
-                /*
-                 * 1. If the volumeNumber is not present in the filename, it is not checked.
-                 * 2. Check the chapterNumber in the chapter against the one in the filename.
-                 * 3. The chpaterName has to either be absent both in the chapter and the filename or match.
-                 */
-                return (!m.Groups[1].Success || m.Groups[1].Value == t.volumeNumber.ToString(GlobalBase.numberFormatDecimalPoint)) &&
-                       m.Groups[2].Value == t.chapterNumber.ToString(GlobalBase.numberFormatDecimalPoint) &&
-                       ((!m.Groups[3].Success && string.IsNullOrEmpty(t.name)) || m.Groups[3].Value == t.name);
-            });
-        }
-        
-        string correctPath = GetArchiveFilePath();
-        if(mangaArchive is not null && mangaArchive.FullName != correctPath)
-            mangaArchive.MoveTo(correctPath, true);
-        return (mangaArchive is not null);
-    }
-    
-    public void CreateChapterMarker()
-    {
-        if (this.id is null)
-            return;
-        string path = Path.Join(TrangaSettings.downloadLocation, parentManga.folderName, $".{id}");
-        File.WriteAllText(path, GetArchiveFilePath());
-        File.SetAttributes(path, FileAttributes.Hidden);
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))  
-            File.SetUnixFileMode(path, UserRead | UserWrite | UserExecute | GroupRead | GroupWrite | GroupExecute | OtherRead | OtherExecute);
-    }
-    
-    /// <summary>
-    /// Creates full file path of chapter-archive
-    /// </summary>
-    /// <returns>Filepath</returns>
-    internal string GetArchiveFilePath()
-    {
-        return Path.Join(TrangaSettings.downloadLocation, parentManga.folderName, $"{parentManga.folderName} - {this.fileName}.cbz");
-    }
-
-    /// <summary>
-    /// Creates a string containing XML of publication and chapter.
-    /// See ComicInfo.xml
-    /// </summary>
-    /// <returns>XML-string</returns>
-    internal string GetComicInfoXmlString()
-    {
-        XElement comicInfo = new XElement("ComicInfo",
-            new XElement("Tags", string.Join(',', parentManga.tags)),
-            new XElement("LanguageISO", parentManga.originalLanguage),
-            new XElement("Title", this.name),
-            new XElement("Writer", string.Join(',', parentManga.authors)),
-            new XElement("Volume", this.volumeNumber),
-            new XElement("Number", this.chapterNumber)
-        );
-        return comicInfo.ToString();
-    }
-}

Tranga/GlobalBase.cs

@@ -1,143 +0,0 @@
-using System.Globalization;
-using System.Text.RegularExpressions;
-using Logging;
-using Newtonsoft.Json;
-using Tranga.LibraryConnectors;
-using Tranga.NotificationConnectors;
-
-namespace Tranga;
-
-public abstract class GlobalBase
-{
-    [JsonIgnore]
-    public Logger? logger { get; init; }
-    protected HashSet<NotificationConnector> notificationConnectors { get; init; }
-    protected HashSet<LibraryConnector> libraryConnectors { get; init; }
-    private Dictionary<string, Manga> cachedPublications { get; init; }
-    public static readonly NumberFormatInfo numberFormatDecimalPoint = new (){ NumberDecimalSeparator = "." };
-    protected static readonly Regex baseUrlRex = new(@"https?:\/\/[0-9A-z\.-]+(:[0-9]+)?");
-
-    protected GlobalBase(GlobalBase clone)
-    {
-        this.logger = clone.logger;
-        this.notificationConnectors = clone.notificationConnectors;
-        this.libraryConnectors = clone.libraryConnectors;
-        this.cachedPublications = clone.cachedPublications;
-    }
-
-    protected GlobalBase(Logger? logger)
-    {
-        this.logger = logger;
-        this.notificationConnectors = TrangaSettings.LoadNotificationConnectors(this);
-        this.libraryConnectors = TrangaSettings.LoadLibraryConnectors(this);
-        this.cachedPublications = new();
-    }
-
-    protected void AddMangaToCache(Manga manga)
-    {
-        if (!this.cachedPublications.TryAdd(manga.internalId, manga))
-        {
-            Log($"Overwriting Manga {manga.internalId}");
-            this.cachedPublications[manga.internalId] = manga;
-        }
-    }
-
-    protected Manga? GetCachedManga(string internalId)
-    {
-        return cachedPublications.TryGetValue(internalId, out Manga manga) switch
-        {
-            true => manga,
-            _ => null
-        };
-    }
-
-    protected IEnumerable<Manga> GetAllCachedManga()
-    {
-        return cachedPublications.Values;
-    }
-
-    protected void Log(string message)
-    {
-        logger?.WriteLine(this.GetType().Name, message);
-    }
-
-    protected void Log(string fStr, params object?[] replace)
-    {
-        Log(string.Format(fStr, replace));
-    }
-
-    protected void SendNotifications(string title, string text, bool buffer = false)
-    {
-        foreach (NotificationConnector nc in notificationConnectors)
-            nc.SendNotification(title, text, buffer);
-    }
-
-    protected void AddNotificationConnector(NotificationConnector notificationConnector)
-    {
-        Log($"Adding {notificationConnector}");
-        notificationConnectors.RemoveWhere(nc => nc.notificationConnectorType == notificationConnector.notificationConnectorType);
-        notificationConnectors.Add(notificationConnector);
-        
-        while(IsFileInUse(TrangaSettings.notificationConnectorsFilePath))
-            Thread.Sleep(100);
-        Log("Exporting notificationConnectors");
-        File.WriteAllText(TrangaSettings.notificationConnectorsFilePath, JsonConvert.SerializeObject(notificationConnectors));
-    }
-
-    protected void DeleteNotificationConnector(NotificationConnector.NotificationConnectorType notificationConnectorType)
-    {
-        Log($"Removing {notificationConnectorType}");
-        notificationConnectors.RemoveWhere(nc => nc.notificationConnectorType == notificationConnectorType);
-        while(IsFileInUse(TrangaSettings.notificationConnectorsFilePath))
-            Thread.Sleep(100);
-        Log("Exporting notificationConnectors");
-        File.WriteAllText(TrangaSettings.notificationConnectorsFilePath, JsonConvert.SerializeObject(notificationConnectors));
-    }
-
-    protected void UpdateLibraries()
-    {
-        foreach(LibraryConnector lc in libraryConnectors)
-            lc.UpdateLibrary();
-    }
-
-    protected void AddLibraryConnector(LibraryConnector libraryConnector)
-    {
-        Log($"Adding {libraryConnector}");
-        libraryConnectors.RemoveWhere(lc => lc.libraryType == libraryConnector.libraryType);
-        libraryConnectors.Add(libraryConnector);
-        
-        while(IsFileInUse(TrangaSettings.libraryConnectorsFilePath))
-            Thread.Sleep(100);
-        Log("Exporting libraryConnectors");
-        File.WriteAllText(TrangaSettings.libraryConnectorsFilePath, JsonConvert.SerializeObject(libraryConnectors, Formatting.Indented));
-    }
-
-    protected void DeleteLibraryConnector(LibraryConnector.LibraryType libraryType)
-    {
-        Log($"Removing {libraryType}");
-        libraryConnectors.RemoveWhere(lc => lc.libraryType == libraryType);
-        while(IsFileInUse(TrangaSettings.libraryConnectorsFilePath))
-            Thread.Sleep(100);
-        Log("Exporting libraryConnectors");
-        File.WriteAllText(TrangaSettings.libraryConnectorsFilePath, JsonConvert.SerializeObject(libraryConnectors, Formatting.Indented));
-    }
-
-    protected bool IsFileInUse(string filePath) => IsFileInUse(filePath, this.logger);
-
-    public static bool IsFileInUse(string filePath, Logger? logger)
-    {
-        if (!File.Exists(filePath))
-            return false;
-        try
-        {
-            using FileStream stream = new (filePath, FileMode.Open, FileAccess.Read, FileShare.None);
-            stream.Close();
-            return false;
-        }
-        catch (IOException)
-        {
-            logger?.WriteLine($"File is in use {filePath}");
-            return true;
-        }
-    }
-}

Tranga/Jobs/DownloadChapter.cs

@@ -1,54 +0,0 @@
-using System.Net;
-using Tranga.MangaConnectors;
-
-namespace Tranga.Jobs;
-
-public class DownloadChapter : Job
-{
-    public Chapter chapter { get; init; }
-
-    public DownloadChapter(GlobalBase clone, MangaConnector connector, Chapter chapter, DateTime lastExecution, string? parentJobId = null) : base(clone, JobType.DownloadChapterJob, connector, lastExecution, parentJobId: parentJobId)
-    {
-        this.chapter = chapter;
-    }
-    
-    public DownloadChapter(GlobalBase clone, MangaConnector connector, Chapter chapter, string? parentJobId = null) : base(clone, JobType.DownloadChapterJob, connector, parentJobId: parentJobId)
-    {
-        this.chapter = chapter;
-    }
-    
-    protected override string GetId()
-    {
-        return $"{GetType()}-{chapter.parentManga.internalId}-{chapter.chapterNumber}";
-    }
-
-    public override string ToString()
-    {
-        return $"{id} Chapter: {chapter}";
-    }
-
-    protected override IEnumerable<Job> ExecuteReturnSubTasksInternal(JobBoss jobBoss)
-    {
-        Task downloadTask = new(delegate
-        {
-            mangaConnector.CopyCoverFromCacheToDownloadLocation(chapter.parentManga);
-            HttpStatusCode success = mangaConnector.DownloadChapter(chapter, this.progressToken);
-            chapter.parentManga.UpdateLatestDownloadedChapter(chapter);
-            if (success == HttpStatusCode.OK)
-            {
-                UpdateLibraries();
-                SendNotifications("Chapter downloaded", $"{chapter.parentManga.sortName} - {chapter.chapterNumber}", true);
-            }
-        });
-        downloadTask.Start();
-        return Array.Empty<Job>();
-    }
-
-    public override bool Equals(object? obj)
-    {
-        if (obj is not DownloadChapter otherJob)
-            return false;
-        return otherJob.mangaConnector == this.mangaConnector &&
-               otherJob.chapter.Equals(this.chapter);
-    }
-}

Tranga/Jobs/DownloadNewChapters.cs

@@ -1,59 +0,0 @@
-using Tranga.MangaConnectors;
-
-namespace Tranga.Jobs;
-
-public class DownloadNewChapters : Job
-{
-    public Manga manga { get; set; }
-    public string translatedLanguage { get; init; }
-
-    public DownloadNewChapters(GlobalBase clone, MangaConnector connector, Manga manga, DateTime lastExecution,
-        bool recurring = false, TimeSpan? recurrence = null, string? parentJobId = null, string translatedLanguage = "en") : base(clone, JobType.DownloadNewChaptersJob, connector, lastExecution, recurring,
-        recurrence, parentJobId)
-    {
-        this.manga = manga;
-        this.translatedLanguage = translatedLanguage;
-    }
-    
-    public DownloadNewChapters(GlobalBase clone, MangaConnector connector, Manga manga, bool recurring = false, TimeSpan? recurrence = null, string? parentJobId = null, string translatedLanguage = "en") : base (clone, JobType.DownloadNewChaptersJob, connector, recurring, recurrence, parentJobId)
-    {
-        this.manga = manga;
-        this.translatedLanguage = translatedLanguage;
-    }
-
-    protected override string GetId()
-    {
-        return $"{GetType()}-{manga.internalId}";
-    }
-    
-    public override string ToString()
-    {
-        return $"{id} Manga: {manga}";
-    }
-
-    protected override IEnumerable<Job> ExecuteReturnSubTasksInternal(JobBoss jobBoss)
-    {
-        manga.SaveSeriesInfoJson();
-        Chapter[] chapters = mangaConnector.GetNewChapters(manga, this.translatedLanguage);
-        this.progressToken.increments = chapters.Length;
-        List<Job> jobs = new();
-        mangaConnector.CopyCoverFromCacheToDownloadLocation(manga);
-        foreach (Chapter chapter in chapters)
-        {
-            DownloadChapter downloadChapterJob = new(this, this.mangaConnector, chapter, parentJobId: this.id);
-            jobs.Add(downloadChapterJob);
-        }
-        UpdateMetadata updateMetadataJob = new(this, this.mangaConnector, this.manga, parentJobId: this.id);
-        jobs.Add(updateMetadataJob);
-        progressToken.Complete();
-        return jobs;
-    }
-
-    public override bool Equals(object? obj)
-    {
-        if (obj is not DownloadNewChapters otherJob)
-            return false;
-        return otherJob.mangaConnector == this.mangaConnector &&
-               otherJob.manga.publicationId == this.manga.publicationId;
-    }
-}

Tranga/Jobs/Job.cs

@@ -1,98 +0,0 @@
-using Tranga.MangaConnectors;
-
-namespace Tranga.Jobs;
-
-public abstract class Job : GlobalBase
-{
-    public MangaConnector mangaConnector { get; init; }
-    public ProgressToken progressToken { get; private set; }
-    public bool recurring { get; init; }
-    public TimeSpan? recurrenceTime { get; set; }
-    public DateTime? lastExecution { get; private set; }
-    public DateTime nextExecution => NextExecution();
-    public string id => GetId();
-    internal IEnumerable<Job>? subJobs { get; private set; }
-    public string? parentJobId { get; init; }
-    public enum JobType : byte { DownloadChapterJob, DownloadNewChaptersJob, UpdateMetaDataJob }
-
-    public JobType jobType;
-
-    internal Job(GlobalBase clone, JobType jobType, MangaConnector connector, bool recurring = false, TimeSpan? recurrenceTime = null, string? parentJobId = null) : base(clone)
-    {
-        this.jobType = jobType;
-        this.mangaConnector = connector;
-        this.progressToken = new ProgressToken(0);
-        this.recurring = recurring;
-        if (recurring && recurrenceTime is null)
-            throw new ArgumentException("If recurrence is set to true, a recurrence time has to be provided.");
-        else if(recurring && recurrenceTime is not null)
-            this.lastExecution = DateTime.Now.Subtract((TimeSpan)recurrenceTime);
-        this.recurrenceTime = recurrenceTime ?? TimeSpan.Zero;
-        this.parentJobId = parentJobId;
-    }
-
-    internal Job(GlobalBase clone, JobType jobType, MangaConnector connector, DateTime lastExecution, bool recurring = false,
-        TimeSpan? recurrenceTime = null, string? parentJobId = null) : base(clone)
-    {
-        this.jobType = jobType;
-        this.mangaConnector = connector;
-        this.progressToken = new ProgressToken(0);
-        this.recurring = recurring;
-        if (recurring && recurrenceTime is null)
-            throw new ArgumentException("If recurrence is set to true, a recurrence time has to be provided.");
-        this.lastExecution = lastExecution;
-        this.recurrenceTime = recurrenceTime ?? TimeSpan.Zero;
-        this.parentJobId = parentJobId;
-    }
-
-    protected abstract string GetId();
-
-    public void AddSubJob(Job job)
-    {
-        subJobs ??= new List<Job>();
-        subJobs = subJobs.Append(job);
-    }
-
-    private DateTime NextExecution()
-    {
-        if(recurrenceTime.HasValue && lastExecution.HasValue)
-            return lastExecution.Value.Add(recurrenceTime.Value);
-        if(recurrenceTime.HasValue && !lastExecution.HasValue)
-            return DateTime.Now;
-        return DateTime.MaxValue;
-    }
-
-    public void ResetProgress()
-    {
-        this.progressToken.increments -= progressToken.incrementsCompleted;
-        this.lastExecution = DateTime.Now;
-        this.progressToken.Waiting();
-    }
-
-    public void ExecutionEnqueue()
-    {
-        this.progressToken.increments -= progressToken.incrementsCompleted;
-        this.progressToken.Standby();
-    }
-
-    public void Cancel()
-    {
-        Log($"Cancelling {this}");
-        this.progressToken.cancellationRequested = true;
-        this.progressToken.Cancel();
-        this.lastExecution = DateTime.Now;
-        if(subJobs is not null)
-            foreach(Job subJob in subJobs)
-                subJob.Cancel();
-    }
-
-    public IEnumerable<Job> ExecuteReturnSubTasks(JobBoss jobBoss)
-    {
-        progressToken.Start();
-        subJobs = ExecuteReturnSubTasksInternal(jobBoss);
-        lastExecution = DateTime.Now;
-        return subJobs;
-    }
-
-    protected abstract IEnumerable<Job> ExecuteReturnSubTasksInternal(JobBoss jobBoss);
-}

Tranga/Jobs/JobBoss.cs

@@ -1,301 +0,0 @@
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Text.RegularExpressions;
-using Newtonsoft.Json;
-using Tranga.MangaConnectors;
-using static System.IO.UnixFileMode;
-
-namespace Tranga.Jobs;
-
-public class JobBoss : GlobalBase
-{
-    public HashSet<Job> jobs { get; init; }
-    private Dictionary<MangaConnector, Queue<Job>> mangaConnectorJobQueue { get; init; }
-
-    public JobBoss(GlobalBase clone, HashSet<MangaConnector> connectors) : base(clone)
-    {
-        this.jobs = new();
-        LoadJobsList(connectors);
-        this.mangaConnectorJobQueue = new();
-        Log($"Next job in {jobs.MinBy(job => job.nextExecution)?.nextExecution.Subtract(DateTime.Now)} {jobs.MinBy(job => job.nextExecution)?.id}");
-    }
-
-    public bool AddJob(Job job, string? jobFile = null)
-    {
-        if (ContainsJobLike(job))
-        {
-            Log($"Already Contains Job {job}");
-            return false;
-        }
-        else
-        {
-            if (!this.jobs.Add(job))
-                return false;
-            Log($"Added {job}");
-            UpdateJobFile(job, jobFile);
-        }
-        return true;
-    }
-
-    public void AddJobs(IEnumerable<Job> jobsToAdd)
-    {
-        foreach (Job job in jobsToAdd)
-            AddJob(job);
-    }
-
-    /// <summary>
-    /// Compares contents of the provided job and all current jobs
-    /// Does not check if objects are the same
-    /// </summary>
-    public bool ContainsJobLike(Job job)
-    {
-        return this.jobs.Any(existingJob => existingJob.Equals(job));
-    }
-
-    public void RemoveJob(Job job)
-    {
-        Log($"Removing {job}");
-        job.Cancel();
-        this.jobs.Remove(job);
-        if(job.subJobs is not null && job.subJobs.Any())
-            RemoveJobs(job.subJobs);
-        UpdateJobFile(job);
-    }
-
-    public void RemoveJobs(IEnumerable<Job?> jobsToRemove)
-    {
-        List<Job?> toRemove = jobsToRemove.ToList(); //Prevent multiple enumeration
-        Log($"Removing {toRemove.Count()} jobs.");
-        foreach (Job? job in toRemove)
-            if(job is not null)
-                RemoveJob(job);
-    }
-
-    public IEnumerable<Job> GetJobsLike(string? connectorName = null, string? internalId = null, float? chapterNumber = null)
-    {
-        IEnumerable<Job> ret = this.jobs;
-        if (connectorName is not null)
-            ret = ret.Where(job => job.mangaConnector.name == connectorName);
-        
-        if (internalId is not null && chapterNumber is not null)
-            ret = ret.Where(jjob =>
-            {
-                if (jjob is not DownloadChapter job)
-                    return false;
-                return job.chapter.parentManga.internalId == internalId &&
-                       job.chapter.chapterNumber.Equals(chapterNumber);
-            });
-        else if (internalId is not null)
-            ret = ret.Where(jjob =>
-            {
-                if (jjob is not DownloadNewChapters job)
-                    return false;
-                return job.manga.internalId == internalId;
-            });
-        return ret;
-    }
-
-    public IEnumerable<Job> GetJobsLike(MangaConnector? mangaConnector = null, Manga? publication = null,
-        Chapter? chapter = null)
-    {
-        if (chapter is not null)
-            return GetJobsLike(mangaConnector?.name, chapter.Value.parentManga.internalId, chapter.Value.chapterNumber);
-        else
-            return GetJobsLike(mangaConnector?.name, publication?.internalId);
-    }
-
-    public Job? GetJobById(string jobId)
-    {
-        if (this.jobs.FirstOrDefault(jjob => jjob.id == jobId) is { } job)
-            return job;
-        return null;
-    }
-
-    public bool TryGetJobById(string jobId, out Job? job)
-    {
-        if (this.jobs.FirstOrDefault(jjob => jjob.id == jobId) is { } ret)
-        {
-            job = ret;
-            return true;
-        }
-
-        job = null;
-        return false;
-    }
-
-    private bool QueueContainsJob(Job job)
-    {
-        if (mangaConnectorJobQueue.TryAdd(job.mangaConnector, new Queue<Job>()))//If we can add the queue, there is certainly no job in it
-            return true;
-        return mangaConnectorJobQueue[job.mangaConnector].Contains(job);
-    }
-
-    public void AddJobToQueue(Job job)
-    {
-        Log($"Adding Job to Queue. {job}");
-        if(!QueueContainsJob(job))
-            mangaConnectorJobQueue[job.mangaConnector].Enqueue(job);
-        job.ExecutionEnqueue();
-    }
-
-    private void AddJobsToQueue(IEnumerable<Job> newJobs)
-    {
-        foreach(Job job in newJobs)
-            AddJobToQueue(job);
-    }
-
-    private void LoadJobsList(HashSet<MangaConnector> connectors)
-    {
-        if (!Directory.Exists(TrangaSettings.jobsFolderPath)) //No jobs to load
-        {
-            Directory.CreateDirectory(TrangaSettings.jobsFolderPath);
-            if(RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-                File.SetUnixFileMode(TrangaSettings.jobsFolderPath, UserRead | UserWrite | UserExecute | GroupRead | OtherRead);
-            return;
-        }
-
-        //Load json-job-files
-        foreach (FileInfo file in Directory.GetFiles(TrangaSettings.jobsFolderPath, "*.json").Select(f => new FileInfo(f)))
-        {
-            Log($"Adding {file.Name}");
-            try
-            {
-                Job? job = JsonConvert.DeserializeObject<Job>(File.ReadAllText(file.FullName),
-                    new JobJsonConverter(this, new MangaConnectorJsonConverter(this, connectors)));
-                if (job is null) throw new NullReferenceException();
-                
-                Log($"Adding Job {job}");
-                if (!AddJob(job, file.FullName)) //If we detect a duplicate, delete the file.
-                {
-                    //string path = string.Concat(file.FullName, ".duplicate");
-                    //file.MoveTo(path);
-                    //Log($"Duplicate detected or otherwise not able to add job to list.\nMoved job {job} to {path}");
-                    Log($"Duplicate detected or otherwise not able to add job to list. Removed the file {file.FullName} {job}");
-                }
-            }
-            catch (Exception e)
-            {
-                if (e is not UnreachableException or NullReferenceException)
-                    throw;
-                Log(e.Message);
-                string newName = file.FullName + ".failed";
-                Log($"Failed loading file {file.Name}.\nMoving to {newName}.\n" +
-                    $"If you think this is a bug, upload contents of the file to the Bugreport!");
-                File.Move(file.FullName, newName);
-                continue;
-            }
-        }
-
-        //Connect jobs to parent-jobs and add Publications to cache
-        foreach (Job job in this.jobs)
-        {
-            Log($"Loading Job {job}");
-            Job? parentJob = this.jobs.FirstOrDefault(jjob => jjob.id == job.parentJobId);
-            if (parentJob is not null)
-            {
-                parentJob.AddSubJob(job);
-                Log($"Parent Job {parentJob}");
-            }
-            if (job is DownloadNewChapters dncJob)
-                AddMangaToCache(dncJob.manga);
-        }
-
-        string[] coverFiles = Directory.GetFiles(TrangaSettings.coverImageCache);
-        foreach(string fileName in coverFiles.Where(fileName => !GetAllCachedManga().Any(manga => manga.coverFileNameInCache == fileName)))
-            File.Delete(fileName);
-    }
-
-    internal void UpdateJobFile(Job job, string? oldFile = null)
-    {
-        string newJobFilePath = Path.Join(TrangaSettings.jobsFolderPath, $"{job.id}.json");
-        string oldFilePath = oldFile??Path.Join(TrangaSettings.jobsFolderPath, $"{job.id}.json");
-
-        //Delete old file
-        if (File.Exists(oldFilePath))
-        {
-            Log($"Deleting Job-file {oldFilePath}");
-            try
-            {
-                while(IsFileInUse(oldFilePath))
-                    Thread.Sleep(10);
-                File.Delete(oldFilePath);
-            }
-            catch (Exception e)
-            {
-                Log($"Error deleting {oldFilePath} job {job.id}\n{e}");
-                return; //Don't export a new file when we haven't actually deleted the old one
-            }
-        }
-
-        //Export job (in new file) if it is still in our jobs list
-        if (GetJobById(job.id) is not null)
-        {
-            Log($"Exporting Job {newJobFilePath}");
-            string jobStr = JsonConvert.SerializeObject(job, Formatting.Indented);
-            while(IsFileInUse(newJobFilePath))
-                Thread.Sleep(10);
-            File.WriteAllText(newJobFilePath, jobStr);
-            if(RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-                File.SetUnixFileMode(newJobFilePath, UserRead | UserWrite | GroupRead | OtherRead);
-        }
-    }
-
-    private void UpdateAllJobFiles()
-    {
-        Log("Exporting Jobs");
-        foreach (Job job in this.jobs)
-            UpdateJobFile(job);
-
-        //Remove files with jobs not in this.jobs-list
-        Regex idRex = new (@"(.*)\.json");
-        foreach (FileInfo file in new DirectoryInfo(TrangaSettings.jobsFolderPath).EnumerateFiles())
-        {
-            if (idRex.IsMatch(file.Name))
-            {
-                string id = idRex.Match(file.Name).Groups[1].Value;
-                if (!this.jobs.Any(job => job.id == id))
-                {
-                    try
-                    {
-                        file.Delete();
-                    }
-                    catch (Exception e)
-                    {
-                        Log(e.ToString());
-                    }
-                }
-            }
-        }
-    }
-
-    public void CheckJobs()
-    {
-        AddJobsToQueue(jobs.Where(job => job.progressToken.state == ProgressToken.State.Waiting && job.nextExecution < DateTime.Now && !QueueContainsJob(job)).OrderBy(job => job.nextExecution));
-        foreach (Queue<Job> jobQueue in mangaConnectorJobQueue.Values)
-        {
-            if(jobQueue.Count < 1)
-                continue;
-            Job queueHead = jobQueue.Peek();
-            if (queueHead.progressToken.state is ProgressToken.State.Complete or ProgressToken.State.Cancelled)
-            {
-                if(!queueHead.recurring)
-                    RemoveJob(queueHead);
-                else
-                    queueHead.ResetProgress();
-                jobQueue.Dequeue();
-                Log($"Next job in {jobs.MinBy(job => job.nextExecution)?.nextExecution.Subtract(DateTime.Now)} {jobs.MinBy(job => job.nextExecution)?.id}");
-            }else if (queueHead.progressToken.state is ProgressToken.State.Standby)
-            {
-                Job eJob = jobQueue.Peek();
-                Job[] subJobs = eJob.ExecuteReturnSubTasks(this).ToArray();
-                UpdateJobFile(eJob);
-                AddJobs(subJobs);
-                AddJobsToQueue(subJobs);
-            }else if (queueHead.progressToken.state is ProgressToken.State.Running && DateTime.Now.Subtract(queueHead.progressToken.lastUpdate) > TimeSpan.FromMinutes(5))
-            {
-                Log($"{queueHead} inactive for more than 5 minutes. Cancelling.");
-                queueHead.Cancel();
-            }
-        }
-    }
- }

Tranga/Jobs/JobJsonConverter.cs

@@ -1,84 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using Tranga.MangaConnectors;
-
-namespace Tranga.Jobs;
-
-public class JobJsonConverter : JsonConverter
-{
-    private GlobalBase _clone;
-    private MangaConnectorJsonConverter _mangaConnectorJsonConverter;
-
-    internal JobJsonConverter(GlobalBase clone, MangaConnectorJsonConverter mangaConnectorJsonConverter)
-    {
-        this._clone = clone;
-        this._mangaConnectorJsonConverter = mangaConnectorJsonConverter;
-    }
-    
-    public override bool CanConvert(Type objectType)
-    {
-        return (objectType == typeof(Job));
-    }
-
-    public override object ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
-    {
-        JObject jo = JObject.Load(reader);
-
-        if (jo.ContainsKey("jobType") && jo["jobType"]!.Value<byte>() == (byte)Job.JobType.UpdateMetaDataJob)
-        {
-            return new UpdateMetadata(this._clone,
-                jo.GetValue("mangaConnector")!.ToObject<MangaConnector>(JsonSerializer.Create(new JsonSerializerSettings()
-                {
-                    Converters =
-                    {
-                        this._mangaConnectorJsonConverter
-                    }
-                }))!,
-                jo.GetValue("manga")!.ToObject<Manga>(),
-                jo.GetValue("parentJobId")!.Value<string?>());
-        }else if ((jo.ContainsKey("jobType") && jo["jobType"]!.Value<byte>() == (byte)Job.JobType.DownloadNewChaptersJob) || jo.ContainsKey("translatedLanguage"))//TODO change to jobType
-        {
-            DateTime lastExecution = jo.GetValue("lastExecution") is {} le 
-                ? le.ToObject<DateTime>()
-                : DateTime.UnixEpoch; //TODO do null checks on all variables
-            return new DownloadNewChapters(this._clone,
-                jo.GetValue("mangaConnector")!.ToObject<MangaConnector>(JsonSerializer.Create(new JsonSerializerSettings()
-                {
-                    Converters =
-                    {
-                        this._mangaConnectorJsonConverter
-                    }
-                }))!,
-                jo.GetValue("manga")!.ToObject<Manga>(),
-                lastExecution,
-                jo.GetValue("recurring")!.Value<bool>(),
-                jo.GetValue("recurrenceTime")!.ToObject<TimeSpan?>(),
-                jo.GetValue("parentJobId")!.Value<string?>());
-        }else if ((jo.ContainsKey("jobType") && jo["jobType"]!.Value<byte>() == (byte)Job.JobType.DownloadChapterJob) || jo.ContainsKey("chapter"))//TODO change to jobType
-        {
-            return new DownloadChapter(this._clone,
-                jo.GetValue("mangaConnector")!.ToObject<MangaConnector>(JsonSerializer.Create(new JsonSerializerSettings()
-                {
-                    Converters =
-                    {
-                        this._mangaConnectorJsonConverter
-                    }
-                }))!,
-                jo.GetValue("chapter")!.ToObject<Chapter>(),
-                DateTime.UnixEpoch,
-                jo.GetValue("parentJobId")!.Value<string?>());
-        }
-
-        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/Jobs/ProgressToken.cs

@@ -1,78 +0,0 @@
-namespace Tranga.Jobs;
-
-public class ProgressToken
-{
-    public bool cancellationRequested { get; set; }
-    public int increments { get; set; }
-    public int incrementsCompleted { get; set; }
-    public float progress => GetProgress();
-    public DateTime lastUpdate { get; private set; }
-    public DateTime executionStarted { get; private set; }
-    public TimeSpan timeRemaining => GetTimeRemaining();
-    
-    public enum State { Running, Complete, Standby, Cancelled, Waiting }
-    public State state { get; private set; }
-
-    public ProgressToken(int increments)
-    {
-        this.cancellationRequested = false;
-        this.increments = increments;
-        this.incrementsCompleted = 0;
-        this.state = State.Waiting;
-        this.executionStarted = DateTime.UnixEpoch;
-        this.lastUpdate = DateTime.UnixEpoch;
-    }
-
-    private float GetProgress()
-    {
-        if(increments > 0 && incrementsCompleted > 0)
-            return incrementsCompleted / (float)increments;
-        return 0;
-    }
-
-    private TimeSpan GetTimeRemaining()
-    {
-        if (increments > 0 && incrementsCompleted > 0)
-            return DateTime.Now.Subtract(this.executionStarted).Divide(incrementsCompleted).Multiply(increments - incrementsCompleted);
-        return TimeSpan.MaxValue;
-    }
-
-    public void Increment()
-    {
-        this.lastUpdate = DateTime.Now;
-        this.incrementsCompleted++;
-        if (incrementsCompleted > increments)
-            state = State.Complete;
-    }
-
-    public void Standby()
-    {
-        this.lastUpdate = DateTime.Now;
-        state = State.Standby;
-    }
-
-    public void Start()
-    {
-        this.lastUpdate = DateTime.Now;
-        state = State.Running;
-        this.executionStarted = DateTime.Now;
-    }
-
-    public void Complete()
-    {
-        this.lastUpdate = DateTime.Now;
-        state = State.Complete;
-    }
-
-    public void Cancel()
-    {
-        this.lastUpdate = DateTime.Now;
-        state = State.Cancelled;
-    }
-
-    public void Waiting()
-    {
-        this.lastUpdate = DateTime.Now;
-        state = State.Waiting;
-    }
-}

Tranga/Jobs/UpdateMetadata.cs

@@ -1,76 +0,0 @@
-using Tranga.MangaConnectors;
-
-namespace Tranga.Jobs;
-
-public class UpdateMetadata : Job
-{
-    public Manga manga { get; set; }
-    
-    public UpdateMetadata(GlobalBase clone, MangaConnector connector, Manga manga, string? parentJobId = null) : base(clone, JobType.UpdateMetaDataJob, connector, parentJobId: parentJobId)
-    {
-        this.manga = manga;
-    }
-    
-    protected override string GetId()
-    {
-        return $"{GetType()}-{manga.internalId}";
-    }
-
-    public override string ToString()
-    {
-        return $"{id} Manga: {manga}";
-    }
-
-    protected override IEnumerable<Job> ExecuteReturnSubTasksInternal(JobBoss jobBoss)
-    {
-        //Retrieve new Metadata
-        Manga? possibleUpdatedManga = mangaConnector.GetMangaFromId(manga.publicationId);
-        if (possibleUpdatedManga is { } updatedManga)
-        {
-            if (updatedManga.Equals(this.manga)) //Check if anything changed
-            {
-                this.progressToken.Complete();
-                return Array.Empty<Job>();
-            }
-            
-            this.manga = manga.WithMetadata(updatedManga);
-            this.manga.SaveSeriesInfoJson(true);
-            this.mangaConnector.CopyCoverFromCacheToDownloadLocation(manga);
-            foreach (Job job in jobBoss.GetJobsLike(publication: this.manga))
-            {
-                string oldFile;
-                if (job is DownloadNewChapters dc)
-                {
-                    oldFile = dc.id;
-                    dc.manga = this.manga;
-                }
-                else if (job is UpdateMetadata um)
-                {
-                    oldFile = um.id;
-                    um.manga = this.manga;
-                }
-                else 
-                    continue;
-                jobBoss.UpdateJobFile(job, oldFile);
-            }
-            this.progressToken.Complete();
-        }
-        else
-        {
-            Log($"Could not find Manga {manga}");
-            this.progressToken.Cancel();
-            return Array.Empty<Job>();
-        }
-        this.progressToken.Cancel();
-        return Array.Empty<Job>();
-    }
-
-    public override bool Equals(object? obj)
-    {
-        
-        if (obj is not UpdateMetadata otherJob)
-            return false;
-        return otherJob.mangaConnector == this.mangaConnector &&
-               otherJob.manga.publicationId == this.manga.publicationId;
-    }
-}