Snarky comments. Documentation

Tasks are now executed in another Thread.
Replaced TrangaTask.isBeingExecuted bool with 3-states: Waiting, Enqueued, Running
Added Queue size to CLI output.

README.md

@@ -0,0 +1,5 @@
+Has a interactive CLI-Version as well as API-Version (no documentation of API yet).
+
+Only one Connector so far: MangaDex.org (Timeout between requests 750ms)
+
+Can automatically download new Chapters every given time-period.

Tranga-API/Dockerfile

@@ -0,0 +1,20 @@
+FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
+WORKDIR /src
+COPY ["Tranga-API/Tranga-API.csproj", "Tranga-API/"]
+RUN dotnet restore "Tranga-API/Tranga-API.csproj"
+COPY . .
+WORKDIR "/src/Tranga-API"
+RUN dotnet build "Tranga-API.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "Tranga-API.csproj" -c Release -o /app/publish /p:UseAppHost=false
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "Tranga-API.dll"]

Tranga-API/Program.cs

@@ -0,0 +1,49 @@
+using System.Text.Json;
+using Tranga;
+using Tranga.Connectors;
+
+TaskManager taskManager = new TaskManager(Directory.GetCurrentDirectory());
+var builder = WebApplication.CreateBuilder(args);
+var app = builder.Build();
+
+app.MapGet("/GetConnectors", () => JsonSerializer.Serialize(taskManager.GetAvailableConnectors().Values.ToArray()));
+
+app.MapGet("/GetPublications", (string connectorName, string? title) =>
+{
+    Connector connector = taskManager.GetConnector(connectorName);
+
+    Publication[] publications;
+    if (title is not null)
+        publications = connector.GetPublications(title);
+    else
+        publications = connector.GetPublications();
+
+    return JsonSerializer.Serialize(publications);
+});
+
+app.MapGet("/ListTasks", () => JsonSerializer.Serialize(taskManager.GetAllTasks()));
+
+app.MapGet("/CreateTask",
+    (TrangaTask.Task task, string connectorName, string? publicationName, TimeSpan reoccurrence, string language) =>
+    {
+        Publication? publication =
+            taskManager.GetAllPublications().FirstOrDefault(pub => pub.downloadUrl == publicationName);
+        if (publication is null)
+            JsonSerializer.Serialize($"Publication {publicationName} is unknown.");
+        
+        taskManager.AddTask(task, connectorName, publication, reoccurrence, language);
+        JsonSerializer.Serialize("Success");
+    });
+
+app.MapGet("/RemoveTask", (TrangaTask.Task task, string connector, string? publicationName) =>
+{
+    Publication? publication =
+        taskManager.GetAllPublications().FirstOrDefault(pub => pub.downloadUrl == publicationName);
+    if (publication is null)
+        JsonSerializer.Serialize($"Publication {publicationName} is unknown.");
+        
+    taskManager.RemoveTask(task, connector, publication);
+    JsonSerializer.Serialize("Success");
+});
+
+app.Run();

Tranga-API/Properties/launchSettings.json

@@ -0,0 +1,37 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:14826",
+      "sslPort": 44333
+    }
+  },
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "http://localhost:5119",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "https://localhost:7070;http://localhost:5119",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

Tranga-API/Tranga-API.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <Nullable>enable</Nullable>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <RootNamespace>Tranga_API</RootNamespace>
+        <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <Content Include="..\.dockerignore">
+        <Link>.dockerignore</Link>
+      </Content>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Tranga\Tranga.csproj" />
+    </ItemGroup>
+
+</Project>

Tranga-API/appsettings.Development.json

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

Tranga-API/appsettings.json

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

Tranga-API/tasks.json

@@ -0,0 +1 @@
+[{"reoccurrence":"00:00:00","lastExecuted":"2023-05-19T17:34:40.5349215+02:00","connectorName":"MangaDex","task":0,"publication":{"sortName":null,"description":null,"tags":null,"posterUrl":null,"year":null,"originalLanguage":null,"status":null,"folderName":null,"downloadUrl":null},"language":"en"}]

Tranga-CLI/Tranga_Cli.cs

@@ -1,76 +1,341 @@
-using Tranga;
+using System.Globalization;
+using Tranga;
 using Tranga.Connectors;
 
 namespace Tranga_CLI;
 
+/*
+ * This is written with pure hatred for readability.
+ * At some point do this properly.
+ * Read at own risk.
+ */
+
 public static class Tranga_Cli
 {
     public static void Main(string[] args)
     {
-        Console.WriteLine("Output folder path (D:):");
-        string? folderPath = Console.ReadLine();
-        while(folderPath is null )
-            folderPath = Console.ReadLine();
-        if (folderPath.Length < 1)
-            folderPath = "D:";
+        TaskManager.SettingsData settings;
+        string settingsPath = Path.Join(Directory.GetCurrentDirectory(), "data.json");
+        if (File.Exists(settingsPath))
+            settings = TaskManager.LoadData(Directory.GetCurrentDirectory());
+        else
+            settings = new TaskManager.SettingsData(Directory.GetCurrentDirectory(), null, new HashSet<TrangaTask>());
+
+            
+        Console.WriteLine($"Output folder path [{settings.downloadLocation}]:");
+        string? tmpPath = Console.ReadLine();
+        while(tmpPath is null)
+            tmpPath = Console.ReadLine();
+        if(tmpPath.Length > 0)
+            settings.downloadLocation = tmpPath;
         
-        DownloadNow(folderPath);
+        Console.WriteLine($"Komga BaseURL [{settings.komga?.baseUrl}]:");
+        string? tmpUrl = Console.ReadLine();
+        while (tmpUrl is null)
+            tmpUrl = Console.ReadLine();
+        if (tmpUrl.Length > 0)
+        {
+            Console.WriteLine("Username:");
+            string? tmpUser = Console.ReadLine();
+            while (tmpUser is null || tmpUser.Length < 1)
+                tmpUser = Console.ReadLine();
+            
+            Console.WriteLine("Password:");
+            string tmpPass = string.Empty;
+            ConsoleKey key;
+            do
+            {
+                var keyInfo = Console.ReadKey(intercept: true);
+                key = keyInfo.Key;
+
+                if (key == ConsoleKey.Backspace && tmpPass.Length > 0)
+                {
+                    Console.Write("\b \b");
+                    tmpPass = tmpPass[0..^1];
+                }
+                else if (!char.IsControl(keyInfo.KeyChar))
+                {
+                    Console.Write("*");
+                    tmpPass += keyInfo.KeyChar;
+                }
+            } while (key != ConsoleKey.Enter);
+
+            settings.komga = new Komga(tmpUrl, tmpUser, tmpPass);
+        }
+
+        //For now only TaskManager mode
+        /*
+        Console.Write("Mode (D: Interactive only, T: TaskManager):");
+        ConsoleKeyInfo mode = Console.ReadKey();
+        while (mode.Key != ConsoleKey.D && mode.Key != ConsoleKey.T)
+            mode = Console.ReadKey();
+        Console.WriteLine();
+        
+        if(mode.Key == ConsoleKey.D)
+            DownloadNow(settings);
+        else if (mode.Key == ConsoleKey.T)
+            TaskMode(settings);*/
+        TaskMode(settings);
     }
 
-    private static void DownloadNow(string folderPath)
+    private static void TaskMode(TaskManager.SettingsData settings)
     {
-        Connector connector = SelectConnector(folderPath);
+        TaskManager taskManager = new TaskManager(settings);
+        ConsoleKey selection = ConsoleKey.NoName;
+        int menu = 0;
+        while (selection != ConsoleKey.Escape && selection != ConsoleKey.Q)
+        {
+            switch (menu)
+            {
+                case 1:
+                    PrintTasks(taskManager.GetAllTasks());
+                    Console.WriteLine("Press any key.");
+                    Console.ReadKey();
+                    menu = 0;
+                    break;
+                case 2:
+                    TrangaTask.Task task = SelectTask();
+                    
+                    Connector? connector = null;
+                    if(task != TrangaTask.Task.UpdateKomgaLibrary)
+                        connector = SelectConnector(settings.downloadLocation, taskManager.GetAvailableConnectors().Values.ToArray());
+                    
+                    Publication? publication = null;
+                    if(task != TrangaTask.Task.UpdatePublications && task != TrangaTask.Task.UpdateKomgaLibrary)
+                        publication = SelectPublication(connector!);
+                    
+                    TimeSpan reoccurrence = SelectReoccurrence();
+                    TrangaTask newTask = taskManager.AddTask(task, connector?.name, publication, reoccurrence, "en");
+                    Console.WriteLine(newTask);
+                    Console.WriteLine("Press any key.");
+                    Console.ReadKey();
+                    menu = 0;
+                    break;
+                case 3:
+                    RemoveTask(taskManager);
+                    Console.WriteLine("Press any key.");
+                    Console.ReadKey();
+                    menu = 0;
+                    break;
+                case 4:
+                    ExecuteTaskNow(taskManager);
+                    Console.WriteLine("Press any key.");
+                    Console.ReadKey();
+                    menu = 0;
+                    break;
+                case 5:
+                    Console.WriteLine("Search-Query (Name):");
+                    string? query = Console.ReadLine();
+                    while (query is null || query.Length < 1)
+                        query = Console.ReadLine();
+                    PrintTasks(taskManager.GetAllTasks().Where(qTask =>
+                        qTask.ToString().ToLower().Contains(query, StringComparison.OrdinalIgnoreCase)).ToArray());
+                    Console.WriteLine("Press any key.");
+                    Console.ReadKey();
+                    menu = 0;
+                    break; 
+                case 6:
+                    PrintTasks(taskManager.GetAllTasks().Where(eTask => eTask.state == TrangaTask.ExecutionState.Running).ToArray());
+                    Console.WriteLine("Press any key.");
+                    Console.ReadKey();
+                    menu = 0;
+                    break;
+                default:
+                    selection = Menu(taskManager, settings.downloadLocation);
+                    switch (selection)
+                    {
+                        case ConsoleKey.L:
+                            menu = 1;
+                            break;
+                        case ConsoleKey.C:
+                            menu = 2;
+                            break;
+                        case ConsoleKey.D:
+                            menu = 3;
+                            break;
+                        case ConsoleKey.E:
+                            menu = 4;
+                            break;
+                        case ConsoleKey.U:
+                            menu = 0;
+                            break;
+                        case ConsoleKey.S:
+                            menu = 5;
+                            break;
+                        case ConsoleKey.R:
+                            menu = 6;
+                            break;
+                        default:
+                            menu = 0;
+                            break;
+                    }
+                    break;
+            }
+        }
 
-        Console.WriteLine("Search query (leave empty for all):");
-        string? query = Console.ReadLine();
+        if (taskManager.GetAllTasks().Any(task => task.state == TrangaTask.ExecutionState.Running))
+        {
+            Console.WriteLine("Force quit (Even with running tasks?) y/N");
+            selection = Console.ReadKey().Key;
+            while(selection != ConsoleKey.Y && selection != ConsoleKey.N)
+                selection = Console.ReadKey().Key;
+            taskManager.Shutdown(selection == ConsoleKey.Y);
+        }else
+            // ReSharper disable once RedundantArgumentDefaultValue Better readability
+            taskManager.Shutdown(false);
+    }
 
-        Publication[] publications = connector.GetPublications(query ?? "");
-        Publication selectedPub = SelectPublication(publications);
+    private static ConsoleKey Menu(TaskManager taskManager, string folderPath)
+    {
+        int taskCount = taskManager.GetAllTasks().Length;
+        int taskRunningCount = taskManager.GetAllTasks().Count(task => task.state == TrangaTask.ExecutionState.Running);
+        int taskEnqueuedCount =
+            taskManager.GetAllTasks().Count(task => task.state == TrangaTask.ExecutionState.Enqueued);
+        Console.Clear();
+        Console.WriteLine($"Download Folder: {folderPath} Tasks (Running/Queue/Total): {taskRunningCount}/{taskEnqueuedCount}/{taskCount}");
+        Console.WriteLine("U: Update this Screen");
+        Console.WriteLine("L: List tasks");
+        Console.WriteLine("C: Create Task");
+        Console.WriteLine("D: Delete Task");
+        Console.WriteLine("E: Execute Task now");
+        Console.WriteLine("S: Search Task");
+        Console.WriteLine("R: Running Tasks");
+        Console.WriteLine("Q: Exit");
+        ConsoleKey selection = Console.ReadKey().Key;
+        Console.WriteLine();
+        return selection;
+    }
+
+    private static void PrintTasks(TrangaTask[] tasks)
+    {
+        int taskCount = tasks.Length;
+        int taskRunningCount = tasks.Count(task => task.state == TrangaTask.ExecutionState.Running);
+        int taskEnqueuedCount = tasks.Count(task => task.state == TrangaTask.ExecutionState.Enqueued);
+        Console.Clear();
+        int tIndex = 0;
+        Console.WriteLine($"Tasks (Running/Queue/Total): {taskRunningCount}/{taskEnqueuedCount}/{taskCount}");
+        foreach(TrangaTask trangaTask in tasks)
+            Console.WriteLine($"{tIndex++:000}: {trangaTask}");
+    }
+
+    private static void ExecuteTaskNow(TaskManager taskManager)
+    {
+        TrangaTask[] tasks = taskManager.GetAllTasks();
+        if (tasks.Length < 1)
+        {
+            Console.Clear();
+            Console.WriteLine("There are no available Tasks.");
+            return;
+        }
+        PrintTasks(tasks);
         
-        Chapter[] allChapteres = connector.GetChapters(selectedPub, "en");
-        Chapter[] downloadChapters = SelectChapters(allChapteres);
+        Console.WriteLine($"Select Task (0-{tasks.Length - 1}):");
+
+        string? selectedTask = Console.ReadLine();
+        while(selectedTask is null || selectedTask.Length < 1)
+            selectedTask = Console.ReadLine();
+        int selectedTaskIndex = Convert.ToInt32(selectedTask);
+        
+        taskManager.ExecuteTaskNow(tasks[selectedTaskIndex]);
+    }
+
+    private static void RemoveTask(TaskManager taskManager)
+    {
+        TrangaTask[] tasks = taskManager.GetAllTasks();
+        if (tasks.Length < 1)
+        {
+            Console.Clear();
+            Console.WriteLine("There are no available Tasks.");
+            return;
+        }
+        PrintTasks(tasks);
+        
+        Console.WriteLine($"Select Task (0-{tasks.Length - 1}):");
+
+        string? selectedTask = Console.ReadLine();
+        while(selectedTask is null || selectedTask.Length < 1)
+            selectedTask = Console.ReadLine();
+        int selectedTaskIndex = Convert.ToInt32(selectedTask);
+
+        taskManager.RemoveTask(tasks[selectedTaskIndex].task, tasks[selectedTaskIndex].connectorName, tasks[selectedTaskIndex].publication);
+    }
+
+    private static TrangaTask.Task SelectTask()
+    {
+        Console.Clear();
+        string[] taskNames = Enum.GetNames<TrangaTask.Task>();
+        
+        int tIndex = 0;
+        Console.WriteLine("Available Tasks:");
+        foreach (string taskName in taskNames)
+            Console.WriteLine($"{tIndex++}: {taskName}");
+        Console.WriteLine($"Select Task (0-{taskNames.Length - 1}):");
+
+        string? selectedTask = Console.ReadLine();
+        while(selectedTask is null || selectedTask.Length < 1)
+            selectedTask = Console.ReadLine();
+        int selectedTaskIndex = Convert.ToInt32(selectedTask);
+
+        string selectedTaskName = taskNames[selectedTaskIndex];
+        return Enum.Parse<TrangaTask.Task>(selectedTaskName);
+    }
+
+    private static TimeSpan SelectReoccurrence()
+    {
+        Console.WriteLine("Select reoccurrence Timer (Format hh:mm:ss):");
+        return TimeSpan.Parse(Console.ReadLine()!, new CultureInfo("en-US"));
+    }
+
+    private static void DownloadNow(TaskManager.SettingsData settings)
+    {
+        Connector connector = SelectConnector(settings.downloadLocation, new Connector[]{new MangaDex(settings.downloadLocation)});
+
+        Publication publication = SelectPublication(connector);
+        
+        Chapter[] downloadChapters = SelectChapters(connector, publication);
 
         if (downloadChapters.Length > 0)
         {
-            connector.DownloadCover(selectedPub);
-            File.WriteAllText(Path.Join(folderPath, selectedPub.folderName, "series.json"),selectedPub.GetSeriesInfo());
+            connector.DownloadCover(publication);
+            connector.SaveSeriesInfo(publication);
         }
 
         foreach (Chapter chapter in downloadChapters)
         {
-            Console.WriteLine($"Downloading {selectedPub.sortName} V{chapter.volumeNumber}C{chapter.chapterNumber}");
-            connector.DownloadChapter(selectedPub, chapter);
+            Console.WriteLine($"Downloading {publication.sortName} V{chapter.volumeNumber}C{chapter.chapterNumber}");
+            connector.DownloadChapter(publication, chapter);
         }
     }
 
-    private static Connector SelectConnector(string folderPath)
+    private static Connector SelectConnector(string folderPath, Connector[] connectors)
     {
-        Console.WriteLine("Select Connector:");
-        Console.WriteLine("0: MangaDex");
+        Console.Clear();
+        
+        int cIndex = 0;
+        Console.WriteLine("Connectors:");
+        foreach (Connector connector in connectors)
+            Console.WriteLine($"{cIndex++}: {connector.name}");
+        Console.WriteLine($"Select Connector (0-{connectors.Length - 1}):");
 
         string? selectedConnector = Console.ReadLine();
         while(selectedConnector is null || selectedConnector.Length < 1)
             selectedConnector = Console.ReadLine();
         int selectedConnectorIndex = Convert.ToInt32(selectedConnector);
-
-        Connector connector;
-        switch (selectedConnectorIndex)
-        {
-            case 0:
-                connector = new MangaDex(folderPath);
-                break;
-            default:
-                connector = new MangaDex(folderPath);
-                break;
-        }
-
-        return connector;
+        
+        return connectors[selectedConnectorIndex];
     }
 
-    private static Publication SelectPublication(Publication[] publications)
+    private static Publication SelectPublication(Connector connector)
     {
+        Console.Clear();
+        Console.WriteLine($"Connector: {connector.name}");
+        Console.WriteLine("Publication search query (leave empty for all):");
+        string? query = Console.ReadLine();
+
+        Publication[] publications = connector.GetPublications(query ?? "");
         
         int pIndex = 0;
+        Console.WriteLine("Publications:");
         foreach(Publication publication in publications)
             Console.WriteLine($"{pIndex++}: {publication.sortName}");
         Console.WriteLine($"Select publication to Download (0-{publications.Length - 1}):");
@@ -81,9 +346,14 @@ public static class Tranga_Cli
         return publications[Convert.ToInt32(selected)];
     }
 
-    private static Chapter[] SelectChapters(Chapter[] chapters)
+    private static Chapter[] SelectChapters(Connector connector, Publication publication)
     {
+        Console.Clear();
+        Console.WriteLine($"Connector: {connector.name} Publication: {publication.sortName}");
+        Chapter[] chapters = connector.GetChapters(publication, "en");
+        
         int cIndex = 0;
+        Console.WriteLine("Chapters:");
         foreach (Chapter ch in chapters)
         {
             string name = cIndex.ToString();
@@ -99,7 +369,7 @@ public static class Tranga_Cli
             selected = Console.ReadLine();
 
         int start = 0;
-        int end = 0;
+        int end;
         if (selected == "a")
             end = chapters.Length - 1;
         else if (selected.Contains('-'))

Tranga.sln

@@ -4,6 +4,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tranga", ".\Tranga\Tranga.c
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tranga-CLI", "Tranga-CLI\Tranga-CLI.csproj", "{4899E3B2-B259-479A-B43E-042D043E9501}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tranga-API", "Tranga-API\Tranga-API.csproj", "{6284C936-4E90-486B-BC46-0AFAD85AD8EE}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -18,5 +20,9 @@ Global
 		{4899E3B2-B259-479A-B43E-042D043E9501}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{4899E3B2-B259-479A-B43E-042D043E9501}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{4899E3B2-B259-479A-B43E-042D043E9501}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6284C936-4E90-486B-BC46-0AFAD85AD8EE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6284C936-4E90-486B-BC46-0AFAD85AD8EE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6284C936-4E90-486B-BC46-0AFAD85AD8EE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6284C936-4E90-486B-BC46-0AFAD85AD8EE}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

Tranga.sln.DotSettings

@@ -1,2 +1,3 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Komga/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Tranga/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

Tranga/Chapter.cs

@@ -2,26 +2,32 @@
 
 namespace Tranga;
 
+/// <summary>
+/// Has to be Part of a publication
+/// Includes the Chapter-Name, -VolumeNumber, -ChapterNumber, the location of the chapter on the internet and the saveName of the local file.
+/// </summary>
 public struct Chapter
 {
-    public Publication publication { get; }
     public string? name { get; }
     public string? volumeNumber { get; }
     public string? chapterNumber { get; }
     public string url { get; }
-    
     public string fileName { get; }
+    public string sortNumber { get; }
 
-    public Chapter(Publication publication, string? name, string? volumeNumber, string? chapterNumber, string url)
+    public Chapter(string? name, string? volumeNumber, string? chapterNumber, string url)
     {
-        this.publication = publication;
         this.name = name;
-        this.volumeNumber = volumeNumber;
+        this.volumeNumber = volumeNumber is { Length: > 0 } ? volumeNumber : "1";
         this.chapterNumber = chapterNumber;
         this.url = url;
         string chapterName = string.Concat((name ?? "").Split(Path.GetInvalidFileNameChars()));
-        double multiplied = Convert.ToDouble(chapterNumber, new NumberFormatInfo() { NumberDecimalSeparator = "." }) *
-                            Convert.ToInt32(volumeNumber);
-        this.fileName = $"{chapterName} - V{volumeNumber}C{chapterNumber} - {multiplied}";
+        NumberFormatInfo nfi = new NumberFormatInfo()
+        {
+            NumberDecimalSeparator = "."
+        };
+        sortNumber = decimal.Round(Convert.ToDecimal(this.volumeNumber) * Convert.ToDecimal(this.chapterNumber, nfi), 1)
+            .ToString(nfi);
+        this.fileName = $"{chapterName} - V{volumeNumber}C{chapterNumber} - {sortNumber}";
     }
 }

Tranga/Connector.cs

@@ -1,59 +1,182 @@
 using System.IO.Compression;
 using System.Net;
+using System.Xml.Linq;
 
 namespace Tranga;
 
+/// <summary>
+/// Base-Class for all Connectors
+/// Provides some methods to be used by all Connectors, as well as a DownloadClient
+/// </summary>
 public abstract class Connector
 {
-    public Connector(string downloadLocation)
+    internal string downloadLocation { get; }  //Location of local files
+    protected DownloadClient downloadClient { get; }
+
+    protected Connector(string downloadLocation, uint downloadDelay)
     {
         this.downloadLocation = downloadLocation;
+        this.downloadClient = new DownloadClient(downloadDelay);
     }
     
-    internal string downloadLocation { get; }
-    public abstract string name { get; }
+    public abstract string name { get; } //Name of the Connector (e.g. Website)
+    
+    /// <summary>
+    /// Returns all Publications with the given string.
+    /// If the string is empty or null, returns all Publication of the Connector
+    /// </summary>
+    /// <param name="publicationTitle">Search-Query</param>
+    /// <returns>Publications matching the query</returns>
     public abstract Publication[] GetPublications(string publicationTitle = "");
+    
+    /// <summary>
+    /// Returns all Chapters of the publication in the provided language.
+    /// If the language is empty or null, returns all Chapters in all Languages.
+    /// </summary>
+    /// <param name="publication">Publication to get Chapters for</param>
+    /// <param name="language">Language of the Chapters</param>
+    /// <returns>Array of Chapters matching Publication and Language</returns>
     public abstract Chapter[] GetChapters(Publication publication, string language = "");
-    public abstract void DownloadChapter(Publication publication, Chapter chapter); //where to?
-    protected abstract void DownloadImage(string url, string savePath);
+    
+    /// <summary>
+    /// Retrieves the Chapter (+Images) from the website.
+    /// Should later call DownloadChapterImages to retrieve the individual Images of the Chapter.
+    /// </summary>
+    /// <param name="publication">Publication that contains Chapter</param>
+    /// <param name="chapter">Chapter with Images to retrieve</param>
+    public abstract void DownloadChapter(Publication publication, Chapter chapter);
+    
+    /// <summary>
+    /// Retrieves the Cover from the Website
+    /// </summary>
+    /// <param name="publication">Publication to retrieve Cover for</param>
     public abstract void DownloadCover(Publication publication);
 
-    protected void DownloadChapter(string[] imageUrls, string saveArchiveFilePath)
+    /// <summary>
+    /// Saves the series-info to series.json in the Publication Folder
+    /// </summary>
+    /// <param name="publication">Publication to save series.json for</param>
+    public void SaveSeriesInfo(Publication publication)
     {
-        string tempFolder = Path.GetTempFileName();
-        File.Delete(tempFolder);
-        Directory.CreateDirectory(tempFolder);
+        //Check if Publication already has a Folder and a series.json
+        string publicationFolder = Path.Join(downloadLocation, publication.folderName);
+        if(!Directory.Exists(publicationFolder))
+            Directory.CreateDirectory(publicationFolder);
+        
+        string seriesInfoPath = Path.Join(publicationFolder, "series.json");
+        if(!File.Exists(seriesInfoPath))
+            File.WriteAllText(seriesInfoPath,publication.GetSeriesInfoJson());
+    }
 
-        int chapter = 0;
-        foreach (string imageUrl in imageUrls)
-        {
-            string[] split = imageUrl.Split('.');
-            string extension = split[split.Length - 1];
-            DownloadImage(imageUrl, Path.Join(tempFolder, $"{chapter++}.{extension}"));
-        }
+    /// <summary>
+    /// Creates a string containing XML of publication and chapter.
+    /// See ComicInfo.xml
+    /// </summary>
+    /// <returns>XML-string</returns>
+    protected static string CreateComicInfo(Publication publication, Chapter chapter)
+    {
+        XElement comicInfo = new XElement("ComicInfo",
+            new XElement("Tags", string.Join(',',publication.tags)),
+            new XElement("LanguageISO", publication.originalLanguage),
+            new XElement("Title", chapter.name),
+            new XElement("Volume", chapter.volumeNumber),
+            new XElement("Number", chapter.chapterNumber) //TODO check if this is correct at some point
+        );
+        return comicInfo.ToString();
+    }
 
+    /// <summary>
+    /// Checks if a chapter-archive is already present
+    /// </summary>
+    /// <returns>true if chapter is present</returns>
+    public bool ChapterIsDownloaded(Publication publication, Chapter chapter)
+    {
+        return File.Exists(CreateFullFilepath(publication, chapter));
+    }
+
+    /// <summary>
+    /// Creates full file path of chapter-archive
+    /// </summary>
+    /// <returns>Filepath</returns>
+    protected string CreateFullFilepath(Publication publication, Chapter chapter)
+    {
+        return Path.Join(downloadLocation, publication.folderName, chapter.fileName);
+    }
+    
+    /// <summary>
+    /// Downloads Image from URL and saves it to the given path(incl. fileName)
+    /// </summary>
+    /// <param name="imageUrl"></param>
+    /// <param name="fullPath"></param>
+    /// <param name="downloadClient">DownloadClient of the connector</param>
+    protected static void DownloadImage(string imageUrl, string fullPath, DownloadClient downloadClient)
+    {
+        DownloadClient.RequestResult requestResult = downloadClient.MakeRequest(imageUrl);
+        byte[] buffer = new byte[requestResult.result.Length];
+        requestResult.result.ReadExactly(buffer, 0, buffer.Length);
+        File.WriteAllBytes(fullPath, buffer);
+    }
+    
+    /// <summary>
+    /// Downloads all Images from URLs, Compresses to zip(cbz) and saves.
+    /// </summary>
+    /// <param name="imageUrls">List of URLs to download Images from</param>
+    /// <param name="saveArchiveFilePath">Full path to save archive to (without file ending .cbz)</param>
+    /// <param name="downloadClient">DownloadClient of the connector</param>
+    /// <param name="comicInfoPath">Path of the generate Chapter ComicInfo.xml, if it was generated</param>
+    protected static void DownloadChapterImages(string[] imageUrls, string saveArchiveFilePath, DownloadClient downloadClient, string? comicInfoPath = null)
+    {
+        //Check if Publication Directory already exists
         string[] splitPath = saveArchiveFilePath.Split(Path.DirectorySeparatorChar);
         string directoryPath = Path.Combine(splitPath.Take(splitPath.Length - 1).ToArray());
         if (!Directory.Exists(directoryPath))
             Directory.CreateDirectory(directoryPath);
-
+        
         string fullPath = $"{saveArchiveFilePath}.cbz";
-        File.Delete(fullPath);
-        ZipFile.CreateFromDirectory(tempFolder, fullPath);
-    }
+        if (File.Exists(fullPath)) //Don't download twice.
+            return;
+        
+        //Create a temporary folder to store images
+        string tempFolder = Directory.CreateTempSubdirectory().FullName;
 
-    internal class DownloadClient
+        int chapter = 0;
+        //Download all Images to temporary Folder
+        foreach (string imageUrl in imageUrls)
+        {
+            string[] split = imageUrl.Split('.');
+            string extension = split[^1];
+            DownloadImage(imageUrl, Path.Join(tempFolder, $"{chapter++}.{extension}"), downloadClient);
+        }
+        
+        if(comicInfoPath is not null)
+            File.Copy(comicInfoPath, Path.Join(tempFolder, "ComicInfo.xml"));
+        
+        //ZIP-it and ship-it
+        ZipFile.CreateFromDirectory(tempFolder, fullPath);
+        Directory.Delete(tempFolder, true); //Cleanup
+    }
+    
+    protected class DownloadClient
     {
         private readonly TimeSpan _requestSpeed;
         private DateTime _lastRequest;
         private static readonly HttpClient Client = new();
 
+        /// <summary>
+        /// Creates a httpClient
+        /// </summary>
+        /// <param name="delay">minimum delay between requests (to avoid spam)</param>
         public DownloadClient(uint delay)
         {
             _requestSpeed = TimeSpan.FromMilliseconds(delay);
             _lastRequest = DateTime.Now.Subtract(_requestSpeed);
         }
         
+        /// <summary>
+        /// Request Webpage
+        /// </summary>
+        /// <param name="url"></param>
+        /// <returns>RequestResult with StatusCode and Stream of received data</returns>
         public RequestResult MakeRequest(string url)
         {
             while((DateTime.Now - _lastRequest) < _requestSpeed)

Tranga/Connectors/MangaDex.cs

@@ -1,4 +1,5 @@
 using System.Globalization;
+using System.Net;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 
@@ -6,29 +7,41 @@ namespace Tranga.Connectors;
 public class MangaDex : Connector
 {
     public override string name { get; }
-    private readonly DownloadClient _downloadClient = new (750);
 
-    public MangaDex(string downloadLocation) : base(downloadLocation)
+    public MangaDex(string downloadLocation, uint downloadDelay) : base(downloadLocation, downloadDelay)
     {
-        name = "MangaDex.org";
+        name = "MangaDex";
+    }
+    
+    public MangaDex(string downloadLocation) : base(downloadLocation, 750)
+    {
+        name = "MangaDex";
     }
 
     public override Publication[] GetPublications(string publicationTitle = "")
     {
-        const int limit = 100;
-        int offset = 0;
-        int total = int.MaxValue;
+        const int limit = 100; //How many values we want returned at once
+        int offset = 0; //"Page"
+        int total = int.MaxValue; //How many total results are there, is updated on first request
         HashSet<Publication> publications = new();
-        while (offset < total)
+        while (offset < total) //As long as we haven't requested all "Pages"
         {
-            DownloadClient.RequestResult requestResult = _downloadClient.MakeRequest($"https://api.mangadex.org/manga?limit={limit}&title={publicationTitle}&offset={offset}");
+            //Request next Page
+            DownloadClient.RequestResult requestResult =
+                downloadClient.MakeRequest(
+                    $"https://api.mangadex.org/manga?limit={limit}&title={publicationTitle}&offset={offset}");
+            if (requestResult.statusCode != HttpStatusCode.OK)
+                break;
             JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
+            
             offset += limit;
             if (result is null)
                 break;
             
-            total = result["total"]!.GetValue<int>();
-            JsonArray mangaInResult = result["data"]!.AsArray();
+            total = result["total"]!.GetValue<int>(); //Update the total number of Publications
+            
+            JsonArray mangaInResult = result["data"]!.AsArray(); //Manga-data-Array
+            //Loop each Manga and extract information from JSON
             foreach (JsonNode? mangeNode in mangaInResult)
             {
                 JsonObject manga = (JsonObject)mangeNode!;
@@ -36,8 +49,8 @@ public class MangaDex : Connector
                 
                 string title = attributes["title"]!.AsObject().ContainsKey("en") && attributes["title"]!["en"] is not null
                     ? attributes["title"]!["en"]!.GetValue<string>()
-                    : "";
-                
+                    : attributes["title"]![((IDictionary<string, JsonNode?>)attributes["title"]!.AsObject()).Keys.First()]!.GetValue<string>();
+
                 string? description = attributes["description"]!.AsObject().ContainsKey("en") && attributes["description"]!["en"] is not null
                     ? attributes["description"]!["en"]!.GetValue<string?>()
                     : null;
@@ -102,10 +115,9 @@ public class MangaDex : Connector
                     year,
                     originalLanguage,
                     status,
-                    this,
                     manga["id"]!.GetValue<string>()
                 );
-                publications.Add(pub);
+                publications.Add(pub); //Add Publication (Manga) to result
             }
         }
 
@@ -114,15 +126,19 @@ public class MangaDex : Connector
 
     public override Chapter[] GetChapters(Publication publication, string language = "")
     {
-        const int limit = 100;
-        int offset = 0;
-        string id = publication.downloadUrl;
-        int total = int.MaxValue;
+        const int limit = 100; //How many values we want returned at once
+        int offset = 0; //"Page"
+        int total = int.MaxValue; //How many total results are there, is updated on first request
         List<Chapter> chapters = new();
+        //As long as we haven't requested all "Pages"
         while (offset < total)
         {
+            //Request next "Page"
             DownloadClient.RequestResult requestResult =
-                _downloadClient.MakeRequest($"https://api.mangadex.org/manga/{id}/feed?limit={limit}&offset={offset}&translatedLanguage%5B%5D={language}");
+                downloadClient.MakeRequest(
+                    $"https://api.mangadex.org/manga/{publication.downloadUrl}/feed?limit={limit}&offset={offset}&translatedLanguage%5B%5D={language}");
+            if (requestResult.statusCode != HttpStatusCode.OK)
+                break;
             JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
             
             offset += limit;
@@ -131,6 +147,7 @@ public class MangaDex : Connector
             
             total = result["total"]!.GetValue<int>();
             JsonArray chaptersInResult = result["data"]!.AsArray();
+            //Loop through all Chapters in result and extract information from JSON
             foreach (JsonNode? jsonNode in chaptersInResult)
             {
                 JsonObject chapter = (JsonObject)jsonNode!;
@@ -149,10 +166,11 @@ public class MangaDex : Connector
                     ? attributes["chapter"]!.GetValue<string>()
                     : null;
                 
-                chapters.Add(new Chapter(publication, title, volume, chapterNum, chapterId));
+                chapters.Add(new Chapter(title, volume, chapterNum, chapterId));
             }
         }
 
+        //Return Chapters ordered by Chapter-Number
         NumberFormatInfo chapterNumberFormatInfo = new()
         {
             NumberDecimalSeparator = "."
@@ -162,8 +180,11 @@ public class MangaDex : Connector
 
     public override void DownloadChapter(Publication publication, Chapter chapter)
     {
+        //Request URLs for Chapter-Images
         DownloadClient.RequestResult requestResult =
-            _downloadClient.MakeRequest($"https://api.mangadex.org/at-home/server/{chapter.url}?forcePort443=false'");
+            downloadClient.MakeRequest($"https://api.mangadex.org/at-home/server/{chapter.url}?forcePort443=false'");
+        if (requestResult.statusCode != HttpStatusCode.OK)
+            return;
         JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
         if (result is null)
             return;
@@ -171,36 +192,50 @@ public class MangaDex : Connector
         string baseUrl = result["baseUrl"]!.GetValue<string>();
         string hash = result["chapter"]!["hash"]!.GetValue<string>();
         JsonArray imageFileNames = result["chapter"]!["data"]!.AsArray();
+        //Loop through all imageNames and construct urls (imageUrl)
         HashSet<string> imageUrls = new();
         foreach (JsonNode? image in imageFileNames)
             imageUrls.Add($"{baseUrl}/data/{hash}/{image!.GetValue<string>()}");
 
-        DownloadChapter(imageUrls.ToArray(), Path.Join(downloadLocation, publication.folderName, chapter.fileName));
-    }
-
-    protected override void DownloadImage(string url, string savePath)
-    {
-        DownloadClient.RequestResult requestResult = _downloadClient.MakeRequest(url);
-        byte[] buffer = new byte[requestResult.result.Length];
-        requestResult.result.ReadExactly(buffer, 0, buffer.Length);
-        File.WriteAllBytes(savePath, buffer);
+        string comicInfoPath = Path.GetTempFileName();
+        File.WriteAllText(comicInfoPath, CreateComicInfo(publication, chapter));
+        
+        //Download Chapter-Images
+        DownloadChapterImages(imageUrls.ToArray(), CreateFullFilepath(publication, chapter), downloadClient, comicInfoPath);
     }
 
     public override void DownloadCover(Publication publication)
     {
-        DownloadClient.RequestResult requestResult = _downloadClient.MakeRequest($"https://api.mangadex.org/cover/{publication.posterUrl}");
+        //Check if Publication already has a Folder and cover
+        string publicationFolder = Path.Join(downloadLocation, publication.folderName);
+        if(!Directory.Exists(publicationFolder))
+            Directory.CreateDirectory(publicationFolder);
+        DirectoryInfo dirInfo = new (publicationFolder);
+        foreach(FileInfo fileInfo in dirInfo.EnumerateFiles())
+            if (fileInfo.Name.Contains("cover."))
+                return;
+
+        //Request information where to download Cover
+        DownloadClient.RequestResult requestResult =
+            downloadClient.MakeRequest($"https://api.mangadex.org/cover/{publication.posterUrl}");
+        if (requestResult.statusCode != HttpStatusCode.OK)
+            return;
         JsonObject? result = JsonSerializer.Deserialize<JsonObject>(requestResult.result);
         if (result is null)
             return;
 
-        string fileName = result!["data"]!["attributes"]!["fileName"]!.GetValue<string>();
+        string fileName = result["data"]!["attributes"]!["fileName"]!.GetValue<string>();
 
         string coverUrl = $"https://uploads.mangadex.org/covers/{publication.downloadUrl}/{fileName}";
+        
+        //Get file-extension (jpg, png)
         string[] split = coverUrl.Split('.');
-        string extension = split[split.Length - 1];
+        string extension = split[^1];
 
         string outFolderPath = Path.Join(downloadLocation, publication.folderName);
         Directory.CreateDirectory(outFolderPath);
-        DownloadImage(coverUrl, Path.Join(downloadLocation, publication.folderName, $"cover.{extension}"));
+        
+        //Download cover-Image
+        DownloadImage(coverUrl, Path.Join(downloadLocation, publication.folderName, $"cover.{extension}"), this.downloadClient);
     }
 }

Tranga/Komga.cs

@@ -0,0 +1,118 @@
+using System.Net.Http.Headers;
+using System.Text.Json.Nodes;
+using Newtonsoft.Json;
+using JsonSerializer = System.Text.Json.JsonSerializer;
+
+namespace Tranga;
+
+/// <summary>
+/// Provides connectivity to Komga-API
+/// Can fetch and update libraries
+/// </summary>
+public class Komga
+{
+    public string baseUrl { get; }
+    public string auth { get; } //Base64 encoded, if you use your password everywhere, you have problems
+    
+    /// <param name="baseUrl">Base-URL of Komga instance, no trailing slashes(/)</param>
+    /// <param name="username">Komga Username</param>
+    /// <param name="password">Komga password, will be base64 encoded. yea</param>
+    public Komga(string baseUrl, string username, string password)
+    {
+        this.baseUrl = baseUrl;
+        this.auth = Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes($"{username}:{password}"));
+    }
+    
+    /// <param name="baseUrl">Base-URL of Komga instance, no trailing slashes(/)</param>
+    /// <param name="auth">Base64 string of username and password (username):(password)</param>
+    [JsonConstructor]
+    public Komga(string baseUrl, string auth)
+    {
+        this.baseUrl = baseUrl;
+        this.auth = auth;
+    }
+
+    /// <summary>
+    /// Fetches all libraries available to the user
+    /// </summary>
+    /// <returns>Array of KomgaLibraries</returns>
+    public KomgaLibrary[] GetLibraries()
+    {
+        Stream data = NetClient.MakeRequest($"{baseUrl}/api/v1/libraries", auth);
+        JsonArray? result = JsonSerializer.Deserialize<JsonArray>(data);
+        if (result is null)
+            return Array.Empty<KomgaLibrary>();
+
+        HashSet<KomgaLibrary> ret = new();
+
+        foreach (JsonNode jsonNode in result)
+        {
+            var jObject = (JsonObject?)jsonNode;
+            string libraryId = jObject!["id"]!.GetValue<string>();
+            string libraryName = jObject!["name"]!.GetValue<string>();
+            ret.Add(new KomgaLibrary(libraryId, libraryName));
+        }
+
+        return ret.ToArray();
+    }
+
+    /// <summary>
+    /// Updates library with given id
+    /// </summary>
+    /// <param name="libraryId">Id of the Komga-Library</param>
+    /// <returns>true if successful</returns>
+    public bool UpdateLibrary(string libraryId)
+    {
+        return NetClient.MakePost($"{baseUrl}/api/v1/libraries/{libraryId}/scan", auth);
+    }
+
+    public struct KomgaLibrary
+    {
+        public string id { get; }
+        public string name { get; }
+
+        public KomgaLibrary(string id, string name)
+        {
+            this.id = id;
+            this.name = name;
+        }
+    }
+
+    private static class NetClient
+    {
+        public static Stream MakeRequest(string url, string auth)
+        {
+            HttpClient client = new();
+            HttpRequestMessage requestMessage = new HttpRequestMessage
+            {
+                Method = HttpMethod.Get,
+                RequestUri = new Uri(url),
+                Headers =
+                {
+                    { "Accept", "application/json" },
+                    { "Authorization", new AuthenticationHeaderValue("Basic", auth).ToString() }
+                }
+            };
+            HttpResponseMessage response = client.Send(requestMessage);
+            Stream resultString = response.IsSuccessStatusCode ? response.Content.ReadAsStream() : Stream.Null;
+            return resultString;
+        }
+
+        public static bool MakePost(string url, string auth)
+        {
+            HttpClient client = new();
+            HttpRequestMessage requestMessage = new HttpRequestMessage
+            {
+                Method = HttpMethod.Post,
+                RequestUri = new Uri(url),
+                Headers =
+                {
+                    { "Accept", "application/json" },
+                    { "Authorization", new AuthenticationHeaderValue("Basic", auth).ToString() }
+                }
+            };
+            HttpResponseMessage response = client.Send(requestMessage);
+            return response.IsSuccessStatusCode;
+        }
+    }
+}

Tranga/Publication.cs

@@ -1,24 +1,27 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
+using Newtonsoft.Json;
 
 namespace Tranga;
 
-public struct Publication
+/// <summary>
+/// Contains information on a Publication (Manga)
+/// </summary>
+public readonly struct Publication
 {
     public string sortName { get; }
-    public string[,] altTitles { get;  }
+    // ReSharper disable UnusedAutoPropertyAccessor.Global we need it, trust
+    [JsonIgnore]public string[,] altTitles { get; }
+    // ReSharper disable trice MemberCanBePrivate.Global, trust
     public string? description { get; }
     public string[] tags { get; }
     public string? posterUrl { get; }
-    public string[,]? links { get; }
+    [JsonIgnore]public string[,]? links { get; }
     public int? year { get; }
     public string? originalLanguage { get; }
     public string status { get; }
     public string folderName { get; }
-    public Connector connector { get; }
     public string downloadUrl { get; }
 
-    public Publication(string sortName, string? description, string[,] altTitles, string[] tags, string? posterUrl, string[,]? links, int? year, string? originalLanguage, string status, Connector connector, string downloadUrl)
+    public Publication(string sortName, string? description, string[,] altTitles, string[] tags, string? posterUrl, string[,]? links, int? year, string? originalLanguage, string status, string downloadUrl)
     {
         this.sortName = sortName;
         this.description = description;
@@ -29,37 +32,63 @@ public struct Publication
         this.year = year;
         this.originalLanguage = originalLanguage;
         this.status = status;
-        this.connector = connector;
         this.downloadUrl = downloadUrl;
-        this.folderName = string.Concat(sortName.Split(Path.GetInvalidPathChars()));
-    }
-
-    public string GetSeriesInfo()
-    {
-        SeriesInfo si = new (new Metadata(this.sortName, this.year.ToString() ?? string.Empty, this.status, this.description ?? ""));
-        return JsonSerializer.Serialize(si, JsonSerializerOptions.Default);
+        this.folderName = string.Concat(sortName.Split(Path.GetInvalidPathChars().Concat(Path.GetInvalidFileNameChars()).ToArray()));
     }
     
-    internal struct SeriesInfo
+    /// <returns>Serialized JSON String for series.json</returns>
+    public string GetSeriesInfoJson()
     {
+        SeriesInfo si = new (new Metadata(this.sortName, this.year.ToString() ?? string.Empty, this.status, this.description ?? ""));
+        return System.Text.Json.JsonSerializer.Serialize(si);
+    }
+
+    //Only for series.json
+    private struct SeriesInfo
+    {
+        // ReSharper disable once UnusedAutoPropertyAccessor.Local we need it, trust
         [JsonRequired]public Metadata metadata { get; }
         public SeriesInfo(Metadata metadata) => this.metadata = metadata;
     }
-        
-    internal struct Metadata
+
+    //Only for series.json what an abomination, why are all the fields not-null????
+    private struct Metadata
     {
+        // ReSharper disable UnusedAutoPropertyAccessor.Local we need them all, trust me
+        [JsonRequired] public string type { get; }
+        [JsonRequired] public string publisher { get; }
+        // ReSharper disable twice IdentifierTypo
+        [JsonRequired] public int comicid  { get; }
+        [JsonRequired] public string booktype { get; }
+        // ReSharper disable InconsistentNaming This one property is capitalized. Why?
+        [JsonRequired] public string ComicImage { get; }
+        [JsonRequired] public int total_issues { get; }
+        [JsonRequired] public string publication_run { get; }
         [JsonRequired]public string name { get; }
         [JsonRequired]public string year { get; }
         [JsonRequired]public string status { get; }
-        // ReSharper disable twice InconsistentNaming
         [JsonRequired]public string description_text { get; }
 
         public Metadata(string name, string year, string status, string description_text)
         {
             this.name = name;
             this.year = year;
-            this.status = status;
+            if(status == "ongoing" || status == "hiatus")
+                this.status = "Continuing";
+            else if (status == "completed" || status == "cancelled")
+                this.status = "Ended";
+            else
+                this.status = status;
             this.description_text = description_text;
+            
+            //kill it with fire, but otherwise Komga will not parse
+            type = "Manga";
+            publisher = "";
+            comicid = 0;
+            booktype = "";
+            ComicImage = "";
+            total_issues = 0;
+            publication_run = "";
         }
     }
 }

Tranga/TaskExecutor.cs

@@ -0,0 +1,121 @@
+namespace Tranga;
+
+/// <summary>
+/// Executes TrangaTasks
+/// Based on the TrangaTask.Task a method is called.
+/// The chapterCollection is updated with new Publications/Chapters.
+/// </summary>
+public static class TaskExecutor
+{
+    /// <summary>
+    /// Executes TrangaTask.
+    /// </summary>
+    /// <param name="taskManager">Parent</param>
+    /// <param name="trangaTask">Task to execute</param>
+    /// <param name="chapterCollection">Current chapterCollection to update</param>
+    /// <exception cref="ArgumentException">Is thrown when there is no Connector available with the name of the TrangaTask.connectorName</exception>
+    public static void Execute(TaskManager taskManager, TrangaTask trangaTask, Dictionary<Publication, List<Chapter>> chapterCollection)
+    {
+        //Only execute task if it is not already being executed.
+        if (trangaTask.state == TrangaTask.ExecutionState.Running)
+            return;
+        trangaTask.state = TrangaTask.ExecutionState.Running;
+        
+        //Connector is not needed for all tasks
+        Connector? connector = null;
+        if (trangaTask.task != TrangaTask.Task.UpdateKomgaLibrary)
+            connector = taskManager.GetConnector(trangaTask.connectorName!);
+
+        //Call appropriate Method based on TrangaTask.Task
+        switch (trangaTask.task)
+        {
+            case TrangaTask.Task.DownloadNewChapters:
+                DownloadNewChapters(connector!, (Publication)trangaTask.publication!, trangaTask.language, chapterCollection);
+                break;
+            case TrangaTask.Task.UpdateChapters:
+                UpdateChapters(connector!, (Publication)trangaTask.publication!, trangaTask.language, chapterCollection);
+                break;
+            case TrangaTask.Task.UpdatePublications:
+                UpdatePublications(connector!, chapterCollection);
+                break;
+            case TrangaTask.Task.UpdateKomgaLibrary:
+                UpdateKomgaLibrary(taskManager);
+                break;
+        }
+
+        trangaTask.state = TrangaTask.ExecutionState.Waiting;
+        trangaTask.lastExecuted = DateTime.Now;
+    }
+
+    /// <summary>
+    /// Updates all Komga-Libraries
+    /// </summary>
+    /// <param name="taskManager">Parent</param>
+    private static void UpdateKomgaLibrary(TaskManager taskManager)
+    {
+        if (taskManager.komga is null)
+            return;
+        Komga komga = taskManager.komga;
+
+        Komga.KomgaLibrary[] allLibraries = komga.GetLibraries();
+        foreach (Komga.KomgaLibrary lib in allLibraries)
+            komga.UpdateLibrary(lib.id);
+    }
+
+    /// <summary>
+    /// Updates the available Publications from a Connector (all of them)
+    /// </summary>
+    /// <param name="connector">Connector to receive Publications from</param>
+    /// <param name="chapterCollection"></param>
+    private static void UpdatePublications(Connector connector, Dictionary<Publication, List<Chapter>> chapterCollection)
+    {
+        Publication[] publications = connector.GetPublications();
+        foreach (Publication publication in publications)
+            chapterCollection.TryAdd(publication, new List<Chapter>());
+    }
+
+    /// <summary>
+    /// Checks for new Chapters and Downloads new ones.
+    /// If no Chapters had been downloaded previously, download also cover and create series.json
+    /// </summary>
+    /// <param name="connector">Connector to use</param>
+    /// <param name="publication">Publication to check</param>
+    /// <param name="language">Language to receive chapters for</param>
+    /// <param name="chapterCollection"></param>
+    private static void DownloadNewChapters(Connector connector, Publication publication, string language, Dictionary<Publication, List<Chapter>> chapterCollection)
+    {
+        List<Chapter> newChapters = UpdateChapters(connector, publication, language, chapterCollection);
+        connector.DownloadCover(publication);
+        
+        //Check if Publication already has a Folder and a series.json
+        string publicationFolder = Path.Join(connector.downloadLocation, publication.folderName);
+        if(!Directory.Exists(publicationFolder))
+            Directory.CreateDirectory(publicationFolder);
+        
+        string seriesInfoPath = Path.Join(publicationFolder, "series.json");
+        if(!File.Exists(seriesInfoPath))
+            File.WriteAllText(seriesInfoPath,publication.GetSeriesInfoJson());
+
+        foreach(Chapter newChapter in newChapters)
+            connector.DownloadChapter(publication, newChapter);
+    }
+
+    /// <summary>
+    /// Updates the available Chapters of a Publication
+    /// </summary>
+    /// <param name="connector">Connector to use</param>
+    /// <param name="publication">Publication to check</param>
+    /// <param name="language">Language to receive chapters for</param>
+    /// <param name="chapterCollection"></param>
+    /// <returns>List of Chapters that were previously not in collection</returns>
+    private static List<Chapter> UpdateChapters(Connector connector, Publication publication, string language, Dictionary<Publication, List<Chapter>> chapterCollection)
+    {
+        List<Chapter> newChaptersList = new();
+        chapterCollection.TryAdd(publication, newChaptersList); //To ensure publication is actually in collection
+        
+        Chapter[] newChapters = connector.GetChapters(publication, language);
+        newChaptersList = newChapters.Where(nChapter => !connector.ChapterIsDownloaded(publication, nChapter)).ToList();
+        
+        return newChaptersList;
+    }
+}

Tranga/TaskManager.cs

@@ -1,54 +1,257 @@
-namespace Tranga;
+using Newtonsoft.Json;
+using Tranga.Connectors;
 
+namespace Tranga;
+
+/// <summary>
+/// Manages all TrangaTasks.
+/// Provides a Threaded environment to execute Tasks, and still manage the Task-Collection
+/// </summary>
 public class TaskManager
 {
-    private readonly Dictionary<Publication, Chapter[]> _chapterCollection;
+    private readonly Dictionary<Publication, List<Chapter>> _chapterCollection = new();
     private readonly HashSet<TrangaTask> _allTasks;
     private bool _continueRunning = true;
+    private readonly Connector[] _connectors;
+    private Dictionary<Connector, List<TrangaTask>> tasksToExecute = new();
+    private string downloadLocation { get; }
     
-    public TaskManager()
+    public Komga? komga { get; private set; }
+
+    /// <param name="folderPath">Local path to save data (Manga) to</param>
+    /// <param name="komgaBaseUrl">The Url of the Komga-instance that you want to update</param>
+    /// <param name="komgaUsername">The Komga username</param>
+    /// <param name="komgaPassword">The Komga password</param>
+    public TaskManager(string folderPath, string? komgaBaseUrl = null, string? komgaUsername = null, string? komgaPassword = null)
     {
-        _chapterCollection = new();
-        _allTasks = new ();
+        this.downloadLocation = folderPath;
+
+        if (komgaBaseUrl != null && komgaUsername != null && komgaPassword != null)
+            this.komga = new Komga(komgaBaseUrl, komgaUsername, komgaPassword);
+        this._connectors = new Connector[]{ new MangaDex(folderPath) };
+        foreach(Connector cConnector in this._connectors)
+            tasksToExecute.Add(cConnector, new List<TrangaTask>());
+        _allTasks = new HashSet<TrangaTask>();
+        
         Thread taskChecker = new(TaskCheckerThread);
         taskChecker.Start();
     }
 
+    public TaskManager(SettingsData settings)
+    {
+        this._connectors = new Connector[]{ new MangaDex(settings.downloadLocation) };
+        foreach(Connector cConnector in this._connectors)
+            tasksToExecute.Add(cConnector, new List<TrangaTask>());
+        this.downloadLocation = settings.downloadLocation;
+        this.komga = settings.komga;
+        _allTasks = settings.allTasks;
+        Thread taskChecker = new(TaskCheckerThread);
+        taskChecker.Start();
+    }
+
+    /// <summary>
+    /// Runs continuously until shutdown.
+    /// Checks if tasks have to be executed (time elapsed)
+    /// </summary>
     private void TaskCheckerThread()
     {
         while (_continueRunning)
         {
-            foreach (TrangaTask task in _allTasks.Where(trangaTask => (DateTime.Now - trangaTask.lastExecuted) > trangaTask.reoccurrence))
+            //Check if previous tasks have finished and execute new tasks
+            foreach (KeyValuePair<Connector, List<TrangaTask>> connectorTaskQueue in tasksToExecute)
             {
-                if (!task.lastExecutedSuccessfully)
+                connectorTaskQueue.Value.RemoveAll(task => task.state == TrangaTask.ExecutionState.Waiting);
+                if (connectorTaskQueue.Value.Count > 0 && !connectorTaskQueue.Value.All(task => task.state is TrangaTask.ExecutionState.Running or TrangaTask.ExecutionState.Waiting))
+                    ExecuteTaskNow(connectorTaskQueue.Value.First());
+            }
+            
+            //Check if task should be executed
+            //Depending on type execute immediately or enqueue
+            foreach (TrangaTask task in _allTasks.Where(aTask => aTask.ShouldExecute()))
+            {
+                task.state = TrangaTask.ExecutionState.Enqueued;
+                if(task.connectorName is null)
+                    ExecuteTaskNow(task);
+                else
                 {
-                    task.Abort();
-                    //Add logging that task has failed
+                    tasksToExecute[GetConnector(task.connectorName!)].Add(task);
                 }
-                task.Execute();
             }
             Thread.Sleep(1000);
         }
     }
 
-    public bool PublicationAlreadyAdded(Publication publication)
+    /// <summary>
+    /// Forces the execution of a given task
+    /// </summary>
+    /// <param name="task">Task to execute</param>
+    public void ExecuteTaskNow(TrangaTask task)
     {
-        throw new NotImplementedException();
-        //TODO fuzzy check publications
+        if (!this._allTasks.Contains(task))
+            return;
+        
+        Task t = new Task(() =>
+        {
+            TaskExecutor.Execute(this, task, this._chapterCollection);
+        });
+        t.Start();
     }
 
-    public Publication[] GetAddedPublications()
+    /// <summary>
+    /// Creates and adds a new Task to the task-Collection
+    /// </summary>
+    /// <param name="task">TrangaTask.Task to later execute</param>
+    /// <param name="connectorName">Name of the connector to use</param>
+    /// <param name="publication">Publication to execute Task on, can be null in case of unrelated Task</param>
+    /// <param name="reoccurrence">Time-Interval between Executions</param>
+    /// <param name="language">language, should Task require parameter. Can be empty</param>
+    /// <exception cref="ArgumentException">Is thrown when connectorName is not a available Connector</exception>
+    public TrangaTask AddTask(TrangaTask.Task task, string? connectorName, Publication? publication, TimeSpan reoccurrence,
+        string language = "")
     {
-        throw new NotImplementedException();
+        if (task != TrangaTask.Task.UpdateKomgaLibrary && connectorName is null)
+            throw new ArgumentException($"connectorName can not be null for task {task}");
+
+        TrangaTask newTask;
+        if (task == TrangaTask.Task.UpdateKomgaLibrary)
+        {
+            newTask = new TrangaTask(task, null, null, reoccurrence, language);
+            
+            //Check if same task already exists
+            // ReSharper disable once SimplifyLinqExpressionUseAll readabilty
+            if (!_allTasks.Any(trangaTask => trangaTask.task == task))
+            {
+                _allTasks.Add(newTask);
+            }
+        }
+        else
+        {
+            //Get appropriate Connector from available Connectors for TrangaTask
+            Connector? connector = _connectors.FirstOrDefault(c => c.name == connectorName);
+            if (connector is null)
+                throw new ArgumentException($"Connector {connectorName} is not a known connector.");
+        
+            newTask = new TrangaTask(task, connector.name, publication, reoccurrence, language);
+            
+            //Check if same task already exists
+            if (!_allTasks.Any(trangaTask => trangaTask.task == task && trangaTask.connectorName == connector.name &&
+                                             trangaTask.publication?.downloadUrl == publication?.downloadUrl))
+            {
+                if(task != TrangaTask.Task.UpdatePublications)
+                    _chapterCollection.Add((Publication)publication!, new List<Chapter>());
+                _allTasks.Add(newTask);
+            }
+        }
+        ExportData(Directory.GetCurrentDirectory());
+        
+        return newTask;
     }
 
-    public TrangaTask[] GetTasks()
+    /// <summary>
+    /// Removes Task from task-collection
+    /// </summary>
+    /// <param name="task">TrangaTask.Task type</param>
+    /// <param name="connectorName">Name of Connector that was used</param>
+    /// <param name="publication">Publication that was used</param>
+    public void RemoveTask(TrangaTask.Task task, string connectorName, Publication? publication)
     {
-        return _allTasks.ToArray();
+        _allTasks.RemoveWhere(trangaTask =>
+            trangaTask.task == task && trangaTask.connectorName == connectorName &&
+            trangaTask.publication?.downloadUrl == publication?.downloadUrl);
+        ExportData(Directory.GetCurrentDirectory());
+    }
+    
+    /// <returns>All available Connectors</returns>
+    public Dictionary<string, Connector> GetAvailableConnectors()
+    {
+        return this._connectors.ToDictionary(connector => connector.name, connector => connector);
+    }
+    
+    /// <returns>All TrangaTasks in task-collection</returns>
+    public TrangaTask[] GetAllTasks()
+    {
+        TrangaTask[] ret = new TrangaTask[_allTasks.Count];
+        _allTasks.CopyTo(ret);
+        return ret;
+    }
+    
+    /// <returns>All added Publications</returns>
+    public Publication[] GetAllPublications()
+    {
+        return this._chapterCollection.Keys.ToArray();
     }
 
-    public void Shutdown()
+    /// <summary>
+    /// Return Connector with given Name
+    /// </summary>
+    /// <param name="connectorName">Connector-name (exact)</param>
+    /// <exception cref="Exception">If Connector is not available</exception>
+    public Connector GetConnector(string connectorName)
+    {
+        Connector? ret = this._connectors.FirstOrDefault(connector => connector.name == connectorName);
+        if (ret is null)
+            throw new Exception($"Connector {connectorName} is not an available Connector.");
+        return (Connector)ret!;
+    }
+    
+    /// <summary>
+    /// Shuts down the taskManager.
+    /// </summary>
+    /// <param name="force">If force is true, tasks are aborted.</param>
+    public void Shutdown(bool force = false)
     {
         _continueRunning = false;
+        ExportData(Directory.GetCurrentDirectory());
+        
+        if(force)
+            Environment.Exit(_allTasks.Count(task => task.state is TrangaTask.ExecutionState.Enqueued or TrangaTask.ExecutionState.Running));
+        
+        //Wait for tasks to finish
+        while(_allTasks.Any(task => task.state is TrangaTask.ExecutionState.Running or TrangaTask.ExecutionState.Enqueued))
+            Thread.Sleep(10);
+        Environment.Exit(0);
+    }
+
+    /// <summary>
+    /// Loads stored data (settings, tasks) from file
+    /// </summary>
+    /// <param name="importFolderPath">working directory, filename has to be data.json</param>
+    public static SettingsData LoadData(string importFolderPath)
+    {
+        string importPath = Path.Join(importFolderPath, "data.json");
+        if (!File.Exists(importPath))
+            return new SettingsData("", null, new HashSet<TrangaTask>());
+
+        string toRead = File.ReadAllText(importPath);
+        SettingsData data = JsonConvert.DeserializeObject<SettingsData>(toRead)!;
+
+        return data;
+    }
+
+    /// <summary>
+    /// Exports data (settings, tasks) to file
+    /// </summary>
+    /// <param name="exportFolderPath">Folder path, filename will be data.json</param>
+    private void ExportData(string exportFolderPath)
+    {
+        SettingsData data = new SettingsData(this.downloadLocation, this.komga, this._allTasks);
+
+        string exportPath = Path.Join(exportFolderPath, "data.json");
+        string serializedData = JsonConvert.SerializeObject(data);
+        File.WriteAllText(exportPath, serializedData);
+    }
+
+    public class SettingsData
+    {
+        public string downloadLocation { get; set; }
+        public Komga? komga { get; set; }
+        public HashSet<TrangaTask> allTasks { get; }
+
+        public SettingsData(string downloadLocation, Komga? komga, HashSet<TrangaTask> allTasks)
+        {
+            this.downloadLocation = downloadLocation;
+            this.komga = komga;
+            this.allTasks = allTasks;
+        }
     }
 }

Tranga/Tranga.csproj

@@ -6,4 +6,8 @@
         <Nullable>enable</Nullable>
     </PropertyGroup>
 
+    <ItemGroup>
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    </ItemGroup>
+
 </Project>

Tranga/TrangaTask.cs

@@ -1,64 +1,61 @@
-namespace Tranga;
+using Newtonsoft.Json;
 
+namespace Tranga;
+
+/// <summary>
+/// Stores information on Task
+/// </summary>
 public class TrangaTask
 {
-    private readonly Action _taskAction;
-    private Task? _task;
-    public bool lastExecutedSuccessfully => _task is not null && _task.IsCompleted;
+    // ReSharper disable once CommentTypo ...Tell me why!
+    // ReSharper disable once MemberCanBePrivate.Global I want it thaaat way
     public TimeSpan reoccurrence { get; }
-    public DateTime lastExecuted { get; private set; }
+    public DateTime lastExecuted { get; set; }
+    public string? connectorName { get; }
+    public Task task { get; }
+    public Publication? publication { get; }
+    public string language { get; }
+    [JsonIgnore]public ExecutionState state { get; set; }
 
-    public TrangaTask(Action taskAction, TimeSpan reoccurrence)
+    public enum ExecutionState
     {
-        this._taskAction = taskAction;
+        Waiting,
+        Enqueued,
+        Running
+    };
+
+    public TrangaTask(Task task, string? connectorName, Publication? publication, TimeSpan reoccurrence, string language = "")
+    {
+        if(task != Task.UpdateKomgaLibrary && connectorName is null)
+            throw new ArgumentException($"connectorName can not be null for task {task}");
+        
+        if (publication is null && task != Task.UpdatePublications && task != Task.UpdateKomgaLibrary)
+            throw new ArgumentException($"Publication can not be null for task {task}");
+        
+        this.publication = publication;
         this.reoccurrence = reoccurrence;
+        this.lastExecuted = DateTime.Now.Subtract(reoccurrence);
+        this.connectorName = connectorName;
+        this.task = task;
+        this.language = language;
     }
 
-    public void Abort()
+    /// <returns>True if elapsed time since last execution is greater than set interval</returns>
+    public bool ShouldExecute()
     {
-        if(_task is not null && !_task.IsCompleted)
-            _task.Dispose();
+        return DateTime.Now.Subtract(this.lastExecuted) > reoccurrence && state is ExecutionState.Waiting;
     }
 
-    public void Execute()
+    public enum Task
     {
-        lastExecuted = DateTime.Now;
-        _task = new (_taskAction);
-        _task.Start();
+        UpdatePublications,
+        UpdateChapters,
+        DownloadNewChapters,
+        UpdateKomgaLibrary
     }
 
-    public static TrangaTask CreateDownloadChapterTask(Connector connector, Publication publication, Chapter chapter, TimeSpan reoccurrence)
+    public override string ToString()
     {
-        void TaskAction()
-        {
-            connector.DownloadChapter(publication, chapter);
-        }
-        return new TrangaTask(TaskAction, reoccurrence);
-    }
-    
-    public static TrangaTask CreateUpdateChaptersTask(ref Dictionary<Publication, Chapter[]> chapterCollection, Connector connector, Publication publication, string language, TimeSpan reoccurrence)
-    {
-        Dictionary<Publication, Chapter[]> pChapterCollection = chapterCollection;
-
-        void TaskAction()
-        {
-            Chapter[] chapters = connector.GetChapters(publication, language);
-            if(pChapterCollection.TryAdd(publication, chapters))
-                pChapterCollection[publication] = chapters;
-        }
-        return new TrangaTask(TaskAction, reoccurrence);
-    }
-
-    public static TrangaTask CreateUpdatePublicationsTask(ref Dictionary<Publication, Chapter[]> chapterCollection, Connector connector, TimeSpan reoccurrence)
-    {
-        Dictionary<Publication, Chapter[]> pChapterCollection = chapterCollection;
-
-        void TaskAction()
-        {
-            Publication[] publications = connector.GetPublications();
-            foreach (Publication publication in publications)
-                pChapterCollection.TryAdd(publication, Array.Empty<Chapter>());
-        }
-        return new TrangaTask(TaskAction, reoccurrence);
+        return $"{task}\t{lastExecuted}\t{reoccurrence}\t{state}\t{connectorName}\t{publication?.sortName}";
     }
 }