Refactored more archive code into the service and updated documentation now that methods are public.

API.Tests/Services/ArchiveServiceTests.cs

@@ -1,6 +1,5 @@
 using System.IO;
 using System.IO.Compression;
-using API.Extensions;
 using API.Interfaces;
 using API.Services;
 using Microsoft.Extensions.Logging;
@@ -14,9 +13,6 @@ namespace API.Tests.Services
         private readonly IArchiveService _archiveService;
         private readonly ILogger<ArchiveService> _logger = Substitute.For<ILogger<ArchiveService>>();
 
-        private readonly string _testDirectory =
-            Path.Join(Directory.GetCurrentDirectory(), "../../../Services/Test Data/ArchiveService");
-
         public ArchiveServiceTests()
         {
             _archiveService = new ArchiveService(_logger);
@@ -29,9 +25,21 @@ namespace API.Tests.Services
         [InlineData("file in folder_alt.zip", true)]
         public void ArchiveNeedsFlatteningTest(string archivePath, bool expected)
         {
-            var file = Path.Join(_testDirectory, archivePath);
+            var testDirectory = Path.Join(Directory.GetCurrentDirectory(), "../../../Services/Test Data/ArchiveService");
+            var file = Path.Join(testDirectory, archivePath);
             using ZipArchive archive = ZipFile.OpenRead(file);
             Assert.Equal(expected, _archiveService.ArchiveNeedsFlattening(archive));
         }
+        
+        [Theory]
+        [InlineData("v10.cbz", "v10.expected.jpg")]
+        [InlineData("v10 - with folder.cbz", "v10 - with folder.expected.jpg")]
+        [InlineData("v10 - nested folder.cbz", "v10 - nested folder.expected.jpg")]
+        public void GetCoverImageTest(string inputFile, string expectedOutputFile)
+        {
+            var testDirectory = Path.Join(Directory.GetCurrentDirectory(), "../../../Services/Test Data/CoverImageTests");
+            var expectedBytes = File.ReadAllBytes(Path.Join(testDirectory, expectedOutputFile));
+            Assert.Equal(expectedBytes, _archiveService.GetCoverImage(Path.Join(testDirectory, inputFile)));
+        }
     }
 }

API.Tests/Services/ScannerServiceTests.cs

@@ -9,23 +9,15 @@ namespace API.Tests.Services
 {
     public class ScannerServiceTests
     {
-        private readonly ScannerService _scannerService;
+        // private readonly ScannerService _scannerService;
-        private readonly ILogger<ScannerService> _logger = Substitute.For<ILogger<ScannerService>>();
+        // private readonly ILogger<ScannerService> _logger = Substitute.For<ILogger<ScannerService>>();
-        private readonly IUnitOfWork _unitOfWork = Substitute.For<IUnitOfWork>();
+        // private readonly IUnitOfWork _unitOfWork = Substitute.For<IUnitOfWork>();
-        private readonly string _testDirectory = Path.Join(Directory.GetCurrentDirectory(), "../../../Services/Test Data/ScannerService");
+        // private readonly string _testDirectory = Path.Join(Directory.GetCurrentDirectory(), "../../../Services/Test Data/ScannerService");
-        public ScannerServiceTests()
+        // public ScannerServiceTests()
-        {
+        // {
-            _scannerService = new ScannerService(_unitOfWork, _logger);
+        //     _scannerService = new ScannerService(_unitOfWork, _logger);
-        }
+        // }
 
-        [Theory]
+        
-        [InlineData("v10.cbz", "v10.expected.jpg")]
-        [InlineData("v10 - with folder.cbz", "v10 - with folder.expected.jpg")]
-        [InlineData("v10 - nested folder.cbz", "v10 - nested folder.expected.jpg")]
-        public void GetCoverImageTest(string inputFile, string expectedOutputFile)
-        {
-            var expectedBytes = File.ReadAllBytes(Path.Join(_testDirectory, expectedOutputFile));
-            Assert.Equal(expectedBytes, _scannerService.GetCoverImage(Path.Join(_testDirectory, inputFile)));
-        }
     }
 }

API/Interfaces/IArchiveService.cs

@@ -5,6 +5,8 @@ namespace API.Interfaces
     public interface IArchiveService
     {
         bool ArchiveNeedsFlattening(ZipArchive archive);
-        public void ExtractArchive(string archivePath, string extractPath);
+        void ExtractArchive(string archivePath, string extractPath);
+        int GetNumberOfPagesFromArchive(string archivePath);
+        byte[] GetCoverImage(string filepath, bool createThumbnail = false);
     }
 }

API/Services/ArchiveService.cs

@@ -1,10 +1,12 @@
-using System.Diagnostics;
+using System;
+using System.Diagnostics;
 using System.IO;
 using System.IO.Compression;
 using System.Linq;
 using API.Extensions;
 using API.Interfaces;
 using Microsoft.Extensions.Logging;
+using NetVips;
 
 namespace API.Services
 {
@@ -19,17 +21,111 @@ namespace API.Services
         {
             _logger = logger;
         }
+        
+        public int GetNumberOfPagesFromArchive(string archivePath)
+        {
+            if (!File.Exists(archivePath) || !Parser.Parser.IsArchive(archivePath))
+            {
+                _logger.LogError($"Archive {archivePath} could not be found.");
+                return 0;
+            }
+           
+            _logger.LogDebug($"Getting Page numbers from  {archivePath}");
 
+            try
+            {
+                using ZipArchive archive = ZipFile.OpenRead(archivePath); // ZIPFILE
+                return archive.Entries.Count(e => Parser.Parser.IsImage(e.FullName));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "There was an exception when reading archive stream.");
+                return 0;
+            }
+           
+           
+        }
+        
+        /// <summary>
+        /// Generates byte array of cover image.
+        /// Given a path to a compressed file (zip, rar, cbz, cbr, etc), will ensure the first image is returned unless
+        /// a folder.extension exists in the root directory of the compressed file.
+        /// </summary>
+        /// <param name="filepath"></param>
+        /// <param name="createThumbnail">Create a smaller variant of file extracted from archive. Archive images are usually 1MB each.</param>
+        /// <returns></returns>
+        public byte[] GetCoverImage(string filepath, bool createThumbnail = false)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(filepath) || !File.Exists(filepath) || !Parser.Parser.IsArchive(filepath)) return Array.Empty<byte>();
+
+                _logger.LogDebug($"Extracting Cover image from {filepath}");
+                using ZipArchive archive = ZipFile.OpenRead(filepath);
+                if (!archive.HasFiles()) return Array.Empty<byte>();
+
+                var folder = archive.Entries.SingleOrDefault(x => Path.GetFileNameWithoutExtension(x.Name).ToLower() == "folder");
+                var entries = archive.Entries.Where(x => Path.HasExtension(x.FullName) && Parser.Parser.IsImage(x.FullName)).OrderBy(x => x.FullName).ToList();
+                ZipArchiveEntry entry;
+                
+                if (folder != null)
+                {
+                    entry = folder;
+                } else if (!entries.Any())
+                {
+                    return Array.Empty<byte>();
+                }
+                else
+                {
+                    entry = entries[0];
+                }
+
+
+                if (createThumbnail)
+                {
+                    try
+                    {
+                        using var stream = entry.Open();
+                        var thumbnail = Image.ThumbnailStream(stream, 320);
+                        return thumbnail.WriteToBuffer(".jpg");
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "There was a critical error and prevented thumbnail generation.");
+                    }
+                }
+                
+                return ExtractEntryToImage(entry);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "There was an exception when reading archive stream.");
+                return Array.Empty<byte>();
+            }
+        }
+        
+        private static byte[] ExtractEntryToImage(ZipArchiveEntry entry)
+        {
+            using var stream = entry.Open();
+            using var ms = new MemoryStream();
+            stream.CopyTo(ms);
+            var data = ms.ToArray();
+
+            return data;
+        }
+
+        /// <summary>
+        /// Given an archive stream, will assess whether directory needs to be flattened so that the extracted archive files are directly
+        /// under extract path and not nested in subfolders. See <see cref="DirectoryInfoExtensions"/> Flatten method.
+        /// </summary>
+        /// <param name="archive">An opened archive stream</param>
+        /// <returns></returns>
         public bool ArchiveNeedsFlattening(ZipArchive archive)
         {
             // Sometimes ZipArchive will list the directory and others it will just keep it in the FullName
             return archive.Entries.Count > 0 &&
                 !Path.HasExtension(archive.Entries.ElementAt(0).FullName) ||
                 archive.Entries.Any(e => e.FullName.Contains(Path.AltDirectorySeparatorChar));
-            
-            // return archive.Entries.Count > 0 &&
-            //        archive.Entries.Any(e => e.FullName.Contains(Path.AltDirectorySeparatorChar));
-            //return archive.Entries.Count > 0 && !Path.HasExtension(archive.Entries.ElementAt(0).FullName);
         }
 
         /// <summary>

API/Services/ScannerService.cs

@@ -20,12 +20,14 @@ namespace API.Services
     {
        private readonly IUnitOfWork _unitOfWork;
        private readonly ILogger<ScannerService> _logger;
+       private readonly IArchiveService _archiveService;
        private ConcurrentDictionary<string, List<ParserInfo>> _scannedSeries;
 
-       public ScannerService(IUnitOfWork unitOfWork, ILogger<ScannerService> logger)
+       public ScannerService(IUnitOfWork unitOfWork, ILogger<ScannerService> logger, IArchiveService archiveService)
        {
           _unitOfWork = unitOfWork;
           _logger = logger;
+          _archiveService = archiveService;
        }
 
        public void ScanLibraries()
@@ -218,7 +220,7 @@ namespace API.Services
              FilePath = info.FullFilePath,
              Chapter = chapter,
              Format = info.Format,
-             NumberOfPages = info.Format == MangaFormat.Archive ? GetNumberOfPagesFromArchive(info.FullFilePath): 1
+             NumberOfPages = info.Format == MangaFormat.Archive ? _archiveService.GetNumberOfPagesFromArchive(info.FullFilePath): 1
           };
        }
        
@@ -250,7 +252,7 @@ namespace API.Services
                 {
                    existingFile.Chapter = MinimumNumberFromRange(info.Chapters);
                    existingFile.Format = info.Format;
-                   existingFile.NumberOfPages = GetNumberOfPagesFromArchive(info.FullFilePath);
+                   existingFile.NumberOfPages = _archiveService.GetNumberOfPagesFromArchive(info.FullFilePath);
                 }
                 else
                 {
@@ -298,7 +300,7 @@ namespace API.Services
              if (forceUpdate || volume.CoverImage == null || !volume.Files.Any())
              {
                 var firstFile = volume.Files.OrderBy(x => x.Chapter).FirstOrDefault();
-                if (firstFile != null) volume.CoverImage = GetCoverImage(firstFile.FilePath, true); // ZIPFILE
+                if (firstFile != null) volume.CoverImage = _archiveService.GetCoverImage(firstFile.FilePath, true);
              }
 
              volume.Pages = volume.Files.Sum(x => x.NumberOfPages);
@@ -307,105 +309,17 @@ namespace API.Services
           return volumes;
        }
 
-      
+
 
 
        public void ScanSeries(int libraryId, int seriesId)
-        {
+       {
-           throw new NotImplementedException();
+          throw new NotImplementedException();
-        }
+       }
-
-        private int GetNumberOfPagesFromArchive(string archivePath)
-        {
-           if (!File.Exists(archivePath) || !Parser.Parser.IsArchive(archivePath))
-           {
-              _logger.LogError($"Archive {archivePath} could not be found.");
-              return 0;
-           }
-           
-           _logger.LogDebug($"Getting Page numbers from  {archivePath}");
-
-           try
-           {
-              using ZipArchive archive = ZipFile.OpenRead(archivePath); // ZIPFILE
-              return archive.Entries.Count(e => Parser.Parser.IsImage(e.FullName));
-           }
-           catch (Exception ex)
-           {
-              _logger.LogError(ex, "There was an exception when reading archive stream.");
-              return 0;
-           }
-           
-           
-        }
-
-        /// <summary>
-        /// Generates byte array of cover image.
-        /// Given a path to a compressed file (zip, rar, cbz, cbr, etc), will ensure the first image is returned unless
-        /// a folder.extension exists in the root directory of the compressed file.
-        /// </summary>
-        /// <param name="filepath"></param>
-        /// <param name="createThumbnail">Create a smaller variant of file extracted from archive. Archive images are usually 1MB each.</param>
-        /// <returns></returns>
-        public byte[] GetCoverImage(string filepath, bool createThumbnail = false)
-        {
-            try
-            {
-                if (string.IsNullOrEmpty(filepath) || !File.Exists(filepath) || !Parser.Parser.IsArchive(filepath)) return Array.Empty<byte>();
-
-                _logger.LogDebug($"Extracting Cover image from {filepath}");
-                using ZipArchive archive = ZipFile.OpenRead(filepath);
-                if (!archive.HasFiles()) return Array.Empty<byte>();
-
-                var folder = archive.Entries.SingleOrDefault(x => Path.GetFileNameWithoutExtension(x.Name).ToLower() == "folder");
-                var entries = archive.Entries.Where(x => Path.HasExtension(x.FullName) && Parser.Parser.IsImage(x.FullName)).OrderBy(x => x.FullName).ToList();
-                ZipArchiveEntry entry;
-                
-                if (folder != null)
-                {
-                    entry = folder;
-                } else if (!entries.Any())
-                {
-                    return Array.Empty<byte>();
-                }
-                else
-                {
-                    entry = entries[0];
-                }
 
 
-                if (createThumbnail)
-                {
-                    try
-                    {
-                        using var stream = entry.Open();
-                        var thumbnail = Image.ThumbnailStream(stream, 320);
-                        return thumbnail.WriteToBuffer(".jpg");
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "There was a critical error and prevented thumbnail generation.");
-                    }
-                }
-                
-                return ExtractEntryToImage(entry);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "There was an exception when reading archive stream.");
-                return Array.Empty<byte>();
-            }
-        }
-        
-        private static byte[] ExtractEntryToImage(ZipArchiveEntry entry)
-        {
-            using var stream = entry.Open();
-            using var ms = new MemoryStream();
-            stream.CopyTo(ms);
-            var data = ms.ToArray();
 
-            return data;
+       
-        }
 
     }
 }