Scan Loop Fortification (#1573)

* Cleanup some messaging in the scan loop to be more context bearing

* Added Response Caching to Series Detail for 1 min, due to the heavy nature of the call.

* Refactored code to make it so that processing of series runs sync correctly.

Added a log to inform the user of corrupted volume from buggy code in v0.5.6.

* Moved folder watching out of experimental

* Fixed an issue where empty folders could break the scan loop

* Another fix for when dates aren't valid, the scanner wouldn't get the proper min and would throw an exception (develop)

* Implemented the ability to edit release year from the UI for a series.

* Added a unit test for some new logic

* Code smells

* Rewrote the handler for suspending watching to be more resilient and ensure no two threads have a race condition.

* More error handling for when a ScanFolder is invoked but multiple series belong to that folder, log it to the user and default to a library scan.

* ScanSeries now will check for kavitaignores higher than it's own folder and respect library level.

* Fixed an issue where image series with a folder name containing the word "folder" could get ignored as it thought the image was a cover image.

When a series folder is moved or deleted, skip parent ignore finding.

* Removed some old files, added in scanFolder a check if the series found for a folder is in a book library and if so to always do a library scan (as books are often nested into one folder with  multiple series). Added some unit tests

* Refactored some scan loop logic into ComicInfo, wrote tests and updated some documentation to make the fields more clear.

* Added a test for GetLastWriteTime based on recent bug

* Cleaned up some redundant code

* Fixed a bad merge

* Code smells

* Removed a package that's no longer used.

* Ensure we check against ScanQueue on ScanFolder enqueuing

* Documentation and more bullet proofing to ensure Hangfire checks work more as expected

API/Services/Tasks/Scanner/ParseScannedFiles.cs

@@ -1,12 +1,14 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using API.Entities.Enums;
 using API.Extensions;
 using API.Parser;
 using API.SignalR;
+using Kavita.Common.Helpers;
 using Microsoft.Extensions.Logging;
 
 namespace API.Services.Tasks.Scanner;
@@ -39,6 +41,7 @@ public class SeriesModified
     public string SeriesName { get; set; }
     public DateTime LastScanned { get; set; }
     public MangaFormat Format { get; set; }
+    public IEnumerable<string> LibraryRoots { get; set; }
 }
 
 
@@ -109,7 +112,41 @@ public class ParseScannedFiles
             await folderAction(new List<string>(), folderPath);
             return;
         }
-        await folderAction(_directoryService.ScanFiles(folderPath), folderPath);
+        // We need to calculate all folders till library root and see if any kavitaignores
+        var seriesMatcher = new GlobMatcher();
+        try
+        {
+            var roots = seriesPaths[folderPath][0].LibraryRoots.Select(Scanner.Parser.Parser.NormalizePath).ToList();
+            var libraryFolder = roots.SingleOrDefault(folderPath.Contains);
+
+            if (string.IsNullOrEmpty(libraryFolder) || !Directory.Exists(folderPath))
+            {
+                await folderAction(_directoryService.ScanFiles(folderPath, seriesMatcher), folderPath);
+                return;
+            }
+
+            var allParents = _directoryService.GetFoldersTillRoot(libraryFolder, folderPath);
+            var path = libraryFolder;
+
+            // Apply the library root level kavitaignore
+            var potentialIgnoreFile = _directoryService.FileSystem.Path.Join(path, DirectoryService.KavitaIgnoreFile);
+            seriesMatcher.Merge(_directoryService.CreateMatcherFromFile(potentialIgnoreFile));
+
+            // Then apply kavitaignores for each folder down to where the series folder is
+            foreach (var folderPart in allParents.Reverse())
+            {
+                path = Parser.Parser.NormalizePath(Path.Join(libraryFolder, folderPart));
+                potentialIgnoreFile = _directoryService.FileSystem.Path.Join(path, DirectoryService.KavitaIgnoreFile);
+                seriesMatcher.Merge(_directoryService.CreateMatcherFromFile(potentialIgnoreFile));
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "There was an error trying to find and apply .kavitaignores above the Series Folder. Scanning without them present");
+        }
+
+
+        await folderAction(_directoryService.ScanFiles(folderPath, seriesMatcher), folderPath);
     }