Only update jobs that still exist

Do not include Manga.CoverUrl and CoverFileNameInCache in API-request-responses

API/APIEndpointRecords/CoverFormatRequestRecord.cs

@@ -1,13 +0,0 @@
-using SixLabors.ImageSharp;
-
-namespace API.APIEndpointRecords;
-
-public record CoverFormatRequestRecord(Size size)
-{
-    public bool Validate()
-    {
-        if (size.Height <= 0 || size.Width <= 0 || size.Height > 65535 || size.Width > 65535) //JPEG max size
-            return false;
-        return true;
-    }
-}

API/Controllers/JobController.cs

@@ -63,6 +63,20 @@ public class JobController(PgsqlContext context) : Controller
         return Ok(jobsOfType);
     }
 
+    /// <summary>
+    /// Returns all Jobs of requested Type and State
+    /// </summary>
+    /// <param name="JobType">Requested Job-Type</param>
+    /// <param name="JobState">Requested Job-State</param>
+    /// <response code="200"></response>
+    [HttpGet("TypeAndState/{JobType}/{JobState}")]
+    [ProducesResponseType<Job[]>(Status200OK, "application/json")]
+    public IActionResult GetJobsOfType(JobType JobType, JobState JobState)
+    {
+        Job[] jobsOfType = context.Jobs.Where(job => job.JobType == JobType && job.state == JobState).ToArray();
+        return Ok(jobsOfType);
+    }
+
     /// <summary>
     /// Return Job with ID
     /// </summary>

API/Controllers/MangaConnectorController.cs

@@ -8,7 +8,7 @@ namespace API.Controllers;
 
 [ApiVersion(2)]
 [ApiController]
-[Route("v{v:apiVersion}")]
+[Route("v{v:apiVersion}/[controller]")]
 public class MangaConnectorController(PgsqlContext context) : Controller
 {
     /// <summary>

API/Controllers/MangaController.cs

@@ -1,9 +1,7 @@
-using API.APIEndpointRecords;
+using API.Schema;
-using API.Schema;
 using API.Schema.Jobs;
 using Asp.Versioning;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc.ModelBinding;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Processing;
@@ -92,34 +90,45 @@ public class MangaController(PgsqlContext context) : Controller
     /// Returns Cover of Manga
     /// </summary>
     /// <param name="MangaId">Manga-ID</param>
-    /// <param name="formatRequest">Formatting/Resizing Request</param>
+    /// <param name="width">If width is provided, height needs to also be provided</param>
+    /// <param name="height">If height is provided, width needs to also be provided</param>
     /// <response code="200">JPEG Image</response>
     /// <response code="204">Cover not loaded</response>
     /// <response code="400">The formatting-request was invalid</response>
     /// <response code="404">Manga with ID not found</response>
-    [HttpPost("{MangaId}/Cover")]
+    [HttpGet("{MangaId}/Cover")]
     [ProducesResponseType<byte[]>(Status200OK,"image/jpeg")]
     [ProducesResponseType(Status204NoContent)]
     [ProducesResponseType(Status400BadRequest)]
     [ProducesResponseType(Status404NotFound)]
-    public IActionResult GetCover(string MangaId, [FromBody(EmptyBodyBehavior = EmptyBodyBehavior.Allow)]CoverFormatRequestRecord? formatRequest)
+    public IActionResult GetCover(string MangaId, [FromQuery]int? width, [FromQuery]int? height)
     {
         Manga? m = context.Manga.Find(MangaId);
         if (m is null)
             return NotFound();
+        if (!System.IO.File.Exists(m.CoverFileNameInCache))
+        {
+            bool coverIsBeingDownloaded = false;
+            do
+            {
+                coverIsBeingDownloaded = context.Jobs.Where(j => j.JobType == JobType.DownloadMangaCoverJob).AsEnumerable()
+                    .Any(j => j is DownloadMangaCoverJob dmcj && dmcj.MangaId == MangaId);
+                Thread.Sleep(100);
+            } while (coverIsBeingDownloaded);
             if (!System.IO.File.Exists(m.CoverFileNameInCache))
                 return NoContent();
+        }
 
         Image image = Image.Load(m.CoverFileNameInCache);
 
-        if (formatRequest is not null)
+        if (width is { } w && height is { } h)
         {
-            if(!formatRequest.Validate())
+            if (width < 10 || height < 10 || width > 65535 || height > 65535)
                 return BadRequest();
             image.Mutate(i => i.ApplyProcessor(new ResizeProcessor(new ResizeOptions()
             {
                 Mode = ResizeMode.Max,
-                Size = formatRequest.size
+                Size = new Size(w, h)
             }, image.Size)));
         }
         
@@ -147,6 +156,54 @@ public class MangaController(PgsqlContext context) : Controller
         return Ok(ret);
     }
     
+    /// <summary>
+    /// Returns all downloaded Chapters for Manga with ID
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <response code="200"></response>
+    /// <response code="204">No available chapters</response>
+    /// <response code="404">Manga with ID not found.</response>
+    [HttpGet("{MangaId}/Chapters/Downloaded")]
+    [ProducesResponseType<Chapter[]>(Status200OK, "application/json")]
+    [ProducesResponseType(Status204NoContent)]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetChaptersDownloaded(string MangaId)
+    {
+        Manga? m = context.Manga.Find(MangaId);
+        if (m is null)
+            return NotFound();
+        
+        List<Chapter> chapters = context.Chapters.Where(c => c.ParentMangaId == m.MangaId && c.Downloaded == true).ToList();
+        if (chapters.Count == 0)
+            return NoContent();
+        
+        return Ok(chapters);
+    }
+    
+    /// <summary>
+    /// Returns all Chapters not downloaded for Manga with ID
+    /// </summary>
+    /// <param name="MangaId">Manga-ID</param>
+    /// <response code="200"></response>
+    /// <response code="204">No available chapters</response>
+    /// <response code="404">Manga with ID not found.</response>
+    [HttpGet("{MangaId}/Chapters/NotDownloaded")]
+    [ProducesResponseType<Chapter[]>(Status200OK, "application/json")]
+    [ProducesResponseType(Status204NoContent)]
+    [ProducesResponseType(Status404NotFound)]
+    public IActionResult GetChaptersNotDownloaded(string MangaId)
+    {
+        Manga? m = context.Manga.Find(MangaId);
+        if (m is null)
+            return NotFound();
+        
+        List<Chapter> chapters = context.Chapters.Where(c => c.ParentMangaId == m.MangaId && c.Downloaded == false).ToList();
+        if (chapters.Count == 0)
+            return NoContent();
+        
+        return Ok(chapters);
+    }
+    
     /// <summary>
     /// Returns the latest Chapter of requested Manga available on Website
     /// </summary>
@@ -213,15 +270,27 @@ public class MangaController(PgsqlContext context) : Controller
     /// <param name="MangaId">Manga-ID</param>
     /// <response code="200"></response>
     /// <response code="404">Manga with ID not found.</response>
+    /// <response code="500">Error during Database Operation</response>
     [HttpPatch("{MangaId}/IgnoreChaptersBefore")]
-    [ProducesResponseType<float>(Status200OK, "text/plain")]
+    [ProducesResponseType(Status200OK)]
     [ProducesResponseType(Status404NotFound)]
-    public IActionResult IgnoreChaptersBefore(string MangaId)
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult IgnoreChaptersBefore(string MangaId, [FromBody]float chapterThreshold)
     {
         Manga? m = context.Manga.Find(MangaId);
         if (m is null)
             return NotFound();
-        return Ok(m.IgnoreChapterBefore);
+        
+        try
+        {
+            m.IgnoreChapterBefore = chapterThreshold;
+            context.SaveChanges();
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
     }
     
     /// <summary>

API/Controllers/QueryController.cs

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

API/Controllers/SearchController.cs

@@ -3,7 +3,6 @@ using API.Schema.Jobs;
 using API.Schema.MangaConnectors;
 using Asp.Versioning;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
 using static Microsoft.AspNetCore.Http.StatusCodes;
 
 namespace API.Controllers;
@@ -50,17 +49,17 @@ public class SearchController(PgsqlContext context) : Controller
     /// Initiate a search for a Manga on a specific Connector
     /// </summary>
     /// <param name="MangaConnectorName">Manga-Connector-ID</param>
-    /// <param name="SearchName">Name/Title of the Manga</param>
+    /// <param name="name">Name/Title of the Manga</param>
     /// <response code="200"></response>
     /// <response code="404">MangaConnector with ID not found</response>
     /// <response code="406">MangaConnector with ID is disabled</response>
     /// <response code="500">Error during Database Operation</response>
-    [HttpPost("{MangaConnectorName}/{SearchName}")]
+    [HttpPost("{MangaConnectorName}")]
     [ProducesResponseType<Manga[]>(Status200OK, "application/json")]
     [ProducesResponseType(Status404NotFound)]
     [ProducesResponseType(Status406NotAcceptable)]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
-    public IActionResult SearchManga(string MangaConnectorName, string SearchName)
+    public IActionResult SearchManga(string MangaConnectorName, [FromBody]string name)
     {
         MangaConnector? connector = context.MangaConnectors.Find(MangaConnectorName);
         if (connector is null)
@@ -68,7 +67,7 @@ public class SearchController(PgsqlContext context) : Controller
         else if (connector.Enabled is false)
             return StatusCode(406);
         
-        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] mangas = connector.GetManga(SearchName);
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] mangas = connector.GetManga(name);
         List<Manga> retMangas = new();
         foreach ((Manga? manga, List<Author>? authors, List<MangaTag>? tags, List<Link>? links, List<MangaAltTitle>? altTitles) in mangas)
         {
@@ -132,18 +131,18 @@ public class SearchController(PgsqlContext context) : Controller
         if (manga is null)
             return null;
 
-        Manga? existing = context.Manga.FirstOrDefault(m =>
+        Manga? existing = context.Manga.Find(manga.MangaId);
-            m.MangaId == manga.MangaId);
         
         if (tags is not null)
         {
             IEnumerable<MangaTag> mergedTags = tags.Select(mt =>
             {
-                MangaTag? inDb = context.Tags.FirstOrDefault(t => t.Equals(mt));
+                MangaTag? inDb = context.Tags.Find(mt.Tag);
                 return inDb ?? mt;
             });
             manga.MangaTags = mergedTags.ToList();
-            IEnumerable<MangaTag> newTags = manga.MangaTags.Where(mt => !context.Tags.Any(t => t.Tag.Equals(mt.Tag)));
+            IEnumerable<MangaTag> newTags = manga.MangaTags
+                .Where(mt => !context.Tags.Select(t => t.Tag).Contains(mt.Tag));
             context.Tags.AddRange(newTags);
         }
 
@@ -151,12 +150,12 @@ public class SearchController(PgsqlContext context) : Controller
         {
             IEnumerable<Author> mergedAuthors = authors.Select(ma =>
             {
-                Author? inDb = context.Authors.FirstOrDefault(a => a.AuthorName == ma.AuthorName);
+                Author? inDb = context.Authors.Find(ma.AuthorId);
                 return inDb ?? ma;
             });
             manga.Authors = mergedAuthors.ToList();
-            IEnumerable<Author> newAuthors = manga.Authors.Where(ma => !context.Authors.Any(a =>
+            IEnumerable<Author> newAuthors = manga.Authors
-                a.AuthorName == ma.AuthorName));
+                .Where(ma => !context.Authors.Select(a => a.AuthorId).Contains(ma.AuthorId));
             context.Authors.AddRange(newAuthors);
         }
 
@@ -164,13 +163,12 @@ public class SearchController(PgsqlContext context) : Controller
         {
             IEnumerable<Link> mergedLinks = links.Select(ml =>
             {
-                Link? inDb = context.Link.FirstOrDefault(l =>
+                Link? inDb = context.Link.Find(ml.LinkId);
-                    l.LinkProvider == ml.LinkProvider && l.LinkUrl == ml.LinkUrl);
                 return inDb ?? ml;
             });
             manga.Links = mergedLinks.ToList();
-            IEnumerable<Link> newLinks = manga.Links.Where(ml => !context.Link.Any(l =>
+            IEnumerable<Link> newLinks = manga.Links
-                l.LinkProvider == ml.LinkProvider && l.LinkUrl == ml.LinkUrl));
+                .Where(ml => !context.Link.Select(l => l.LinkId).Contains(ml.LinkId));
             context.Link.AddRange(newLinks);
         }
 
@@ -178,13 +176,12 @@ public class SearchController(PgsqlContext context) : Controller
         {
             IEnumerable<MangaAltTitle> mergedAltTitles = altTitles.Select(mat =>
             {
-                MangaAltTitle? inDb = context.AltTitles.FirstOrDefault(at =>
+                MangaAltTitle? inDb = context.AltTitles.Find(mat.AltTitleId);
-                    at.Language == mat.Language && at.Title == mat.Title);
                 return inDb ?? mat;
             });
             manga.AltTitles = mergedAltTitles.ToList();
-            IEnumerable<MangaAltTitle> newAltTitles = manga.AltTitles.Where(mat =>
+            IEnumerable<MangaAltTitle> newAltTitles = manga.AltTitles
-                !context.AltTitles.Any(at => at.Language == mat.Language && at.Title == mat.Title));
+                .Where(mat => !context.AltTitles.Select(at => at.AltTitleId).Contains(mat.AltTitleId));
             context.AltTitles.AddRange(newAltTitles);
         }
         

API/Migrations/20250313145235_dev-130325-1.Designer.cs

@@ -0,0 +1,735 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using API.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250313145235_dev-130325-1")]
+    partial class dev1303251
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ArchiveFileName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("JobId1")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("JobId1");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Link");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasColumnType("text");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasColumnType("text");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.Property<string>("AuthorsAuthorId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorsAuthorId", "MangaId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AuthorManga");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("text");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.AsuraToon", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("AsuraToon");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Bato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Bato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaHere", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaHere");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaKatana", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaKatana");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Mangaworld", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Mangaworld");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ManhuaPlus", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ManhuaPlus");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Weebcentral", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Weebcentral");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany()
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany("DependsOnJobs")
+                        .HasForeignKey("JobId1");
+
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId");
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorsAuthorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Navigation("DependsOnJobs");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250313145235_dev-130325-1.cs

@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev1303251 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "ConnectorId",
+                table: "Manga",
+                newName: "IdOnConnectorSite");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "IdOnConnectorSite",
+                table: "Manga",
+                newName: "ConnectorId");
+        }
+    }
+}

API/Migrations/20250313175936_dev-130325-2.Designer.cs

@@ -0,0 +1,745 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using API.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250313175936_dev-130325-2")]
+    partial class dev1303252
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ArchiveFileName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("JobId1")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("JobId1");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Link");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    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()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasColumnType("text");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.Property<string>("AuthorsAuthorId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorsAuthorId", "MangaId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AuthorManga");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("text");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.AsuraToon", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("AsuraToon");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Bato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Bato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaHere", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaHere");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaKatana", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaKatana");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Mangaworld", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Mangaworld");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ManhuaPlus", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ManhuaPlus");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Weebcentral", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Weebcentral");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany()
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany("DependsOnJobs")
+                        .HasForeignKey("JobId1");
+
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId");
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorsAuthorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Navigation("DependsOnJobs");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250313175936_dev-130325-2.cs

@@ -0,0 +1,94 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev1303252 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "OriginalLanguage",
+                table: "Manga",
+                type: "character varying(8)",
+                maxLength: 8,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "Manga",
+                type: "character varying(512)",
+                maxLength: 512,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "MangaConnectorId",
+                table: "Manga",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(32)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "IdOnConnectorSite",
+                table: "Manga",
+                type: "character varying(128)",
+                maxLength: 128,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "OriginalLanguage",
+                table: "Manga",
+                type: "text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(8)",
+                oldMaxLength: 8,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "Manga",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(512)",
+                oldMaxLength: 512);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "MangaConnectorId",
+                table: "Manga",
+                type: "character varying(32)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "IdOnConnectorSite",
+                table: "Manga",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(128)",
+                oldMaxLength: 128);
+        }
+    }
+}

API/Migrations/20250313180256_dev-130325-3.Designer.cs

@@ -0,0 +1,747 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using API.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250313180256_dev-130325-3")]
+    partial class dev1303253
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ArchiveFileName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("JobId1")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("JobId1");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Link");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasColumnType("text");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.Property<string>("AuthorsAuthorId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorsAuthorId", "MangaId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AuthorManga");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("text");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.AsuraToon", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("AsuraToon");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Bato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Bato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaHere", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaHere");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaKatana", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaKatana");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Mangaworld", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Mangaworld");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ManhuaPlus", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ManhuaPlus");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Weebcentral", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Weebcentral");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany()
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany("DependsOnJobs")
+                        .HasForeignKey("JobId1");
+
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId");
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorsAuthorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Navigation("DependsOnJobs");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250313180256_dev-130325-3.cs

@@ -0,0 +1,58 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev1303253 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "WebsiteUrl",
+                table: "Manga",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "OriginalLanguage",
+                table: "Manga",
+                type: "character varying(8)",
+                maxLength: 8,
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "character varying(8)",
+                oldMaxLength: 8,
+                oldNullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "WebsiteUrl",
+                table: "Manga",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "OriginalLanguage",
+                table: "Manga",
+                type: "character varying(8)",
+                maxLength: 8,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(8)",
+                oldMaxLength: 8);
+        }
+    }
+}

API/Migrations/20250313180926_dev-130325-4.Designer.cs

@@ -0,0 +1,767 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using API.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250313180926_dev-130325-4")]
+    partial class dev1303254
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ArchiveFileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("JobId1")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("JobId1");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Link");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.Property<string>("AuthorsAuthorId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorsAuthorId", "MangaId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AuthorManga");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.AsuraToon", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("AsuraToon");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Bato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Bato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaHere", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaHere");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaKatana", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaKatana");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Mangaworld", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Mangaworld");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ManhuaPlus", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ManhuaPlus");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Weebcentral", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Weebcentral");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany()
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany("DependsOnJobs")
+                        .HasForeignKey("JobId1");
+
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId");
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorsAuthorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Navigation("DependsOnJobs");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250313180926_dev-130325-4.cs

@@ -0,0 +1,366 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev1303254 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "Tag",
+                table: "Tags",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Title",
+                table: "Notifications",
+                type: "character varying(128)",
+                maxLength: 128,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Message",
+                table: "Notifications",
+                type: "character varying(512)",
+                maxLength: 512,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Url",
+                table: "NotificationConnectors",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "HttpMethod",
+                table: "NotificationConnectors",
+                type: "character varying(8)",
+                maxLength: 8,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Body",
+                table: "NotificationConnectors",
+                type: "character varying(512)",
+                maxLength: 512,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "MangaTagsTag",
+                table: "MangaMangaTag",
+                type: "character varying(64)",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "IconUrl",
+                table: "MangaConnectors",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "Manga",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(512)",
+                oldMaxLength: 512);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LinkUrl",
+                table: "Link",
+                type: "character varying(128)",
+                maxLength: 128,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LinkProvider",
+                table: "Link",
+                type: "character varying(128)",
+                maxLength: 128,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "BaseUrl",
+                table: "LibraryConnectors",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Auth",
+                table: "LibraryConnectors",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string[]>(
+                name: "DependsOnJobsIds",
+                table: "Jobs",
+                type: "text[]",
+                maxLength: 64,
+                nullable: false,
+                defaultValue: new string[0],
+                oldClrType: typeof(string[]),
+                oldType: "text[]",
+                oldMaxLength: 64,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Url",
+                table: "Chapters",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Title",
+                table: "Chapters",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ArchiveFileName",
+                table: "Chapters",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "AuthorName",
+                table: "Authors",
+                type: "character varying(128)",
+                maxLength: 128,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Title",
+                table: "AltTitles",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "Tag",
+                table: "Tags",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Title",
+                table: "Notifications",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(128)",
+                oldMaxLength: 128);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Message",
+                table: "Notifications",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(512)",
+                oldMaxLength: 512);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Url",
+                table: "NotificationConnectors",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "HttpMethod",
+                table: "NotificationConnectors",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(8)",
+                oldMaxLength: 8);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Body",
+                table: "NotificationConnectors",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(512)",
+                oldMaxLength: 512);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "MangaTagsTag",
+                table: "MangaMangaTag",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "IconUrl",
+                table: "MangaConnectors",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "Manga",
+                type: "character varying(512)",
+                maxLength: 512,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LinkUrl",
+                table: "Link",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(128)",
+                oldMaxLength: 128);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LinkProvider",
+                table: "Link",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(128)",
+                oldMaxLength: 128);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "BaseUrl",
+                table: "LibraryConnectors",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Auth",
+                table: "LibraryConnectors",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+
+            migrationBuilder.AlterColumn<string[]>(
+                name: "DependsOnJobsIds",
+                table: "Jobs",
+                type: "text[]",
+                maxLength: 64,
+                nullable: true,
+                oldClrType: typeof(string[]),
+                oldType: "text[]",
+                oldMaxLength: 64);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Url",
+                table: "Chapters",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Title",
+                table: "Chapters",
+                type: "text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "ArchiveFileName",
+                table: "Chapters",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "AuthorName",
+                table: "Authors",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(128)",
+                oldMaxLength: 128);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Title",
+                table: "AltTitles",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+        }
+    }
+}

API/Migrations/20250313181126_dev-130325-5.Designer.cs

@@ -0,0 +1,766 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using API.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250313181126_dev-130325-5")]
+    partial class dev1303255
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ArchiveFileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("JobId1")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("JobId1");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Link");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.Property<string>("AuthorsAuthorId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorsAuthorId", "MangaId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AuthorManga");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.AsuraToon", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("AsuraToon");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Bato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Bato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaHere", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaHere");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaKatana", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaKatana");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Mangaworld", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Mangaworld");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ManhuaPlus", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ManhuaPlus");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Weebcentral", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Weebcentral");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany()
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany("DependsOnJobs")
+                        .HasForeignKey("JobId1");
+
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId");
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorsAuthorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Navigation("DependsOnJobs");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250313181126_dev-130325-5.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev1303255 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string[]>(
+                name: "DependsOnJobsIds",
+                table: "Jobs",
+                type: "text[]",
+                maxLength: 64,
+                nullable: true,
+                oldClrType: typeof(string[]),
+                oldType: "text[]",
+                oldMaxLength: 64);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string[]>(
+                name: "DependsOnJobsIds",
+                table: "Jobs",
+                type: "text[]",
+                maxLength: 64,
+                nullable: false,
+                defaultValue: new string[0],
+                oldClrType: typeof(string[]),
+                oldType: "text[]",
+                oldMaxLength: 64,
+                oldNullable: true);
+        }
+    }
+}

API/Migrations/20250313191146_dev-130325-6.Designer.cs

@@ -0,0 +1,768 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using API.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250313191146_dev-130325-6")]
+    partial class dev1303256
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ArchiveFileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("JobId1")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("JobId1");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Link");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.Property<string>("AuthorsAuthorId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorsAuthorId", "MangaId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AuthorManga");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.AsuraToon", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("AsuraToon");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Bato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Bato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaHere", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaHere");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaKatana", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaKatana");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Mangaworld", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Mangaworld");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ManhuaPlus", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ManhuaPlus");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Weebcentral", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Weebcentral");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany()
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany("DependsOnJobs")
+                        .HasForeignKey("JobId1");
+
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId");
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorsAuthorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Navigation("DependsOnJobs");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250313191146_dev-130325-6.cs

@@ -0,0 +1,58 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev1303256 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "ToLocation",
+                table: "Jobs",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "text",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "FromLocation",
+                table: "Jobs",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "text",
+                oldNullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "ToLocation",
+                table: "Jobs",
+                type: "text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "FromLocation",
+                table: "Jobs",
+                type: "text",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256,
+                oldNullable: true);
+        }
+    }
+}

API/Migrations/20250313212324_dev-130325-7.Designer.cs

@@ -0,0 +1,770 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using API.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250313212324_dev-130325-7")]
+    partial class dev1303257
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ArchiveFileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("JobId1")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("JobId1");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Link");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.Property<string>("AuthorsAuthorId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorsAuthorId", "MangaId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AuthorManga");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.AsuraToon", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("AsuraToon");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Bato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Bato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaHere", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaHere");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaKatana", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaKatana");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Mangaworld", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Mangaworld");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ManhuaPlus", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ManhuaPlus");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Weebcentral", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Weebcentral");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany()
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany("DependsOnJobs")
+                        .HasForeignKey("JobId1");
+
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId");
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorsAuthorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Navigation("DependsOnJobs");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250313212324_dev-130325-7.cs

@@ -0,0 +1,64 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev1303257 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AltTitles_Manga_MangaId",
+                table: "AltTitles");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Link_Manga_MangaId",
+                table: "Link");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AltTitles_Manga_MangaId",
+                table: "AltTitles",
+                column: "MangaId",
+                principalTable: "Manga",
+                principalColumn: "MangaId",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Link_Manga_MangaId",
+                table: "Link",
+                column: "MangaId",
+                principalTable: "Manga",
+                principalColumn: "MangaId",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AltTitles_Manga_MangaId",
+                table: "AltTitles");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Link_Manga_MangaId",
+                table: "Link");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AltTitles_Manga_MangaId",
+                table: "AltTitles",
+                column: "MangaId",
+                principalTable: "Manga",
+                principalColumn: "MangaId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Link_Manga_MangaId",
+                table: "Link",
+                column: "MangaId",
+                principalTable: "Manga",
+                principalColumn: "MangaId");
+        }
+    }
+}

API/Migrations/20250313222533_dev-130325-8.Designer.cs

@@ -0,0 +1,770 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using API.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250313222533_dev-130325-8")]
+    partial class dev1303258
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ArchiveFileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("JobId1")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("JobId1");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Link");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.Property<string>("AuthorsAuthorId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorsAuthorId", "MangaId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AuthorManga");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.AsuraToon", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("AsuraToon");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Bato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Bato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaHere", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaHere");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaKatana", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaKatana");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Mangaworld", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Mangaworld");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ManhuaPlus", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ManhuaPlus");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Weebcentral", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Weebcentral");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany()
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany("DependsOnJobs")
+                        .HasForeignKey("JobId1");
+
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId");
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorsAuthorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Navigation("DependsOnJobs");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250313222533_dev-130325-8.cs

@@ -0,0 +1,138 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev1303258 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "Url",
+                table: "NotificationConnectors",
+                type: "character varying(2048)",
+                maxLength: 2048,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Body",
+                table: "NotificationConnectors",
+                type: "character varying(4096)",
+                maxLength: 4096,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(512)",
+                oldMaxLength: 512);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "IconUrl",
+                table: "MangaConnectors",
+                type: "character varying(2048)",
+                maxLength: 2048,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LinkUrl",
+                table: "Link",
+                type: "character varying(2048)",
+                maxLength: 2048,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(128)",
+                oldMaxLength: 128);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LinkProvider",
+                table: "Link",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(128)",
+                oldMaxLength: 128);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Url",
+                table: "Chapters",
+                type: "character varying(2048)",
+                maxLength: 2048,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(256)",
+                oldMaxLength: 256);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "Url",
+                table: "NotificationConnectors",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(2048)",
+                oldMaxLength: 2048);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Body",
+                table: "NotificationConnectors",
+                type: "character varying(512)",
+                maxLength: 512,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(4096)",
+                oldMaxLength: 4096);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "IconUrl",
+                table: "MangaConnectors",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(2048)",
+                oldMaxLength: 2048);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LinkUrl",
+                table: "Link",
+                type: "character varying(128)",
+                maxLength: 128,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(2048)",
+                oldMaxLength: 2048);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "LinkProvider",
+                table: "Link",
+                type: "character varying(128)",
+                maxLength: 128,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(64)",
+                oldMaxLength: 64);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Url",
+                table: "Chapters",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "character varying(2048)",
+                oldMaxLength: 2048);
+        }
+    }
+}

API/Migrations/20250313233529_dev-130325-9.Designer.cs

@@ -0,0 +1,787 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using API.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    [DbContext(typeof(PgsqlContext))]
+    [Migration("20250313233529_dev-130325-9")]
+    partial class dev1303259
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("API.Schema.Author", b =>
+                {
+                    b.Property<string>("AuthorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("AuthorId");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.Property<string>("ChapterId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ArchiveFileName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ChapterNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<bool>("Downloaded")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ParentMangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("VolumeNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChapterId");
+
+                    b.HasIndex("ParentMangaId");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Property<string>("JobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.PrimitiveCollection<string[]>("DependsOnJobsIds")
+                        .HasMaxLength(64)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<byte>("JobType")
+                        .HasColumnType("smallint");
+
+                    b.Property<DateTime>("LastExecution")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ParentJobId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<decimal>("RecurrenceMs")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<byte>("state")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ParentJobId");
+
+                    b.ToTable("Jobs");
+
+                    b.HasDiscriminator<byte>("JobType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.LibraryConnector", b =>
+                {
+                    b.Property<string>("LibraryConnectorId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("BaseUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<byte>("LibraryType")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("LibraryConnectorId");
+
+                    b.ToTable("LibraryConnectors");
+
+                    b.HasDiscriminator<byte>("LibraryType");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.Property<string>("LinkId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkProvider")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LinkUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("LinkId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Link");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("OriginalLanguage")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("text[]");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IconUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.PrimitiveCollection<string[]>("SupportedLanguages")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("text[]");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("MangaConnectors");
+
+                    b.HasDiscriminator<string>("Name").HasValue("MangaConnector");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("API.Schema.MangaTag", b =>
+                {
+                    b.Property<string>("Tag")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Tag");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("API.Schema.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("Urgency")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("NotificationId");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("API.Schema.NotificationConnectors.NotificationConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<Dictionary<string, string>>("Headers")
+                        .IsRequired()
+                        .HasColumnType("hstore");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("NotificationConnectors");
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.Property<string>("AuthorsAuthorId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("AuthorsAuthorId", "MangaId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AuthorManga");
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MangaTagsTag")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("MangaId", "MangaTagsTag");
+
+                    b.HasIndex("MangaTagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("RetrieveChaptersJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)5);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateFilesDownloadedJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)6);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.AsuraToon", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("AsuraToon");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Bato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Bato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaHere", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaHere");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaKatana", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaKatana");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Mangaworld", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Mangaworld");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.ManhuaPlus", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("ManhuaPlus");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Weebcentral", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Weebcentral");
+                });
+
+            modelBuilder.Entity("API.Schema.Chapter", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "ParentManga")
+                        .WithMany()
+                        .HasForeignKey("ParentMangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ParentManga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", "ParentJob")
+                        .WithMany()
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("ParentJob");
+                });
+
+            modelBuilder.Entity("API.Schema.Link", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("Links")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.HasOne("API.Schema.MangaConnectors.MangaConnector", "MangaConnector")
+                        .WithMany()
+                        .HasForeignKey("MangaConnectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MangaConnector");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany("AltTitles")
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("AuthorManga", b =>
+                {
+                    b.HasOne("API.Schema.Author", null)
+                        .WithMany()
+                        .HasForeignKey("AuthorsAuthorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MangaMangaTag", b =>
+                {
+                    b.HasOne("API.Schema.Manga", null)
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.MangaTag", null)
+                        .WithMany()
+                        .HasForeignKey("MangaTagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.RetrieveChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateFilesDownloadedJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250313233529_dev-130325-9.cs

@@ -0,0 +1,103 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev1303259 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Jobs_Jobs_JobId1",
+                table: "Jobs");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Jobs_Jobs_ParentJobId",
+                table: "Jobs");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Jobs_JobId1",
+                table: "Jobs");
+
+            migrationBuilder.DropColumn(
+                name: "JobId1",
+                table: "Jobs");
+
+            migrationBuilder.CreateTable(
+                name: "JobJob",
+                columns: table => new
+                {
+                    DependsOnJobsJobId = table.Column<string>(type: "character varying(64)", nullable: false),
+                    JobId = table.Column<string>(type: "character varying(64)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_JobJob", x => new { x.DependsOnJobsJobId, x.JobId });
+                    table.ForeignKey(
+                        name: "FK_JobJob_Jobs_DependsOnJobsJobId",
+                        column: x => x.DependsOnJobsJobId,
+                        principalTable: "Jobs",
+                        principalColumn: "JobId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_JobJob_Jobs_JobId",
+                        column: x => x.JobId,
+                        principalTable: "Jobs",
+                        principalColumn: "JobId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_JobJob_JobId",
+                table: "JobJob",
+                column: "JobId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Jobs_Jobs_ParentJobId",
+                table: "Jobs",
+                column: "ParentJobId",
+                principalTable: "Jobs",
+                principalColumn: "JobId",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Jobs_Jobs_ParentJobId",
+                table: "Jobs");
+
+            migrationBuilder.DropTable(
+                name: "JobJob");
+
+            migrationBuilder.AddColumn<string>(
+                name: "JobId1",
+                table: "Jobs",
+                type: "character varying(64)",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_JobId1",
+                table: "Jobs",
+                column: "JobId1");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Jobs_Jobs_JobId1",
+                table: "Jobs",
+                column: "JobId1",
+                principalTable: "Jobs",
+                principalColumn: "JobId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Jobs_Jobs_ParentJobId",
+                table: "Jobs",
+                column: "ParentJobId",
+                principalTable: "Jobs",
+                principalColumn: "JobId");
+        }
+    }
+}

API/Migrations/PgsqlContextModelSnapshot.cs

@@ -18,7 +18,7 @@ namespace API.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "9.0.2")
+                .HasAnnotation("ProductVersion", "9.0.3")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
             NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
@@ -32,7 +32,8 @@ namespace API.Migrations
 
                     b.Property<string>("AuthorName")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
 
                     b.HasKey("AuthorId");
 
@@ -47,7 +48,8 @@ namespace API.Migrations
 
                     b.Property<string>("ArchiveFileName")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
 
                     b.Property<string>("ChapterNumber")
                         .IsRequired()
@@ -59,14 +61,17 @@ namespace API.Migrations
 
                     b.Property<string>("ParentMangaId")
                         .IsRequired()
+                        .HasMaxLength(64)
                         .HasColumnType("character varying(64)");
 
                     b.Property<string>("Title")
-                        .HasColumnType("text");
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
 
                     b.Property<string>("Url")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
 
                     b.Property<int?>("VolumeNumber")
                         .HasColumnType("integer");
@@ -91,9 +96,6 @@ namespace API.Migrations
                     b.Property<bool>("Enabled")
                         .HasColumnType("boolean");
 
-                    b.Property<string>("JobId1")
-                        .HasColumnType("character varying(64)");
-
                     b.Property<byte>("JobType")
                         .HasColumnType("smallint");
 
@@ -112,8 +114,6 @@ namespace API.Migrations
 
                     b.HasKey("JobId");
 
-                    b.HasIndex("JobId1");
-
                     b.HasIndex("ParentJobId");
 
                     b.ToTable("Jobs");
@@ -131,11 +131,13 @@ namespace API.Migrations
 
                     b.Property<string>("Auth")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
 
                     b.Property<string>("BaseUrl")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
 
                     b.Property<byte>("LibraryType")
                         .HasColumnType("smallint");
@@ -157,11 +159,13 @@ namespace API.Migrations
 
                     b.Property<string>("LinkProvider")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
 
                     b.Property<string>("LinkUrl")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
 
                     b.Property<string>("MangaId")
                         .HasColumnType("character varying(64)");
@@ -179,11 +183,6 @@ namespace API.Migrations
                         .HasMaxLength(64)
                         .HasColumnType("character varying(64)");
 
-                    b.Property<string>("ConnectorId")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
                     b.Property<string>("CoverFileNameInCache")
                         .HasColumnType("text");
 
@@ -199,26 +198,36 @@ namespace API.Migrations
                         .IsRequired()
                         .HasColumnType("text");
 
+                    b.Property<string>("IdOnConnectorSite")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
                     b.Property<float>("IgnoreChapterBefore")
                         .HasColumnType("real");
 
                     b.Property<string>("MangaConnectorId")
                         .IsRequired()
-                        .HasColumnType("character varying(32)");
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
 
                     b.Property<string>("Name")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
 
                     b.Property<string>("OriginalLanguage")
-                        .HasColumnType("text");
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
 
                     b.Property<byte>("ReleaseStatus")
                         .HasColumnType("smallint");
 
                     b.Property<string>("WebsiteUrl")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
 
                     b.Property<long>("Year")
                         .HasColumnType("bigint");
@@ -246,7 +255,8 @@ namespace API.Migrations
 
                     b.Property<string>("Title")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
 
                     b.HasKey("AltTitleId");
 
@@ -263,6 +273,7 @@ namespace API.Migrations
 
                     b.PrimitiveCollection<string[]>("BaseUris")
                         .IsRequired()
+                        .HasMaxLength(256)
                         .HasColumnType("text[]");
 
                     b.Property<bool>("Enabled")
@@ -270,10 +281,12 @@ namespace API.Migrations
 
                     b.Property<string>("IconUrl")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
 
                     b.PrimitiveCollection<string[]>("SupportedLanguages")
                         .IsRequired()
+                        .HasMaxLength(8)
                         .HasColumnType("text[]");
 
                     b.HasKey("Name");
@@ -288,7 +301,8 @@ namespace API.Migrations
             modelBuilder.Entity("API.Schema.MangaTag", b =>
                 {
                     b.Property<string>("Tag")
-                        .HasColumnType("text");
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
 
                     b.HasKey("Tag");
 
@@ -306,11 +320,13 @@ namespace API.Migrations
 
                     b.Property<string>("Message")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
 
                     b.Property<string>("Title")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
 
                     b.Property<byte>("Urgency")
                         .HasColumnType("smallint");
@@ -328,7 +344,8 @@ namespace API.Migrations
 
                     b.Property<string>("Body")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
 
                     b.Property<Dictionary<string, string>>("Headers")
                         .IsRequired()
@@ -336,11 +353,13 @@ namespace API.Migrations
 
                     b.Property<string>("HttpMethod")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
 
                     b.Property<string>("Url")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
 
                     b.HasKey("Name");
 
@@ -362,13 +381,28 @@ namespace API.Migrations
                     b.ToTable("AuthorManga");
                 });
 
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.Property<string>("DependsOnJobsJobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("DependsOnJobsJobId", "JobId");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("JobJob");
+                });
+
             modelBuilder.Entity("MangaMangaTag", b =>
                 {
                     b.Property<string>("MangaId")
                         .HasColumnType("character varying(64)");
 
                     b.Property<string>("MangaTagsTag")
-                        .HasColumnType("text");
+                        .HasColumnType("character varying(64)");
 
                     b.HasKey("MangaId", "MangaTagsTag");
 
@@ -431,11 +465,13 @@ namespace API.Migrations
 
                     b.Property<string>("FromLocation")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
 
                     b.Property<string>("ToLocation")
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
 
                     b.HasDiscriminator().HasValue((byte)3);
                 });
@@ -549,6 +585,13 @@ namespace API.Migrations
                     b.HasDiscriminator().HasValue("MangaKatana");
                 });
 
+            modelBuilder.Entity("API.Schema.MangaConnectors.Manganato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Manganato");
+                });
+
             modelBuilder.Entity("API.Schema.MangaConnectors.Mangaworld", b =>
                 {
                     b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
@@ -583,13 +626,10 @@ namespace API.Migrations
 
             modelBuilder.Entity("API.Schema.Jobs.Job", b =>
                 {
-                    b.HasOne("API.Schema.Jobs.Job", null)
-                        .WithMany("DependsOnJobs")
-                        .HasForeignKey("JobId1");
-
                     b.HasOne("API.Schema.Jobs.Job", "ParentJob")
                         .WithMany()
-                        .HasForeignKey("ParentJobId");
+                        .HasForeignKey("ParentJobId")
+                        .OnDelete(DeleteBehavior.Cascade);
 
                     b.Navigation("ParentJob");
                 });
@@ -598,7 +638,8 @@ namespace API.Migrations
                 {
                     b.HasOne("API.Schema.Manga", null)
                         .WithMany("Links")
-                        .HasForeignKey("MangaId");
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
                 });
 
             modelBuilder.Entity("API.Schema.Manga", b =>
@@ -616,7 +657,8 @@ namespace API.Migrations
                 {
                     b.HasOne("API.Schema.Manga", null)
                         .WithMany("AltTitles")
-                        .HasForeignKey("MangaId");
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade);
                 });
 
             modelBuilder.Entity("AuthorManga", b =>
@@ -634,6 +676,21 @@ namespace API.Migrations
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("JobJob", b =>
+                {
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnJobsJobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Schema.Jobs.Job", null)
+                        .WithMany()
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("MangaMangaTag", b =>
                 {
                     b.HasOne("API.Schema.Manga", null)
@@ -715,11 +772,6 @@ namespace API.Migrations
                     b.Navigation("Manga");
                 });
 
-            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
-                {
-                    b.Navigation("DependsOnJobs");
-                });
-
             modelBuilder.Entity("API.Schema.Manga", b =>
                 {
                     b.Navigation("AltTitles");

API/Schema/Author.cs

@@ -6,7 +6,10 @@ namespace API.Schema;
 [PrimaryKey("AuthorId")]
 public class Author(string authorName)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string AuthorId { get; init; } = TokenGen.CreateToken(typeof(Author), authorName);
+    [StringLength(128)]
+    [Required]
     public string AuthorName { get; init; } = authorName;
 }

API/Schema/Chapter.cs

@@ -27,19 +27,30 @@ public class Chapter : IComparable<Chapter>
         Title = title;
     }
 
-    [MaxLength(64)] public string ChapterId { get; init; }
+    [StringLength(64)]
-
+    [Required]
+    public string ChapterId { get; init; }
     public int? VolumeNumber { get; private set; }
+    [StringLength(10)]
+    [Required]
+    public string ChapterNumber { get; private set; }
 
-    [MaxLength(10)] public string ChapterNumber { get; private set; }
+    [StringLength(2048)]
-
+    [Required]
+    [Url]
     public string Url { get; internal set; }
+    [StringLength(256)]
     public string? Title { get; private set; }
+    [StringLength(256)]
+    [Required]
     public string ArchiveFileName { get; private set; }
+    [Required]
     public bool Downloaded { get; internal set; } = false;
-
+    [Required]
+    [StringLength(64)]
     public string ParentMangaId { get; internal set; }
-    [JsonIgnore] public Manga? ParentManga { get; init; }
+    [JsonIgnore]
+    public Manga? ParentManga { get; init; }
 
     public int CompareTo(Chapter? other)
     {

API/Schema/Jobs/DownloadAvailableChaptersJob.cs

@@ -1,5 +1,4 @@
 using System.ComponentModel.DataAnnotations;
-using API.Schema.MangaConnectors;
 using Newtonsoft.Json;
 
 namespace API.Schema.Jobs;
@@ -7,7 +6,8 @@ namespace API.Schema.Jobs;
 public class DownloadAvailableChaptersJob(ulong recurrenceMs, string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
     : Job(TokenGen.CreateToken(typeof(DownloadAvailableChaptersJob)), JobType.DownloadAvailableChaptersJob, recurrenceMs, parentJobId, dependsOnJobsIds)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string MangaId { get; init; } = mangaId;
     
     [JsonIgnore]

API/Schema/Jobs/DownloadMangaCoverJob.cs

@@ -1,21 +1,13 @@
 using System.ComponentModel.DataAnnotations;
-using System.IO.Compression;
-using System.Runtime.InteropServices;
-using API.MangaDownloadClients;
-using API.Schema.MangaConnectors;
 using Newtonsoft.Json;
-using SixLabors.ImageSharp;
-using SixLabors.ImageSharp.Formats.Jpeg;
-using SixLabors.ImageSharp.Processing;
-using SixLabors.ImageSharp.Processing.Processors.Binarization;
-using static System.IO.UnixFileMode;
 
 namespace API.Schema.Jobs;
 
 public class DownloadMangaCoverJob(string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
     : Job(TokenGen.CreateToken(typeof(DownloadMangaCoverJob)), JobType.DownloadMangaCoverJob, 0, parentJobId, dependsOnJobsIds)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string MangaId { get; init; } = mangaId;
     [JsonIgnore]
     public Manga? Manga { get; init; }

API/Schema/Jobs/DownloadSingleChapterJob.cs

@@ -15,7 +15,8 @@ namespace API.Schema.Jobs;
 public class DownloadSingleChapterJob(string chapterId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
     : Job(TokenGen.CreateToken(typeof(DownloadSingleChapterJob)), JobType.DownloadSingleChapterJob, 0, parentJobId, dependsOnJobsIds)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string ChapterId { get; init; } = chapterId;
     
     [JsonIgnore]
@@ -74,7 +75,7 @@ public class DownloadSingleChapterJob(string chapterId, string? parentJobId = nu
         chapter.Downloaded = true;
         context.SaveChanges();
 
-        return [];
+        return [new UpdateFilesDownloadedJob(0, manga.MangaId, this.JobId)];
     }
     
     private void ProcessImage(string imagePath)

API/Schema/Jobs/Job.cs

@@ -8,26 +8,31 @@ namespace API.Schema.Jobs;
 [PrimaryKey("JobId")]
 public abstract class Job 
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string JobId { get; init; }
-    
+    [StringLength(64)]
-    [MaxLength(64)]
     public string? ParentJobId { get; init; }
     [JsonIgnore]
     public Job? ParentJob { get; init; }
-    
+    [StringLength(64)]
-    [MaxLength(64)]
     public ICollection<string>? DependsOnJobsIds { get; init; }
     [JsonIgnore]
     public ICollection<Job>? DependsOnJobs { get; init; }
     
+    [Required]
     public JobType JobType { get; init; }
+    [Required]
     public ulong RecurrenceMs { get; set; }
+    [Required]
     public DateTime LastExecution { get; internal set; } = DateTime.UnixEpoch;
     
     [NotMapped]
+    [Required]
     public DateTime NextExecution => LastExecution.AddMilliseconds(RecurrenceMs);
+    [Required]
     public JobState state { get; internal set; } = JobState.Waiting;
+    [Required]
     public bool Enabled { get; internal set; } = true;
 
     public Job(string jobId, JobType jobType, ulong recurrenceMs, Job? parentJob = null, ICollection<Job>? dependsOnJobs = null)
@@ -53,8 +58,9 @@ public abstract class Job
         
         this.state = JobState.Running;
         context.SaveChanges();
-        IEnumerable<Job> newJobs = RunInternal(context);
+        Job[] newJobs = RunInternal(context).ToArray();
         this.state = JobState.Completed;
+        context.Jobs.AddRange(newJobs);
         context.SaveChanges();
         return newJobs;
     }

API/Schema/Jobs/MoveFileOrFolderJob.cs

@@ -1,9 +1,15 @@
-namespace API.Schema.Jobs;
+using System.ComponentModel.DataAnnotations;
+
+namespace API.Schema.Jobs;
 
 public class MoveFileOrFolderJob(string fromLocation, string toLocation, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
     : Job(TokenGen.CreateToken(typeof(MoveFileOrFolderJob)), JobType.MoveFileOrFolderJob, 0, parentJobId, dependsOnJobsIds)
 {
+    [StringLength(256)]
+    [Required]
     public string FromLocation { get; init; } = fromLocation;
+    [StringLength(256)]
+    [Required]
     public string ToLocation { get; init; } = toLocation;
     
     protected override IEnumerable<Job> RunInternal(PgsqlContext context)

API/Schema/Jobs/RetrieveChaptersJob.cs

@@ -7,7 +7,8 @@ namespace API.Schema.Jobs;
 public class RetrieveChaptersJob(ulong recurrenceMs, string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
     : Job(TokenGen.CreateToken(typeof(RetrieveChaptersJob)), JobType.RetrieveChaptersJob, recurrenceMs, parentJobId, dependsOnJobsIds)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string MangaId { get; init; } = mangaId;
     
     [JsonIgnore]
@@ -23,13 +24,13 @@ public class RetrieveChaptersJob(ulong recurrenceMs, string mangaId, string? par
         Manga m = context.Manga.Find(MangaId)!; 
         MangaConnector connector = context.MangaConnectors.Find(m.MangaConnectorId)!;
         // This gets all chapters that are not downloaded
-        Chapter[] allNewChapters = connector.GetNewChapters(m);
+        Chapter[] allNewChapters = connector.GetNewChapters(m).DistinctBy(c => c.ChapterId).ToArray();
         
         // This filters out chapters that are not downloaded but already exist in the DB
         string[] chapterIds = context.Chapters.Where(chapter => chapter.ParentMangaId == m.MangaId).Select(chapter => chapter.ChapterId).ToArray();
         Chapter[] newChapters = allNewChapters.Where(chapter => !chapterIds.Contains(chapter.ChapterId)).ToArray();
-        context.Chapters.AddRangeAsync(newChapters).Wait();
+        context.Chapters.AddRange(newChapters);
-        context.SaveChangesAsync().Wait();
+        context.SaveChanges();
 
         return [];
     }

API/Schema/Jobs/UpdateFilesDownloadedJob.cs

@@ -6,7 +6,8 @@ namespace API.Schema.Jobs;
 public class UpdateFilesDownloadedJob(ulong recurrenceMs, string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
     : Job(TokenGen.CreateToken(typeof(UpdateFilesDownloadedJob)), JobType.UpdateFilesDownloadedJob, recurrenceMs, parentJobId, dependsOnJobsIds)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string MangaId { get; init; } = mangaId;
     
     [JsonIgnore]

API/Schema/Jobs/UpdateMetadataJob.cs

@@ -1,5 +1,4 @@
 using System.ComponentModel.DataAnnotations;
-using API.Schema.MangaConnectors;
 using Newtonsoft.Json;
 
 namespace API.Schema.Jobs;
@@ -7,7 +6,8 @@ namespace API.Schema.Jobs;
 public class UpdateMetadataJob(ulong recurrenceMs, string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
     : Job(TokenGen.CreateToken(typeof(UpdateMetadataJob)), JobType.UpdateMetaDataJob, recurrenceMs, parentJobId, dependsOnJobsIds)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string MangaId { get; init; } = mangaId;
     
     [JsonIgnore]

API/Schema/LibraryConnectors/LibraryConnector.cs

@@ -6,11 +6,18 @@ namespace API.Schema.LibraryConnectors;
 [PrimaryKey("LibraryConnectorId")]
 public abstract class LibraryConnector(string libraryConnectorId, LibraryType libraryType, string baseUrl, string auth)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string LibraryConnectorId { get; } = libraryConnectorId;
 
+    [Required]
     public LibraryType LibraryType { get; init; } = libraryType;
+    [StringLength(256)]
+    [Required]
+    [Url]
     public string BaseUrl { get; init; } = baseUrl;
+    [StringLength(256)]
+    [Required]
     public string Auth { get; init; } = auth;
     
     protected abstract void UpdateLibraryInternal();

API/Schema/Link.cs

@@ -6,15 +6,14 @@ namespace API.Schema;
 [PrimaryKey("LinkId")]
 public class Link(string linkProvider, string linkUrl)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string LinkId { get; init; } = TokenGen.CreateToken(typeof(Link), linkProvider, linkUrl);
+    [StringLength(64)]
+    [Required]
     public string LinkProvider { get; init; } = linkProvider;
+    [StringLength(2048)]
+    [Required]
+    [Url]
     public string LinkUrl { get; init; } = linkUrl;
-
-    public override bool Equals(object? obj)
-    {
-        if (obj is not Link other)
-            return false;
-        return other.LinkProvider == LinkProvider && other.LinkUrl == LinkUrl;
-    }
 }

API/Schema/Manga.cs

@@ -1,6 +1,8 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
+using System.Diagnostics.CodeAnalysis;
 using System.Net;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text.RegularExpressions;
 using API.MangaDownloadClients;
@@ -15,43 +17,72 @@ namespace API.Schema;
 [PrimaryKey("MangaId")]
 public class Manga
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string MangaId { get; init; }
-    [MaxLength(64)]
+    [StringLength(128)]
-    public string ConnectorId { get; init; }
+    [Required]
-
+    public string IdOnConnectorSite { get; init; }
+    [StringLength(256)]
+    [Required]
     public string Name { get; internal set; }
+    [Required]
     public string Description { get; internal set; }
+    [Url]
+    [StringLength(256)]
+    [Required]
     public string WebsiteUrl { get; internal set; }
+    [JsonIgnore]
+    [Url]
     public string CoverUrl { get; internal set; }
+    [JsonIgnore]
     public string? CoverFileNameInCache { get; internal set; }
+    [Required]
     public uint Year { get; internal set; }
+    [StringLength(8)]
+    [Required]
     public string? OriginalLanguage { get; internal set; }
+    [Required]
     public MangaReleaseStatus ReleaseStatus { get; internal set; }
+    [Required]
     public string FolderName { get; private set; }
+    [Required]
     public float IgnoreChapterBefore { get; internal set; }
-
+    [StringLength(64)]
+    [Required]
     public string MangaConnectorId { get; private set; }
     [JsonIgnore] public MangaConnector? MangaConnector { get; private set; }
     
     [JsonIgnore] public ICollection<Author>? Authors { get; internal set; }
-    [NotMapped] public IEnumerable<string> AuthorIds => Authors?.Select(a => a.AuthorId) ?? [];
+    [NotMapped]
+    [StringLength(64)]
+    [Required]
+    public IEnumerable<string> AuthorIds => Authors?.Select(a => a.AuthorId) ?? [];
     
     [JsonIgnore] public ICollection<MangaTag>? MangaTags { get; internal set; }
-    [NotMapped] public IEnumerable<string> Tags => MangaTags.Select(t => t.Tag);
+    [NotMapped]
+    [StringLength(64)]
+    [Required]
+    public IEnumerable<string> Tags => MangaTags?.Select(t => t.Tag) ?? [];
     
     
     [JsonIgnore] public ICollection<Link>? Links { get; internal set; }
-    [NotMapped] public IEnumerable<string> LinkIds => Links?.Select(l => l.LinkId) ?? [];
+    [NotMapped]
+    [StringLength(64)]
+    [Required]
+    public IEnumerable<string> LinkIds => Links?.Select(l => l.LinkId) ?? [];
     
     [JsonIgnore] public ICollection<MangaAltTitle>? AltTitles { get; internal set; }
-    [NotMapped] public IEnumerable<string> AltTitleIds => AltTitles?.Select(a => a.AltTitleId) ?? [];
+    [NotMapped]
+    [StringLength(64)]
+    [Required]
+    public IEnumerable<string> AltTitleIds => AltTitles?.Select(a => a.AltTitleId) ?? [];
 
-    public Manga(string connectorId, string name, string description, string websiteUrl, string coverUrl,
+    public Manga(string idOnConnectorSite, string name, string description, string websiteUrl, string coverUrl,
         string? coverFileNameInCache, uint year, string? originalLanguage, MangaReleaseStatus releaseStatus,
         float ignoreChapterBefore, MangaConnector mangaConnector, ICollection<Author> authors,
         ICollection<MangaTag> mangaTags, ICollection<Link> links, ICollection<MangaAltTitle> altTitles)
-        : this(connectorId, name, description, websiteUrl, coverUrl, coverFileNameInCache, year, originalLanguage,
+        : this(idOnConnectorSite, name, description, websiteUrl, coverUrl, coverFileNameInCache, year, originalLanguage,
             releaseStatus, ignoreChapterBefore, mangaConnector.Name)
     {
         this.Authors = authors;
@@ -60,12 +91,12 @@ public class Manga
         this.AltTitles = altTitles;
     }
     
-    public Manga(string connectorId, string name, string description, string websiteUrl, string coverUrl,
+    public Manga(string idOnConnectorSite, string name, string description, string websiteUrl, string coverUrl,
         string? coverFileNameInCache, uint year, string? originalLanguage, MangaReleaseStatus releaseStatus,
         float ignoreChapterBefore, string mangaConnectorId)
     {
-        MangaId = TokenGen.CreateToken(typeof(Manga), mangaConnectorId, connectorId);
+        MangaId = TokenGen.CreateToken(typeof(Manga), mangaConnectorId, idOnConnectorSite);
-        ConnectorId = connectorId;
+        IdOnConnectorSite = idOnConnectorSite;
         Name = name;
         Description = description;
         WebsiteUrl = websiteUrl;
@@ -119,8 +150,8 @@ public class Manga
         if (File.Exists(saveImagePath))
             return saveImagePath;
         
-        RequestResult coverResult = new HttpDownloadClient().MakeRequest(CoverUrl, RequestType.MangaCover, this.WebsiteUrl);
+        RequestResult coverResult = new HttpDownloadClient().MakeRequest(CoverUrl, RequestType.MangaCover, $"https://{match.Groups[1].Value}");
-        if (coverResult.statusCode is < HttpStatusCode.Accepted or >= HttpStatusCode.Ambiguous)
+        if (coverResult.statusCode is < HttpStatusCode.OK or >= HttpStatusCode.Ambiguous)
             return SaveCoverImageToCache(--retries);
             
         using MemoryStream ms = new();

API/Schema/MangaAltTitle.cs

@@ -7,9 +7,13 @@ namespace API.Schema;
 [PrimaryKey("AltTitleId")]
 public class MangaAltTitle(string language, string title)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string AltTitleId { get; init; } = TokenGen.CreateToken("AltTitle", language, title);
-    [MaxLength(8)]
+    [StringLength(8)]
+    [Required]
     public string Language { get; init; } = language;
+    [StringLength(256)]
+    [Required]
     public string Title { get; set; } = title;
 }

API/Schema/MangaConnectors/MangaConnector.cs

@@ -10,12 +10,19 @@ namespace API.Schema.MangaConnectors;
 [PrimaryKey("Name")]
 public abstract class MangaConnector(string name, string[] supportedLanguages, string[] baseUris, string iconUrl)
 {
-    [MaxLength(32)]
+    [StringLength(32)]
+    [Required]
     public string Name { get; init; } = name;
+    [StringLength(8)]
+    [Required]
     public string[] SupportedLanguages { get; init; } = supportedLanguages;
+    [StringLength(2048)]
+    [Required]
     public string IconUrl { get; init; } = iconUrl;
+    [StringLength(256)]
+    [Required]
     public string[] BaseUris { get; init; } = baseUris;
-    
+    [Required]
     public bool Enabled { get; internal set; } = true;
     
     public abstract (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(string publicationTitle = "");

API/Schema/MangaConnectors/MangaDex.cs

@@ -197,7 +197,7 @@ public class MangaDex : MangaConnector
             //Request next "Page"
             RequestResult requestResult =
                 downloadClient.MakeRequest(
-                    $"https://api.mangadex.org/manga/{manga.ConnectorId}/feed?limit={limit}&offset={offset}&translatedLanguage%5B%5D={language}&contentRating%5B%5D=safe&contentRating%5B%5D=suggestive&contentRating%5B%5D=erotica&contentRating%5B%5D=pornographic", RequestType.MangaDexFeed);
+                    $"https://api.mangadex.org/manga/{manga.IdOnConnectorSite}/feed?limit={limit}&offset={offset}&translatedLanguage%5B%5D={language}&contentRating%5B%5D=safe&contentRating%5B%5D=suggestive&contentRating%5B%5D=erotica&contentRating%5B%5D=pornographic", RequestType.MangaDexFeed);
             if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
                 break;
             JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);

API/Schema/MangaConnectors/WeebCentral.cs

@@ -10,7 +10,7 @@ public class Weebcentral : MangaConnector
     private readonly string[] _filterWords =
         { "a", "the", "of", "as", "to", "no", "for", "on", "with", "be", "and", "in", "wa", "at", "be", "ni" };
 
-    public Weebcentral() : base("Weebcentral", ["en"], ["https://weebcentral.com"], "https://weebcentral.com/favicon.ico")
+    public Weebcentral() : base("Weebcentral", ["en"], ["weebcentral.com"], "https://weebcentral.com/favicon.ico")
     {
         downloadClient = new ChromiumDownloadClient();
     }
@@ -20,7 +20,7 @@ public class Weebcentral : MangaConnector
         const int limit = 32; //How many values we want returned at once
         var offset = 0; //"Page"
         var requestUrl =
-            $"{BaseUris[0]}/search/data?limit={limit}&offset={offset}&text={publicationTitle}&sort=Best+Match&order=Ascending&official=Any&display_mode=Minimal%20Display";
+            $"https://{BaseUris[0]}/search/data?limit={limit}&offset={offset}&text={publicationTitle}&sort=Best+Match&order=Ascending&official=Any&display_mode=Minimal%20Display";
         var requestResult =
             downloadClient.MakeRequest(requestUrl, RequestType.Default);
         if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 ||
@@ -110,12 +110,12 @@ public class Weebcentral : MangaConnector
 
     public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(string publicationId)
     {
-        return GetMangaFromUrl($"https://weebcentral.com/series/{publicationId}");
+        return GetMangaFromUrl($"https://{BaseUris[0]}/series/{publicationId}");
     }
 
     public override Chapter[] GetChapters(Manga manga, string language = "en")
     {
-                var requestUrl = $"{BaseUris[0]}/series/{manga.MangaConnectorId}/full-chapter-list";
+                var requestUrl = $"https://{BaseUris[0]}/series/{manga.MangaConnectorId}/full-chapter-list";
         var requestResult =
             downloadClient.MakeRequest(requestUrl, RequestType.Default);
         if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)

API/Schema/MangaTag.cs

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

API/Schema/Notification.cs

@@ -6,15 +6,22 @@ namespace API.Schema;
 [PrimaryKey("NotificationId")]
 public class Notification(string title, string message = "", NotificationUrgency urgency = NotificationUrgency.Normal, DateTime? date = null)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string NotificationId { get; init; } = TokenGen.CreateToken("Notification");
 
+    [Required]
     public NotificationUrgency Urgency { get; init; } = urgency;
 
+    [StringLength(128)]
+    [Required]
     public string Title { get; init; } = title;
 
+    [StringLength(512)]
+    [Required]
     public string Message { get; init; } = message;
     
+    [Required]
     public DateTime Date { get; init; } = date ?? DateTime.UtcNow;
     
     public Notification() : this("") { }

API/Schema/NotificationConnectors/NotificationConnector.cs

@@ -9,15 +9,24 @@ namespace API.Schema.NotificationConnectors;
 [PrimaryKey("Name")]
 public class NotificationConnector(string name, string url, Dictionary<string, string> headers, string httpMethod, string body)
 {
-    [MaxLength(64)]
+    [StringLength(64)]
+    [Required]
     public string Name { get; init; } = name;
     
+    [StringLength(2048)]
+    [Required]
+    [Url]
     public string Url { get; internal set; } = url;
 
+    [Required]
     public Dictionary<string, string> Headers { get; internal set; } = headers;
 
+    [StringLength(8)]
+    [Required]
     public string HttpMethod { get; internal set; } = httpMethod;
 
+    [StringLength(4096)]
+    [Required]
     public string Body { get; internal set; } = body;
 
     [JsonIgnore]

API/Schema/PgsqlContext.cs

@@ -31,6 +31,7 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .HasValue<Mangaworld>("Mangaworld")
             .HasValue<ManhuaPlus>("ManhuaPlus")
             .HasValue<Weebcentral>("Weebcentral")
+            .HasValue<Manganato>("Manganato")
             .HasValue<MangaDex>("MangaDex");
         modelBuilder.Entity<LibraryConnector>()
             .HasDiscriminator<LibraryType>(l => l.LibraryType)
@@ -49,9 +50,11 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
         modelBuilder.Entity<Job>()
             .HasOne<Job>(j => j.ParentJob)
             .WithMany()
-            .HasForeignKey(j => j.ParentJobId);
+            .HasForeignKey(j => j.ParentJobId)
+            .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<Job>()
-            .HasMany<Job>(j => j.DependsOnJobs);
+            .HasMany<Job>(j => j.DependsOnJobs)
+            .WithMany();
         modelBuilder.Entity<DownloadAvailableChaptersJob>()
             .Navigation(dncj => dncj.Manga)
             .AutoInclude();
@@ -65,7 +68,8 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
         modelBuilder.Entity<Manga>()
             .HasOne<MangaConnector>(m => m.MangaConnector)
             .WithMany()
-            .HasForeignKey(m => m.MangaConnectorId);
+            .HasForeignKey(m => m.MangaConnectorId)
+            .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<Manga>()
             .Navigation(m => m.MangaConnector)
             .AutoInclude();
@@ -83,20 +87,23 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .AutoInclude();
         modelBuilder.Entity<Manga>()
             .HasMany<Link>(m => m.Links)
-            .WithOne();
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<Manga>()
             .Navigation(m => m.Links)
             .AutoInclude();
         modelBuilder.Entity<Manga>()
             .HasMany<MangaAltTitle>(m => m.AltTitles)
-            .WithOne();
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<Manga>()
             .Navigation(m => m.AltTitles)
             .AutoInclude();
         modelBuilder.Entity<Chapter>()
             .HasOne<Manga>(c => c.ParentManga)
             .WithMany()
-            .HasForeignKey(c => c.ParentMangaId);
+            .HasForeignKey(c => c.ParentMangaId)
+            .OnDelete(DeleteBehavior.Cascade);
         modelBuilder.Entity<Chapter>()
             .Navigation(c => c.ParentManga)
             .AutoInclude();

API/TokenGen.cs

@@ -13,8 +13,6 @@ public static class TokenGen
     
     public static string CreateToken(string prefix, params string[] identifiers)
     {
-        
-        
         if (prefix.Length + 1 >= MaximumLength - MinimumLength)
             throw new ArgumentException("Prefix to long to create Token of meaningful length.");
         

API/Tranga.cs

@@ -113,7 +113,6 @@ public static class Tranga
                 Thread t = new(() =>
                 {
                     IEnumerable<Job> newJobs = job.Run(serviceProvider);
-                    context.Jobs.AddRange(newJobs);
                 });
                 RunningJobs.Add(t, job);
                 t.Start();
@@ -125,11 +124,12 @@ public static class Tranga
             foreach ((Thread thread, Job job) thread in removeFromThreadsList)
             {
                 RunningJobs.Remove(thread.thread);
+                if(context.Jobs.Find(thread.job.JobId) is not null)
                     context.Jobs.Update(thread.job);
             }
 
             context.SaveChanges();
-            Thread.Sleep(2000);
+            Thread.Sleep(TrangaSettings.startNewJobTimeoutMs);
         }
     }
 

API/TrangaSettings.cs

@@ -21,6 +21,7 @@ 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;
     [JsonIgnore]
     internal static readonly Dictionary<RequestType, int> DefaultRequestLimits = new ()
     {
@@ -31,7 +32,7 @@ public static class TrangaSettings
         {RequestType.MangaCover, 250},
         {RequestType.Default, 60}
     };
-    public static Dictionary<RequestType, int> requestLimits { get; set; } = DefaultRequestLimits;
+    public static Dictionary<RequestType, int> requestLimits { get; private set; } = DefaultRequestLimits;
 
     public static TimeSpan NotificationUrgencyDelay(NotificationUrgency urgency) => urgency switch
     {
@@ -39,7 +40,7 @@ public static class TrangaSettings
         NotificationUrgency.Normal => TimeSpan.FromMinutes(5),
         NotificationUrgency.Low => TimeSpan.FromMinutes(10),
         _ => TimeSpan.FromHours(1)
-    };
+    }; //TODO make this a setting?
 
     public static void Load()
     {
@@ -161,6 +162,7 @@ public static class TrangaSettings
         jobj.Add("requestLimits", JToken.FromObject(requestLimits));
         jobj.Add("compression", JToken.FromObject(compression));
         jobj.Add("bwImages", JToken.FromObject(bwImages));
+        jobj.Add("startNewJobTimeoutMs", JToken.FromObject(startNewJobTimeoutMs));
         return jobj;
     }
 
@@ -183,5 +185,7 @@ public static class TrangaSettings
             compression = ci.Value<int>()!;
         if (jobj.TryGetValue("bwImages", out JToken? bwi))
             bwImages = bwi.Value<bool>()!;
+        if (jobj.TryGetValue("startNewJobTimeoutMs", out JToken? snjt))
+            startNewJobTimeoutMs = snjt.Value<int>()!;
     }
 }

API/appsettings.Development.json

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

API/appsettings.json

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

README.md

@@ -59,6 +59,8 @@ This repository *does not* include a frontend. A frontend can take many forms, s
 When downloading a chapter (meaning the images that make-up the manga) from a Scanlation-Website, Tranga will
 additionally try and scrape Metadata from the same website ~~or enhance it from third-party sources~~
 (tbd https://github.com/C9Glax/tranga/issues/280).
+Downloaded images can be jpeg-compressed and/or made black and white to save on diskspace
+(measured at least a 50% reduction in size, without a significant loss of quality).
 
 Tranga will then package the contents of each chapter in a `.cbz`-archive and place it in a common folder per Manga.
 If specified, Tranga will then notify library-Managers such as [Komga](https://komga.org/) and [Kavita](https://www.kavitareader.com/) to trigger a scan for new