Metadata-Site Search (Interactive linking)

- Jikan (MAL) linking, fetching/updating

API/API.csproj

@@ -12,6 +12,7 @@
     <ItemGroup>
         <PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" Version="8.1.0" />
         <PackageReference Include="HtmlAgilityPack" Version="1.12.0" />
+        <PackageReference Include="JikanDotNet" Version="2.9.1" />
         <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" />

API/Controllers/JobController.cs

@@ -5,6 +5,7 @@ using API.Schema.Jobs;
 using Asp.Versioning;
 using log4net;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
 using static Microsoft.AspNetCore.Http.StatusCodes;
 // ReSharper disable InconsistentNaming
 
@@ -137,9 +138,10 @@ public class JobController(PgsqlContext context, ILog Log) : Controller
         Job updateFilesDownloaded =
             new UpdateChaptersDownloadedJob(m, record.recurrenceTimeMs, dependsOnJobs: [retrieveChapters]);
         Job downloadChapters = new DownloadAvailableChaptersJob(m, record.recurrenceTimeMs, dependsOnJobs: [retrieveChapters, updateFilesDownloaded]);
+        Job UpdateCover = new UpdateCoverJob(m, record.recurrenceTimeMs, downloadChapters);
         retrieveChapters.ParentJob = downloadChapters;
         updateFilesDownloaded.ParentJob = retrieveChapters;
-        return AddJobs([retrieveChapters, downloadChapters, updateFilesDownloaded]);
+        return AddJobs([retrieveChapters, downloadChapters, updateFilesDownloaded, UpdateCover]);
     }
 
     /// <summary>
@@ -325,6 +327,7 @@ public class JobController(PgsqlContext context, ILog Log) : Controller
     /// Starts the Job with the requested ID
     /// </summary>
     /// <param name="JobId">Job-ID</param>
+    /// <param name="startDependencies">Start Jobs necessary for execution</param>
     /// <response code="202">Job started</response>
     /// <response code="404">Job with ID not found</response>
     /// <response code="409">Job was already running</response>
@@ -334,16 +337,22 @@ public class JobController(PgsqlContext context, ILog Log) : Controller
     [ProducesResponseType(Status404NotFound)]
     [ProducesResponseType(Status409Conflict)]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
-    public IActionResult StartJob(string JobId)
+    public IActionResult StartJob(string JobId, [FromBody(EmptyBodyBehavior = EmptyBodyBehavior.Allow)]bool startDependencies = false)
     {
         Job? ret = context.Jobs.Find(JobId);
         if (ret is null)
             return NotFound();
+        List<Job> dependencies = startDependencies ? ret.GetDependenciesAndSelf() : [ret];
+        
         try
         {
-            if (ret.state >= JobState.Running && ret.state < JobState.Completed)
+            if(dependencies.Any(d => d.state >= JobState.Running && d.state < JobState.Completed))
                 return new ConflictResult();
-            ret.LastExecution = DateTime.UnixEpoch;
+            dependencies.ForEach(d =>
+            {
+                d.LastExecution = DateTime.UnixEpoch;
+                d.state = JobState.CompletedWaiting;
+            });
             context.SaveChanges();
             return Accepted();
         }
@@ -365,4 +374,25 @@ public class JobController(PgsqlContext context, ILog Log) : Controller
     {
         return StatusCode(Status501NotImplemented);
     }
+
+    /// <summary>
+    /// Removes failed and completed Jobs (that are not recurring)
+    /// </summary>
+    /// <response code="202">Job started</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("Cleanup")]
+    public IActionResult CleanupJobs()
+    {
+        try
+        {
+            context.Jobs.RemoveRange(context.Jobs.Where(j => j.state == JobState.Failed || j.state == JobState.Completed));
+            context.SaveChanges();
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
 }

API/Controllers/MangaConnectorController.cs

@@ -24,6 +24,31 @@ public class MangaConnectorController(PgsqlContext context, ILog Log) : Controll
         return Ok(connectors);
     }
 
+    /// <summary>
+    /// Returns the MangaConnector with the requested Name
+    /// </summary>
+    /// <param name="MangaConnectorName"></param>
+    /// <response code="200"></response>
+    /// <response code="404">Connector with ID not found.</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpGet("{MangaConnectorName}")]
+    [ProducesResponseType<MangaConnector>(Status200OK, "application/json")]
+    public IActionResult GetConnector(string MangaConnectorName)
+    {
+        try
+        {
+            if(context.MangaConnectors.Find(MangaConnectorName) is not { } connector)
+                return NotFound();
+
+            return Ok(connector);
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+    }
+    
     /// <summary>
     /// Get all enabled Connectors (Scanlation-Sites)
     /// </summary>

API/Controllers/MangaController.cs

@@ -4,6 +4,7 @@ using API.Schema.Jobs;
 using Asp.Versioning;
 using log4net;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Net.Http.Headers;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Processing;
@@ -139,7 +140,9 @@ public class MangaController(PgsqlContext context, ILog Log) : Controller
         
         using MemoryStream ms = new();
         image.Save(ms, new JpegEncoder(){Quality = 100});
-        return File(ms.GetBuffer(), "image/jpeg");
+        DateTime lastModified = new FileInfo(m.CoverFileNameInCache).LastWriteTime;
+        HttpContext.Response.Headers.CacheControl = "public";
+        return File(ms.GetBuffer(), "image/jpeg", new DateTimeOffset(lastModified), EntityTagHeaderValue.Parse($"\"{lastModified.Ticks}\""));
     }
 
     /// <summary>

API/Controllers/MetadataFetcherController.cs

@@ -0,0 +1,166 @@
+using API.Schema;
+using API.Schema.Contexts;
+using API.Schema.MetadataFetchers;
+using Asp.Versioning;
+using log4net;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+using static Microsoft.AspNetCore.Http.StatusCodes;
+// ReSharper disable InconsistentNaming
+
+namespace API.Controllers;
+
+[ApiVersion(2)]
+[ApiController]
+[Route("v{v:apiVersion}/[controller]")]
+public class MetadataFetcherController(PgsqlContext context, ILog Log) : Controller
+{
+    /// <summary>
+    /// Get all available Connectors (Metadata-Sites)
+    /// </summary>
+    /// <response code="200">Names of Metadata-Fetchers</response>
+    [HttpGet]
+    [ProducesResponseType<string[]>(Status200OK, "application/json")]
+    public IActionResult GetConnectors()
+    {
+        string[] connectors = Tranga.MetadataFetchers.Select(f => f.MetadataFetcherName).ToArray();
+        return Ok(connectors);
+    }
+
+    /// <summary>
+    /// Returns all Mangas which have a linked Metadata-Provider
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpGet("Links")]
+    [ProducesResponseType<MetadataEntry>(Status200OK, "application/json")]
+    public IActionResult GetLinkedEntries()
+    {
+        return Ok(context.MetadataEntries.ToArray());
+    }
+
+    /// <summary>
+    /// Searches Metadata-Provider for Manga-Metadata
+    /// </summary>
+    /// <param name="searchTerm">Instead of using the Manga for search, use a specific term</param>
+    /// <response code="200"></response>
+    /// <response code="400">Metadata-fetcher with Name does not exist</response>
+    /// <response code="404">Manga with ID not found</response>
+    [HttpPost("{MetadataFetcherName}/SearchManga/{MangaId}")]
+    [ProducesResponseType<MetadataSearchResult[]>(Status200OK, "application/json")]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult SearchMangaMetadata(string MangaId, string MetadataFetcherName, [FromBody(EmptyBodyBehavior = EmptyBodyBehavior.Allow)]string? searchTerm = null)
+    {
+        if(context.Mangas.Find(MangaId) is not { } manga)
+            return NotFound();
+        if(Tranga.MetadataFetchers.FirstOrDefault(f => f.MetadataFetcherName == MetadataFetcherName) is not { } fetcher)
+            return BadRequest();
+
+        MetadataSearchResult[] searchResults = searchTerm is null ? fetcher.SearchMetadataEntry(manga) : fetcher.SearchMetadataEntry(searchTerm);
+        return Ok(searchResults);
+    }
+
+    /// <summary>
+    /// Links Metadata-Provider using Provider-Specific Identifier to Manga
+    /// </summary>
+    /// <response code="200"></response>
+    /// <response code="400">Metadata-fetcher with Name does not exist</response>
+    /// <response code="404">Manga with ID not found</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("{MetadataFetcherName}/Link/{MangaId}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult LinkMangaMetadata(string MangaId, string MetadataFetcherName, [FromBody]string Identifier)
+    {
+        if(context.Mangas.Find(MangaId) is not { } manga)
+            return NotFound();
+        if(Tranga.MetadataFetchers.FirstOrDefault(f => f.MetadataFetcherName == MetadataFetcherName) is not { } fetcher)
+            return BadRequest();
+        MetadataEntry entry = fetcher.CreateMetadataEntry(manga, Identifier);
+        
+        try
+        {
+            context.MetadataEntries.Add(entry);
+            context.SaveChanges();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+        return Ok();
+    }
+
+    /// <summary>
+    /// Un-Links Metadata-Provider using Provider-Specific Identifier to Manga
+    /// </summary>
+    /// <response code="200"></response>
+    /// <response code="400">Metadata-fetcher with Name does not exist</response>
+    /// <response code="404">Manga with ID not found</response>
+    /// <response code="412">No Entry linking Manga and Metadata-Provider found</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("{MetadataFetcherName}/Unlink/{MangaId}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status412PreconditionFailed, "text/plain")]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult UnlinkMangaMetadata(string MangaId, string MetadataFetcherName)
+    {
+        if(context.Mangas.Find(MangaId) is not { } manga)
+            return NotFound();
+        if(Tranga.MetadataFetchers.FirstOrDefault(f => f.MetadataFetcherName == MetadataFetcherName) is not { } fetcher)
+            return BadRequest();
+        MetadataEntry? entry = context.MetadataEntries.FirstOrDefault(e => e.MangaId == MangaId && e.MetadataFetcherName == MetadataFetcherName);
+        if (entry is null)
+            return StatusCode(Status412PreconditionFailed, "No entry found");
+        try
+        {
+            context.MetadataEntries.Remove(entry);
+            context.SaveChanges();
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+        return Ok();
+    }
+
+    /// <summary>
+    /// Tries linking a Manga to a Metadata-Provider-Site
+    /// </summary>
+    /// <response code="200"></response>
+    /// <response code="400">MetadataFetcher Name is invalid</response>
+    /// <response code="404">Manga has no linked entry with MetadataFetcher</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("{MetadataFetcherName}/{MangaId}/UpdateMetadata")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult UpdateMetadata(string MangaId, string MetadataFetcherName)
+    {
+        if(Tranga.MetadataFetchers
+               .FirstOrDefault(f =>
+                   f.MetadataFetcherName.Equals(MetadataFetcherName, StringComparison.InvariantCultureIgnoreCase)) is not { } fetcher)
+            return BadRequest();
+        MetadataEntry? entry = context.MetadataEntries
+            .FirstOrDefault(e =>
+                e.MangaId == MangaId && e.MetadataFetcherName.Equals(MetadataFetcherName, StringComparison.InvariantCultureIgnoreCase));
+        if (entry is null)
+            return NotFound();
+        try
+        {
+            fetcher.UpdateMetadata(entry, context);
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e.Message);
+        }
+        return Ok();
+    }
+}

API/Controllers/SearchController.cs

@@ -6,6 +6,7 @@ using Asp.Versioning;
 using log4net;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
+using Soenneker.Utils.String.NeedlemanWunsch;
 using static Microsoft.AspNetCore.Http.StatusCodes;
 // ReSharper disable InconsistentNaming
 
@@ -56,18 +57,32 @@ public class SearchController(PgsqlContext context, ILog Log) : Controller
         return Ok(retMangas.ToArray());
     }
     
+    /// <summary>
+    /// Search for a known Manga
+    /// </summary>
+    /// <param name="Query"></param>
+    /// <response code="200"></response>
+    [HttpGet("Local/{Query}")]
+    [ProducesResponseType<Manga[]>(Status200OK, "application/json")]
+    public IActionResult SearchMangaLocally(string Query)
+    {
+        Dictionary<Manga, double> distance = context.Mangas
+            .ToArray()
+            .ToDictionary(m => m, m => NeedlemanWunschStringUtil.CalculateSimilarityPercentage(Query, m.Name));
+        return Ok(distance.Where(kv => kv.Value > 50).OrderByDescending(kv => kv.Value).Select(kv => kv.Key).ToArray());
+    }
+
     /// <summary>
     /// Returns Manga from MangaConnector associated with URL
     /// </summary>
     /// <param name="url">Manga-Page URL</param>
     /// <response code="200"></response>
     /// <response code="300">Multiple connectors found for URL</response>
-    /// <response code="400">No Manga at URL</response>
-    /// <response code="404">No connector found for URL</response>
+    /// <response code="404">Manga not found</response>
     /// <response code="500">Error during Database Operation</response>
     [HttpPost("Url")]
     [ProducesResponseType<Manga>(Status200OK, "application/json")]
-    [ProducesResponseType(Status400BadRequest)]
+    [ProducesResponseType(Status404NotFound)]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
     public IActionResult GetMangaFromUrl([FromBody]string url)
     {
@@ -75,7 +90,7 @@ public class SearchController(PgsqlContext context, ILog Log) : Controller
             return StatusCode(Status500InternalServerError, "Could not find Global Connector.");
 
         if(connector.GetMangaFromUrl(url) is not { } manga)
-            return BadRequest();
+            return NotFound();
         try
         {
             if(AddMangaToContext(manga) is { } add)

API/Controllers/SettingsController.cs

@@ -1,10 +1,12 @@
-using API.MangaDownloadClients;
+using System.Net.Http.Headers;
+using API.MangaDownloadClients;
 using API.Schema;
 using API.Schema.Contexts;
 using API.Schema.Jobs;
 using Asp.Versioning;
 using log4net;
 using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using static Microsoft.AspNetCore.Http.StatusCodes;
 
@@ -267,4 +269,69 @@ public class SettingsController(PgsqlContext context, ILog Log) : Controller
             return StatusCode(500, e);
         }
     }
+
+    /// <summary>
+    /// Creates a UpdateCoverJob for all Manga
+    /// </summary>
+    /// <response code="200">Array of JobIds</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPost("CleanupCovers")]
+    [ProducesResponseType<string[]>(Status200OK)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CleanupCovers()
+    {
+        try
+        {
+            Tranga.RemoveStaleFiles(context);
+            List<UpdateCoverJob> newJobs = context.Mangas.ToList().Select(m => new UpdateCoverJob(m, 0)).ToList();
+            context.Jobs.AddRange(newJobs);
+            return Ok(newJobs.Select(j => j.JobId));
+        }
+        catch (Exception e)
+        {
+            Log.Error(e);
+            return StatusCode(500, e);
+        }
+    }
+
+    /// <summary>
+    /// Sets the FlareSolverr-URL
+    /// </summary>
+    /// <param name="flareSolverrUrl">URL of FlareSolverr-Instance</param>
+    /// <response code="200"></response>
+    [HttpPost("FlareSolverr/Url")]
+    [ProducesResponseType(Status200OK)]
+    public IActionResult SetFlareSolverrUrl([FromBody]string flareSolverrUrl)
+    {
+        TrangaSettings.UpdateFlareSolverrUrl(flareSolverrUrl);
+        return Ok();
+    }
+
+    /// <summary>
+    /// Resets the FlareSolverr-URL (HttpClient does not use FlareSolverr anymore)
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpDelete("FlareSolverr/Url")]
+    [ProducesResponseType(Status200OK)]
+    public IActionResult ClearFlareSolverrUrl()
+    {
+        TrangaSettings.UpdateFlareSolverrUrl(string.Empty);
+        return Ok();
+    }
+
+    /// <summary>
+    /// Test FlareSolverr
+    /// </summary>
+    /// <response code="200">FlareSolverr is working!</response>
+    /// <response code="500">FlareSolverr is not working</response>
+    [HttpPost("FlareSolverr/Test")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status500InternalServerError)]
+    public IActionResult TestFlareSolverrReachable()
+    {
+        const string knownProtectedUrl = "https://prowlarr.servarr.com/v1/ping";
+        FlareSolverrDownloadClient client = new();
+        RequestResult result = client.MakeRequestInternal(knownProtectedUrl);
+        return (int)result.statusCode >= 200 && (int)result.statusCode < 300 ? Ok() : StatusCode(500, result.statusCode); 
+    }
 }

API/MangaDownloadClients/DownloadClient.cs

@@ -3,7 +3,7 @@ using log4net;
 
 namespace API.MangaDownloadClients;
 
-internal abstract class DownloadClient
+public abstract class DownloadClient
 {
     private static readonly Dictionary<RequestType, DateTime> LastExecutedRateLimit = new();
     protected ILog Log { get; init; }

API/MangaDownloadClients/FlareSolverrDownloadClient.cs

@@ -0,0 +1,180 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using HtmlAgilityPack;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace API.MangaDownloadClients;
+
+public class FlareSolverrDownloadClient : DownloadClient
+{
+    
+    
+    internal override RequestResult MakeRequestInternal(string url, string? referrer = null, string? clickButton = null)
+    {
+        if (clickButton is not null)
+            Log.Warn("Client can not click button");
+        if(referrer is not null)
+            Log.Warn("Client can not set referrer");
+        if (TrangaSettings.flareSolverrUrl == string.Empty)
+        {
+            Log.Error("FlareSolverr URL is empty");
+            return new(HttpStatusCode.InternalServerError, null, Stream.Null);
+        }
+        
+        Uri flareSolverrUri = new (TrangaSettings.flareSolverrUrl);
+        if (flareSolverrUri.Segments.Last() != "v1")
+            flareSolverrUri = new UriBuilder(flareSolverrUri)
+            {
+                Path = "v1"
+            }.Uri;
+        
+        HttpClient client = new()
+        {
+            Timeout = TimeSpan.FromSeconds(10),
+            DefaultVersionPolicy = HttpVersionPolicy.RequestVersionOrHigher,
+            DefaultRequestHeaders = { { "User-Agent", TrangaSettings.userAgent } }
+        };
+
+        JObject requestObj = new()
+        {
+            ["cmd"] = "request.get",
+            ["url"] = url
+        };
+
+        HttpRequestMessage requestMessage = new(HttpMethod.Post, flareSolverrUri)
+        {
+            Content = new StringContent(JsonConvert.SerializeObject(requestObj)),
+        };
+        requestMessage.Content.Headers.ContentType = new ("application/json");
+        Log.Debug($"Requesting {url}");
+        
+        HttpResponseMessage? response;
+        try
+        {
+            response = client.Send(requestMessage);
+        }
+        catch (HttpRequestException e)
+        {
+            Log.Error(e);
+            return new (HttpStatusCode.Unused, null, Stream.Null);
+        }
+
+        if (!response.IsSuccessStatusCode)
+        {
+            Log.Debug($"Request returned status code {(int)response.StatusCode} {response.StatusCode}:\n" +
+                      $"=====\n" +
+                      $"Request:\n" +
+                      $"{requestMessage.Method} {requestMessage.RequestUri}\n" +
+                      $"{requestMessage.Version} {requestMessage.VersionPolicy}\n" +
+                      $"Headers:\n\t{string.Join("\n\t", requestMessage.Headers.Select(h => $"{h.Key}: <{string.Join(">, <", h.Value)}"))}>\n" +
+                      $"{requestMessage.Content?.ReadAsStringAsync().Result}" +
+                      $"=====\n" +
+                      $"Response:\n" +
+                      $"{response.Version}\n" +
+                      $"Headers:\n\t{string.Join("\n\t", response.Headers.Select(h => $"{h.Key}: <{string.Join(">, <", h.Value)}"))}>\n" +
+                      $"{response.Content.ReadAsStringAsync().Result}");
+            return new (response.StatusCode,  null, Stream.Null);
+        }
+
+        string responseString = response.Content.ReadAsStringAsync().Result;
+        JObject responseObj = JObject.Parse(responseString);
+        if (!IsInCorrectFormat(responseObj, out string? reason))
+        {
+            Log.Error($"Wrong format: {reason}");
+            return new(HttpStatusCode.Unused, null, Stream.Null);
+        }
+
+        string statusResponse = responseObj["status"]!.Value<string>()!;
+        if (statusResponse != "ok")
+        {
+            Log.Debug($"Status is not ok: {statusResponse}");
+            return new(HttpStatusCode.Unused, null, Stream.Null);
+        }
+        JObject solution = (responseObj["solution"] as JObject)!;
+
+        if (!Enum.TryParse(solution["status"]!.Value<int>().ToString(), out HttpStatusCode statusCode))
+        {
+            Log.Error($"Wrong format: Cant parse status code: {solution["status"]!.Value<int>()}");
+            return new(HttpStatusCode.Unused, null, Stream.Null);
+        }
+        if (statusCode < HttpStatusCode.OK || statusCode >= HttpStatusCode.MultipleChoices)
+        {
+            Log.Debug($"Status is: {statusCode}");
+            return new(statusCode, null, Stream.Null);
+        }
+
+        if (solution["response"]!.Value<string>() is not { } htmlString)
+        {
+            Log.Error("Wrong format: Cant find response in solution");
+            return new(HttpStatusCode.Unused, null, Stream.Null);
+        }
+
+        if (IsJson(htmlString, out HtmlDocument document, out string? json))
+        {
+            MemoryStream ms = new();
+            ms.Write(Encoding.UTF8.GetBytes(json));
+            ms.Position = 0;
+            return new(statusCode, document, ms);
+        }
+        else
+        {
+            MemoryStream ms = new();
+            ms.Write(Encoding.UTF8.GetBytes(htmlString));
+            ms.Position = 0;
+            return new(statusCode, document, ms);
+        }
+    }
+
+    private bool IsInCorrectFormat(JObject responseObj, [NotNullWhen(false)]out string? reason)
+    {
+        reason = null;
+        if (!responseObj.ContainsKey("status"))
+        {
+            reason = "Cant find status on response";
+            return false;
+        }
+
+        if (responseObj["solution"] is not JObject solution)
+        {
+            reason = "Cant find solution";
+            return false;
+        }
+
+        if (!solution.ContainsKey("status"))
+        {
+            reason = "Wrong format: Cant find status in solution";
+            return false;
+        }
+
+        if (!solution.ContainsKey("response"))
+        {
+
+            reason = "Wrong format: Cant find response in solution";
+            return false;
+        }
+
+        return true;
+    }
+
+    private bool IsJson(string htmlString, out HtmlDocument document, [NotNullWhen(true)]out string? jsonString)
+    {
+        jsonString = null;
+        document = new();
+        document.LoadHtml(htmlString);
+
+        HtmlNode pre = document.DocumentNode.SelectSingleNode("//pre");
+        try
+        {
+            using JsonDocument _ = JsonDocument.Parse(pre.InnerText);
+            jsonString = pre.InnerText;
+            return true;
+        }
+        catch (JsonReaderException)
+        {
+            return false;
+        }
+    }
+}

API/MangaDownloadClients/HttpDownloadClient.cs

@@ -5,46 +5,54 @@ namespace API.MangaDownloadClients;
 
 internal class HttpDownloadClient : DownloadClient
 {
-    private static readonly HttpClient Client = new()
-    {
-        Timeout = TimeSpan.FromSeconds(10)
-    };
-
-    public HttpDownloadClient()
-    {
-        Client.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", TrangaSettings.userAgent);
-    }
-    
     internal override RequestResult MakeRequestInternal(string url, string? referrer = null, string? clickButton = null)
     {
         if (clickButton is not null)
-            Log.Warn("Can not click button on static site.");
-        HttpResponseMessage? response = null;
-        while (response is null)
-        {
-            HttpRequestMessage requestMessage = new(HttpMethod.Get, url);
+            Log.Warn("Client can not click button");
+        HttpClient client = new();
+        client.Timeout = TimeSpan.FromSeconds(10);
+        client.DefaultVersionPolicy = HttpVersionPolicy.RequestVersionOrHigher;
+        client.DefaultRequestHeaders.Add("User-Agent", TrangaSettings.userAgent);
+        HttpResponseMessage? response;
+        Uri uri = new(url);
+        HttpRequestMessage requestMessage = new(HttpMethod.Get, uri);
         if (referrer is not null)
-                requestMessage.Headers.Referrer = new Uri(referrer);
+            requestMessage.Headers.Referrer = new (referrer);
         Log.Debug($"Requesting {url}");
         try
         {
-                response = Client.Send(requestMessage);
+            response = client.Send(requestMessage);
         }
-            catch (Exception e)
+        catch (HttpRequestException e)
         {
-                switch (e)
-                {
-                    case TaskCanceledException:
-                        return new RequestResult(HttpStatusCode.RequestTimeout, null, Stream.Null);
-                    case HttpRequestException:
-                        return new RequestResult(HttpStatusCode.BadRequest, null, Stream.Null);
-                }
-            }
+            Log.Error(e);
+            return new (HttpStatusCode.Unused, null, Stream.Null);
         }
 
         if (!response.IsSuccessStatusCode)
         {
-            return new RequestResult(response.StatusCode,  null, Stream.Null);
+            Log.Debug($"Request returned status code {(int)response.StatusCode} {response.StatusCode}");
+            if (response.Headers.Server.Any(s =>
+                    (s.Product?.Name ?? "").Contains("cloudflare", StringComparison.InvariantCultureIgnoreCase)))
+            {
+                Log.Debug("Retrying with FlareSolverr!");
+                return new FlareSolverrDownloadClient().MakeRequestInternal(url, referrer, clickButton);
+            }
+            else
+            {
+                Log.Debug($"Request returned status code {(int)response.StatusCode} {response.StatusCode}:\n" +
+                          $"=====\n" +
+                          $"Request:\n" +
+                          $"{requestMessage.Method} {requestMessage.RequestUri}\n" +
+                          $"{requestMessage.Version} {requestMessage.VersionPolicy}\n" +
+                          $"Headers:\n\t{string.Join("\n\t", requestMessage.Headers.Select(h => $"{h.Key}: <{string.Join(">, <", h.Value)}"))}>\n" +
+                          $"{requestMessage.Content?.ReadAsStringAsync().Result}" +
+                          $"=====\n" +
+                          $"Response:\n" +
+                          $"{response.Version}\n" +
+                          $"Headers:\n\t{string.Join("\n\t", response.Headers.Select(h => $"{h.Key}: <{string.Join(">, <", h.Value)}"))}>\n" +
+                          $"{response.Content.ReadAsStringAsync().Result}");
+            }
         }
 
         Stream stream;
@@ -55,7 +63,7 @@ internal class HttpDownloadClient : DownloadClient
         catch (Exception e)
         {
             Log.Error(e);
-            return new RequestResult(HttpStatusCode.InternalServerError, null, Stream.Null);
+            return new (HttpStatusCode.Unused, null, Stream.Null);
         }
 
         HtmlDocument? document = null;
@@ -69,12 +77,11 @@ internal class HttpDownloadClient : DownloadClient
         }
 
         // Request has been redirected to another page. For example, it redirects directly to the results when there is only 1 result
-        if (response.RequestMessage is not null && response.RequestMessage.RequestUri is not null)
+        if (response.RequestMessage is not null && response.RequestMessage.RequestUri is not null && response.RequestMessage.RequestUri != uri)
         {
-            return new RequestResult(response.StatusCode, document, stream, true,
-                response.RequestMessage.RequestUri.AbsoluteUri);
+            return new (response.StatusCode, document, stream, true, response.RequestMessage.RequestUri.AbsoluteUri);
         }
 
-        return new RequestResult(response.StatusCode, document, stream);
+        return new (response.StatusCode, document, stream);
     }
 }

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

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

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

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

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

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

API/Migrations/pgsql/20250518161710_UpdateCoverJob.cs

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

API/Migrations/pgsql/20250518183729_Remove-UpdateSingleChapterDownloaded-Job.Designer.cs

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

API/Migrations/pgsql/20250518183729_Remove-UpdateSingleChapterDownloaded-Job.cs

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

API/Migrations/pgsql/20250628204956_AddMAL.Designer.cs

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

API/Migrations/pgsql/20250628204956_AddMAL.cs

@@ -0,0 +1,66 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    /// <inheritdoc />
+    public partial class AddMAL : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "MetadataFetcher",
+                columns: table => new
+                {
+                    MetadataFetcherName = table.Column<string>(type: "text", nullable: false),
+                    MetadataEntry = table.Column<string>(type: "character varying(21)", maxLength: 21, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MetadataFetcher", x => x.MetadataFetcherName);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "MetadataEntries",
+                columns: table => new
+                {
+                    MangaId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    MetadataFetcherName = table.Column<string>(type: "text", nullable: false),
+                    Identifier = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MetadataEntries", x => new { x.MangaId, x.MetadataFetcherName });
+                    table.ForeignKey(
+                        name: "FK_MetadataEntries_Mangas_MangaId",
+                        column: x => x.MangaId,
+                        principalTable: "Mangas",
+                        principalColumn: "MangaId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_MetadataEntries_MetadataFetcher_MetadataFetcherName",
+                        column: x => x.MetadataFetcherName,
+                        principalTable: "MetadataFetcher",
+                        principalColumn: "MetadataFetcherName",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MetadataEntries_MetadataFetcherName",
+                table: "MetadataEntries",
+                column: "MetadataFetcherName");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "MetadataEntries");
+
+            migrationBuilder.DropTable(
+                name: "MetadataFetcher");
+        }
+    }
+}

API/Migrations/pgsql/20250629184056_MetadataEntry-PrimaryKeyChange.Designer.cs

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

API/Migrations/pgsql/20250629184056_MetadataEntry-PrimaryKeyChange.cs

@@ -0,0 +1,54 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations.pgsql
+{
+    /// <inheritdoc />
+    public partial class MetadataEntryPrimaryKeyChange : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_MetadataEntries",
+                table: "MetadataEntries");
+
+            migrationBuilder.DropIndex(
+                name: "IX_MetadataEntries_MetadataFetcherName",
+                table: "MetadataEntries");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_MetadataEntries",
+                table: "MetadataEntries",
+                columns: new[] { "MetadataFetcherName", "Identifier" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MetadataEntries_MangaId",
+                table: "MetadataEntries",
+                column: "MangaId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_MetadataEntries",
+                table: "MetadataEntries");
+
+            migrationBuilder.DropIndex(
+                name: "IX_MetadataEntries_MangaId",
+                table: "MetadataEntries");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_MetadataEntries",
+                table: "MetadataEntries",
+                columns: new[] { "MangaId", "MetadataFetcherName" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MetadataEntries_MetadataFetcherName",
+                table: "MetadataEntries",
+                column: "MetadataFetcherName");
+        }
+    }
+}

API/Migrations/pgsql/PgsqlContextModelSnapshot.cs

@@ -17,7 +17,7 @@ namespace API.Migrations.pgsql
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("ProductVersion", "9.0.5")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
@@ -57,6 +57,10 @@ namespace API.Migrations.pgsql
                         .HasMaxLength(256)
                         .HasColumnType("character varying(256)");
 
+                    b.Property<string>("IdOnConnectorSite")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
                     b.Property<string>("ParentMangaId")
                         .IsRequired()
                         .HasColumnType("character varying(64)");
@@ -251,6 +255,44 @@ namespace API.Migrations.pgsql
                     b.ToTable("Tags");
                 });
 
+            modelBuilder.Entity("API.Schema.MetadataFetchers.MetadataEntry", b =>
+                {
+                    b.Property<string>("MetadataFetcherName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Identifier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MetadataFetcherName", "Identifier");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("MetadataEntries");
+                });
+
+            modelBuilder.Entity("API.Schema.MetadataFetchers.MetadataFetcher", b =>
+                {
+                    b.Property<string>("MetadataFetcherName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MetadataEntry")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("character varying(21)");
+
+                    b.HasKey("MetadataFetcherName");
+
+                    b.ToTable("MetadataFetcher");
+
+                    b.HasDiscriminator<string>("MetadataEntry").HasValue("MetadataFetcher");
+
+                    b.UseTphMappingStrategy();
+                });
+
             modelBuilder.Entity("AuthorToManga", b =>
                 {
                     b.Property<string>("AuthorIds")
@@ -433,24 +475,24 @@ namespace API.Migrations.pgsql
                     b.HasDiscriminator().HasValue((byte)6);
                 });
 
-            modelBuilder.Entity("API.Schema.Jobs.UpdateSingleChapterDownloadedJob", b =>
+            modelBuilder.Entity("API.Schema.Jobs.UpdateCoverJob", b =>
                 {
                     b.HasBaseType("API.Schema.Jobs.Job");
 
-                    b.Property<string>("ChapterId")
+                    b.Property<string>("MangaId")
                         .IsRequired()
                         .HasMaxLength(64)
                         .HasColumnType("character varying(64)");
 
-                    b.HasIndex("ChapterId");
+                    b.HasIndex("MangaId");
 
                     b.ToTable("Jobs", t =>
                         {
-                            t.Property("ChapterId")
-                                .HasColumnName("UpdateSingleChapterDownloadedJob_ChapterId");
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateCoverJob_MangaId");
                         });
 
-                    b.HasDiscriminator().HasValue((byte)8);
+                    b.HasDiscriminator().HasValue((byte)9);
                 });
 
             modelBuilder.Entity("API.Schema.MangaConnectors.ComickIo", b =>
@@ -474,6 +516,13 @@ namespace API.Migrations.pgsql
                     b.HasDiscriminator().HasValue("MangaDex");
                 });
 
+            modelBuilder.Entity("API.Schema.MetadataFetchers.MyAnimeList", b =>
+                {
+                    b.HasBaseType("API.Schema.MetadataFetchers.MetadataFetcher");
+
+                    b.HasDiscriminator().HasValue("MyAnimeList");
+                });
+
             modelBuilder.Entity("API.Schema.Chapter", b =>
                 {
                     b.HasOne("API.Schema.Manga", "ParentManga")
@@ -577,6 +626,25 @@ namespace API.Migrations.pgsql
                     b.Navigation("MangaConnector");
                 });
 
+            modelBuilder.Entity("API.Schema.MetadataFetchers.MetadataEntry", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MetadataFetchers.MetadataFetcher", "MetadataFetcher")
+                        .WithMany()
+                        .HasForeignKey("MetadataFetcherName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+
+                    b.Navigation("MetadataFetcher");
+                });
+
             modelBuilder.Entity("AuthorToManga", b =>
                 {
                     b.HasOne("API.Schema.Author", null)
@@ -696,15 +764,15 @@ namespace API.Migrations.pgsql
                     b.Navigation("Manga");
                 });
 
-            modelBuilder.Entity("API.Schema.Jobs.UpdateSingleChapterDownloadedJob", b =>
+            modelBuilder.Entity("API.Schema.Jobs.UpdateCoverJob", b =>
                 {
-                    b.HasOne("API.Schema.Chapter", "Chapter")
+                    b.HasOne("API.Schema.Manga", "Manga")
                         .WithMany()
-                        .HasForeignKey("ChapterId")
+                        .HasForeignKey("MangaId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
-                    b.Navigation("Chapter");
+                    b.Navigation("Manga");
                 });
 
             modelBuilder.Entity("API.Schema.Manga", b =>

API/Program.cs

@@ -124,7 +124,7 @@ using (IServiceScope scope = app.Services.CreateScope())
     context.Jobs.AddRange(context.Jobs.Where(j => j.JobType == JobType.DownloadAvailableChaptersJob)
         .Include(downloadAvailableChaptersJob => ((DownloadAvailableChaptersJob)downloadAvailableChaptersJob).Manga)
         .ToList()
-        .Select(dacj => new UpdateChaptersDownloadedJob(((DownloadAvailableChaptersJob)dacj).Manga, 0)));
+        .Select(dacj => new UpdateChaptersDownloadedJob(((DownloadAvailableChaptersJob)dacj).Manga, 0, dacj)));
     context.Jobs.RemoveRange(context.Jobs.Where(j => j.state == JobState.Completed && j.RecurrenceMs < 1));
     foreach (Job job in context.Jobs.Where(j => j.state == JobState.Running))
     {
@@ -149,6 +149,12 @@ using (IServiceScope scope = app.Services.CreateScope())
 
 TrangaSettings.Load();
 Tranga.StartLogger();
+
+using (IServiceScope scope = app.Services.CreateScope())
+{
+    PgsqlContext context = scope.ServiceProvider.GetRequiredService<PgsqlContext>();
+    Tranga.RemoveStaleFiles(context);
+}
 Tranga.JobStarterThread.Start(app.Services);
 //Tranga.NotificationSenderThread.Start(app.Services); //TODO RE-ENABLE
 

API/Schema/Chapter.cs

@@ -13,6 +13,7 @@ public class Chapter : IComparable<Chapter>
 {
     [StringLength(64)] [Required] public string ChapterId { get; init; }
 
+    [StringLength(256)]public string? IdOnConnectorSite { get; init; }
     public string ParentMangaId { get; init; }
     [JsonIgnore] public Manga ParentManga { get; init; } = null!;
 
@@ -28,9 +29,10 @@ public class Chapter : IComparable<Chapter>
     [Required] public bool Downloaded { get; internal set; }
     [NotMapped] public string FullArchiveFilePath => Path.Join(ParentManga.FullDirectoryPath, FileName);
 
-    public Chapter(Manga parentManga, string url, string chapterNumber, int? volumeNumber = null, string? title = null)
+    public Chapter(Manga parentManga, string url, string chapterNumber, int? volumeNumber = null, string? idOnConnectorSite = null, string? title = null)
     {
         this.ChapterId = TokenGen.CreateToken(typeof(Chapter), parentManga.MangaId, chapterNumber);
+        this.IdOnConnectorSite = idOnConnectorSite;
         this.ParentMangaId = parentManga.MangaId;
         this.ParentManga = parentManga;
         this.VolumeNumber = volumeNumber;
@@ -44,9 +46,10 @@ public class Chapter : IComparable<Chapter>
     /// <summary>
     /// EF ONLY!!!
     /// </summary>
-    internal Chapter(string chapterId, string parentMangaId, int? volumeNumber, string chapterNumber, string url, string? title, string fileName, bool downloaded)
+    internal Chapter(string chapterId, string parentMangaId, int? volumeNumber, string chapterNumber, string url, string? idOnConnectorSite, string? title, string fileName, bool downloaded)
     {
         this.ChapterId = chapterId;
+        this.IdOnConnectorSite = idOnConnectorSite;
         this.ParentMangaId = parentMangaId;
         this.VolumeNumber = volumeNumber;
         this.ChapterNumber = chapterNumber;
@@ -172,13 +175,20 @@ public class Chapter : IComparable<Chapter>
     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)
         );
+        if(Title is not null)
+            comicInfo.Add(new XElement("Title", Title));
+        if(ParentManga.MangaTags.Count > 0)
+            comicInfo.Add(new XElement("Tags", string.Join(',', ParentManga.MangaTags.Select(tag => tag.Tag))));
+        if(VolumeNumber is not null)
+            comicInfo.Add(new XElement("Volume", VolumeNumber));
+        if(ParentManga.Authors.Count > 0)
+            comicInfo.Add(new XElement("Writer", string.Join(',', ParentManga.Authors.Select(author => author.AuthorName))));
+        if(ParentManga.OriginalLanguage is not null)
+            comicInfo.Add(new XElement("LanguageISO", ParentManga.OriginalLanguage));
+        if(ParentManga.Description != string.Empty)
+            comicInfo.Add(new XElement("Summary", ParentManga.Description));
         return comicInfo.ToString();
     }
 

API/Schema/Contexts/PgsqlContext.cs

@@ -1,5 +1,6 @@
 using API.Schema.Jobs;
 using API.Schema.MangaConnectors;
+using API.Schema.MetadataFetchers;
 using log4net;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Diagnostics;
@@ -15,6 +16,7 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
     public DbSet<Chapter> Chapters { get; set; }
     public DbSet<Author> Authors { get; set; }
     public DbSet<MangaTag> Tags { get; set; }
+    public DbSet<MetadataEntry> MetadataEntries { get; set; }
     private ILog Log => LogManager.GetLogger(GetType());
     
     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
@@ -38,15 +40,14 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .HasValue<DownloadSingleChapterJob>(JobType.DownloadSingleChapterJob)
             .HasValue<DownloadMangaCoverJob>(JobType.DownloadMangaCoverJob)
             .HasValue<RetrieveChaptersJob>(JobType.RetrieveChaptersJob)
-            .HasValue<UpdateChaptersDownloadedJob>(JobType.UpdateChaptersDownloadedJob)
-            .HasValue<UpdateSingleChapterDownloadedJob>(JobType.UpdateSingleChapterDownloadedJob);
+            .HasValue<UpdateCoverJob>(JobType.UpdateCoverJob)
+            .HasValue<UpdateChaptersDownloadedJob>(JobType.UpdateChaptersDownloadedJob);
         
         //Job specification
         modelBuilder.Entity<DownloadAvailableChaptersJob>()
             .HasOne<Manga>(j => j.Manga)
             .WithMany()
             .HasForeignKey(j => j.MangaId)
-            .IsRequired()
             .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<DownloadAvailableChaptersJob>()
             .Navigation(j => j.Manga)
@@ -55,7 +56,6 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .HasOne<Manga>(j => j.Manga)
             .WithMany()
             .HasForeignKey(j => j.MangaId)
-            .IsRequired()
             .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<DownloadMangaCoverJob>()
             .Navigation(j => j.Manga)
@@ -64,7 +64,6 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .HasOne<Chapter>(j => j.Chapter)
             .WithMany()
             .HasForeignKey(j => j.ChapterId)
-            .IsRequired()
             .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<DownloadSingleChapterJob>()
             .Navigation(j => j.Chapter)
@@ -73,7 +72,6 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .HasOne<Manga>(j => j.Manga)
             .WithMany()
             .HasForeignKey(j => j.MangaId)
-            .IsRequired()
             .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<MoveMangaLibraryJob>()
             .Navigation(j => j.Manga)
@@ -82,7 +80,6 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .HasOne<LocalLibrary>(j => j.ToLibrary)
             .WithMany()
             .HasForeignKey(j => j.ToLibraryId)
-            .IsRequired()
             .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<MoveMangaLibraryJob>()
             .Navigation(j => j.ToLibrary)
@@ -91,7 +88,6 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .HasOne<Manga>(j => j.Manga)
             .WithMany()
             .HasForeignKey(j => j.MangaId)
-            .IsRequired()
             .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<RetrieveChaptersJob>()
             .Navigation(j => j.Manga)
@@ -100,7 +96,6 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .HasOne<Manga>(j => j.Manga)
             .WithMany()
             .HasForeignKey(j => j.MangaId)
-            .IsRequired()
             .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<UpdateChaptersDownloadedJob>()
             .Navigation(j => j.Manga)
@@ -132,7 +127,6 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .HasMany<Manga>()
             .WithOne(m => m.MangaConnector)
             .HasForeignKey(m => m.MangaConnectorName)
-            .IsRequired()
             .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<Manga>()
             .Navigation(m => m.MangaConnector)
@@ -143,7 +137,6 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .HasMany<Chapter>(m => m.Chapters)
             .WithOne(c => c.ParentManga)
             .HasForeignKey(c => c.ParentMangaId)
-            .IsRequired()
             .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<Chapter>()
             .Navigation(c => c.ParentManga)
@@ -200,5 +193,18 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
         modelBuilder.Entity<Manga>()
             .Navigation(m => m.Library)
             .AutoInclude();
+        
+        modelBuilder.Entity<MetadataFetcher>()
+            .HasDiscriminator<string>(nameof(MetadataEntry))
+            .HasValue<MyAnimeList>(nameof(MyAnimeList));
+        //MetadataEntry
+        modelBuilder.Entity<MetadataEntry>()
+            .HasOne<Manga>(entry => entry.Manga)
+            .WithMany()
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<MetadataEntry>()
+            .HasOne<MetadataFetcher>(entry => entry.MetadataFetcher)
+            .WithMany()
+            .OnDelete(DeleteBehavior.Cascade);
     }
 }

API/Schema/Jobs/DownloadAvailableChaptersJob.cs

@@ -28,14 +28,15 @@ public class DownloadAvailableChaptersJob : Job
     /// <summary>
     /// EF ONLY!!!
     /// </summary>
-    internal DownloadAvailableChaptersJob(ILazyLoader lazyLoader, string mangaId, ulong recurrenceMs, string? parentJobId)
-        : base(lazyLoader, TokenGen.CreateToken(typeof(DownloadAvailableChaptersJob)), JobType.DownloadAvailableChaptersJob, recurrenceMs, parentJobId)
+    internal DownloadAvailableChaptersJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string mangaId, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.DownloadAvailableChaptersJob, recurrenceMs, parentJobId)
     {
         this.MangaId = mangaId;
     }
     
     protected override IEnumerable<Job> RunInternal(PgsqlContext context)
     {
+        context.Entry(Manga).Reference<LocalLibrary>(m => m.Library).Load();
         return Manga.Chapters.Where(c => c.Downloaded == false).Select(chapter => new DownloadSingleChapterJob(chapter, this));
     }
 }

API/Schema/Jobs/DownloadMangaCoverJob.cs

@@ -29,8 +29,8 @@ public class DownloadMangaCoverJob : Job
     /// <summary>
     /// EF ONLY!!!
     /// </summary>
-    internal DownloadMangaCoverJob(ILazyLoader lazyLoader, string mangaId, string? parentJobId)
-        : base(lazyLoader, TokenGen.CreateToken(typeof(DownloadMangaCoverJob)), JobType.DownloadMangaCoverJob, 0, parentJobId)
+    internal DownloadMangaCoverJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string mangaId, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.DownloadMangaCoverJob, recurrenceMs, parentJobId)
     {
         this.MangaId = mangaId;
     }

API/Schema/Jobs/DownloadSingleChapterJob.cs

@@ -37,24 +37,37 @@ public class DownloadSingleChapterJob : Job
     /// <summary>
     /// EF ONLY!!!
     /// </summary>
-    internal DownloadSingleChapterJob(ILazyLoader lazyLoader, string chapterId, string? parentJobId)
-        : base(lazyLoader, TokenGen.CreateToken(typeof(DownloadSingleChapterJob)), JobType.DownloadSingleChapterJob, 0, parentJobId)
+    internal DownloadSingleChapterJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string chapterId, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.DownloadSingleChapterJob, recurrenceMs, parentJobId)
     {
         this.ChapterId = chapterId;
     }
     
     protected override IEnumerable<Job> RunInternal(PgsqlContext context)
     {
+        if (Chapter.Downloaded)
+        {
+            Log.Info("Chapter was already downloaded.");
+            return [];
+        }
         string[] imageUrls = Chapter.ParentManga.MangaConnector.GetChapterImageUrls(Chapter);
         if (imageUrls.Length < 1)
         {
             Log.Info($"No imageUrls for chapter {ChapterId}");
             return [];
         }
+        context.Entry(Chapter.ParentManga).Reference<LocalLibrary>(m => m.Library).Load(); //Need to explicitly load, because we are not accessing navigation directly...
         string saveArchiveFilePath = Chapter.FullArchiveFilePath;
+        Log.Debug($"Chapter path: {saveArchiveFilePath}");
         
         //Check if Publication Directory already exists
-        string directoryPath = Path.GetDirectoryName(saveArchiveFilePath)!;
+        string? directoryPath = Path.GetDirectoryName(saveArchiveFilePath);
+        if (directoryPath is null)
+        {
+            Log.Error($"Directory path could not be found: {saveArchiveFilePath}");
+            this.state = JobState.Failed;
+            return [];
+        }
         if (!Directory.Exists(directoryPath))
         {
             Log.Info($"Creating publication Directory: {directoryPath}");
@@ -121,21 +134,39 @@ public class DownloadSingleChapterJob : Job
     {
         if (!TrangaSettings.bwImages && TrangaSettings.compression == 100)
         {
-            Log.Debug($"No processing requested for image");
+            Log.Debug("No processing requested for image");
             return;
         }
         
         Log.Debug($"Processing image: {imagePath}");
 
+        try
+        {
             using Image image = Image.Load(imagePath);
-        File.Delete(imagePath);
-        if(TrangaSettings.bwImages) 
+            if (TrangaSettings.bwImages)
                 image.Mutate(i => i.ApplyProcessor(new AdaptiveThresholdProcessor()));
+            File.Delete(imagePath);
             image.SaveAsJpeg(imagePath, new JpegEncoder()
             {
                 Quality = TrangaSettings.compression
             });
         }
+        catch (Exception e)
+        {
+            if (e is UnknownImageFormatException or NotSupportedException)
+            {
+                //If the Image-Format is not processable by ImageSharp, we can't modify it.
+                Log.Debug($"Unable to process {imagePath}: Not supported image format");
+            }else if (e is InvalidImageContentException)
+            {
+                Log.Debug($"Unable to process {imagePath}: Invalid Content");
+            }
+            else
+            {
+                Log.Error(e);
+            }
+        }
+    }
     
     private void CopyCoverFromCacheToDownloadLocation(Manga manga)
     {
@@ -159,7 +190,7 @@ public class DownloadSingleChapterJob : Job
         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);
+            File.SetUnixFileMode(newFilePath, GroupRead | GroupWrite | UserRead | UserWrite | OtherRead | OtherWrite);
         Log.Debug($"Copied cover from {fileInCache} to {newFilePath}");
     }
     

API/Schema/Jobs/Job.cs

@@ -35,7 +35,6 @@ public abstract class Job
     [Required] public bool Enabled { get; internal set; } = true;
 
     [JsonIgnore] [NotMapped] internal bool IsCompleted => state is >= (JobState)128 and < (JobState)192;
-    [JsonIgnore] [NotMapped] internal bool DependenciesFulfilled => DependsOnJobs.All(j => j.IsCompleted);
 
     [NotMapped] [JsonIgnore] protected ILog Log { get; init; }
     [NotMapped] [JsonIgnore] protected ILazyLoader LazyLoader { get; init; }
@@ -67,31 +66,31 @@ public abstract class Job
         this.Log = LogManager.GetLogger(this.GetType());
     }
 
-    public IEnumerable<Job> Run(IServiceProvider serviceProvider)
+    public IEnumerable<Job> Run(PgsqlContext context, ref bool running)
     {
         Log.Info($"Running job {JobId}");
         DateTime jobStart = DateTime.UtcNow;
         Job[]? ret = null;
 
-        using IServiceScope scope = serviceProvider.CreateScope();
-        PgsqlContext context = scope.ServiceProvider.GetRequiredService<PgsqlContext>();
         try
         {
-            context.Attach(this);
             this.state = JobState.Running;
             context.SaveChanges();
+            running = true;
             ret = RunInternal(context).ToArray();
-            this.state = JobState.Completed;
-            context.Jobs.AddRange(ret);
             Log.Info($"Job {JobId} completed. Generated {ret.Length} new jobs.");
+            this.state = this.RecurrenceMs > 0 ? JobState.CompletedWaiting : JobState.Completed;
+            this.LastExecution = DateTime.UtcNow;
             context.SaveChanges();
         }
         catch (Exception e)
         {
             if (e is not DbUpdateException)
             {
-                this.state = JobState.Failed;
                 Log.Error($"Failed to run job {JobId}", e);
+                this.state = JobState.Failed;
+                this.Enabled = false;
+                this.LastExecution = DateTime.UtcNow;
                 context.SaveChanges();
             }
             else
@@ -100,12 +99,36 @@ public abstract class Job
             }
         }
 
+        try
+        {
+            if (ret != null)
+            {
+                context.Jobs.AddRange(ret);
+                context.SaveChanges();
+            }
+        }
+        catch (DbUpdateException e)
+        {
+            Log.Error($"Failed to update Database {JobId}", e);
+        }
+        
         Log.Info($"Finished Job {JobId}! (took {DateTime.UtcNow.Subtract(jobStart).TotalMilliseconds}ms)");
         return ret ?? [];
     }
     
     protected abstract IEnumerable<Job> RunInternal(PgsqlContext context);
 
+    public List<Job> GetDependenciesAndSelf()
+    {
+        List<Job> ret = new ();
+        foreach (Job job in DependsOnJobs)
+        {
+            ret.AddRange(job.GetDependenciesAndSelf());
+        }
+        ret.Add(this);
+        return ret;
+    }
+
     public override string ToString()
     {
         return $"{JobId}";

API/Schema/Jobs/JobType.cs

@@ -5,11 +5,10 @@ public enum JobType : byte
 {
     DownloadSingleChapterJob = 0, 
     DownloadAvailableChaptersJob = 1, 
-    UpdateMetaDataJob = 2,
     MoveFileOrFolderJob = 3,
     DownloadMangaCoverJob = 4,
     RetrieveChaptersJob = 5,
     UpdateChaptersDownloadedJob = 6,
     MoveMangaLibraryJob = 7,
-    UpdateSingleChapterDownloadedJob = 8,
+    UpdateCoverJob = 9,
 }

API/Schema/Jobs/MoveFileOrFolderJob.cs

@@ -23,8 +23,8 @@ public class MoveFileOrFolderJob : Job
     /// <summary>
     /// EF ONLY!!!
     /// </summary>
-    internal MoveFileOrFolderJob(ILazyLoader lazyLoader, string jobId, string fromLocation, string toLocation, string? parentJobId)
-        : base(lazyLoader, jobId, JobType.MoveFileOrFolderJob, 0, parentJobId)
+    internal MoveFileOrFolderJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string fromLocation, string toLocation, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.MoveFileOrFolderJob, recurrenceMs, parentJobId)
     {
         this.FromLocation = fromLocation;
         this.ToLocation = toLocation;

API/Schema/Jobs/MoveMangaLibraryJob.cs

@@ -33,8 +33,8 @@ public class MoveMangaLibraryJob : Job
     /// <summary>
     /// EF ONLY!!!
     /// </summary>
-    internal MoveMangaLibraryJob(ILazyLoader lazyLoader, string mangaId, string toLibraryId, string? parentJobId)
-        : base(lazyLoader, TokenGen.CreateToken(typeof(MoveMangaLibraryJob)), JobType.MoveMangaLibraryJob, 0, parentJobId)
+    internal MoveMangaLibraryJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string mangaId, string toLibraryId, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.MoveMangaLibraryJob, recurrenceMs, parentJobId)
     {
         this.MangaId = mangaId;
         this.ToLibraryId = toLibraryId;
@@ -42,6 +42,7 @@ public class MoveMangaLibraryJob : Job
     
     protected override IEnumerable<Job> RunInternal(PgsqlContext context)
     {
+        context.Entry(Manga).Reference<LocalLibrary>(m => m.Library).Load();
         Dictionary<Chapter, string> oldPath = Manga.Chapters.ToDictionary(c => c, c => c.FullArchiveFilePath);
         Manga.Library = ToLibrary;
         try

API/Schema/Jobs/RetrieveChaptersJob.cs

@@ -31,8 +31,8 @@ public class RetrieveChaptersJob : Job
     /// <summary>
     /// EF ONLY!!!
     /// </summary>
-    internal RetrieveChaptersJob(ILazyLoader lazyLoader, string mangaId, string language, ulong recurrenceMs, string? parentJobId)
-        : base(lazyLoader, TokenGen.CreateToken(typeof(RetrieveChaptersJob)), JobType.RetrieveChaptersJob, recurrenceMs, parentJobId)
+    internal RetrieveChaptersJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string mangaId, string language, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.RetrieveChaptersJob, recurrenceMs, parentJobId)
     {
         this.MangaId = mangaId;
         this.Language = language;
@@ -41,13 +41,14 @@ public class RetrieveChaptersJob : Job
     protected override IEnumerable<Job> RunInternal(PgsqlContext context)
     {
         // This gets all chapters that are not downloaded
-        Chapter[] allChapters = Manga.MangaConnector.GetChapters(Manga, Language);
-        Chapter[] newChapters = allChapters.Where(chapter => Manga.Chapters.Contains(chapter) == false).ToArray();
-        Log.Info($"{newChapters.Length} new chapters.");
+        Chapter[] allChapters = Manga.MangaConnector.GetChapters(Manga, Language).DistinctBy(c => c.ChapterId).ToArray();
+        Chapter[] newChapters = allChapters.Where(chapter => Manga.Chapters.Select(c => c.ChapterId).Contains(chapter.ChapterId) == false).ToArray();
+        Log.Info($"{Manga.Chapters.Count} existing + {newChapters.Length} new chapters.");
 
         try
         {
-            context.Chapters.AddRange(newChapters);
+            foreach (Chapter newChapter in newChapters)
+                Manga.Chapters.Add(newChapter);
             context.SaveChanges();
         }
         catch (DbUpdateException e)

API/Schema/Jobs/UpdateChaptersDownloadedJob.cs

@@ -1,5 +1,6 @@
 using System.ComponentModel.DataAnnotations;
 using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Newtonsoft.Json;
 
@@ -28,14 +29,28 @@ public class UpdateChaptersDownloadedJob : Job
     /// <summary>
     /// EF ONLY!!!
     /// </summary>
-    internal UpdateChaptersDownloadedJob(ILazyLoader lazyLoader, string mangaId, ulong recurrenceMs, string? parentJobId)
-        : base(lazyLoader, TokenGen.CreateToken(typeof(UpdateChaptersDownloadedJob)), JobType.UpdateChaptersDownloadedJob, recurrenceMs, parentJobId)
+    internal UpdateChaptersDownloadedJob(ILazyLoader lazyLoader, string jobId, ulong recurrenceMs, string mangaId, string? parentJobId)
+        : base(lazyLoader, jobId, JobType.UpdateChaptersDownloadedJob, recurrenceMs, parentJobId)
     {
         this.MangaId = mangaId;
     }
     
     protected override IEnumerable<Job> RunInternal(PgsqlContext context)
     {
-        return Manga.Chapters.Select(c => new UpdateSingleChapterDownloadedJob(c, this));
+        context.Entry(Manga).Reference<LocalLibrary>(m => m.Library).Load();
+        foreach (Chapter mangaChapter in Manga.Chapters)
+        {
+            mangaChapter.Downloaded = mangaChapter.CheckDownloaded();
+        }
+
+        try
+        {
+            context.SaveChanges();
+        }
+        catch (DbUpdateException e)
+        {
+            Log.Error(e);
+        }
+        return [];
     }
 }

API/Schema/Jobs/UpdateCoverJob.cs

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

API/Schema/Jobs/UpdateSingleChapterDownloadedJob.cs

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

API/Schema/MangaConnectors/ComickIo.cs

@@ -78,7 +78,7 @@ public class ComickIo : MangaConnector
     public override Chapter[] GetChapters(Manga manga, string? language = null)
     {
         Log.Info($"Getting Chapters: {manga.IdOnConnectorSite}");
-        List<string> chapterHids = new();
+        List<Chapter> chapters = new();
         int page = 1;
         while(page < 50)
         {
@@ -95,16 +95,13 @@ public class ComickIo : MangaConnector
             JToken data = JToken.Parse(sr.ReadToEnd());
             JArray? chaptersArray = data["chapters"] as JArray;
 
-            if (chaptersArray?.Count < 1)
+            if (chaptersArray is null || chaptersArray.Count < 1)
                 break;
             
-            chapterHids.AddRange(chaptersArray?.Select(token => token.Value<string>("hid")!)!);
+            chapters.AddRange(ParseChapters(manga, chaptersArray));
 
             page++;
         }
-        Log.Debug($"Getting chapters for {manga.Name} yielded {chapterHids.Count} hids. Requesting chapters now...");
-
-        List<Chapter> chapters = chapterHids.Select(hid => ChapterFromHid(manga, hid)).ToList();
 
         return chapters.ToArray();
     }
@@ -219,29 +216,23 @@ public class ComickIo : MangaConnector
             year: year, originalLanguage: originalLanguage);
     }
 
-    private Chapter ChapterFromHid(Manga parentManga, string hid)
+    private List<Chapter> ParseChapters(Manga parentManga, JArray chaptersArray)
     {
-        string requestUrl = $"https://api.comick.fun/chapter/{hid}";
-        RequestResult result = downloadClient.MakeRequest(requestUrl, RequestType.Default);
-        if ((int)result.statusCode < 200 || (int)result.statusCode >= 300)
+        List<Chapter> chapters = new ();
+        foreach (JToken chapter in chaptersArray)
         {
-            Log.Error("Request failed");
-            throw new Exception("Request failed");
-        }
-        
-        using StreamReader sr = new (result.result);
-        JToken data = JToken.Parse(sr.ReadToEnd());
-
-        string? canonical = data.Value<string>("canonical");
-        string? chapterNum = data["chapter"]?.Value<string>("chap");
-        string? volumeNumStr = data["chapter"]?.Value<string>("vol");
+            string? chapterNum = chapter.Value<string>("chap");
+            string? volumeNumStr = chapter.Value<string>("vol");
             int? volumeNum = volumeNumStr is null ? null : int.Parse(volumeNumStr);
-        string? title = data["chapter"]?.Value<string>("title");
+            string? title = chapter.Value<string>("title");
+            string? hid = chapter.Value<string>("hid");
+            string url = $"https://comick.io/comic/{parentManga.IdOnConnectorSite}/{hid}";
             
-        if(chapterNum is null)
-            throw new Exception("chapterNum is null");
+            if(chapterNum is null || hid is null)
+                continue;
 
-        string url = $"https://comick.io{canonical}";
-        return new Chapter(parentManga, url, chapterNum, volumeNum, title);
+            chapters.Add(new (parentManga, url, chapterNum, volumeNum, hid, title));
+        }
+        return chapters;
     }
 }

API/Schema/MangaConnectors/MangaDex.cs

@@ -226,22 +226,25 @@ public class MangaDex : MangaConnector
     private Manga ParseMangaFromJToken(JToken jToken)
     {
         string? id = jToken.Value<string>("id");
+        if(id is null)
+            throw new Exception("jToken was not in expected format");
         
         JObject? attributes = jToken["attributes"] as JObject;
-        string? name = attributes?["title"]?.Value<string>("en");
-        string? description = attributes?["description"]?.Value<string>("en");
-        string? status = attributes?["status"]?.Value<string>();
-        uint? year = attributes?["year"]?.Value<uint>();
-        string? originalLanguage = attributes?["originalLanguage"]?.Value<string>();
-        JArray? altTitlesJArray = attributes?["altTitles"] as JArray;
-        JArray? tagsJArray = attributes?["tags"] as JArray;
-        
+        if(attributes is null)
+            throw new Exception("jToken was not in expected format");
+        string? name = attributes["title"]?.Value<string>("en") ?? attributes["title"]?.First?.First?.Value<string>();
+        string description = attributes["description"]?.Value<string>("en")??attributes["description"]?.First?.First?.Value<string>()??"";
+        string? status = attributes["status"]?.Value<string>();
+        uint? year = attributes["year"]?.Value<uint?>();
+        string? originalLanguage = attributes["originalLanguage"]?.Value<string>();
+        JArray? altTitlesJArray = attributes.TryGetValue("altTitles", out JToken? altTitlesArray) ? altTitlesArray as JArray : null;
+        JArray? tagsJArray = attributes.TryGetValue("tags", out JToken? tagsArray) ? tagsArray as JArray : null;
         JArray? relationships = jToken["relationships"] as JArray;
-        string? coverFileName =
-            relationships?.FirstOrDefault(r => r["type"]?.Value<string>() == "cover_art")?["attributes"]?.Value<string>("fileName");
+        if (name is null || status is null || relationships is null)
+            throw new Exception("jToken was not in expected format");
         
-        if (id is null || attributes is null || name is null || description is null || status is null ||
-            altTitlesJArray is null || tagsJArray is null || relationships is null || coverFileName is null)
+        string? coverFileName = relationships.FirstOrDefault(r => r["type"]?.Value<string>() == "cover_art")?["attributes"]?.Value<string>("fileName");
+        if(coverFileName is null)
             throw new Exception("jToken was not in expected format");
         
         List<Link> links = attributes["links"]?
@@ -276,7 +279,7 @@ public class MangaDex : MangaConnector
                 return new Link(key, url);
             }).ToList()!;
 
-        List<MangaAltTitle> altTitles = altTitlesJArray
+        List<MangaAltTitle> altTitles = (altTitlesJArray??[])
             .Select(t =>
             {
                 JObject? j = t as JObject;
@@ -286,9 +289,9 @@ public class MangaDex : MangaConnector
                 return new MangaAltTitle(p.Name, p.Value.ToString());
             }).Where(x => x is not null).ToList()!;
         
-        List<MangaTag> tags = tagsJArray
+        List<MangaTag> tags = (tagsJArray??[])
             .Where(t => t.Value<string>("type") == "tag")
-            .Select(t => t["attributes"]?["name"]?.Value<string>("en"))
+            .Select(t => t["attributes"]?["name"]?.Value<string>("en")??t["attributes"]?["name"]?.First?.First?.Value<string>())
             .Select(str => str is not null ? new MangaTag(str) : null)
             .Where(x => x is not null).ToList()!;
         
@@ -330,6 +333,6 @@ public class MangaDex : MangaConnector
             volume = int.Parse(volumeStr);
         
         string url = $"https://mangadex.org/chapter/{id}";
-        return new Chapter(parentManga, url, chapter, volume, title);
+        return new Chapter(parentManga, url, chapter, volume, id, title);
     }
 }

API/Schema/MetadataFetchers/MetadataEntry.cs

@@ -0,0 +1,35 @@
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+
+namespace API.Schema.MetadataFetchers;
+
+[PrimaryKey("MetadataFetcherName", "Identifier")]
+public class MetadataEntry
+{
+    [JsonIgnore]
+    public Manga Manga { get; init; } = null!;
+    public string MangaId  { get; init; }
+    [JsonIgnore]
+    public MetadataFetcher MetadataFetcher { get; init; } = null!;
+    public string MetadataFetcherName { get; init; }
+    public string Identifier { get; init; }
+
+    public MetadataEntry(MetadataFetcher fetcher, Manga manga, string identifier)
+    {
+        this.Manga = manga;
+        this.MangaId = manga.MangaId;
+        this.MetadataFetcher = fetcher;
+        this.MetadataFetcherName = fetcher.MetadataFetcherName;
+        this.Identifier = identifier;
+    }
+
+    /// <summary>
+    /// EFCORE only!!!!
+    /// </summary>
+    internal MetadataEntry(string mangaId, string identifier, string metadataFetcherName)
+    {
+        this.MangaId = mangaId;
+        this.Identifier = identifier;
+        this.MetadataFetcherName = metadataFetcherName;
+    }
+}

API/Schema/MetadataFetchers/MetadataFetcher.cs

@@ -0,0 +1,37 @@
+using System.Diagnostics.CodeAnalysis;
+using API.Schema.Contexts;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema.MetadataFetchers;
+
+[PrimaryKey("MetadataFetcherName")]
+public abstract class MetadataFetcher
+{
+    // ReSharper disable once EntityFramework.ModelValidation.UnlimitedStringLength
+    public string MetadataFetcherName { get; init; }
+
+    protected MetadataFetcher()
+    {
+        this.MetadataFetcherName = this.GetType().Name;
+    }
+    
+    /// <summary>
+    /// EFCORE ONLY!!!
+    /// </summary>
+    internal MetadataFetcher(string metadataFetcherName)
+    {
+        this.MetadataFetcherName = metadataFetcherName;
+    }
+
+    internal MetadataEntry CreateMetadataEntry(Manga manga, string identifier) =>
+        new (this, manga, identifier);
+    
+    public abstract MetadataSearchResult[] SearchMetadataEntry(Manga manga);
+    
+    public abstract MetadataSearchResult[] SearchMetadataEntry(string searchTerm);
+
+    /// <summary>
+    /// Updates the Manga linked in the MetadataEntry
+    /// </summary>
+    public abstract void UpdateMetadata(MetadataEntry metadataEntry, PgsqlContext dbContext);
+}

API/Schema/MetadataFetchers/MetadataSearchResult.cs

@@ -0,0 +1,3 @@
+namespace API.Schema.MetadataFetchers;
+
+public record MetadataSearchResult(string Identifier, string Name, string Url, string? Description = null, string? CoverUrl = null);

API/Schema/MetadataFetchers/MyAnimeList.cs

@@ -0,0 +1,79 @@
+using System.Text.RegularExpressions;
+using API.Schema.Contexts;
+using JikanDotNet;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Schema.MetadataFetchers;
+
+public class MyAnimeList : MetadataFetcher
+{
+    private static readonly Jikan Jikan = new ();
+    private static readonly Regex GetIdFromUrl = new(@"https?:\/\/myanimelist\.net\/manga\/([0-9]+)\/?.*");
+    
+    public override MetadataSearchResult[] SearchMetadataEntry(Manga manga)
+    {
+        if (manga.Links.Any(link => link.LinkProvider.Equals("MyAnimeList", StringComparison.InvariantCultureIgnoreCase)))
+        {
+            string url = manga.Links.First(link => link.LinkProvider.Equals("MyAnimeList", StringComparison.InvariantCultureIgnoreCase)).LinkUrl;
+            Match m = GetIdFromUrl.Match(url);
+            if (m.Success && m.Groups[1].Success)
+            {
+                long id = long.Parse(m.Groups[1].Value);
+                JikanDotNet.Manga data = Jikan.GetMangaAsync(id).Result.Data;
+                return [new MetadataSearchResult(id.ToString(), data.Titles.First().Title, data.Url, data.Synopsis)];
+            }
+        }
+
+        return SearchMetadataEntry(manga.Name);
+    }
+
+    public override MetadataSearchResult[] SearchMetadataEntry(string searchTerm)
+    {
+        
+        ICollection<JikanDotNet.Manga> resultData = Jikan.SearchMangaAsync(searchTerm).Result.Data;
+        if (resultData.Count < 1)
+            return [];
+        return resultData.Select(data =>
+                new MetadataSearchResult(data.MalId.ToString(), data.Titles.First().Title, data.Url, data.Synopsis))
+            .ToArray();
+    }
+
+    /// <summary>
+    /// Updates the Manga linked in the MetadataEntry
+    /// </summary>
+    /// <param name="metadataEntry"></param>
+    /// <param name="dbContext"></param>
+    /// <exception cref="FormatException"></exception>
+    /// <exception cref="DbUpdateException"></exception>
+    public override void UpdateMetadata(MetadataEntry metadataEntry, PgsqlContext dbContext)
+    {
+        Manga dbManga = dbContext.Mangas.Find(metadataEntry.MangaId)!;
+        MangaFull resultData;
+        try
+        {
+            long id = long.Parse(metadataEntry.Identifier);
+            resultData = Jikan.GetMangaFullDataAsync(id).Result.Data;
+        }
+        catch (Exception)
+        {
+            throw new FormatException("ID was not in correct format");
+        }
+
+        try
+        {
+            dbManga.Name = resultData.Titles.First().Title;
+            dbManga.Description = resultData.Synopsis;
+            dbManga.AltTitles.Clear();
+            dbManga.AltTitles = resultData.Titles.Select(t => new MangaAltTitle(t.Type, t.Title)).ToList();
+            dbManga.Authors.Clear();
+            dbManga.Authors = resultData.Authors.Select(a => new Author(a.Name)).ToList();
+
+            dbContext.SaveChanges();
+        }
+        catch (DbUpdateException e)
+        {
+            throw;
+        }
+    }
+    
+}

API/Tranga.cs

@@ -2,11 +2,11 @@
 using API.Schema.Contexts;
 using API.Schema.Jobs;
 using API.Schema.MangaConnectors;
+using API.Schema.MetadataFetchers;
 using API.Schema.NotificationConnectors;
 using log4net;
 using log4net.Config;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.ChangeTracking;
 
 namespace API;
 
@@ -25,6 +25,7 @@ public static class Tranga
     public static Thread NotificationSenderThread { get; } = new (NotificationSender);
     public static Thread JobStarterThread { get; } = new (JobStarter);
     private static readonly ILog Log = LogManager.GetLogger(typeof(Tranga));
+    internal static MetadataFetcher[] MetadataFetchers = [new MyAnimeList()];
 
     internal static void StartLogger()
     {
@@ -33,6 +34,23 @@ public static class Tranga
         Log.Info(TRANGA);
     }
 
+    internal static void RemoveStaleFiles(PgsqlContext context)
+    {
+        Log.Info("Removing stale files...");
+        if (!Directory.Exists(TrangaSettings.coverImageCache))
+            return;
+        string[] usedFiles = context.Mangas.Select(m => m.CoverFileNameInCache).Where(s => s != null).ToArray()!;
+        string[] extraneousFiles = new DirectoryInfo(TrangaSettings.coverImageCache).GetFiles()
+            .Where(f => usedFiles.Contains(f.FullName) == false)
+            .Select(f => f.FullName)
+            .ToArray();
+        foreach (string path in extraneousFiles)
+        {
+            Log.Info($"Deleting {path}");
+            File.Delete(path);
+        }
+    }
+    
     private static void NotificationSender(object? serviceProviderObj)
     {
         if (serviceProviderObj is null)
@@ -103,87 +121,69 @@ public static class Tranga
             return;
         }
         IServiceProvider serviceProvider = (IServiceProvider)serviceProviderObj;
-        using IServiceScope scope = serviceProvider.CreateScope();
-        PgsqlContext context = scope.ServiceProvider.GetRequiredService<PgsqlContext>();
         
         while (true)
         {            
             Log.Debug("Starting Job-Cycle...");
             DateTime cycleStart = DateTime.UtcNow;
-            Log.Debug("Loading Jobs...");
-            DateTime loadStart = DateTime.UtcNow;
-            context.Jobs.Load();
-            Log.Debug("Updating Entries...");
-            foreach (EntityEntry entityEntry in context.ChangeTracker.Entries().ToArray())
-                entityEntry.Reload();
-            Log.Debug($"Jobs Loaded! (took {DateTime.UtcNow.Subtract(loadStart).TotalMilliseconds}ms)");
-            //Update finished Jobs to new states
-            List<Job> completedJobs = context.Jobs.Local.Where(j => j.state == JobState.Completed).ToList();
-            foreach (Job completedJob in completedJobs)
-                if (completedJob.RecurrenceMs <= 0)
-                    context.Jobs.Remove(completedJob);
-                else
-                {
-                    completedJob.state = JobState.CompletedWaiting;
-                    completedJob.LastExecution = DateTime.UtcNow;
-                }
-            List<Job> failedJobs = context.Jobs.Local.Where(j => j.state == JobState.Failed).ToList();
-            foreach (Job failedJob in failedJobs)
-            {
-                failedJob.Enabled = false;
-                failedJob.LastExecution = DateTime.UtcNow;
-            }
+            using IServiceScope scope = serviceProvider.CreateScope();
+            PgsqlContext cycleContext = scope.ServiceProvider.GetRequiredService<PgsqlContext>();
 
-            //Retrieve waiting and due Jobs
-            List<Job> runningJobs = context.Jobs.Local.Where(j => j.state == JobState.Running).ToList();
+            //Get Running Jobs
+            List<Job> runningJobs = cycleContext.Jobs.GetRunningJobs();
             
             DateTime filterStart = DateTime.UtcNow;
             Log.Debug("Filtering Jobs...");
-            List<MangaConnector> busyConnectors = GetBusyConnectors(runningJobs);
 
-            List<Job> waitingJobs = GetWaitingJobs(context.Jobs.Local.ToList());
-            List<Job> dueJobs = FilterDueJobs(waitingJobs);
-            List<Job> jobsWithoutBusyConnectors = FilterJobWithBusyConnectors(dueJobs, busyConnectors);
-            List<Job> jobsWithoutMissingDependencies = FilterJobDependencies(context, jobsWithoutBusyConnectors);
+            List<Job> waitingJobs = cycleContext.Jobs.GetWaitingJobs();
+            List<Job> dueJobs = waitingJobs.FilterDueJobs();
+            List<Job> jobsWithoutDependencies = dueJobs.FilterJobDependencies();
 
-            List<Job> jobsWithoutDownloading =
-                jobsWithoutMissingDependencies
-                    .Where(j => j.JobType != JobType.DownloadSingleChapterJob)
-                    .DistinctBy(j => j.JobType)
-                    .ToList();
-            List<Job> firstChapterPerConnector =
-                jobsWithoutMissingDependencies
-                    .Where(j => j.JobType == JobType.DownloadSingleChapterJob)
-                    .OrderBy(j =>
-                    {
-                        DownloadSingleChapterJob dscj = (DownloadSingleChapterJob)j;
-                        return dscj.Chapter;
-                    })
-                    .DistinctBy(j =>
-                    {
-                        DownloadSingleChapterJob dscj = (DownloadSingleChapterJob)j;
-                        return dscj.Chapter.ParentManga.MangaConnector;
-                    })
-                    .ToList();
+            List<Job> jobsWithoutDownloading = jobsWithoutDependencies.FilterJobsWithoutDownloading();
             
-            List<Job> startJobs = jobsWithoutDownloading.Concat(firstChapterPerConnector).ToList();
+            //Match running and waiting jobs per Connector
+            Dictionary<string, Dictionary<JobType, List<Job>>> runningJobsPerConnector =
+                runningJobs.GetJobsPerJobTypeAndConnector();
+            Dictionary<string, Dictionary<JobType, List<Job>>> waitingJobsPerConnector =
+                jobsWithoutDependencies.GetJobsPerJobTypeAndConnector();
+            List<Job> jobsNotHeldBackByConnector =
+                MatchJobsRunningAndWaiting(runningJobsPerConnector, waitingJobsPerConnector);
+            
+
+            List<Job> startJobs = jobsWithoutDownloading.Concat(jobsNotHeldBackByConnector).ToList();
             Log.Debug($"Jobs Filtered! (took {DateTime.UtcNow.Subtract(filterStart).TotalMilliseconds}ms)");
             
             
             //Start Jobs that are allowed to run (preconditions match)
             foreach (Job job in startJobs)
             {
+                bool running = false;
                 Thread t = new(() =>
                 {
-                    job.Run(serviceProvider);
+                    using IServiceScope jobScope = serviceProvider.CreateScope();
+                    PgsqlContext jobContext = jobScope.ServiceProvider.GetRequiredService<PgsqlContext>();
+                    if (jobContext.Jobs.Find(job.JobId) is not { } inContext)
+                        return;
+                    inContext.Run(jobContext, ref running); //FIND the job IN THE NEW CONTEXT!!!!!!! SO WE DON'T GET TRACKING PROBLEMS AND AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
                 });
                 RunningJobs.Add(t, job);
                 t.Start();
+                while(!running)
+                    Thread.Sleep(10);
             }
-            Log.Debug($"Jobs Completed: {completedJobs.Count} Failed: {failedJobs.Count} Running: {runningJobs.Count}\n" +
-                      $"Waiting: {waitingJobs.Count}\n" +
-                      $"\tof which Due: {dueJobs.Count}\n" +
-                      $"\t\tof which Started: {jobsWithoutMissingDependencies.Count}");
+            Log.Debug($"Running: {runningJobs.Count}\n" +
+                      $"{string.Join("\n", runningJobs.Select(s => "\t- " + s))}\n" +
+                      $"Waiting: {waitingJobs.Count} Due: {dueJobs.Count}\n" +
+                      $"{string.Join("\n", dueJobs.Select(s => "\t- " + s))}\n" +
+                      $"of which {jobsWithoutDependencies.Count} without missing dependencies, of which\n" +
+                      $"\t{jobsWithoutDownloading.Count} without downloading\n" +
+                      $"\t{jobsNotHeldBackByConnector.Count} not held back by Connector\n" +
+                      $"{startJobs.Count} were started:\n" +
+                      $"{string.Join("\n", startJobs.Select(s => "\t- " + s))}");
+
+            if (Log.IsDebugEnabled && dueJobs.Count < 1)
+                if(waitingJobs.MinBy(j => j.NextExecution) is { } nextJob)
+                    Log.Debug($"Next job in {nextJob.NextExecution.Subtract(DateTime.UtcNow)} (at {nextJob.NextExecution}): {nextJob.JobId}");
 
             (Thread, Job)[] removeFromThreadsList = RunningJobs.Where(t => !t.Key.IsAlive)
                 .Select(t => (t.Key, t.Value)).ToArray();
@@ -195,72 +195,138 @@ public static class Tranga
 
             try
             {
-                context.SaveChanges();
+                cycleContext.SaveChanges();
             }
             catch (DbUpdateException e)
             {
                 Log.Error("Failed saving Job changes.", e);
             }
-            Log.Debug($"Job-Cycle over! (took {DateTime.UtcNow.Subtract(cycleStart).TotalMilliseconds}ms)");
+            Log.Debug($"Job-Cycle over! (took {DateTime.UtcNow.Subtract(cycleStart).TotalMilliseconds}ms");
             Thread.Sleep(TrangaSettings.startNewJobTimeoutMs);
         }
     }
     
-    private static List<MangaConnector> GetBusyConnectors(List<Job> runningJobs)
+    private static List<Job> GetRunningJobs(this IQueryable<Job> jobs)
     {
-        HashSet<MangaConnector> busyConnectors = new();
-        foreach (Job runningJob in runningJobs)
-        {
-            if(GetJobConnector(runningJob) is { } mangaConnector)
-                busyConnectors.Add(mangaConnector);
-        }
-        return busyConnectors.ToList();
+        DateTime start = DateTime.UtcNow;
+        List<Job> ret = jobs.Where(j => j.state == JobState.Running).ToList();
+        DateTime end = DateTime.UtcNow;
+        Log.Debug($"Getting running Jobs took {end.Subtract(start).TotalMilliseconds}ms");
+        return ret;
     }
     
-    private static List<Job> GetWaitingJobs(List<Job> jobs) =>
-        jobs
-            .Where(j =>
-                j.Enabled &&
-                (j.state == JobState.FirstExecution || j.state == JobState.CompletedWaiting))
-            .ToList();
-
-    private static List<Job> FilterDueJobs(List<Job> jobs) =>
-        jobs
-            .Where(j => j.NextExecution < DateTime.UtcNow)
-            .ToList();
-
-    private static List<Job> FilterJobDependencies(PgsqlContext context, List<Job> jobs) =>
-        jobs
-            .Where(j =>
+    private static List<Job> GetWaitingJobs(this IQueryable<Job> jobs)
     {
-                Log.Debug($"Loading Job Preconditions {j}...");
-                context.Entry(j).Collection(j => j.DependsOnJobs).Load();
-                Log.Debug($"Loaded Job Preconditions {j}!");
-                return j.DependenciesFulfilled;
-            })
-            .ToList();
+        DateTime start = DateTime.UtcNow;
+        List<Job> ret = jobs.Where(j => j.state == JobState.CompletedWaiting || j.state == JobState.FirstExecution).ToList();
+        DateTime end = DateTime.UtcNow;
+        Log.Debug($"Getting waiting Jobs took {end.Subtract(start).TotalMilliseconds}ms");
+        return ret;
+    }
         
-    private static List<Job> FilterJobWithBusyConnectors(List<Job> jobs, List<MangaConnector> busyConnectors) =>
-        jobs
-            .Where(j =>
+
+    private static List<Job> FilterDueJobs(this List<Job> jobs)
     {
-                //Filter jobs with busy connectors
-                if (GetJobConnector(j) is { } mangaConnector)
-                    return busyConnectors.Contains(mangaConnector) == false;
-                return true;
-            })
-            .ToList();
+        DateTime start = DateTime.UtcNow;
+        List<Job> ret = jobs.Where(j => j.NextExecution < DateTime.UtcNow).ToList();
+        DateTime end = DateTime.UtcNow;
+        Log.Debug($"Filtering Due Jobs took {end.Subtract(start).TotalMilliseconds}ms");
+        return ret;
+    }
         
-    private static MangaConnector? GetJobConnector(Job job)
+
+    private static List<Job> FilterJobDependencies(this List<Job> jobs)
+    {
+        DateTime start = DateTime.UtcNow;
+        List<Job> ret = jobs.Where(job => job.DependsOnJobs.All(j => j.IsCompleted)).ToList();
+        DateTime end = DateTime.UtcNow;
+        Log.Debug($"Filtering Dependencies took {end.Subtract(start).TotalMilliseconds}ms");
+        return ret;
+    }
+    
+
+    private static List<Job> FilterJobsWithoutDownloading(this List<Job> jobs)
+    {
+        JobType[] types = [JobType.MoveFileOrFolderJob, JobType.MoveMangaLibraryJob, JobType.UpdateChaptersDownloadedJob];
+        DateTime start = DateTime.UtcNow;
+        List<Job> ret = jobs.Where(j => types.Contains(j.JobType)).ToList();
+        DateTime end = DateTime.UtcNow;
+        Log.Debug($"Filtering Jobs without Download took {end.Subtract(start).TotalMilliseconds}ms");
+        return ret;
+    }
+    
+
+    private static Dictionary<string, Dictionary<JobType, List<Job>>> GetJobsPerJobTypeAndConnector(this List<Job> jobs)
+    {
+        DateTime start = DateTime.UtcNow;
+        Dictionary<string, Dictionary<JobType, List<Job>>> ret = new();
+        foreach (Job job in jobs)
+        {
+            if(GetJobConnectorName(job) is not { } connector)
+                continue;
+            if (!ret.ContainsKey(connector))
+                ret.Add(connector, new());
+            if (!ret[connector].ContainsKey(job.JobType))
+                ret[connector].Add(job.JobType, new());
+            ret[connector][job.JobType].Add(job);
+        }
+        DateTime end = DateTime.UtcNow;
+        Log.Debug($"Fetching connector per Job for jobs took {end.Subtract(start).TotalMilliseconds}ms");
+        return ret;
+    }
+
+    private static List<Job> MatchJobsRunningAndWaiting(Dictionary<string, Dictionary<JobType, List<Job>>> running,
+        Dictionary<string, Dictionary<JobType, List<Job>>> waiting)
+    {
+        DateTime start = DateTime.UtcNow;
+        List<Job> ret = new();
+        foreach ((string connector, Dictionary<JobType, List<Job>> jobTypeJobsWaiting) in waiting)
+        {
+            if (running.TryGetValue(connector, out Dictionary<JobType, List<Job>>? jobTypeJobsRunning))
+            {   //MangaConnector has running Jobs
+                //Match per JobType
+                foreach ((JobType jobType, List<Job> jobsWaiting) in jobTypeJobsWaiting)
+                {
+                    if(jobTypeJobsRunning.ContainsKey(jobType))
+                        //Already a job of Type running on MangaConnector
+                        continue;
+                    if (jobType is not JobType.DownloadSingleChapterJob)
+                        //If it is not a DownloadSingleChapterJob, just add the first
+                        ret.Add(jobsWaiting.First());
+                    else
+                        //Add the Job with the lowest Chapternumber
+                        ret.Add(jobsWaiting.OrderBy(j => ((DownloadSingleChapterJob)j).Chapter).First());
+                }
+            }
+            else
+            {   //MangaConnector has no running Jobs
+                foreach ((JobType jobType, List<Job> jobsWaiting) in jobTypeJobsWaiting)
+                {
+                    if (jobType is not JobType.DownloadSingleChapterJob)
+                        //If it is not a DownloadSingleChapterJob, just add the first
+                        ret.Add(jobsWaiting.First());
+                    else
+                        //Add the Job with the lowest Chapternumber
+                        ret.Add(jobsWaiting.OrderBy(j => ((DownloadSingleChapterJob)j).Chapter).First());
+                }
+            }
+        }
+        DateTime end = DateTime.UtcNow;
+        Log.Debug($"Getting eligible jobs (not held back by Connector) took {end.Subtract(start).TotalMilliseconds}ms");
+        return ret;
+    }
+    
+    
+    private static string? GetJobConnectorName(Job job)
     {
         if (job is DownloadAvailableChaptersJob dacj)
-            return dacj.Manga.MangaConnector;
+            return dacj.Manga.MangaConnectorName;
         if (job is DownloadMangaCoverJob dmcj)
-            return  dmcj.Manga.MangaConnector;
+            return  dmcj.Manga.MangaConnectorName;
         if (job is DownloadSingleChapterJob dscj)
-            return  dscj.Chapter.ParentManga.MangaConnector;
+            return  dscj.Chapter.ParentManga.MangaConnectorName;
         if (job is RetrieveChaptersJob rcj)
-            return rcj.Manga.MangaConnector;
+            return rcj.Manga.MangaConnectorName;
         return null;
     }
 }

API/TrangaSettings.cs

@@ -11,10 +11,11 @@ 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";
+    internal static readonly string DefaultUserAgent = $"Tranga/2.0 ({Enum.GetName(Environment.OSVersion.Platform)}; {(Environment.Is64BitOperatingSystem ? "x64" : "")})";
     public static string userAgent { get; private set; } = DefaultUserAgent;
     public static int compression{ get; private set; } = 40;
     public static bool bwImages { get; private set; } = false;
+    public static string flareSolverrUrl { get; private set; } = string.Empty;
     /// <summary>
     /// Placeholders:
     /// %M Manga Name
@@ -35,14 +36,14 @@ public static class TrangaSettings
     [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;
+    public static int startNewJobTimeoutMs { get; private set; } = 20000;
     [JsonIgnore]
     internal static readonly Dictionary<RequestType, int> DefaultRequestLimits = new ()
     {
         {RequestType.MangaInfo, 60},
         {RequestType.MangaDexFeed, 60},
-        {RequestType.MangaDexImage, 40},
-        {RequestType.MangaImage, 60},
+        {RequestType.MangaDexImage, 60},
+        {RequestType.MangaImage, 240},
         {RequestType.MangaCover, 60},
         {RequestType.Default, 60}
     };
@@ -102,6 +103,12 @@ public static class TrangaSettings
         ExportSettings();
     }
 
+    public static void UpdateFlareSolverrUrl(string url)
+    {
+        flareSolverrUrl = url;
+        ExportSettings();
+    }
+
     public static void ResetRequestLimits()
     {
         requestLimits = DefaultRequestLimits;
@@ -148,6 +155,7 @@ public static class TrangaSettings
         jobj.Add("bwImages", JToken.FromObject(bwImages));
         jobj.Add("startNewJobTimeoutMs", JToken.FromObject(startNewJobTimeoutMs));
         jobj.Add("chapterNamingScheme", JToken.FromObject(chapterNamingScheme));
+        jobj.Add("flareSolverrUrl", JToken.FromObject(flareSolverrUrl));
         return jobj;
     }
 
@@ -174,5 +182,7 @@ public static class TrangaSettings
             startNewJobTimeoutMs = snjt.Value<int>()!;
         if (jobj.TryGetValue("chapterNamingScheme", out JToken? cns))
             chapterNamingScheme = cns.Value<string>()!;
+        if (jobj.TryGetValue("flareSolverrUrl", out JToken? fsu))
+            flareSolverrUrl = fsu.Value<string>()!;
     }
 }

Dockerfile

@@ -39,4 +39,4 @@ WORKDIR /publish
 COPY --chown=1000:1000 --from=build-env /publish .
 USER 0
 ENTRYPOINT ["dotnet", "/publish/API.dll"]
-CMD ["-f", "-c", "-l", "/usr/share/tranga-api/logs"]
+CMD [""]

README.md

@@ -31,14 +31,7 @@
 Tranga can download Chapters and Metadata from "Scanlation" sites such as 
 
 - [MangaDex.org](https://mangadex.org/) (Multilingual)
-- [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)
-- [Weebcentral](https://weebcentral.com) (en)
-- [Webtoons](https://www.webtoons.com/en/) (en)
+- [Comick.io](https://comick.io/)
 - ❓ 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/).  
@@ -47,25 +40,29 @@ Notifications can be sent to your devices using [Gotify](https://gotify.net/), [
 
 ## 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.
+DOES: Download Images from a Website.<br />
+DOES: Create Archives.<br />
+
+### how:
+
+Tranga (this repository) is a REST-API and worker in one. Tranga provides REST-Endpoints to configure workers (Jobs).
+Requests include searches for Manga, creating and starting Jobs such as downloading available chapters.
+For available endpoints check `<hostedInstance>/swagger`
 
 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
+When downloading a chapter (meaning the images that make-up the manga) from a 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).
+([tbd issue](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/
-).
+chapters. Tranga can also send notifications to your devices via third-party services such as [Gotify](https://gotify.net/), [Ntfy](https://ntfy.sh/),
+or any other REST Webhook.
 
 ## Screenshots
 
@@ -87,17 +84,18 @@ Endpoints are documented in Swagger. Just spin up an instance, and go to `http:/
 
 ## Built With
 
-- .NET
-  - ASP.NET
-  - Entity Framework
+- ASP.NET
+  - Entity Framework Core
 - [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)
+- [Swagger](https://github.com/domaindrivendev/Swashbuckle.AspNetCore/blob/master/LICENSE)
 - [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json/blob/master/LICENSE.md)
+- [Sixlabors.ImageSharp](https://docs-v2.sixlabors.com/articles/imagesharp/index.html#license)
 - [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)
+- [Jikan](https://jikan.moe/)
+  - [Jikan.Net](https://github.com/Ervie/jikan.net)
 - 💙 Blåhaj 🦈
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>
@@ -117,6 +115,8 @@ Endpoints are documented in Swagger. Just spin up an instance, and go to `http:/
 
 ### Docker
 
+Built for AMD64 (and ARM64, maybe, if it feels like it).
+
 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
@@ -127,13 +127,13 @@ access the folder. Permission conflicts with Komga and Kavita should thus be lim
 
 ### Bare-Metal
 
-While not supported/currently built, Tranga will also run Bare-Metal without issue.
+While not supported/currently built, Tranga should also run Bare-Metal without issue.
 
 Configuration-Files will be stored per OS:
 - Linux `/usr/share/tranga-api`
 - Windows `%appdata%/tranga-api`
 
-Downloads (default) are stored in - but this can be configured in `settings.json`:
+Downloads (default) are stored in - but this can be configured in `settings.json` (which will be generated on first after first launch):
 - Linux `/Manga`
 - Windows `%currentDirectory%/Downloads`
 
@@ -149,27 +149,33 @@ If you want to contribute, please feel free to fork and create a Pull-Request!
 General rules:
 - Strongly-type your variables. This improves readability.
 ```csharp
-var xyz = Object.GetSomething(); //Do not do this. What type is xyz?
+var xyz = Object.GetSomething(); //Do not do this. What type is xyz (without looking at Method returns etc.)?
 Manga[] zyx = Object.GetAnotherThing(); //I can now easily see that zyx is an Array.
 ```
+Tranga is using a code-first Entity-Framework Core approach. If you modify the db-table structure you need to create a migration.
 
 **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
+- `Program.cs` Configuration for ASP.NET, Swagger (also in `NamedSwaggerGenOptions.cs`)
+- `Tranga.cs` Worker-Logic
 - `Schema/` Entity-Framework
   - `Schema/Jobs/` + Logic for Jobs
   - `Schema/**/` + Logic for **
-  - `Schema/PgsqlContext.cs` EF configuration
+  - `Schema/Contexts/` 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 />
+If you want to add a new Website-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
+3. In `PgsqlContext.cs` add the Discriminator for the Connector (the value is the name of the connector, as defined
 in the constructor).
+4. In `Program.cs` add a new Object to the Array.
+
+### How to test locally
+
+In the Project root a `docker-compose.local.yaml` file will compile the code and create the container(s).
 
 <!-- LICENSE -->
 ## License

Tranga.sln.DotSettings

@@ -2,6 +2,7 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=altnames/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=authorsartists/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Gotify/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=jikan/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=jjob/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Komga/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=lunasea/@EntryIndexedValue">True</s:Boolean>

docker-compose.local.yaml

@@ -11,10 +11,16 @@ services:
     ports:
       - "6531:6531"
     depends_on:
-      - tranga-pg
+      tranga-pg:
+        condition: service_healthy
     environment:
       - POSTGRES_HOST=tranga-pg
     restart: unless-stopped
+    logging:
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "5"
   tranga-pg:
     image: postgres:latest
     container_name: tranga-pg
@@ -22,4 +28,15 @@ services:
       - "5432:5432"
     environment:
       - POSTGRES_PASSWORD=postgres
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready"]
+      interval: 30s
+      timeout: 60s
+      retries: 5
+      start_period: 80s
     restart: unless-stopped
+    logging:
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "5"

docker-compose.yaml

@@ -1,7 +1,7 @@
-version: '3'
+version: '3'
 services:
   tranga-api:
-    image: glax/tranga-api:latest
+    image: glax/tranga-api:Server-V2
     container_name: tranga-api
     volumes:
       - ./Manga:/Manga
@@ -9,18 +9,29 @@ services:
     ports:
       - "6531:6531"
     depends_on:
-      - tranga-pg
+      tranga-pg:
+        condition: service_healthy
     environment:
       - POSTGRES_HOST=tranga-pg
     restart: unless-stopped
+    logging:
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "5"
   tranga-website:
-    image: glax/tranga-website:latest
+    image: glax/tranga-website:Server-V2
     container_name: tranga-website
     ports:
       - "9555:80"
     depends_on: 
       - tranga-api
     restart: unless-stopped
+    logging:
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "5"
   tranga-pg:
     image: postgres:latest
     container_name: tranga-pg
@@ -28,4 +39,15 @@ services:
       - "5432:5432"
     environment:
       - POSTGRES_PASSWORD=postgres
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready"]
+      interval: 30s
+      timeout: 60s
+      retries: 5
+      start_period: 80s
     restart: unless-stopped
+    logging:
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "5"