Refactored Cache Cleanup code.

API/Controllers/SeriesController.cs

@@ -36,13 +36,14 @@ namespace API.Controllers
         public async Task<ActionResult<bool>> DeleteSeries(int seriesId)
         {
             var username = User.GetUsername();
-            var volumes = (await _unitOfWork.SeriesRepository.GetVolumesForSeriesAsync(new []{seriesId})).Select(x => x.Id).ToArray();
+            //var volumes = (await _unitOfWork.SeriesRepository.GetVolumesForSeriesAsync(new []{seriesId})).Select(x => x.Id).ToArray();
+            var chapterIds = (await _unitOfWork.SeriesRepository.GetChapterIdsForSeriesAsync(new []{seriesId}));
             _logger.LogInformation($"Series {seriesId} is being deleted by {username}.");
             var result = await _unitOfWork.SeriesRepository.DeleteSeriesAsync(seriesId);
 
             if (result)
             {
-                _taskScheduler.CleanupVolumes(volumes);
+                _taskScheduler.CleanupChapters(chapterIds);
             }
             return Ok(result);
         }

API/Data/SeriesRepository.cs

@@ -175,6 +175,32 @@ namespace API.Data
                 .SingleOrDefaultAsync();
         }
 
+        public async Task<int[]> GetChapterIdsForSeriesAsync(int[] seriesIds)
+        {
+            var series = await _context.Series
+                .Where(s => seriesIds.Contains(s.Id))
+                .Include(s => s.Volumes)
+                .ThenInclude(v => v.Chapters)
+                .ToListAsync();
+
+            // TODO: refactor this
+            IList<int> chapterIds = new List<int>();
+            foreach (var s in series)
+            {
+                foreach (var v in s.Volumes)
+                {
+                    foreach (var c in v.Chapters)
+                    {
+                        chapterIds.Add(c.Id);
+                    }
+                }
+            }
+
+            return chapterIds.ToArray();
+
+            //return series.Select(s => s.Volumes).Select(v => v.Select(v => v.Chapters)).Select(c => c.Id);
+        }
+
         private async Task AddSeriesModifiers(int userId, List<SeriesDto> series)
         {
             var userProgress = await _context.AppUserProgresses

API/Interfaces/ICacheService.cs

@@ -21,8 +21,8 @@ namespace API.Interfaces
         /// <summary>
         /// Clears cache directory of all volumes. This can be invoked from deleting a library or a series.
         /// </summary>
-        /// <param name="volumeIds">Volumes that belong to that library. Assume the library might have been deleted before this invocation.</param>
+        /// <param name="chapterIds">Volumes that belong to that library. Assume the library might have been deleted before this invocation.</param>
-        void CleanupVolumes(int[] volumeIds);
+        void CleanupChapters(int[] chapterIds);
         
 
         /// <summary>

API/Interfaces/ISeriesRepository.cs

@@ -26,5 +26,6 @@ namespace API.Interfaces
         Task<Series> GetSeriesByIdAsync(int seriesId);
 
         //Task<MangaFileDto> GetVolumeMangaFileDtos(int volumeId);
+        Task<int[]> GetChapterIdsForSeriesAsync(int[] seriesIds);
     }
 }

API/Interfaces/ITaskScheduler.cs

@@ -3,7 +3,7 @@
     public interface ITaskScheduler
     {
         void ScanLibrary(int libraryId, bool forceUpdate = false);
-        void CleanupVolumes(int[] volumeIds);
+        void CleanupChapters(int[] chapterIds);
         void ScanSeries(int libraryId, int seriesId);
     }
 }

API/Services/CacheService.cs

@@ -47,7 +47,7 @@ namespace API.Services
             
             foreach (var file in chapter.Files)
             {
-                var extractPath = GetCachePath(chapterId, file);
+                var extractPath = GetCachePath(chapterId);
                 _archiveService.ExtractArchive(file.FilePath, extractPath);
             }
 
@@ -73,14 +73,14 @@ namespace API.Services
             _logger.LogInformation("Cache directory purged.");
         }
         
-        public void CleanupVolumes(int[] volumeIds)
+        public void CleanupChapters(int[] chapterIds)
         {
             // TODO: Fix this code to work with chapters
             _logger.LogInformation($"Running Cache cleanup on Volumes");
             
-            foreach (var volume in volumeIds)
+            foreach (var chapter in chapterIds)
             {
-                var di = new DirectoryInfo(Path.Join(CacheDirectory, volume + ""));
+                var di = new DirectoryInfo(GetCachePath(chapter));
                 if (di.Exists)
                 {
                     di.Delete(true);    
@@ -90,31 +90,15 @@ namespace API.Services
             _logger.LogInformation("Cache directory purged");
         }
 
-        
-
 
         /// <summary>
         /// Returns the cache path for a given Chapter. Should be cacheDirectory/{chapterId}/
         /// </summary>
         /// <param name="chapterId"></param>
-        /// <param name="file"></param>
         /// <returns></returns>
-        public string GetCachePath(int chapterId, MangaFile file)
+        private string GetCachePath(int chapterId)
         {
-            var extractPath = Path.GetFullPath(Path.Join(CacheDirectory, $"{chapterId}/"));
+            return Path.GetFullPath(Path.Join(CacheDirectory, $"{chapterId}/"));
-            // if (file.Chapter != null)
-            // {
-            //     extractPath = Path.Join(extractPath, chapterId + "");
-            // }
-            return extractPath;
-        }
-
-        public IEnumerable<MangaFile> GetOrderedChapters(ICollection<MangaFile> files)
-        {
-            // BUG: This causes a problem because total pages on a volume assumes "specials" to be there
-            //return files.OrderBy(f => f.Chapter).Where(f => f.Chapter > 0 || f.Volume.Number != 0);
-            return files;
-            //return files.OrderBy(f => f.Chapter, new ChapterSortComparer());
         }
 
         public async Task<(string path, MangaFile file)> GetCachedPagePath(Chapter chapter, int page)
@@ -124,9 +108,10 @@ namespace API.Services
             var chapterFiles = chapter.Files ?? await _unitOfWork.VolumeRepository.GetFilesForChapter(chapter.Id);
             foreach (var mangaFile in chapterFiles)
             {
-                if (page + 1 < (mangaFile.NumberOfPages + pagesSoFar))
+                if (page < (mangaFile.NumberOfPages + pagesSoFar))
                 {
-                    var path = GetCachePath(chapter.Id, mangaFile);
+                    var path = GetCachePath(chapter.Id);
+                    // TODO: GetFiles should only get image files.
                     var files = _directoryService.GetFiles(path);
                     Array.Sort(files, _numericComparer);
                     

API/Services/TaskScheduler.cs

@@ -34,9 +34,9 @@ namespace API.Services
             BackgroundJob.Enqueue(() => _scannerService.ScanLibrary(libraryId, forceUpdate));
         }
 
-        public void CleanupVolumes(int[] volumeIds)
+        public void CleanupChapters(int[] chapterIds)
         {
-            BackgroundJob.Enqueue(() => _cacheService.CleanupVolumes(volumeIds));
+            BackgroundJob.Enqueue(() => _cacheService.CleanupChapters(chapterIds));
             
         }