New: Parse existing subtitles and extra files

Towards #459

src/NzbDrone.Core/Extras/Others/ExistingOtherExtraImporter.cs

@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using NLog;
+using NzbDrone.Common.Extensions;
+using NzbDrone.Core.Extras.Files;
+using NzbDrone.Core.Parser;
+using NzbDrone.Core.Tv;
+
+namespace NzbDrone.Core.Extras.Others
+{
+    public class ExistingOtherExtraImporter : ImportExistingExtraFilesBase<OtherExtraFile>
+    {
+        private readonly IExtraFileService<OtherExtraFile> _otherExtraFileService;
+        private readonly IParsingService _parsingService;
+        private readonly Logger _logger;
+
+        public ExistingOtherExtraImporter(IExtraFileService<OtherExtraFile> otherExtraFileService,
+                                          IParsingService parsingService,
+                                          Logger logger)
+            : base(otherExtraFileService)
+        {
+            _otherExtraFileService = otherExtraFileService;
+            _parsingService = parsingService;
+            _logger = logger;
+        }
+
+        public override int Order
+        {
+            get
+            {
+                return 2;
+            }
+        }
+
+        public override IEnumerable<ExtraFile> ProcessFiles(Series series, List<string> filesOnDisk, List<string> importedFiles)
+        {
+            _logger.Debug("Looking for existing extra files in {0}", series.Path);
+
+            var extraFiles = new List<OtherExtraFile>();
+            var filteredFiles = FilterAndClean(series, filesOnDisk, importedFiles);
+
+            foreach (var possibleExtraFile in filteredFiles)
+            {
+                var localEpisode = _parsingService.GetLocalEpisode(possibleExtraFile, series);
+
+                if (localEpisode == null)
+                {
+                    _logger.Debug("Unable to parse extra file: {0}", possibleExtraFile);
+                    continue;
+                }
+
+                if (localEpisode.Episodes.Empty())
+                {
+                    _logger.Debug("Cannot find related episodes for: {0}", possibleExtraFile);
+                    continue;
+                }
+
+                if (localEpisode.Episodes.DistinctBy(e => e.EpisodeFileId).Count() > 1)
+                {
+                    _logger.Debug("Extra file: {0} does not match existing files.", possibleExtraFile);
+                    continue;
+                }
+
+                var extraFile = new OtherExtraFile
+                {
+                    SeriesId = series.Id,
+                    SeasonNumber = localEpisode.SeasonNumber,
+                    EpisodeFileId = localEpisode.Episodes.First().EpisodeFileId,
+                    RelativePath = series.Path.GetRelativePath(possibleExtraFile),
+                    Extension = Path.GetExtension(possibleExtraFile)
+                };
+
+                extraFiles.Add(extraFile);
+            }
+
+            _logger.Info("Found {0} existing other extra files", extraFiles.Count);
+            _otherExtraFileService.Upsert(extraFiles);
+
+            return extraFiles;
+        }
+    }
+}

src/NzbDrone.Core/Extras/Others/OtherExtraFile.cs

@@ -0,0 +1,8 @@
+using NzbDrone.Core.Extras.Files;
+
+namespace NzbDrone.Core.Extras.Others
+{
+    public class OtherExtraFile : ExtraFile
+    {
+    }
+}

src/NzbDrone.Core/Extras/Others/OtherExtraFileRepository.cs

@@ -0,0 +1,18 @@
+using NzbDrone.Core.Datastore;
+using NzbDrone.Core.Extras.Files;
+using NzbDrone.Core.Messaging.Events;
+
+namespace NzbDrone.Core.Extras.Others
+{
+    public interface IOtherExtraFileRepository : IExtraFileRepository<OtherExtraFile>
+    {
+    }
+
+    public class OtherExtraFileRepository : ExtraFileRepository<OtherExtraFile>, IOtherExtraFileRepository
+    {
+        public OtherExtraFileRepository(IMainDatabase database, IEventAggregator eventAggregator)
+            : base(database, eventAggregator)
+        {
+        }
+    }
+}

src/NzbDrone.Core/Extras/Others/OtherExtraFileService.cs

@@ -0,0 +1,19 @@
+using NLog;
+using NzbDrone.Common.Disk;
+using NzbDrone.Core.Extras.Files;
+using NzbDrone.Core.Tv;
+
+namespace NzbDrone.Core.Extras.Others
+{
+    public interface IOtherExtraFileService : IExtraFileService<OtherExtraFile>
+    {
+    }
+
+    public class OtherExtraFileService : ExtraFileService<OtherExtraFile>, IOtherExtraFileService
+    {
+        public OtherExtraFileService(IExtraFileRepository<OtherExtraFile> repository, ISeriesService seriesService, IDiskProvider diskProvider, Logger logger)
+            : base(repository, seriesService, diskProvider, logger)
+        {
+        }
+    }
+}

src/NzbDrone.Core/Extras/Others/OtherExtraService.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using NLog;
+using NzbDrone.Common.Disk;
+using NzbDrone.Common.Extensions;
+using NzbDrone.Core.Configuration;
+using NzbDrone.Core.Extras.Files;
+using NzbDrone.Core.MediaFiles;
+using NzbDrone.Core.Tv;
+
+namespace NzbDrone.Core.Extras.Others
+{
+    public class OtherExtraService : ExtraFileManager<OtherExtraFile>
+    {
+        private readonly IOtherExtraFileService _otherExtraFileService;
+        private readonly IDiskProvider _diskProvider;
+        private readonly Logger _logger;
+
+        public OtherExtraService(IConfigService configService,
+                                 IDiskTransferService diskTransferService,
+                                 IOtherExtraFileService otherExtraFileService,
+                                 IDiskProvider diskProvider,
+                                 Logger logger)
+            : base(configService, diskTransferService, otherExtraFileService)
+        {
+            _otherExtraFileService = otherExtraFileService;
+            _diskProvider = diskProvider;
+            _logger = logger;
+        }
+
+        public override int Order
+        {
+            get
+            {
+                return 2;
+            }
+        }
+
+        public override IEnumerable<ExtraFile> CreateAfterSeriesScan(Series series, List<EpisodeFile> episodeFiles)
+        {
+            return Enumerable.Empty<ExtraFile>();
+        }
+
+        public override IEnumerable<ExtraFile> CreateAfterEpisodeImport(Series series, EpisodeFile episodeFile)
+        {
+            return Enumerable.Empty<ExtraFile>();
+        }
+
+        public override IEnumerable<ExtraFile> CreateAfterEpisodeImport(Series series, string seriesFolder, string seasonFolder)
+        {
+            return Enumerable.Empty<ExtraFile>();
+        }
+
+        public override IEnumerable<ExtraFile> MoveFilesAfterRename(Series series, List<EpisodeFile> episodeFiles)
+        {
+            // TODO: Remove
+            // We don't want to move files after rename yet.
+
+            return Enumerable.Empty<ExtraFile>();
+
+            var extraFiles = _otherExtraFileService.GetFilesBySeries(series.Id);
+            var movedFiles = new List<OtherExtraFile>();
+
+            foreach (var episodeFile in episodeFiles)
+            {
+                var extraFilesForEpisodeFile = extraFiles.Where(m => m.EpisodeFileId == episodeFile.Id).ToList();
+
+                foreach (var extraFile in extraFilesForEpisodeFile)
+                {
+                    var existingFileName = Path.Combine(series.Path, extraFile.RelativePath);
+                    var extension = Path.GetExtension(existingFileName).TrimStart('.');
+                    var newFileName = Path.ChangeExtension(Path.Combine(series.Path, episodeFile.RelativePath), extension);
+
+                    if (newFileName.PathNotEquals(existingFileName))
+                    {
+                        try
+                        {
+                            _diskProvider.MoveFile(existingFileName, newFileName);
+                            extraFile.RelativePath = series.Path.GetRelativePath(newFileName);
+                            movedFiles.Add(extraFile);
+                        }
+                        catch (Exception ex)
+                        {
+                            _logger.Warn(ex, "Unable to move extra file: {0}", existingFileName);
+                        }
+                    }
+                }
+            }
+
+            _otherExtraFileService.Upsert(movedFiles);
+
+            return movedFiles;
+        }
+
+        public override ExtraFile Import(Series series, EpisodeFile episodeFile, string path, string extension, bool readOnly)
+        {
+            // If the extension is .nfo we need to change it to .nfo-orig
+            if (Path.GetExtension(path).Equals(".nfo"))
+            {
+                extension += "-orig";
+            }
+
+            var extraFile = ImportFile(series, episodeFile, path, extension, readOnly);
+
+            _otherExtraFileService.Upsert(extraFile);
+
+            return extraFile;
+        }
+    }
+}