Actions initial commit

2025-10-17 10:50:45 +02:00 · 2025-10-16 02:52:04 +02:00
parent 13fb917c5d
commit 53276e858b
36 changed files with 1013 additions and 169 deletions
--- a/API/Workers/BaseWorkerWithContext.cs
+++ b/API/Workers/BaseWorkerWithContext.cs
@@ -1,24 +0,0 @@
-using System.Configuration;
-using Microsoft.EntityFrameworkCore;
-
-namespace API.Workers;
-
-public abstract class BaseWorkerWithContext<T>(IEnumerable<BaseWorker>? dependsOn = null) : BaseWorker(dependsOn) where T : DbContext
-{
-    protected T DbContext = null!;
-    private IServiceScope? _scope;
-
-    public void SetScope(IServiceScope scope)
-    {
-        this._scope = scope;
-        this.DbContext = scope.ServiceProvider.GetRequiredService<T>();
-    }
-    
-    /// <exception cref="ConfigurationErrorsException">Scope has not been set. <see cref="SetScope"/></exception>
-    public new Task<BaseWorker[]> DoWork()
-    {
-        if (DbContext is null)
-            throw new ConfigurationErrorsException("Scope has not been set.");
-        return base.DoWork();
-    }
-}
--- a/API/Workers/BaseWorkerWithContexts.cs
+++ b/API/Workers/BaseWorkerWithContexts.cs
@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Workers;
+
+public abstract class BaseWorkerWithContexts(IEnumerable<BaseWorker>? dependsOn = null) : BaseWorker(dependsOn)
+{
+    /// <summary>
+    /// Returns the context of requested type <typeparamref name="T"/>
+    /// </summary>
+    /// <param name="scope"></param>
+    /// <typeparam name="T">Type of <see cref="DbContext"/></typeparam>
+    /// <returns>Context in scope</returns>
+    /// <exception cref="Exception">Scope not set</exception>
+    protected T GetContext<T>(IServiceScope scope) where T : DbContext
+    {
+        if (scope is not { } serviceScope)
+            throw new Exception("Scope not set!");
+        return serviceScope.ServiceProvider.GetRequiredService<T>();
+    }
+
+    protected abstract void SetContexts(IServiceScope serviceScope);
+    
+    public new Task<BaseWorker[]> DoWork(IServiceScope serviceScope, Action? callback = null)
+    {
+        SetContexts(serviceScope);
+        return base.DoWork(callback);
+    }
+}
--- a/API/Workers/MangaDownloadWorkers/DownloadChapterFromMangaconnectorWorker.cs
+++ b/API/Workers/MangaDownloadWorkers/DownloadChapterFromMangaconnectorWorker.cs
@@ -1,8 +1,10 @@
+using System.Diagnostics.CodeAnalysis;
 using System.IO.Compression;
 using System.Runtime.InteropServices;
 using System.Text;
 using API.MangaConnectors;
-using API.MangaDownloadClients;
+using API.Schema.ActionsContext;
+using API.Schema.ActionsContext.Actions;
 using API.Schema.MangaContext;
 using API.Workers.PeriodicWorkers;
 using Microsoft.EntityFrameworkCore;
@@ -21,14 +23,26 @@ namespace API.Workers.MangaDownloadWorkers;
 /// <param name="chId"></param>
 /// <param name="dependsOn"></param>
 public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> chId, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<MangaContext>(dependsOn)
+    : BaseWorkerWithContexts(dependsOn)
 {
    private readonly string _mangaConnectorIdId = chId.Key;
+
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private MangaContext MangaContext = null!;
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private ActionsContext ActionsContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        MangaContext = GetContext<MangaContext>(serviceScope);
+        ActionsContext = GetContext<ActionsContext>(serviceScope);
+    }
+    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
        Log.Debug($"Downloading chapter for MangaConnectorId {_mangaConnectorIdId}...");
        // Getting MangaConnector info
-        if (await DbContext.MangaConnectorToChapter
+        if (await MangaContext.MangaConnectorToChapter
                .Include(id => id.Obj)
                .ThenInclude(c => c.ParentManga)
                .ThenInclude(m => m.Library)
@@ -39,7 +53,7 @@ public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> c
        }
        
        // Check if Chapter already exists...
-        if (await mangaConnectorId.Obj.CheckDownloaded(DbContext, CancellationToken))
+        if (await mangaConnectorId.Obj.CheckDownloaded(MangaContext, CancellationToken))
        {
            Log.Warn("Chapter already exists!");
            return [];
@@ -66,7 +80,7 @@ public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> c
        {
            Log.Info($"No imageUrls for chapter {chapter}");
            mangaConnectorId.UseForDownload = false; // Do not try to download from this again
-            if(await DbContext.Sync(CancellationToken, GetType(), "Disable Id") is { success: false } result)
+            if(await MangaContext.Sync(CancellationToken, GetType(), "Disable Id") is { success: false } result)
                Log.Error(result.exceptionMessage);
            return [];
        }
@@ -121,7 +135,7 @@ public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> c
        await CopyCoverFromCacheToDownloadLocation(chapter.ParentManga);
        
        Log.Debug($"Loading collections {chapter}");
-        foreach (CollectionEntry collectionEntry in DbContext.Entry(chapter.ParentManga).Collections)
+        foreach (CollectionEntry collectionEntry in MangaContext.Entry(chapter.ParentManga).Collections)
            await collectionEntry.LoadAsync(CancellationToken);

        if (File.Exists(saveArchiveFilePath))
@@ -173,11 +187,15 @@ public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> c

        chapter.Downloaded = true;
        chapter.FileName = new FileInfo(saveArchiveFilePath).Name;
-        if(await DbContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } e)
-            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
+        if(await MangaContext.Sync(CancellationToken, GetType(), "Downloading complete") is { success: false } chapterContextException)
+            Log.Error($"Failed to save database changes: {chapterContextException.exceptionMessage}");
        
        Log.Debug($"Downloaded chapter {chapter}.");

+        ActionsContext.Actions.Add(new ChapterDownloadedActionRecord(chapter));
+        if(await ActionsContext.Sync(CancellationToken, GetType(), "Download complete") is { success: false } actionsContextException)
+            Log.Error($"Failed to save database changes: {actionsContextException.exceptionMessage}");
+
        bool refreshLibrary = await CheckLibraryRefresh();
        if(refreshLibrary)
            Log.Info($"Condition {Tranga.Settings.LibraryRefreshSetting} met.");
@@ -188,12 +206,12 @@ public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> c
    private async Task<bool> CheckLibraryRefresh() => Tranga.Settings.LibraryRefreshSetting switch
    {
        LibraryRefreshSetting.AfterAllFinished => await AllDownloadsFinished(),
-        LibraryRefreshSetting.AfterMangaFinished => await DbContext.MangaConnectorToChapter.Include(chId => chId.Obj).Where(chId => chId.UseForDownload).AllAsync(chId => chId.Obj.Downloaded, CancellationToken),
+        LibraryRefreshSetting.AfterMangaFinished => await MangaContext.MangaConnectorToChapter.Include(chId => chId.Obj).Where(chId => chId.UseForDownload).AllAsync(chId => chId.Obj.Downloaded, CancellationToken),
        LibraryRefreshSetting.AfterEveryChapter => true,
        LibraryRefreshSetting.WhileDownloading => await AllDownloadsFinished() ||  DateTime.UtcNow.Subtract(RefreshLibrariesWorker.LastRefresh).TotalMinutes > Tranga.Settings.RefreshLibraryWhileDownloadingEveryMinutes,
        _ => true
    };
-    private async Task<bool> AllDownloadsFinished() => (await StartNewChapterDownloadsWorker.GetMissingChapters(DbContext, CancellationToken)).Count == 0;
+    private async Task<bool> AllDownloadsFinished() => (await StartNewChapterDownloadsWorker.GetMissingChapters(MangaContext, CancellationToken)).Count == 0;
    
    private async Task<Stream> ProcessImage(Stream imageStream, CancellationToken? cancellationToken = null)
    {
@@ -244,7 +262,7 @@ public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> c
    {
        Log.Debug($"Copying cover for {manga}");

-        manga = await DbContext.MangaIncludeAll().FirstAsync(m => m.Key == manga.Key, CancellationToken);
+        manga = await MangaContext.MangaIncludeAll().FirstAsync(m => m.Key == manga.Key, CancellationToken);
        string publicationFolder;
        try
        {
@@ -278,7 +296,7 @@ public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> c
            
            coverFileNameInCache = mangaConnector.SaveCoverImageToCache(mangaConnectorId);
            manga.CoverFileNameInCache = coverFileNameInCache;
-            if (await DbContext.Sync(CancellationToken, reason: "Update cover filename") is { success: false } result)
+            if (await MangaContext.Sync(CancellationToken, reason: "Update cover filename") is { success: false } result)
                Log.Error($"Couldn't update cover filename {result.exceptionMessage}");
        }
        if (coverFileNameInCache is null)
--- a/API/Workers/MangaDownloadWorkers/DownloadCoverFromMangaconnectorWorker.cs
+++ b/API/Workers/MangaDownloadWorkers/DownloadCoverFromMangaconnectorWorker.cs
@@ -1,4 +1,7 @@
+using System.Diagnostics.CodeAnalysis;
 using API.MangaConnectors;
+using API.Schema.ActionsContext;
+using API.Schema.ActionsContext.Actions;
 using API.Schema.MangaContext;
 using Microsoft.EntityFrameworkCore;

@@ -8,16 +11,28 @@ namespace API.Workers.MangaDownloadWorkers;
 /// Downloads the cover for Manga from Mangaconnector
 /// </summary>
 public class DownloadCoverFromMangaconnectorWorker(MangaConnectorId<Manga> mcId, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<MangaContext>(dependsOn)
+    : BaseWorkerWithContexts(dependsOn)
 {
-    internal readonly string MangaConnectorIdId = mcId.Key;
+    private readonly string _mangaConnectorIdId = mcId.Key;
+
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private MangaContext MangaContext = null!;
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private ActionsContext ActionsContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        MangaContext = GetContext<MangaContext>(serviceScope);
+        ActionsContext = GetContext<ActionsContext>(serviceScope);
+    }
+    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        Log.Debug($"Getting Cover for MangaConnectorId {MangaConnectorIdId}...");
+        Log.Debug($"Getting Cover for MangaConnectorId {_mangaConnectorIdId}...");
        // Getting MangaConnector info
-        if (await DbContext.MangaConnectorToManga
+        if (await MangaContext.MangaConnectorToManga
                .Include(id => id.Obj)
-                .FirstOrDefaultAsync(c => c.Key == MangaConnectorIdId, CancellationToken) is not { } mangaConnectorId)
+                .FirstOrDefaultAsync(c => c.Key == _mangaConnectorIdId, CancellationToken) is not { } mangaConnectorId)
        {
            Log.Error("Could not get MangaConnectorId.");
            return []; //TODO Exception?
@@ -35,13 +50,17 @@ public class DownloadCoverFromMangaconnectorWorker(MangaConnectorId<Manga> mcId,
            Log.Error($"Could not get Cover for MangaConnectorId {mangaConnectorId}.");
            return [];
        }
-        DbContext.Entry(mangaConnectorId.Obj).Property(m => m.CoverFileNameInCache).CurrentValue = coverFileName;
+        MangaContext.Entry(mangaConnectorId.Obj).Property(m => m.CoverFileNameInCache).CurrentValue = coverFileName;

-        if(await DbContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } e)
-            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
+        if(await MangaContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } mangaContextException)
+            Log.Error($"Failed to save database changes: {mangaContextException.exceptionMessage}");
+        
+        ActionsContext.Actions.Add(new CoverDownloadedActionRecord(mcId.Obj, coverFileName));
+        if(await MangaContext.Sync(CancellationToken, GetType(), "Download complete") is { success: false } actionsContextException)
+            Log.Error($"Failed to save database changes: {actionsContextException.exceptionMessage}");
        
        return [];
    }
    
-    public override string ToString() => $"{base.ToString()} {MangaConnectorIdId}";
+    public override string ToString() => $"{base.ToString()} {_mangaConnectorIdId}";
 }
--- a/API/Workers/MangaDownloadWorkers/RetrieveMangaChaptersFromMangaconnectorWorker.cs
+++ b/API/Workers/MangaDownloadWorkers/RetrieveMangaChaptersFromMangaconnectorWorker.cs
@@ -1,4 +1,7 @@
+using System.Diagnostics.CodeAnalysis;
 using API.MangaConnectors;
+using API.Schema.ActionsContext;
+using API.Schema.ActionsContext.Actions;
 using API.Schema.MangaContext;
 using Microsoft.EntityFrameworkCore;

@@ -11,18 +14,30 @@ namespace API.Workers.MangaDownloadWorkers;
 /// <param name="language"></param>
 /// <param name="dependsOn"></param>
 public class RetrieveMangaChaptersFromMangaconnectorWorker(MangaConnectorId<Manga> mcId, string language, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<MangaContext>(dependsOn)
+    : BaseWorkerWithContexts(dependsOn)
 {
-    internal readonly string MangaConnectorIdId = mcId.Key;
+    private readonly string _mangaConnectorIdId = mcId.Key;
+
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private MangaContext MangaContext = null!;
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private ActionsContext ActionsContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        MangaContext = GetContext<MangaContext>(serviceScope);
+        ActionsContext = GetContext<ActionsContext>(serviceScope);
+    }
+    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        Log.Debug($"Getting Chapters for MangaConnectorId {MangaConnectorIdId}...");
+        Log.Debug($"Getting Chapters for MangaConnectorId {_mangaConnectorIdId}...");
        // Getting MangaConnector info
-        if (await DbContext.MangaConnectorToManga
+        if (await MangaContext.MangaConnectorToManga
                .Include(id => id.Obj)
                .ThenInclude(m => m.Chapters)
                .ThenInclude(ch => ch.MangaConnectorIds)
-                .FirstOrDefaultAsync(c => c.Key == MangaConnectorIdId, CancellationToken) is not { } mangaConnectorId)
+                .FirstOrDefaultAsync(c => c.Key == _mangaConnectorIdId, CancellationToken) is not { } mangaConnectorId)
        {
            Log.Error("Could not get MangaConnectorId.");
            return []; //TODO Exception?
@@ -62,7 +77,7 @@ public class RetrieveMangaChaptersFromMangaconnectorWorker(MangaConnectorId<Mang
        Log.Debug($"Got {newIds.Count} new download-Ids.");
        
        // Add new ChapterIds to Database
-        DbContext.MangaConnectorToChapter.AddRange(newIds);
+        MangaContext.MangaConnectorToChapter.AddRange(newIds);

        // If Manga is marked for Download from Connector, mark the new Chapters as UseForDownload
        if (mangaConnectorId.UseForDownload)
@@ -73,11 +88,15 @@ public class RetrieveMangaChaptersFromMangaconnectorWorker(MangaConnectorId<Mang
            }
        }

-        if(await DbContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } e)
-            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
+        if(await MangaContext.Sync(CancellationToken, GetType(), "Chapters retrieved") is { success: false } mangaContextException)
+            Log.Error($"Failed to save database changes: {mangaContextException.exceptionMessage}");
+
+        ActionsContext.Actions.Add(new ChaptersRetrievedActionRecord(manga));
+        if(await MangaContext.Sync(CancellationToken, GetType(), "Chapters retrieved") is { success: false } actionsContextException)
+            Log.Error($"Failed to save database changes: {actionsContextException.exceptionMessage}");

        return [];
    }

-    public override string ToString() => $"{base.ToString()} {MangaConnectorIdId}";
+    public override string ToString() => $"{base.ToString()} {_mangaConnectorIdId}";
 }
--- a/API/Workers/MoveFileOrFolderWorker.cs
+++ b/API/Workers/MoveFileOrFolderWorker.cs
@@ -1,12 +1,24 @@
+using System.Diagnostics.CodeAnalysis;
+using API.Schema.ActionsContext;
+using API.Schema.ActionsContext.Actions;
+
 namespace API.Workers;

 public class MoveFileOrFolderWorker(string toLocation, string fromLocation, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorker(dependsOn)
+    : BaseWorkerWithContexts(dependsOn)
 {
    public readonly string FromLocation = fromLocation;
    public readonly string ToLocation = toLocation;
+    
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private ActionsContext ActionsContext = null!;

-    protected override Task<BaseWorker[]> DoWorkInternal()
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        ActionsContext = GetContext<ActionsContext>(serviceScope);
+    }
+
+    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
        try
        {
@@ -14,13 +26,13 @@ public class MoveFileOrFolderWorker(string toLocation, string fromLocation, IEnu
            if (!fi.Exists)
            {
                Log.Error($"File does not exist at {FromLocation}");
-                return new Task<BaseWorker[]>(() => []);
+                return [];
            }

            if (File.Exists(ToLocation))//Do not override existing
            {
                Log.Error($"File already exists at {ToLocation}");
-                return new Task<BaseWorker[]>(() => []);
+                return [];
            } 
            if(fi.Attributes.HasFlag(FileAttributes.Directory))
                MoveDirectory(fi, ToLocation);
@@ -32,7 +44,11 @@ public class MoveFileOrFolderWorker(string toLocation, string fromLocation, IEnu
            Log.Error(e);
        }

-        return new Task<BaseWorker[]>(() => []);
+        ActionsContext.Actions.Add(new DataMovedActionRecord(FromLocation, ToLocation));
+        if(await ActionsContext.Sync(CancellationToken, GetType(), "Library Moved") is { success: false } actionsContextException)
+            Log.Error($"Failed to save database changes: {actionsContextException.exceptionMessage}");
+
+        return [];
    }

    private void MoveDirectory(FileInfo from, string toLocation)
--- a/API/Workers/MoveMangaLibraryWorker.cs
+++ b/API/Workers/MoveMangaLibraryWorker.cs
@@ -1,47 +0,0 @@
-using API.Schema.MangaContext;
-using Microsoft.EntityFrameworkCore;
-
-namespace API.Workers;
-
-/// <summary>
-/// Moves a Manga to a different Library
-/// </summary>
-public class MoveMangaLibraryWorker(Manga manga, FileLibrary toLibrary, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<MangaContext>(dependsOn)
-{
-    internal readonly string MangaId = manga.Key;
-    internal readonly string LibraryId = toLibrary.Key;
-    protected override async Task<BaseWorker[]> DoWorkInternal()
-    {
-        Log.Debug("Moving Manga...");
-        // Get Manga (with and Library)
-        if (await DbContext.Mangas
-                .Include(m => m.Library)
-                .Include(m => m.Chapters)
-                .FirstOrDefaultAsync(m => m.Key == MangaId, CancellationToken) is not { } manga)
-        {
-            Log.Error("Could not find Manga.");
-            return [];
-        }
-        
-        // Get new Library
-        if (await DbContext.FileLibraries.FirstOrDefaultAsync(l => l.Key == LibraryId, CancellationToken) is not { } toLibrary)
-        {
-            Log.Error("Could not find Library.");
-            return [];
-        }
-        
-        // Save old Path (to later move chapters)
-        Dictionary<string, string> oldPath = manga.Chapters.Where(c => c.FileName != null).ToDictionary(c => c.Key, c => c.FullArchiveFilePath)!;
-        // Set new Path
-        manga.Library = toLibrary;
-        
-        if (await DbContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false })
-            return [];
-
-        // Create Jobs to move chapters from old to new Path
-        return oldPath.Select(kv => new MoveFileOrFolderWorker(manga.Chapters.First(ch => ch.Key == kv.Key).FullArchiveFilePath!, kv.Value)).ToArray<BaseWorker>();
-    }
-
-    public override string ToString() => $"{base.ToString()} {MangaId} {LibraryId}";
-}
--- a/API/Workers/PeriodicWorkers/CheckForNewChaptersWorker.cs
+++ b/API/Workers/PeriodicWorkers/CheckForNewChaptersWorker.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using API.Schema.MangaContext;
 using API.Workers.MangaDownloadWorkers;
 using Microsoft.EntityFrameworkCore;
@@ -8,15 +9,23 @@ namespace API.Workers.PeriodicWorkers;
 /// Creates Jobs to update available Chapters for all Manga that are marked for Download
 /// </summary>
 public class CheckForNewChaptersWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<MangaContext>(dependsOn), IPeriodic
+    : BaseWorkerWithContexts(dependsOn), IPeriodic
 {
    public DateTime LastExecution { get; set; } = DateTime.UnixEpoch;
    public TimeSpan Interval { get; set; } = interval??TimeSpan.FromMinutes(60);
    
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private MangaContext MangaContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        MangaContext = GetContext<MangaContext>(serviceScope);
+    }
+    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
        Log.Debug("Checking for new chapters...");
-        List<MangaConnectorId<Manga>> connectorIdsManga = await DbContext.MangaConnectorToManga
+        List<MangaConnectorId<Manga>> connectorIdsManga = await MangaContext.MangaConnectorToManga
            .Include(id => id.Obj)
            .Where(id => id.UseForDownload)
            .ToListAsync(CancellationToken);
@@ -27,5 +36,4 @@ public class CheckForNewChaptersWorker(TimeSpan? interval = null, IEnumerable<Ba

        return newWorkers.ToArray();
    }
-
 }
--- a/API/Workers/PeriodicWorkers/MaintenanceWorkers/CleanupMangaCoversWorker.cs
+++ b/API/Workers/PeriodicWorkers/MaintenanceWorkers/CleanupMangaCoversWorker.cs
@@ -1,18 +1,27 @@
+using System.Diagnostics.CodeAnalysis;
 using API.Schema.MangaContext;
 using Microsoft.EntityFrameworkCore;

 namespace API.Workers.PeriodicWorkers.MaintenanceWorkers;

 public class CleanupMangaCoversWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<MangaContext>(dependsOn), IPeriodic
+    : BaseWorkerWithContexts(dependsOn), IPeriodic
 {
    public DateTime LastExecution { get; set; } = DateTime.UnixEpoch;
    public TimeSpan Interval { get; set; } = interval ?? TimeSpan.FromHours(24);
+
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private MangaContext MangaContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        MangaContext = GetContext<MangaContext>(serviceScope);
+    }
    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
        Log.Info("Removing stale files...");
-        string[] usedFiles = await DbContext.Mangas.Where(m => m.CoverFileNameInCache != null).Select(m => m.CoverFileNameInCache!).ToArrayAsync(CancellationToken);
+        string[] usedFiles = await MangaContext.Mangas.Where(m => m.CoverFileNameInCache != null).Select(m => m.CoverFileNameInCache!).ToArrayAsync(CancellationToken);
        CleanupImageCache(usedFiles, TrangaSettings.CoverImageCacheOriginal);
        CleanupImageCache(usedFiles, TrangaSettings.CoverImageCacheLarge);
        CleanupImageCache(usedFiles, TrangaSettings.CoverImageCacheMedium);
--- a/API/Workers/PeriodicWorkers/MaintenanceWorkers/CleanupMangaconnectorIdsWithoutConnector.cs
+++ b/API/Workers/PeriodicWorkers/MaintenanceWorkers/CleanupMangaconnectorIdsWithoutConnector.cs
@@ -1,29 +1,37 @@
-using System.Text;
+using System.Diagnostics.CodeAnalysis;
 using API.Schema.MangaContext;
 using Microsoft.EntityFrameworkCore;

 namespace API.Workers.PeriodicWorkers.MaintenanceWorkers;

-public class CleanupMangaconnectorIdsWithoutConnector : BaseWorkerWithContext<MangaContext>
+public class CleanupMangaconnectorIdsWithoutConnector : BaseWorkerWithContexts
 {
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private MangaContext MangaContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        MangaContext = GetContext<MangaContext>(serviceScope);
+    }
+    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
        Log.Info("Cleaning up old connector-data");
        string[] connectorNames = Tranga.MangaConnectors.Select(c => c.Name).ToArray();
-        int deletedChapterIds = await DbContext.MangaConnectorToChapter.Where(chId => connectorNames.All(n => n != chId.MangaConnectorName)).ExecuteDeleteAsync(CancellationToken);
+        int deletedChapterIds = await MangaContext.MangaConnectorToChapter.Where(chId => connectorNames.All(n => n != chId.MangaConnectorName)).ExecuteDeleteAsync(CancellationToken);
        Log.Info($"Deleted {deletedChapterIds} chapterIds.");
        
        // Manga without Connector get printed to file, to not lose data...
-        if (await DbContext.MangaConnectorToManga.Include(id => id.Obj) .Where(mcId => connectorNames.All(name => name != mcId.MangaConnectorName)).ToListAsync() is { Count: > 0 } list)
+        if (await MangaContext.MangaConnectorToManga.Include(id => id.Obj) .Where(mcId => connectorNames.All(name => name != mcId.MangaConnectorName)).ToListAsync() is { Count: > 0 } list)
        {
            string filePath = Path.Join(TrangaSettings.WorkingDirectory, $"deletedManga-{DateTime.UtcNow.Ticks}.txt");
            Log.Debug($"Writing deleted manga to {filePath}.");
            await File.WriteAllLinesAsync(filePath, list.Select(id => string.Join('-', id.MangaConnectorName, id.IdOnConnectorSite, id.Obj.Name, id.WebsiteUrl)), CancellationToken);
        }
-        int deletedMangaIds = await DbContext.MangaConnectorToManga.Where(mcId => connectorNames.All(name => name != mcId.MangaConnectorName)).ExecuteDeleteAsync(CancellationToken);
+        int deletedMangaIds = await MangaContext.MangaConnectorToManga.Where(mcId => connectorNames.All(name => name != mcId.MangaConnectorName)).ExecuteDeleteAsync(CancellationToken);
        Log.Info($"Deleted {deletedMangaIds} mangaIds.");
        
-        await DbContext.SaveChangesAsync(CancellationToken);
+        await MangaContext.SaveChangesAsync(CancellationToken);
        return [];
    }
 }
--- a/API/Workers/PeriodicWorkers/MaintenanceWorkers/RemoveOldNotificationsWorker.cs
+++ b/API/Workers/PeriodicWorkers/MaintenanceWorkers/RemoveOldNotificationsWorker.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using API.Schema.NotificationsContext;
 using Microsoft.EntityFrameworkCore;

@@ -7,18 +8,26 @@ namespace API.Workers.PeriodicWorkers.MaintenanceWorkers;
 /// Removes sent notifications from database
 /// </summary>
 public class RemoveOldNotificationsWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<NotificationsContext>(dependsOn), IPeriodic
+    : BaseWorkerWithContexts(dependsOn), IPeriodic
 {
    public DateTime LastExecution { get; set; } = DateTime.UnixEpoch;
    public TimeSpan Interval { get; set; } = interval ??  TimeSpan.FromHours(1);
+
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private NotificationsContext NotificationsContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        NotificationsContext = GetContext<NotificationsContext>(serviceScope);
+    }
    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
        Log.Debug("Removing old notifications...");
-        int removed = await DbContext.Notifications.Where(n => n.IsSent).ExecuteDeleteAsync(CancellationToken);
+        int removed = await NotificationsContext.Notifications.Where(n => n.IsSent).ExecuteDeleteAsync(CancellationToken);
        Log.Debug($"Removed {removed} old notifications...");
        
-        if(await DbContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } e)
+        if(await NotificationsContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } e)
            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
        
        return [];
--- a/API/Workers/PeriodicWorkers/SendNotificationsWorker.cs
+++ b/API/Workers/PeriodicWorkers/SendNotificationsWorker.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using API.Schema.NotificationsContext;
 using API.Schema.NotificationsContext.NotificationConnectors;
 using Microsoft.EntityFrameworkCore;
@@ -10,15 +11,24 @@ namespace API.Workers.PeriodicWorkers;
 /// <param name="interval"></param>
 /// <param name="dependsOn"></param>
 public class SendNotificationsWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<NotificationsContext>(dependsOn), IPeriodic
+    : BaseWorkerWithContexts(dependsOn), IPeriodic
 {
    public DateTime LastExecution { get; set; } = DateTime.UnixEpoch;
    public TimeSpan Interval { get; set; } = interval??TimeSpan.FromMinutes(1);
+    
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private NotificationsContext NotificationsContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        NotificationsContext = GetContext<NotificationsContext>(serviceScope);
+    }
+    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
        Log.Debug("Sending notifications...");
-        List<NotificationConnector> connectors = await DbContext.NotificationConnectors.ToListAsync(CancellationToken);
-        List<Notification> unsentNotifications = await DbContext.Notifications.Where(n => n.IsSent == false).ToListAsync(CancellationToken);
+        List<NotificationConnector> connectors = await NotificationsContext.NotificationConnectors.ToListAsync(CancellationToken);
+        List<Notification> unsentNotifications = await NotificationsContext.Notifications.Where(n => n.IsSent == false).ToListAsync(CancellationToken);
        
        Log.Debug($"Sending {unsentNotifications.Count} notifications to {connectors.Count} connectors...");
        
@@ -27,16 +37,15 @@ public class SendNotificationsWorker(TimeSpan? interval = null, IEnumerable<Base
            connectors.ForEach(connector =>
            {
                connector.SendNotification(notification.Title, notification.Message);
-                DbContext.Entry(notification).Property(n => n.IsSent).CurrentValue = true;
+                NotificationsContext.Entry(notification).Property(n => n.IsSent).CurrentValue = true;
            });
        });
        
        Log.Debug("Notifications sent.");
        
-        if(await DbContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } e)
+        if(await NotificationsContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } e)
            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
            
        return [];
    }
-
 }
--- a/API/Workers/PeriodicWorkers/StartNewChapterDownloadsWorker.cs
+++ b/API/Workers/PeriodicWorkers/StartNewChapterDownloadsWorker.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using API.Schema.MangaContext;
 using API.Workers.MangaDownloadWorkers;
 using Microsoft.EntityFrameworkCore;
@@ -8,17 +9,26 @@ namespace API.Workers.PeriodicWorkers;
 /// Create new Workers for Chapters on Manga marked for Download, that havent been downloaded yet.
 /// </summary>
 public class StartNewChapterDownloadsWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<MangaContext>(dependsOn), IPeriodic
+    : BaseWorkerWithContexts(dependsOn), IPeriodic
 {

    public DateTime LastExecution { get; set; } = DateTime.UnixEpoch;
    public TimeSpan Interval { get; set; } = interval ?? TimeSpan.FromMinutes(1);
+    
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private MangaContext MangaContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        MangaContext = GetContext<MangaContext>(serviceScope);
+    }
+    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
        Log.Debug("Checking for missing chapters...");
        
        // Get missing chapters
-        List<MangaConnectorId<Chapter>> missingChapters = await GetMissingChapters(DbContext, CancellationToken);
+        List<MangaConnectorId<Chapter>> missingChapters = await GetMissingChapters(MangaContext, CancellationToken);
        
        Log.Debug($"Found {missingChapters.Count} missing downloads.");
        
--- a/API/Workers/PeriodicWorkers/UpdateChaptersDownloadedWorker.cs
+++ b/API/Workers/PeriodicWorkers/UpdateChaptersDownloadedWorker.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using API.Schema.MangaContext;
 using Microsoft.EntityFrameworkCore;

@@ -7,20 +8,29 @@ namespace API.Workers.PeriodicWorkers;
 /// Updates the database to reflect changes made on disk
 /// </summary>
 public class UpdateChaptersDownloadedWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<MangaContext>(dependsOn), IPeriodic
+    : BaseWorkerWithContexts(dependsOn), IPeriodic
 {
    public DateTime LastExecution { get; set; } = DateTime.UnixEpoch;
    public TimeSpan Interval { get; set; } = interval??TimeSpan.FromDays(1);
+    
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private MangaContext MangaContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        MangaContext = GetContext<MangaContext>(serviceScope);
+    }
+    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
        Log.Debug("Checking chapter files...");
-        List<Chapter> chapters = await DbContext.Chapters.ToListAsync(CancellationToken);
+        List<Chapter> chapters = await MangaContext.Chapters.ToListAsync(CancellationToken);
        Log.Debug($"Checking {chapters.Count} chapters...");
        foreach (Chapter chapter in chapters)
        {
            try
            {
-                chapter.Downloaded = await chapter.CheckDownloaded(DbContext, CancellationToken);
+                chapter.Downloaded = await chapter.CheckDownloaded(MangaContext, CancellationToken);
            }
            catch (Exception exception)
            {
@@ -28,7 +38,7 @@ public class UpdateChaptersDownloadedWorker(TimeSpan? interval = null, IEnumerab
            }
        }

-        if(await DbContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } e)
+        if(await MangaContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } e)
            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
        
        return [];
--- a/API/Workers/PeriodicWorkers/UpdateCoversWorker.cs
+++ b/API/Workers/PeriodicWorkers/UpdateCoversWorker.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using API.Schema.MangaContext;
 using API.Workers.MangaDownloadWorkers;
 using Microsoft.EntityFrameworkCore;
@@ -10,15 +11,22 @@ namespace API.Workers.PeriodicWorkers;
 /// <param name="interval"></param>
 /// <param name="dependsOn"></param>
 public class UpdateCoversWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<MangaContext>(dependsOn), IPeriodic
+    : BaseWorkerWithContexts(dependsOn), IPeriodic
 {
-
    public DateTime LastExecution { get; set; } = DateTime.UnixEpoch;
    public TimeSpan Interval { get; set; } = interval ?? TimeSpan.FromHours(6);
    
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private MangaContext MangaContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        MangaContext = GetContext<MangaContext>(serviceScope);
+    }
+    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        List<MangaConnectorId<Manga>> manga = await DbContext.MangaConnectorToManga.Where(mcId => mcId.UseForDownload).ToListAsync(CancellationToken);
+        List<MangaConnectorId<Manga>> manga = await MangaContext.MangaConnectorToManga.Where(mcId => mcId.UseForDownload).ToListAsync(CancellationToken);
        List<BaseWorker> newWorkers = manga.Select(m => new DownloadCoverFromMangaconnectorWorker(m)).ToList<BaseWorker>();
        return newWorkers.ToArray();
    }
--- a/API/Workers/PeriodicWorkers/UpdateMetadataWorker.cs
+++ b/API/Workers/PeriodicWorkers/UpdateMetadataWorker.cs
@@ -1,3 +1,6 @@
+using System.Diagnostics.CodeAnalysis;
+using API.Schema.ActionsContext;
+using API.Schema.ActionsContext.Actions;
 using API.Schema.MangaContext;
 using API.Schema.MangaContext.MetadataFetchers;
 using Microsoft.EntityFrameworkCore;
@@ -10,20 +13,31 @@ namespace API.Workers.PeriodicWorkers;
 /// <param name="interval"></param>
 /// <param name="dependsOn"></param>
 public class UpdateMetadataWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
-    : BaseWorkerWithContext<MangaContext>(dependsOn), IPeriodic
+    : BaseWorkerWithContexts(dependsOn), IPeriodic
 {

    public DateTime LastExecution { get; set; } = DateTime.UnixEpoch;
    public TimeSpan Interval { get; set; } = interval ?? TimeSpan.FromHours(12);
+
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private MangaContext MangaContext = null!;
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private ActionsContext ActionsContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        MangaContext = GetContext<MangaContext>(serviceScope);
+        ActionsContext = GetContext<ActionsContext>(serviceScope);
+    }
    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
        Log.Debug("Updating metadata...");
        // Get MetadataEntries of Manga marked for download
-        List<MetadataEntry> metadataEntriesToUpdate = await DbContext.MangaConnectorToManga
+        List<MetadataEntry> metadataEntriesToUpdate = await MangaContext.MangaConnectorToManga
            .Where(m => m.UseForDownload) // Get marked Manga
            .Join(
-                DbContext.MetadataEntries.Include(e => e.MetadataFetcher).Include(e => e.Manga),
+                MangaContext.MetadataEntries.Include(e => e.MetadataFetcher).Include(e => e.Manga),
                mcId => mcId.ObjId,
                e => e.MangaId,
                (mcId, e) => e) // return MetadataEntry
@@ -33,12 +47,16 @@ public class UpdateMetadataWorker(TimeSpan? interval = null, IEnumerable<BaseWor
        foreach (MetadataEntry metadataEntry in metadataEntriesToUpdate)
        {
            Log.Debug($"Updating metadata of {metadataEntry}...");
-            await metadataEntry.MetadataFetcher.UpdateMetadata(metadataEntry, DbContext, CancellationToken);
+            await metadataEntry.MetadataFetcher.UpdateMetadata(metadataEntry, MangaContext, CancellationToken);
+            ActionsContext.Actions.Add(new MetadataUpdatedActionRecord(metadataEntry.Manga, metadataEntry.MetadataFetcher));
        }
        Log.Debug("Updated metadata.");

-        if(await DbContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } e)
+        if(await MangaContext.Sync(CancellationToken, GetType(), System.Reflection.MethodBase.GetCurrentMethod()?.Name) is { success: false } e)
            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
+        
+        if(await ActionsContext.Sync(CancellationToken, GetType(), "Metadata Updated") is { success: false } actionsContextException)
+            Log.Error($"Failed to save database changes: {actionsContextException.exceptionMessage}");

        return [];
    }
--- a/API/Workers/RefreshLibrariesWorker.cs
+++ b/API/Workers/RefreshLibrariesWorker.cs
@@ -1,20 +1,27 @@
+using System.Diagnostics.CodeAnalysis;
 using API.Schema.LibraryContext;
 using API.Schema.LibraryContext.LibraryConnectors;
 using Microsoft.EntityFrameworkCore;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;

 namespace API.Workers;

-public class RefreshLibrariesWorker(IEnumerable<BaseWorker>? dependsOn = null) : BaseWorkerWithContext<LibraryContext>(dependsOn)
+public class RefreshLibrariesWorker(IEnumerable<BaseWorker>? dependsOn = null) : BaseWorkerWithContexts(dependsOn)
 {
    public static DateTime LastRefresh { get; set; } = DateTime.UnixEpoch;
    
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private LibraryContext LibraryContext = null!;
+
+    protected override void SetContexts(IServiceScope serviceScope)
+    {
+        LibraryContext = GetContext<LibraryContext>(serviceScope);
+    }
+    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
        Log.Debug("Refreshing libraries...");
        LastRefresh = DateTime.UtcNow;
-        List<LibraryConnector> libraries = await DbContext.LibraryConnectors.ToListAsync(CancellationToken);
+        List<LibraryConnector> libraries = await LibraryContext.LibraryConnectors.ToListAsync(CancellationToken);
        foreach (LibraryConnector connector in libraries)
            await connector.UpdateLibrary(CancellationToken);
        Log.Debug("Libraries Refreshed...");