Port Manganato

# Conflicts:
#	Tranga/Chapter.cs
#	Tranga/MangaConnectors/Manganato.cs
#	Tranga/MangaConnectors/WeebCentral.cs

.github/ISSUE_TEMPLATE/new_connector.yml

@@ -12,7 +12,7 @@ body:
   - type: checkboxes
     attributes:
       label: Is the Website free to access?
-      description: We can't support pay-to-use sites.
+      description: We can't support pay-to-use sites, or captcha-proxied sites as Cloudflare.
       options:
         - label: The Website is freely accessible.
           required: true
@@ -20,4 +20,4 @@ body:
     attributes:
       label: Anything else?
     validations:
-      required: false
+      required: false

.github/workflows/docker-image-cuttingedge.yml

@@ -17,7 +17,7 @@ jobs:
 
       # https://github.com/docker/setup-qemu-action#usage
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3.5.0
+        uses: docker/setup-qemu-action@v3.6.0
 
       # https://github.com/marketplace/actions/docker-setup-buildx
       - name: Set up Docker Buildx

.github/workflows/docker-image-dev.yml

@@ -17,7 +17,7 @@ jobs:
 
       # https://github.com/docker/setup-qemu-action#usage
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3.5.0
+        uses: docker/setup-qemu-action@v3.6.0
 
       # https://github.com/marketplace/actions/docker-setup-buildx
       - name: Set up Docker Buildx

.github/workflows/docker-image-master.yml

@@ -17,7 +17,7 @@ jobs:
 
       # https://github.com/docker/setup-qemu-action#usage
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3.5.0
+        uses: docker/setup-qemu-action@v3.6.0
 
       # https://github.com/marketplace/actions/docker-setup-buildx
       - name: Set up Docker Buildx

.github/workflows/docker-image-serverv2.yml

@@ -17,7 +17,7 @@ jobs:
 
       # https://github.com/docker/setup-qemu-action#usage
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3.5.0
+        uses: docker/setup-qemu-action@v3.6.0
 
       # https://github.com/marketplace/actions/docker-setup-buildx
       - name: Set up Docker Buildx

API/API.csproj

@@ -27,6 +27,7 @@
         <PackageReference Include="SixLabors.ImageSharp" Version="3.1.7" />
         <PackageReference Include="Soenneker.Utils.String.NeedlemanWunsch" Version="3.0.920" />
         <PackageReference Include="Swashbuckle.AspNetCore" Version="7.3.1" />
+        <PackageReference Include="Swashbuckle.AspNetCore.Newtonsoft" Version="7.3.1" />
         <PackageReference Include="System.Drawing.Common" Version="9.0.2" />
     </ItemGroup>
 

API/Controllers/JobController.cs

@@ -83,58 +83,114 @@ public class JobController(PgsqlContext context) : Controller
     }
 
     /// <summary>
-    /// Create a new CreateNewDownloadChapterJob
+    /// Create a new DownloadAvailableChaptersJob
     /// </summary>
     /// <param name="MangaId">ID of Manga</param>
     /// <param name="recurrenceTime">How often should we check for new chapters</param>
-    /// <response code="201">Created new Job</response>
+    /// <response code="201">Job-IDs</response>
+    /// <response code="404">Could not find Manga with ID</response>
     /// <response code="500">Error during Database Operation</response>
-    [HttpPut("NewDownloadChapterJob/{MangaId}")]
-    [ProducesResponseType(Status201Created)]
+    [HttpPut("DownloadAvailableChaptersJob/{MangaId}")]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
     public IActionResult CreateNewDownloadChapterJob(string MangaId, [FromBody]ulong recurrenceTime)
     {
-        Job job = new DownloadNewChaptersJob(recurrenceTime, MangaId);
-        return AddJob(job);
+        if (context.Manga.Find(MangaId) is null)
+            return NotFound();
+        Job dep = new RetrieveChaptersJob(recurrenceTime, MangaId);
+        Job job = new DownloadAvailableChaptersJob(recurrenceTime, MangaId, null, [dep.JobId]);
+        return AddJobs([dep, job]);
     }
 
     /// <summary>
     /// Create a new DownloadSingleChapterJob
     /// </summary>
     /// <param name="ChapterId">ID of the Chapter</param>
-    /// <response code="201">Created new Job</response>
+    /// <response code="201">Job-IDs</response>
+    /// <response code="404">Could not find Chapter with ID</response>
     /// <response code="500">Error during Database Operation</response>
     [HttpPut("DownloadSingleChapterJob/{ChapterId}")]
-    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
     public IActionResult CreateNewDownloadChapterJob(string ChapterId)
     {
+        if(context.Chapters.Find(ChapterId) is null)
+            return NotFound();
         Job job = new DownloadSingleChapterJob(ChapterId);
-        return AddJob(job);
+        return AddJobs([job]);
+    }
+
+    /// <summary>
+    /// Create a new UpdateFilesDownloadedJob
+    /// </summary>
+    /// <param name="MangaId">ID of the Manga</param>
+    /// <response code="201">Job-IDs</response>
+    /// <response code="201">Could not find Manga with ID</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("UpdateFilesJob/{MangaId}")]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateUpdateFilesDownloadedJob(string MangaId)
+    {
+        if(context.Manga.Find(MangaId) is null)
+            return NotFound();
+        Job job = new UpdateFilesDownloadedJob(0, MangaId);
+        return AddJobs([job]);
+    }
+
+    /// <summary>
+    /// Create a new UpdateMetadataJob for all Manga
+    /// </summary>
+    /// <response code="201">Job-IDs</response>
+    /// <response code="500">Error during Database Operation</response>
+    [HttpPut("UpdateAllFilesJob")]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
+    public IActionResult CreateUpdateAllFilesDownloadedJob()
+    {
+        List<string> ids = context.Manga.Select(m => m.MangaId).ToList();
+        List<UpdateFilesDownloadedJob> jobs =  ids.Select(id => new UpdateFilesDownloadedJob(0, id)).ToList();
+        try
+        {
+            context.Jobs.AddRange(jobs);
+            context.SaveChanges();
+            return Created();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
     }
 
     /// <summary>
     /// Create a new UpdateMetadataJob
     /// </summary>
     /// <param name="MangaId">ID of the Manga</param>
-    /// <response code="201">Created new Job</response>
+    /// <response code="201">Job-IDs</response>
+    /// <response code="404">Could not find Manga with ID</response>
     /// <response code="500">Error during Database Operation</response>
     [HttpPut("UpdateMetadataJob/{MangaId}")]
-    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
+    [ProducesResponseType(Status404NotFound)]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
     public IActionResult CreateUpdateMetadataJob(string MangaId)
     {
+        if(context.Manga.Find(MangaId) is null)
+            return NotFound();
         Job job = new UpdateMetadataJob(0, MangaId);
-        return AddJob(job);
+        return AddJobs([job]);
     }
 
     /// <summary>
     /// Create a new UpdateMetadataJob for all Manga
     /// </summary>
-    /// <response code="201">Created new Job</response>
+    /// <response code="201">Job-IDs</response>
     /// <response code="500">Error during Database Operation</response>
-    [HttpPut("UpdateMetadataJob")]
-    [ProducesResponseType(Status201Created)]
+    [HttpPut("UpdateAllMetadataJob")]
+    [ProducesResponseType<string[]>(Status201Created, "application/json")]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
     public IActionResult CreateUpdateAllMetadataJob()
     {
@@ -152,13 +208,13 @@ public class JobController(PgsqlContext context) : Controller
         }
     }
     
-    private IActionResult AddJob(Job job)
+    private IActionResult AddJobs(Job[] jobs)
     {
         try
         {
-            context.Jobs.Add(job);
+            context.Jobs.AddRange(jobs);
             context.SaveChanges();
-            return new CreatedResult(job.JobId, job);
+            return new CreatedResult((string?)null, jobs.Select(j => j.JobId).ToArray());
         }
         catch (Exception e)
         {
@@ -276,10 +332,11 @@ public class JobController(PgsqlContext context) : Controller
     /// Stops the Job with the requested ID
     /// </summary>
     /// <param name="JobId">Job-ID</param>
-    /// <remarks>NOT IMPLEMENTED</remarks>
+    /// <remarks><h1>NOT IMPLEMENTED</h1></remarks>
     [HttpPost("{JobId}/Stop")]
+    [ProducesResponseType(Status501NotImplemented)]
     public IActionResult StopJob(string JobId)
     {
-        throw new NotImplementedException();
+        return StatusCode(501);
     }
 }

API/Controllers/MangaController.cs

@@ -1,5 +1,6 @@
 using API.APIEndpointRecords;
 using API.Schema;
+using API.Schema.Jobs;
 using Asp.Versioning;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
@@ -228,10 +229,28 @@ public class MangaController(PgsqlContext context) : Controller
     /// </summary>
     /// <param name="MangaId">Manga-ID</param>
     /// <param name="folder">New Directory-Path</param>
-    /// <remarks>NOT IMPLEMENTED</remarks>
+    /// <response code="202">Folder is going to be moved</response>
+    /// <response code="500">Error during Database Operation</response>
     [HttpPost("{MangaId}/MoveFolder")]
+    [ProducesResponseType(Status202Accepted)]
+    [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
     public IActionResult MoveFolder(string MangaId, [FromBody]string folder)
     {
-        throw new NotImplementedException();
+        Manga? manga = context.Manga.Find(MangaId);
+        if (manga is null)
+            return NotFound();
+        MoveFileOrFolderJob dep = manga.UpdateFolderName(TrangaSettings.downloadLocation, folder);
+        UpdateFilesDownloadedJob up = new UpdateFilesDownloadedJob(0, manga.MangaId, null, [dep.JobId]);
+        
+        try
+        {
+            context.Jobs.AddRange([dep, up]);
+            context.SaveChanges();
+            return Accepted();
+        }
+        catch (Exception e)
+        {
+            return StatusCode(500, e.Message);
+        }
     }
 }

API/Controllers/NotificationConnectorController.cs

@@ -50,11 +50,11 @@ public class NotificationConnectorController(PgsqlContext context) : Controller
     /// </summary>
     /// <remarks>Formatting placeholders: "%title" and "%text" can be placed in url, header-values and body and will be replaced when notifications are sent</remarks>
     /// <param name="notificationConnector">Notification-Connector</param>
-    /// <response code="201"></response>
+    /// <response code="201">ID of new connector</response>
     /// <response code="409">A NotificationConnector with name already exists</response>
     /// <response code="500">Error during Database Operation</response>
     [HttpPut]
-    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
     [ProducesResponseType(Status409Conflict)]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
     public IActionResult CreateConnector([FromBody]NotificationConnector notificationConnector)
@@ -65,7 +65,7 @@ public class NotificationConnectorController(PgsqlContext context) : Controller
         {
             context.NotificationConnectors.Add(notificationConnector);
             context.SaveChanges();
-            return Created();
+            return Created(notificationConnector.Name, notificationConnector);
         }
         catch (Exception e)
         {
@@ -77,12 +77,12 @@ public class NotificationConnectorController(PgsqlContext context) : Controller
     /// Creates a new Gotify-Notification-Connector
     /// </summary>
     /// <remarks>Priority needs to be between 0 and 10</remarks>
-    /// <response code="201"></response>
+    /// <response code="201">ID of new connector</response>
     /// <response code="400"></response>
     /// <response code="409">A NotificationConnector with name already exists</response>
     /// <response code="500">Error during Database Operation</response>
     [HttpPut("Gotify")]
-    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
     [ProducesResponseType(Status400BadRequest)]
     [ProducesResponseType(Status409Conflict)]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
@@ -103,12 +103,12 @@ public class NotificationConnectorController(PgsqlContext context) : Controller
     /// Creates a new Ntfy-Notification-Connector
     /// </summary>
     /// <remarks>Priority needs to be between 1 and 5</remarks>
-    /// <response code="201"></response>
+    /// <response code="201">ID of new connector</response>
     /// <response code="400"></response>
     /// <response code="409">A NotificationConnector with name already exists</response>
     /// <response code="500">Error during Database Operation</response>
     [HttpPut("Ntfy")]
-    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
     [ProducesResponseType(Status400BadRequest)]
     [ProducesResponseType(Status409Conflict)]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
@@ -136,12 +136,12 @@ public class NotificationConnectorController(PgsqlContext context) : Controller
     /// Creates a new Lunasea-Notification-Connector
     /// </summary>
     /// <remarks>https://docs.lunasea.app/lunasea/notifications/custom-notifications for id. Either device/:device_id or user/:user_id</remarks>
-    /// <response code="201"></response>
+    /// <response code="201">ID of new connector</response>
     /// <response code="400"></response>
     /// <response code="409">A NotificationConnector with name already exists</response>
     /// <response code="500">Error during Database Operation</response>
     [HttpPut("Lunasea")]
-    [ProducesResponseType(Status201Created)]
+    [ProducesResponseType<string>(Status201Created, "application/json")]
     [ProducesResponseType(Status400BadRequest)]
     [ProducesResponseType(Status409Conflict)]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]

API/Controllers/SearchController.cs

@@ -49,8 +49,8 @@ public class SearchController(PgsqlContext context) : Controller
     /// <summary>
     /// Initiate a search for a Manga on a specific Connector
     /// </summary>
-    /// <param name="id">Manga-Connector-ID</param>
-    /// <param name="name">Name/Title of the Manga</param>
+    /// <param name="MangaConnectorName">Manga-Connector-ID</param>
+    /// <param name="SearchName">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>
@@ -60,15 +60,15 @@ public class SearchController(PgsqlContext context) : Controller
     [ProducesResponseType(Status404NotFound)]
     [ProducesResponseType(Status406NotAcceptable)]
     [ProducesResponseType<string>(Status500InternalServerError, "text/plain")]
-    public IActionResult SearchManga(string id, string name)
+    public IActionResult SearchManga(string MangaConnectorName, string SearchName)
     {
-        MangaConnector? connector = context.MangaConnectors.Find(id);
+        MangaConnector? connector = context.MangaConnectors.Find(MangaConnectorName);
         if (connector is null)
             return NotFound();
         else if (connector.Enabled is false)
             return StatusCode(406);
         
-        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] mangas = connector.GetManga(name);
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] mangas = connector.GetManga(SearchName);
         List<Manga> retMangas = new();
         foreach ((Manga? manga, List<Author>? authors, List<MangaTag>? tags, List<Link>? links, List<MangaAltTitle>? altTitles) in mangas)
         {
@@ -142,8 +142,8 @@ public class SearchController(PgsqlContext context) : Controller
                 MangaTag? inDb = context.Tags.FirstOrDefault(t => t.Equals(mt));
                 return inDb ?? mt;
             });
-            manga.Tags = mergedTags.ToList();
-            IEnumerable<MangaTag> newTags = manga.Tags.Where(mt => !context.Tags.Any(t => t.Tag.Equals(mt.Tag)));
+            manga.MangaTags = mergedTags.ToList();
+            IEnumerable<MangaTag> newTags = manga.MangaTags.Where(mt => !context.Tags.Any(t => t.Tag.Equals(mt.Tag)));
             context.Tags.AddRange(newTags);
         }
 
@@ -195,6 +195,7 @@ public class SearchController(PgsqlContext context) : Controller
             context.Manga.Add(manga);
 
         context.Jobs.Add(new DownloadMangaCoverJob(manga.MangaId));
+        context.Jobs.Add(new RetrieveChaptersJob(0, manga.MangaId));
 
         context.SaveChanges();
         return existing ?? manga;

API/Controllers/SettingsController.cs

@@ -72,15 +72,46 @@ public class SettingsController(PgsqlContext context) : Controller
     /// <summary>
     /// Update all Request-Limits to new values
     /// </summary>
-    /// <remarks>NOT IMPLEMENTED</remarks>
+    /// <remarks><h1>NOT IMPLEMENTED</h1></remarks>
     [HttpPatch("RequestLimits")]
+    [ProducesResponseType(Status501NotImplemented)]
     public IActionResult SetRequestLimits()
     {
-        throw new NotImplementedException();
+        return StatusCode(501);
+    }
+
+    /// <summary>
+    /// Updates a Request-Limit value
+    /// </summary>
+    /// <param name="RequestType">Type of Request</param>
+    /// <param name="requestLimit">New limit in Requests/Minute</param>
+    /// <response code="200"></response>
+    /// <response code="400">Limit needs to be greater than 0</response>
+    [HttpPatch("RequestLimits/{RequestType}")]
+    [ProducesResponseType(Status200OK)]
+    [ProducesResponseType(Status400BadRequest)]
+    public IActionResult SetRequestLimit(RequestType RequestType, [FromBody]int requestLimit)
+    {
+        if (requestLimit <= 0)
+            return BadRequest();
+        TrangaSettings.UpdateRequestLimit(RequestType, requestLimit);
+        return Ok();
     }
     
     /// <summary>
-    /// Reset all Request-Limits
+    /// Reset Request-Limit
+    /// </summary>
+    /// <response code="200"></response>
+    [HttpDelete("RequestLimits/{RequestType}")]
+    [ProducesResponseType<string>(Status200OK)]
+    public IActionResult ResetRequestLimits(RequestType RequestType)
+    {
+        TrangaSettings.UpdateRequestLimit(RequestType, TrangaSettings.DefaultRequestLimits[RequestType]);
+        return Ok();
+    }
+    
+    /// <summary>
+    /// Reset Request-Limit
     /// </summary>
     /// <response code="200"></response>
     [HttpDelete("RequestLimits")]

API/Migrations/20250308154843_dev-080325-2.Designer.cs

@@ -0,0 +1,673 @@
+// <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("20250308154843_dev-080325-2")]
+    partial class dev0803252
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.2")
+                .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>("ConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasColumnType("text");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.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>("TagsTag")
+                        .HasColumnType("text");
+
+                    b.HasKey("MangaId", "TagsTag");
+
+                    b.HasIndex("TagsTag");
+
+                    b.ToTable("MangaMangaTag");
+                });
+
+            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.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("DownloadMangaCoverJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)4);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadNewChaptersJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("ChapterId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("ChapterId");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.MoveFileOrFolderJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("FromLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToLocation")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue((byte)3);
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasBaseType("API.Schema.Jobs.Job");
+
+                    b.Property<string>("MangaId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("Jobs", t =>
+                        {
+                            t.Property("MangaId")
+                                .HasColumnName("UpdateMetadataJob_MangaId");
+                        });
+
+                    b.HasDiscriminator().HasValue((byte)2);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Kavita", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)1);
+                });
+
+            modelBuilder.Entity("API.Schema.LibraryConnectors.Komga", b =>
+                {
+                    b.HasBaseType("API.Schema.LibraryConnectors.LibraryConnector");
+
+                    b.HasDiscriminator().HasValue((byte)0);
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.AsuraToon", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("AsuraToon");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.Bato", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("Bato");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaDex", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaDex");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaHere", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaHere");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaKatana", b =>
+                {
+                    b.HasBaseType("API.Schema.MangaConnectors.MangaConnector");
+
+                    b.HasDiscriminator().HasValue("MangaKatana");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.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("TagsTag")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            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.DownloadNewChaptersJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
+                {
+                    b.HasOne("API.Schema.Chapter", "Chapter")
+                        .WithMany()
+                        .HasForeignKey("ChapterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Chapter");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.UpdateMetadataJob", b =>
+                {
+                    b.HasOne("API.Schema.Manga", "Manga")
+                        .WithMany()
+                        .HasForeignKey("MangaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.Jobs.Job", b =>
+                {
+                    b.Navigation("DependsOnJobs");
+                });
+
+            modelBuilder.Entity("API.Schema.Manga", b =>
+                {
+                    b.Navigation("AltTitles");
+
+                    b.Navigation("Links");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Migrations/20250308154843_dev-080325-2.cs

@@ -0,0 +1,62 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev0803252 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "AltTitleIds",
+                table: "Manga");
+
+            migrationBuilder.DropColumn(
+                name: "AuthorIds",
+                table: "Manga");
+
+            migrationBuilder.DropColumn(
+                name: "LinkIds",
+                table: "Manga");
+
+            migrationBuilder.DropColumn(
+                name: "TagIds",
+                table: "Manga");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string[]>(
+                name: "AltTitleIds",
+                table: "Manga",
+                type: "text[]",
+                nullable: false,
+                defaultValue: new string[0]);
+
+            migrationBuilder.AddColumn<string[]>(
+                name: "AuthorIds",
+                table: "Manga",
+                type: "text[]",
+                nullable: false,
+                defaultValue: new string[0]);
+
+            migrationBuilder.AddColumn<string[]>(
+                name: "LinkIds",
+                table: "Manga",
+                type: "text[]",
+                nullable: false,
+                defaultValue: new string[0]);
+
+            migrationBuilder.AddColumn<string[]>(
+                name: "TagIds",
+                table: "Manga",
+                type: "text[]",
+                nullable: false,
+                defaultValue: new string[0]);
+        }
+    }
+}

API/Migrations/20250308162728_dev-080325-3.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("20250308162728_dev-080325-3")]
+    partial class dev0803253
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.2")
+                .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>("ConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasColumnType("text");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.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>("TagsTag")
+                        .HasColumnType("text");
+
+                    b.HasKey("MangaId", "TagsTag");
+
+                    b.HasIndex("TagsTag");
+
+                    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("TagsTag")
+                        .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/20250308162728_dev-080325-3.cs

@@ -0,0 +1,126 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev0803253 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Jobs_Manga_DownloadMangaCoverJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.RenameColumn(
+                name: "DownloadMangaCoverJob_MangaId",
+                table: "Jobs",
+                newName: "UpdateFilesDownloadedJob_MangaId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Jobs_DownloadMangaCoverJob_MangaId",
+                table: "Jobs",
+                newName: "IX_Jobs_UpdateFilesDownloadedJob_MangaId");
+
+            migrationBuilder.AddColumn<string>(
+                name: "DownloadAvailableChaptersJob_MangaId",
+                table: "Jobs",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "RetrieveChaptersJob_MangaId",
+                table: "Jobs",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_DownloadAvailableChaptersJob_MangaId",
+                table: "Jobs",
+                column: "DownloadAvailableChaptersJob_MangaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Jobs_RetrieveChaptersJob_MangaId",
+                table: "Jobs",
+                column: "RetrieveChaptersJob_MangaId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Jobs_Manga_DownloadAvailableChaptersJob_MangaId",
+                table: "Jobs",
+                column: "DownloadAvailableChaptersJob_MangaId",
+                principalTable: "Manga",
+                principalColumn: "MangaId",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Jobs_Manga_RetrieveChaptersJob_MangaId",
+                table: "Jobs",
+                column: "RetrieveChaptersJob_MangaId",
+                principalTable: "Manga",
+                principalColumn: "MangaId",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Jobs_Manga_UpdateFilesDownloadedJob_MangaId",
+                table: "Jobs",
+                column: "UpdateFilesDownloadedJob_MangaId",
+                principalTable: "Manga",
+                principalColumn: "MangaId",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Jobs_Manga_DownloadAvailableChaptersJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Jobs_Manga_RetrieveChaptersJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Jobs_Manga_UpdateFilesDownloadedJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Jobs_DownloadAvailableChaptersJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Jobs_RetrieveChaptersJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.DropColumn(
+                name: "DownloadAvailableChaptersJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.DropColumn(
+                name: "RetrieveChaptersJob_MangaId",
+                table: "Jobs");
+
+            migrationBuilder.RenameColumn(
+                name: "UpdateFilesDownloadedJob_MangaId",
+                table: "Jobs",
+                newName: "DownloadMangaCoverJob_MangaId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Jobs_UpdateFilesDownloadedJob_MangaId",
+                table: "Jobs",
+                newName: "IX_Jobs_DownloadMangaCoverJob_MangaId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Jobs_Manga_DownloadMangaCoverJob_MangaId",
+                table: "Jobs",
+                column: "DownloadMangaCoverJob_MangaId",
+                principalTable: "Manga",
+                principalColumn: "MangaId",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

API/Migrations/20250308170713_dev-080325-4.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("20250308170713_dev-080325-4")]
+    partial class dev0803254
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.2")
+                .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>("ConnectorId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("CoverFileNameInCache")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CoverUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FolderName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<float>("IgnoreChapterBefore")
+                        .HasColumnType("real");
+
+                    b.Property<string>("MangaConnectorId")
+                        .IsRequired()
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalLanguage")
+                        .HasColumnType("text");
+
+                    b.Property<byte>("ReleaseStatus")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("WebsiteUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Year")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MangaId");
+
+                    b.HasIndex("MangaConnectorId");
+
+                    b.ToTable("Manga");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaAltTitle", b =>
+                {
+                    b.Property<string>("AltTitleId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("MangaId")
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AltTitleId");
+
+                    b.HasIndex("MangaId");
+
+                    b.ToTable("AltTitles");
+                });
+
+            modelBuilder.Entity("API.Schema.MangaConnectors.MangaConnector", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("BaseUris")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.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/20250308170713_dev-080325-4.cs

@@ -0,0 +1,62 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Migrations
+{
+    /// <inheritdoc />
+    public partial class dev0803254 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_MangaMangaTag_Tags_TagsTag",
+                table: "MangaMangaTag");
+
+            migrationBuilder.RenameColumn(
+                name: "TagsTag",
+                table: "MangaMangaTag",
+                newName: "MangaTagsTag");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_MangaMangaTag_TagsTag",
+                table: "MangaMangaTag",
+                newName: "IX_MangaMangaTag_MangaTagsTag");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_MangaMangaTag_Tags_MangaTagsTag",
+                table: "MangaMangaTag",
+                column: "MangaTagsTag",
+                principalTable: "Tags",
+                principalColumn: "Tag",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_MangaMangaTag_Tags_MangaTagsTag",
+                table: "MangaMangaTag");
+
+            migrationBuilder.RenameColumn(
+                name: "MangaTagsTag",
+                table: "MangaMangaTag",
+                newName: "TagsTag");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_MangaMangaTag_MangaTagsTag",
+                table: "MangaMangaTag",
+                newName: "IX_MangaMangaTag_TagsTag");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_MangaMangaTag_Tags_TagsTag",
+                table: "MangaMangaTag",
+                column: "TagsTag",
+                principalTable: "Tags",
+                principalColumn: "Tag",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

API/Migrations/PgsqlContextModelSnapshot.cs

@@ -179,14 +179,6 @@ namespace API.Migrations
                         .HasMaxLength(64)
                         .HasColumnType("character varying(64)");
 
-                    b.PrimitiveCollection<string[]>("AltTitleIds")
-                        .IsRequired()
-                        .HasColumnType("text[]");
-
-                    b.PrimitiveCollection<string[]>("AuthorIds")
-                        .IsRequired()
-                        .HasColumnType("text[]");
-
                     b.Property<string>("ConnectorId")
                         .IsRequired()
                         .HasMaxLength(64)
@@ -210,10 +202,6 @@ namespace API.Migrations
                     b.Property<float>("IgnoreChapterBefore")
                         .HasColumnType("real");
 
-                    b.PrimitiveCollection<string[]>("LinkIds")
-                        .IsRequired()
-                        .HasColumnType("text[]");
-
                     b.Property<string>("MangaConnectorId")
                         .IsRequired()
                         .HasColumnType("character varying(32)");
@@ -228,10 +216,6 @@ namespace API.Migrations
                     b.Property<byte>("ReleaseStatus")
                         .HasColumnType("smallint");
 
-                    b.PrimitiveCollection<string[]>("TagIds")
-                        .IsRequired()
-                        .HasColumnType("text[]");
-
                     b.Property<string>("WebsiteUrl")
                         .IsRequired()
                         .HasColumnType("text");
@@ -383,17 +367,17 @@ namespace API.Migrations
                     b.Property<string>("MangaId")
                         .HasColumnType("character varying(64)");
 
-                    b.Property<string>("TagsTag")
+                    b.Property<string>("MangaTagsTag")
                         .HasColumnType("text");
 
-                    b.HasKey("MangaId", "TagsTag");
+                    b.HasKey("MangaId", "MangaTagsTag");
 
-                    b.HasIndex("TagsTag");
+                    b.HasIndex("MangaTagsTag");
 
                     b.ToTable("MangaMangaTag");
                 });
 
-            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
                 {
                     b.HasBaseType("API.Schema.Jobs.Job");
 
@@ -407,13 +391,13 @@ namespace API.Migrations
                     b.ToTable("Jobs", t =>
                         {
                             t.Property("MangaId")
-                                .HasColumnName("DownloadMangaCoverJob_MangaId");
+                                .HasColumnName("DownloadAvailableChaptersJob_MangaId");
                         });
 
-                    b.HasDiscriminator().HasValue((byte)4);
+                    b.HasDiscriminator().HasValue((byte)1);
                 });
 
-            modelBuilder.Entity("API.Schema.Jobs.DownloadNewChaptersJob", b =>
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
                 {
                     b.HasBaseType("API.Schema.Jobs.Job");
 
@@ -424,7 +408,7 @@ namespace API.Migrations
 
                     b.HasIndex("MangaId");
 
-                    b.HasDiscriminator().HasValue((byte)1);
+                    b.HasDiscriminator().HasValue((byte)4);
                 });
 
             modelBuilder.Entity("API.Schema.Jobs.DownloadSingleChapterJob", b =>
@@ -456,6 +440,46 @@ namespace API.Migrations
                     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");
@@ -620,12 +644,12 @@ namespace API.Migrations
 
                     b.HasOne("API.Schema.MangaTag", null)
                         .WithMany()
-                        .HasForeignKey("TagsTag")
+                        .HasForeignKey("MangaTagsTag")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
                 });
 
-            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
+            modelBuilder.Entity("API.Schema.Jobs.DownloadAvailableChaptersJob", b =>
                 {
                     b.HasOne("API.Schema.Manga", "Manga")
                         .WithMany()
@@ -636,7 +660,7 @@ namespace API.Migrations
                     b.Navigation("Manga");
                 });
 
-            modelBuilder.Entity("API.Schema.Jobs.DownloadNewChaptersJob", b =>
+            modelBuilder.Entity("API.Schema.Jobs.DownloadMangaCoverJob", b =>
                 {
                     b.HasOne("API.Schema.Manga", "Manga")
                         .WithMany()
@@ -658,6 +682,28 @@ namespace API.Migrations
                     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")

API/Program.cs

@@ -8,6 +8,7 @@ using Asp.Versioning;
 using Asp.Versioning.Builder;
 using Asp.Versioning.Conventions;
 using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 
 var builder = WebApplication.CreateBuilder(args);
@@ -25,25 +26,27 @@ builder.Services.AddCors(options =>
 });
 
 builder.Services.AddApiVersioning(option =>
-{
-    option.AssumeDefaultVersionWhenUnspecified = true;
-    option.DefaultApiVersion = new ApiVersion(2); 
-    option.ReportApiVersions = true; 
-    option.ApiVersionReader = ApiVersionReader.Combine(
-        new UrlSegmentApiVersionReader(),
-        new QueryStringApiVersionReader("api-version"),
-        new HeaderApiVersionReader("X-Version"),
-        new MediaTypeApiVersionReader("x-version"));
-})
-.AddMvc(options =>
-{
-    options.Conventions.Add(new VersionByNamespaceConvention());
-})
-    .AddApiExplorer(options => {
-    options.GroupNameFormat = "'v'V";
-    options.SubstituteApiVersionInUrl = true;
-});
+    {
+        option.AssumeDefaultVersionWhenUnspecified = true;
+        option.DefaultApiVersion = new ApiVersion(2);
+        option.ReportApiVersions = true;
+        option.ApiVersionReader = ApiVersionReader.Combine(
+            new UrlSegmentApiVersionReader(),
+            new QueryStringApiVersionReader("api-version"),
+            new HeaderApiVersionReader("X-Version"),
+            new MediaTypeApiVersionReader("x-version"));
+    })
+    .AddMvc(options =>
+    {
+        options.Conventions.Add(new VersionByNamespaceConvention());
+    })
+    .AddApiExplorer(options =>
+    {
+        options.GroupNameFormat = "'v'V";
+        options.SubstituteApiVersionInUrl = true;
+    });
 builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGenNewtonsoftSupport();
 builder.Services.AddSwaggerGen(opt =>
 {
     var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
@@ -58,12 +61,13 @@ builder.Services.AddDbContext<PgsqlContext>(options =>
                       $"Password={Environment.GetEnvironmentVariable("POSTGRES_PASSWORD")??"postgres"}"));
 
 builder.Services.AddControllers(options =>
-    {
-        options.AllowEmptyInputInBodyModelBinding = true;
-    })
-    .AddNewtonsoftJson(opts =>
+{
+    options.AllowEmptyInputInBodyModelBinding = true;
+});
+builder.Services.AddControllers().AddNewtonsoftJson(opts =>
 {
     opts.SerializerSettings.Converters.Add(new StringEnumConverter());
+    opts.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
 });
 
 builder.WebHost.UseUrls("http://*:6531");
@@ -110,14 +114,13 @@ using (var scope = app.Services.CreateScope())
             new MangaKatana(),
             new Mangaworld(),
             new ManhuaPlus(),
-            new Weebcentral()
+            new Weebcentral(),
+            new Manganato()
         ];
     MangaConnector[] newConnectors = connectors.Where(c => !context.MangaConnectors.Contains(c)).ToArray();
     context.MangaConnectors.AddRange(newConnectors);
 
-    IQueryable<string> updateMetadataJobMangaIds = context.Jobs.Where(j => j.JobType == JobType.UpdateMetaDataJob).Select(j => ((UpdateMetadataJob)j).MangaId);
-    Job[] newUpdateMetadataJobs = context.Manga.Where(m => !updateMetadataJobMangaIds.Contains(m.MangaId)).ToList().Select(m => new UpdateMetadataJob(0, m.MangaId)).ToArray();
-    context.Jobs.AddRange(newUpdateMetadataJobs);
+    context.Jobs.AddRange(context.Manga.AsEnumerable().Select(m => new UpdateFilesDownloadedJob(0, m.MangaId)));
     
     context.Jobs.RemoveRange(context.Jobs.Where(j => j.state == JobState.Completed && j.RecurrenceMs < 1));
     

API/Schema/Chapter.cs

@@ -39,8 +39,7 @@ public class Chapter : IComparable<Chapter>
     public bool Downloaded { get; internal set; } = false;
 
     public string ParentMangaId { get; internal set; }
-    [JsonIgnore]
-    public Manga? ParentManga { get; init; }
+    [JsonIgnore] public Manga? ParentManga { get; init; }
 
     public int CompareTo(Chapter? other)
     {
@@ -130,7 +129,7 @@ public class Chapter : IComparable<Chapter>
     internal string GetComicInfoXmlString()
     {
         XElement comicInfo = new("ComicInfo",
-            new XElement("Tags", string.Join(',', ParentManga.Tags.Select(tag => tag.Tag))),
+            new XElement("Tags", string.Join(',', ParentManga.MangaTags.Select(tag => tag.Tag))),
             new XElement("LanguageISO", ParentManga.OriginalLanguage),
             new XElement("Title", Title),
             new XElement("Writer", string.Join(',', ParentManga.Authors.Select(author => author.AuthorName))),

API/Schema/Jobs/DownloadAvailableChaptersJob.cs

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

API/Schema/Jobs/JobType.cs

@@ -4,8 +4,10 @@
 public enum JobType : byte
 {
     DownloadSingleChapterJob = 0, 
-    DownloadNewChaptersJob = 1, 
+    DownloadAvailableChaptersJob = 1, 
     UpdateMetaDataJob = 2,
     MoveFileOrFolderJob = 3,
-    DownloadMangaCoverJob = 4
+    DownloadMangaCoverJob = 4,
+    RetrieveChaptersJob = 5,
+    UpdateFilesDownloadedJob = 6
 }

API/Schema/Jobs/MoveFileOrFolderJob.cs

@@ -8,6 +8,33 @@ public class MoveFileOrFolderJob(string fromLocation, string toLocation, string?
     
     protected override IEnumerable<Job> RunInternal(PgsqlContext context)
     {
-        throw new NotImplementedException();
+        try
+        {
+            FileInfo fi = new FileInfo(FromLocation);
+            if (!fi.Exists)
+                return [];
+            if (File.Exists(ToLocation))//Do not override existing
+                return [];
+            if(fi.Attributes.HasFlag(FileAttributes.Directory))
+                MoveDirectory(fi, ToLocation);
+            else
+                MoveFile(fi, ToLocation);
+        }
+        catch (Exception e)
+        {
+            
+        }
+
+        return [];
+    }
+
+    private void MoveDirectory(FileInfo from, string toLocation)
+    {
+        Directory.Move(from.FullName, toLocation);        
+    }
+
+    private void MoveFile(FileInfo from, string toLocation)
+    {
+        File.Move(from.FullName, toLocation);
     }
 }

API/Schema/Jobs/RetrieveChaptersJob.cs

@@ -1,11 +1,11 @@
-using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations;
 using API.Schema.MangaConnectors;
 using Newtonsoft.Json;
 
 namespace API.Schema.Jobs;
 
-public class DownloadNewChaptersJob(ulong recurrenceMs, string mangaId, string? parentJobId = null, ICollection<string>? dependsOnJobsIds = null)
-    : Job(TokenGen.CreateToken(typeof(DownloadNewChaptersJob)), JobType.DownloadNewChaptersJob, recurrenceMs, parentJobId, dependsOnJobsIds)
+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)]
     public string MangaId { get; init; } = mangaId;
@@ -30,7 +30,7 @@ public class DownloadNewChaptersJob(ulong recurrenceMs, string mangaId, string?
         Chapter[] newChapters = allNewChapters.Where(chapter => !chapterIds.Contains(chapter.ChapterId)).ToArray();
         context.Chapters.AddRangeAsync(newChapters).Wait();
         context.SaveChangesAsync().Wait();
-        
-        return allNewChapters.Select(chapter => new DownloadSingleChapterJob(chapter.ChapterId, this.JobId));
+
+        return [];
     }
 }

API/Schema/Jobs/UpdateFilesDownloadedJob.cs

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

API/Schema/Jobs/UpdateMetadataJob.cs

@@ -21,14 +21,6 @@ public class UpdateMetadataJob(ulong recurrenceMs, string mangaId, string? paren
     /// <param name="context"></param>
     protected override IEnumerable<Job> RunInternal(PgsqlContext context)
     {
-        //Manga manga = Manga ?? context.Manga.Find(MangaId)!;
-        IQueryable<Chapter> chapters = context.Chapters.Where(c => c.ParentMangaId == MangaId);
-        foreach (Chapter chapter in chapters)
-            chapter.Downloaded = chapter.IsDownloaded();
-
-        context.SaveChanges();
-        return [];
-        
-        //TODO implement Metadata-Update from MangaConnector
+        return [];//TODO
     }
 }

API/Schema/Manga.cs

@@ -1,5 +1,5 @@
-using System.Collections;
 using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
 using System.Net;
 using System.Runtime.InteropServices;
 using System.Text.RegularExpressions;
@@ -32,39 +32,31 @@ public class Manga
     public float IgnoreChapterBefore { get; internal set; }
 
     public string MangaConnectorId { get; private set; }
-    [JsonIgnore]
-    public MangaConnector? MangaConnector { get; private set; }
+    [JsonIgnore] public MangaConnector? MangaConnector { get; private set; }
     
-    public ICollection<string> AuthorIds { get; internal set; }
-    [JsonIgnore]
-    public ICollection<Author>? Authors { get; internal set; }
+    [JsonIgnore] public ICollection<Author>? Authors { get; internal set; }
+    [NotMapped] public IEnumerable<string> AuthorIds => Authors?.Select(a => a.AuthorId) ?? [];
     
-    public ICollection<string> TagIds { get; internal set; }
-    [JsonIgnore]
-    public ICollection<MangaTag>? Tags { get; internal set; }
+    [JsonIgnore] public ICollection<MangaTag>? MangaTags { get; internal set; }
+    [NotMapped] public IEnumerable<string> Tags => MangaTags.Select(t => t.Tag);
     
-    public ICollection<string> LinkIds { get; internal set; }
-    [JsonIgnore]
-    public ICollection<Link>? Links { get; internal set; }
     
-    public ICollection<string> AltTitleIds { get; internal set; }
-    [JsonIgnore]
-    public ICollection<MangaAltTitle>? AltTitles { get; internal set; }
+    [JsonIgnore] public ICollection<Link>? Links { get; internal set; }
+    [NotMapped] 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) ?? [];
 
     public Manga(string connectorId, string name, string description, string websiteUrl, string coverUrl,
         string? coverFileNameInCache, uint year, string? originalLanguage, MangaReleaseStatus releaseStatus,
         float ignoreChapterBefore, MangaConnector mangaConnector, ICollection<Author> authors,
-        ICollection<MangaTag> tags, ICollection<Link> links, ICollection<MangaAltTitle> altTitles)
+        ICollection<MangaTag> mangaTags, ICollection<Link> links, ICollection<MangaAltTitle> altTitles)
         : this(connectorId, name, description, websiteUrl, coverUrl, coverFileNameInCache, year, originalLanguage,
             releaseStatus, ignoreChapterBefore, mangaConnector.Name)
     {
-        this.AuthorIds = authors.Select(a => a.AuthorId) as ICollection<string>;
         this.Authors = authors;
-        this.TagIds = tags.Select(t => t.Tag) as ICollection<string>;
-        this.Tags = tags;
-        this.LinkIds = links.Select(l => l.LinkId) as ICollection<string>;
+        this.MangaTags = mangaTags;
         this.Links = links;
-        this.AltTitleIds = altTitles.Select(t => t.AltTitleId) as ICollection<string>;
         this.AltTitles = altTitles;
     }
     
@@ -103,7 +95,7 @@ public class Manga
         this.OriginalLanguage = other.OriginalLanguage;
         this.Authors = other.Authors;
         this.Links = other.Links;
-        this.Tags = other.Tags;
+        this.MangaTags = other.MangaTags;
         this.AltTitles = other.AltTitles;
         this.ReleaseStatus = other.ReleaseStatus;
     }
@@ -127,7 +119,7 @@ public class Manga
         if (File.Exists(saveImagePath))
             return saveImagePath;
         
-        RequestResult coverResult = new HttpDownloadClient().MakeRequest(CoverUrl, RequestType.MangaCover);
+        RequestResult coverResult = new HttpDownloadClient().MakeRequest(CoverUrl, RequestType.MangaCover, this.WebsiteUrl);
         if (coverResult.statusCode is < HttpStatusCode.Accepted or >= HttpStatusCode.Ambiguous)
             return SaveCoverImageToCache(--retries);
             

API/Schema/MangaConnectors/Manganato.cs

@@ -0,0 +1,219 @@
+using System.Globalization;
+using System.Net;
+using System.Text.RegularExpressions;
+using API.MangaDownloadClients;
+using HtmlAgilityPack;
+
+namespace API.Schema.MangaConnectors;
+
+public class Manganato : MangaConnector
+{
+    public Manganato() : base("Manganato", ["en"],
+        ["natomanga.com", "manganato.gg", "mangakakalot.gg", "nelomanga.com"],
+        "https://www.manganato.gg/images/favicon-manganato.webp")
+    {
+        this.downloadClient = new HttpDownloadClient();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] GetManga(
+        string publicationTitle = "")
+    {
+        string sanitizedTitle = string.Join('_', Regex.Matches(publicationTitle, "[A-z]*").Where(str => str.Length > 0))
+            .ToLower();
+        string requestUrl = $"https://manganato.gg/search/story/{sanitizedTitle}";
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return [];
+
+        if (requestResult.htmlDocument is null)
+            return [];
+        (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] publications =
+            ParsePublicationsFromHtml(requestResult.htmlDocument);
+        return publications;
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)[] ParsePublicationsFromHtml(
+        HtmlDocument document)
+    {
+        List<HtmlNode> searchResults =
+            document.DocumentNode.Descendants("div").Where(n => n.HasClass("story_item")).ToList();
+        List<string> urls = new();
+        foreach (HtmlNode mangaResult in searchResults)
+        {
+            try
+            {
+                urls.Add(mangaResult.Descendants("h3").First(n => n.HasClass("story_name"))
+                    .Descendants("a").First().GetAttributeValue("href", ""));
+            }
+            catch
+            {
+                //failed to get a url, send it to the void
+            }
+        }
+
+        List<(Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)> ret = new();
+        foreach (string url in urls)
+        {
+            (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? manga = GetMangaFromUrl(url);
+            if (manga is { } m)
+                ret.Add(m);
+        }
+
+        return ret.ToArray();
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)? GetMangaFromId(
+        string publicationId)
+    {
+        return GetMangaFromUrl($"https://chapmanganato.com/{publicationId}");
+    }
+
+    public override (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?)?
+        GetMangaFromUrl(string url)
+    {
+        RequestResult requestResult =
+            downloadClient.MakeRequest(url, RequestType.MangaInfo);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return null;
+
+        if (requestResult.htmlDocument is null)
+            return null;
+        return ParseSinglePublicationFromHtml(requestResult.htmlDocument, url.Split('/')[^1], url);
+    }
+
+    private (Manga, List<Author>?, List<MangaTag>?, List<Link>?, List<MangaAltTitle>?) ParseSinglePublicationFromHtml(
+        HtmlDocument document, string publicationId, string websiteUrl)
+    {
+        Dictionary<string, string> altTitles = new();
+        List<MangaTag> tags = new();
+        List<Author> authors = new();
+        MangaReleaseStatus releaseStatus = MangaReleaseStatus.Unreleased;
+
+        HtmlNode infoNode = document.DocumentNode.Descendants("ul").First(d => d.HasClass("manga-info-text"));
+
+        string sortName = infoNode.Descendants("h1").First().InnerText;
+
+        foreach (HtmlNode li in infoNode.Descendants("li"))
+        {
+            string text = li.InnerText.Trim().ToLower();
+
+            if (text.StartsWith("author(s) :"))
+            {
+                authors = li.Descendants("a").Select(a => a.InnerText.Trim()).Select(a => new Author(a)).ToList();
+            }
+            else if (text.StartsWith("status :"))
+            {
+                string status = text.Replace("status :", "").Trim().ToLower();
+                if (string.IsNullOrWhiteSpace(status))
+                    releaseStatus = MangaReleaseStatus.Continuing;
+                else if (status == "ongoing")
+                    releaseStatus = MangaReleaseStatus.Continuing;
+                else
+                    releaseStatus = Enum.Parse<MangaReleaseStatus>(status, true);
+            }
+            else if (li.HasClass("genres"))
+            {
+                tags = li.Descendants("a").Select(a => new MangaTag(a.InnerText.Trim())).ToList();
+            }
+        }
+
+        string posterUrl = document.DocumentNode.Descendants("div").First(s => s.HasClass("manga-info-pic"))
+            .Descendants("img").First()
+            .GetAttributes().First(a => a.Name == "src").Value;
+
+        string description = document.DocumentNode.SelectSingleNode("//div[@id='contentBox']")
+            .InnerText.Replace("Description :", "");
+        while (description.StartsWith('\n'))
+            description = description.Substring(1);
+
+        string pattern = "MMM-dd-yyyy HH:mm";
+
+        HtmlNode? oldestChapter = document.DocumentNode
+            .SelectNodes("//div[contains(concat(' ',normalize-space(@class),' '),' row ')]/span[@title]").MaxBy(
+                node => DateTime.ParseExact(node.GetAttributeValue("title", "Dec-31-2400 23:59"), pattern,
+                    CultureInfo.InvariantCulture).Millisecond);
+
+
+        uint year = Convert.ToUInt32(DateTime.ParseExact(
+            oldestChapter?.GetAttributeValue("title", "Dec 31 2400, 23:59") ?? "Dec 31 2400, 23:59", pattern,
+            CultureInfo.InvariantCulture).Year);
+
+        Manga manga = new(publicationId, sortName, description, websiteUrl, posterUrl, null, year, null, releaseStatus,
+            -1, this, authors, tags, [], []);
+        return (manga, authors, tags, [], []);
+    }
+
+    public override Chapter[] GetChapters(Manga manga, string language = "en")
+    {
+        string requestUrl = manga.WebsiteUrl;
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300)
+            return Array.Empty<Chapter>();
+
+        //Return Chapters ordered by Chapter-Number
+        if (requestResult.htmlDocument is null)
+            return Array.Empty<Chapter>();
+        List<Chapter> chapters = ParseChaptersFromHtml(manga, requestResult.htmlDocument);
+        return chapters.Order().ToArray();
+    }
+
+    internal override string[] GetChapterImageUrls(Chapter chapter)
+    {
+        string requestUrl = chapter.Url;
+        RequestResult requestResult =
+            downloadClient.MakeRequest(requestUrl, RequestType.Default);
+        if ((int)requestResult.statusCode < 200 || (int)requestResult.statusCode >= 300 ||
+            requestResult.htmlDocument is null)
+            return [];
+
+        string[] imageUrls = ParseImageUrlsFromHtml(requestResult.htmlDocument);
+
+        return imageUrls;
+    }
+
+    private List<Chapter> ParseChaptersFromHtml(Manga manga, HtmlDocument document)
+    {
+        List<Chapter> ret = new();
+
+        HtmlNode chapterList = document.DocumentNode.Descendants("div").First(l => l.HasClass("chapter-list"));
+
+        Regex volRex = new(@"Vol\.([0-9]+).*");
+        Regex chapterRex = new(@"https:\/\/chapmanganato.[A-z]+\/manga-[A-z0-9]+\/chapter-([0-9\.]+)");
+        Regex nameRex = new(@"Chapter ([0-9]+(\.[0-9]+)*){1}:? (.*)");
+
+        foreach (HtmlNode chapterInfo in chapterList.Descendants("div").Where(x => x.HasClass("row")))
+        {
+            string url = chapterInfo.Descendants("a").First().GetAttributeValue("href", "");
+            var name = chapterInfo.Descendants("a").First().InnerText.Trim();
+            string chapterName = nameRex.Match(name).Groups[3].Value;
+            string chapterNumber = Regex.Match(name, @"Chapter ([0-9]+(\.[0-9]+)*)").Groups[1].Value;
+            string? volumeNumber = Regex.Match(chapterName, @"Vol\.([0-9]+)").Groups[1].Value;
+            if (string.IsNullOrWhiteSpace(volumeNumber))
+                volumeNumber = "0";
+            try
+            {
+                ret.Add(new Chapter(manga, url, chapterNumber, int.Parse(volumeNumber), chapterName));
+            }
+            catch (Exception e)
+            {
+            }
+        }
+
+        ret.Reverse();
+        return ret;
+    }
+
+    private string[] ParseImageUrlsFromHtml(HtmlDocument document)
+    {
+        List<string> ret = new();
+
+        HtmlNode imageContainer =
+            document.DocumentNode.Descendants("div").First(i => i.HasClass("container-chapter-reader"));
+        foreach (HtmlNode imageNode in imageContainer.Descendants("img"))
+            ret.Add(imageNode.GetAttributeValue("src", ""));
+
+        return ret.ToArray();
+    }
+}

API/Schema/PgsqlContext.cs

@@ -36,21 +36,23 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .HasDiscriminator<LibraryType>(l => l.LibraryType)
             .HasValue<Komga>(LibraryType.Komga)
             .HasValue<Kavita>(LibraryType.Kavita);
-        
+
         modelBuilder.Entity<Job>()
             .HasDiscriminator<JobType>(j => j.JobType)
             .HasValue<MoveFileOrFolderJob>(JobType.MoveFileOrFolderJob)
-            .HasValue<DownloadNewChaptersJob>(JobType.DownloadNewChaptersJob)
+            .HasValue<DownloadAvailableChaptersJob>(JobType.DownloadAvailableChaptersJob)
             .HasValue<DownloadSingleChapterJob>(JobType.DownloadSingleChapterJob)
             .HasValue<DownloadMangaCoverJob>(JobType.DownloadMangaCoverJob)
-            .HasValue<UpdateMetadataJob>(JobType.UpdateMetaDataJob);
+            .HasValue<UpdateMetadataJob>(JobType.UpdateMetaDataJob)
+            .HasValue<RetrieveChaptersJob>(JobType.RetrieveChaptersJob)
+            .HasValue<UpdateFilesDownloadedJob>(JobType.UpdateFilesDownloadedJob);
         modelBuilder.Entity<Job>()
             .HasOne<Job>(j => j.ParentJob)
             .WithMany()
             .HasForeignKey(j => j.ParentJobId);
         modelBuilder.Entity<Job>()
             .HasMany<Job>(j => j.DependsOnJobs);
-        modelBuilder.Entity<DownloadNewChaptersJob>()
+        modelBuilder.Entity<DownloadAvailableChaptersJob>()
             .Navigation(dncj => dncj.Manga)
             .AutoInclude();
         modelBuilder.Entity<DownloadSingleChapterJob>()
@@ -74,10 +76,10 @@ public class PgsqlContext(DbContextOptions<PgsqlContext> options) : DbContext(op
             .Navigation(m => m.Authors)
             .AutoInclude();
         modelBuilder.Entity<Manga>()
-            .HasMany<MangaTag>(m => m.Tags)
+            .HasMany<MangaTag>(m => m.MangaTags)
             .WithMany();
         modelBuilder.Entity<Manga>()
-            .Navigation(m => m.Tags)
+            .Navigation(m => m.MangaTags)
             .AutoInclude();
         modelBuilder.Entity<Manga>()
             .HasMany<Link>(m => m.Links)

API/Tranga.cs

@@ -91,10 +91,10 @@ public static class Tranga
                 // If the job is already running, skip it
                 if (RunningJobs.Values.Any(j => j.JobId == job.JobId)) continue;
 
-                if (job is DownloadNewChaptersJob dncj)
+                if (job is DownloadAvailableChaptersJob dncj)
                 {
                     if (RunningJobs.Values.Any(j =>
-                            j is DownloadNewChaptersJob rdncj &&
+                            j is DownloadAvailableChaptersJob rdncj &&
                             rdncj.Manga?.MangaConnector == dncj.Manga?.MangaConnector))
                     {
                         continue;
@@ -143,13 +143,15 @@ public static class Tranga
         IEnumerable<Job> ret = new List<Job>();
         if(jobsByType.ContainsKey(JobType.MoveFileOrFolderJob))
             ret = ret.Concat(jobsByType[JobType.MoveFileOrFolderJob]);
-        if(jobsByType.ContainsKey(JobType.DownloadMangaCoverJob))
-         ret = ret.Concat(jobsByType[JobType.DownloadMangaCoverJob]);
+        if(jobsByType.ContainsKey(JobType.DownloadMangaCoverJob)) 
+            ret = ret.Concat(jobsByType[JobType.DownloadMangaCoverJob]);
+        if(jobsByType.ContainsKey(JobType.UpdateFilesDownloadedJob))
+            ret = ret.Concat(jobsByType[JobType.UpdateFilesDownloadedJob]);
 
         Dictionary<MangaConnector, List<Job>> metadataJobsByConnector = new();
-        if (jobsByType.ContainsKey(JobType.DownloadNewChaptersJob))
+        if (jobsByType.ContainsKey(JobType.DownloadAvailableChaptersJob))
         {
-            foreach (DownloadNewChaptersJob job in jobsByType[JobType.DownloadNewChaptersJob])
+            foreach (DownloadAvailableChaptersJob job in jobsByType[JobType.DownloadAvailableChaptersJob])
             {
                 Manga manga = job.Manga ?? context.Manga.Find(job.MangaId)!;
                 MangaConnector connector = manga.MangaConnector ?? context.MangaConnectors.Find(manga.MangaConnectorId)!;
@@ -167,6 +169,16 @@ public static class Tranga
                     metadataJobsByConnector[connector].Add(job);
             }
         }
+        if (jobsByType.ContainsKey(JobType.RetrieveChaptersJob))
+        {
+            foreach (RetrieveChaptersJob job in jobsByType[JobType.RetrieveChaptersJob])
+            {
+                Manga manga = job.Manga ?? context.Manga.Find(job.MangaId)!;
+                MangaConnector connector = manga.MangaConnector ?? context.MangaConnectors.Find(manga.MangaConnectorId)!;
+                if(!metadataJobsByConnector.TryAdd(connector, [job]))
+                    metadataJobsByConnector[connector].Add(job);
+            }
+        }
         foreach (List<Job> metadataJobs in metadataJobsByConnector.Values)
             ret = ret.Append(metadataJobs.MinBy(j => j.NextExecution))!;
 

API/TrangaSettings.cs

@@ -111,7 +111,7 @@ public static class TrangaSettings
         ExportSettings();
     }
 
-    public static void UpdateRateLimit(RequestType requestType, int newLimit)
+    public static void UpdateRequestLimit(RequestType requestType, int newLimit)
     {
         requestLimits[requestType] = newLimit;
         ExportSettings();

README.md

@@ -44,24 +44,24 @@
 Tranga can download Chapters and Metadata from "Scanlation" sites such as 
 
 - [MangaDex.org](https://mangadex.org/) (Multilingual)
-- [Manganato.com](https://manganato.com/) (en)
+- [Manganato.gg](https://manganato.com/) (en)
 - [MangaKatana.com](https://mangakatana.com) (en)
 - [Mangaworld.bz](https://www.mangaworld.bz/) (it)
 - [Bato.to](https://bato.to/v3x) (en)
 - [ManhuaPlus](https://manhuaplus.org/) (en)
 - [MangaHere](https://www.mangahere.cc/) (en) (Their covers aren't scrapeable.)
 - [Weebcentral](https://weebcentral.com) (en)
-- [Webtoons](https://www.webtoons.com/en/)
+- [Webtoons](https://www.webtoons.com/en/) (en)
 - ❓ Open an [issue](https://github.com/C9Glax/tranga/issues/new?assignees=&labels=New+Connector&projects=&template=new_connector.yml&title=%5BNew+Connector%5D%3A+)
 
 and trigger a library-scan with [Komga](https://komga.org/) and [Kavita](https://www.kavitareader.com/).  
 Notifications can be sent to your devices using [Gotify](https://gotify.net/), [LunaSea](https://www.lunasea.app/) or [Ntfy](https://ntfy.sh/
-).
+), or any other service that can use REST Webhooks.
 
 ### What this does and doesn't do
 
 Tranga (this git-repo) will open a port (standard 6531) and listen for requests to add Jobs to Monitor and/or download specific Manga.
-The configuration is all done through HTTP-Requests. [Documentation](docs/API_Calls_v2.md)
+The configuration is all done through HTTP-Requests.
 
 _**For a web-frontend use [tranga-website](https://github.com/C9Glax/tranga-website).**_
 
@@ -91,7 +91,6 @@ That is why I wanted to create my own project, in a language I understand, and t
 - [Html Agility Pack (HAP)](https://html-agility-pack.net/)
 - [Soenneker.Utils.String.NeedlemanWunsch](https://github.com/soenneker/soenneker.utils.string.needlemanwunsch)
 - [Sixlabors.ImageSharp](https://docs-v2.sixlabors.com/articles/imagesharp/index.html#license)
-- [zstd-wrapper](https://github.com/oleg-st/ZstdSharp) [zstd](https://github.com/facebook/zstd)
 - 💙 Blåhaj 🦈
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>
@@ -120,10 +119,7 @@ access the folder.
 
 ### Prerequisites
 
-#### To Build
-[.NET-Core 8.0 SDK](https://dotnet.microsoft.com/en-us/download/dotnet/8.0)
-#### To Run
-[.NET-Core 8.0 Runtime](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) scroll down a bit, should be on the right the second item.
+.NET-9.0
 
 See the [open issues](https://github.com/C9Glax/tranga/issues) for a full list of proposed features (and known issues).