diff options
Diffstat (limited to 'Emby.Server.Implementations/FileOrganization')
7 files changed, 1622 insertions, 0 deletions
diff --git a/Emby.Server.Implementations/FileOrganization/EpisodeFileOrganizer.cs b/Emby.Server.Implementations/FileOrganization/EpisodeFileOrganizer.cs new file mode 100644 index 000000000..3f4ede478 --- /dev/null +++ b/Emby.Server.Implementations/FileOrganization/EpisodeFileOrganizer.cs @@ -0,0 +1,834 @@ +using MediaBrowser.Controller.Configuration; +using MediaBrowser.Controller.Entities.TV; +using MediaBrowser.Controller.FileOrganization; +using MediaBrowser.Controller.Library; +using MediaBrowser.Controller.Providers; +using MediaBrowser.Model.Entities; +using MediaBrowser.Model.Extensions; +using MediaBrowser.Model.FileOrganization; +using MediaBrowser.Model.Logging; +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using Emby.Server.Implementations.Library; +using Emby.Server.Implementations.Logging; +using MediaBrowser.Common.IO; +using MediaBrowser.Controller.Entities; +using MediaBrowser.Controller.IO; +using MediaBrowser.Model.IO; +using MediaBrowser.Naming.TV; +using EpisodeInfo = MediaBrowser.Controller.Providers.EpisodeInfo; + +namespace Emby.Server.Implementations.FileOrganization +{ + public class EpisodeFileOrganizer + { + private readonly ILibraryMonitor _libraryMonitor; + private readonly ILibraryManager _libraryManager; + private readonly ILogger _logger; + private readonly IFileSystem _fileSystem; + private readonly IFileOrganizationService _organizationService; + private readonly IServerConfigurationManager _config; + private readonly IProviderManager _providerManager; + + private readonly CultureInfo _usCulture = new CultureInfo("en-US"); + + public EpisodeFileOrganizer(IFileOrganizationService organizationService, IServerConfigurationManager config, IFileSystem fileSystem, ILogger logger, ILibraryManager libraryManager, ILibraryMonitor libraryMonitor, IProviderManager providerManager) + { + _organizationService = organizationService; + _config = config; + _fileSystem = fileSystem; + _logger = logger; + _libraryManager = libraryManager; + _libraryMonitor = libraryMonitor; + _providerManager = providerManager; + } + + public async Task<FileOrganizationResult> OrganizeEpisodeFile(string path, AutoOrganizeOptions options, bool overwriteExisting, CancellationToken cancellationToken) + { + _logger.Info("Sorting file {0}", path); + + var result = new FileOrganizationResult + { + Date = DateTime.UtcNow, + OriginalPath = path, + OriginalFileName = Path.GetFileName(path), + Type = FileOrganizerType.Episode, + FileSize = _fileSystem.GetFileInfo(path).Length + }; + + try + { + if (_libraryMonitor.IsPathLocked(path)) + { + result.Status = FileSortingStatus.Failure; + result.StatusMessage = "Path is locked by other processes. Please try again later."; + return result; + } + + var namingOptions = ((LibraryManager)_libraryManager).GetNamingOptions(); + var resolver = new EpisodeResolver(namingOptions, new PatternsLogger()); + + var episodeInfo = resolver.Resolve(path, false) ?? + new MediaBrowser.Naming.TV.EpisodeInfo(); + + var seriesName = episodeInfo.SeriesName; + + if (!string.IsNullOrEmpty(seriesName)) + { + var seasonNumber = episodeInfo.SeasonNumber; + + result.ExtractedSeasonNumber = seasonNumber; + + // Passing in true will include a few extra regex's + var episodeNumber = episodeInfo.EpisodeNumber; + + result.ExtractedEpisodeNumber = episodeNumber; + + var premiereDate = episodeInfo.IsByDate ? + new DateTime(episodeInfo.Year.Value, episodeInfo.Month.Value, episodeInfo.Day.Value) : + (DateTime?)null; + + if (episodeInfo.IsByDate || (seasonNumber.HasValue && episodeNumber.HasValue)) + { + if (episodeInfo.IsByDate) + { + _logger.Debug("Extracted information from {0}. Series name {1}, Date {2}", path, seriesName, premiereDate.Value); + } + else + { + _logger.Debug("Extracted information from {0}. Series name {1}, Season {2}, Episode {3}", path, seriesName, seasonNumber, episodeNumber); + } + + var endingEpisodeNumber = episodeInfo.EndingEpsiodeNumber; + + result.ExtractedEndingEpisodeNumber = endingEpisodeNumber; + + await OrganizeEpisode(path, + seriesName, + seasonNumber, + episodeNumber, + endingEpisodeNumber, + premiereDate, + options, + overwriteExisting, + false, + result, + cancellationToken).ConfigureAwait(false); + } + else + { + var msg = string.Format("Unable to determine episode number from {0}", path); + result.Status = FileSortingStatus.Failure; + result.StatusMessage = msg; + _logger.Warn(msg); + } + } + else + { + var msg = string.Format("Unable to determine series name from {0}", path); + result.Status = FileSortingStatus.Failure; + result.StatusMessage = msg; + _logger.Warn(msg); + } + + var previousResult = _organizationService.GetResultBySourcePath(path); + + if (previousResult != null) + { + // Don't keep saving the same result over and over if nothing has changed + if (previousResult.Status == result.Status && previousResult.StatusMessage == result.StatusMessage && result.Status != FileSortingStatus.Success) + { + return previousResult; + } + } + + await _organizationService.SaveResult(result, CancellationToken.None).ConfigureAwait(false); + } + catch (Exception ex) + { + result.Status = FileSortingStatus.Failure; + result.StatusMessage = ex.Message; + } + + return result; + } + + public async Task<FileOrganizationResult> OrganizeWithCorrection(EpisodeFileOrganizationRequest request, AutoOrganizeOptions options, CancellationToken cancellationToken) + { + var result = _organizationService.GetResult(request.ResultId); + + try + { + Series series = null; + + if (request.NewSeriesProviderIds.Count > 0) + { + // We're having a new series here + SeriesInfo seriesRequest = new SeriesInfo(); + seriesRequest.ProviderIds = request.NewSeriesProviderIds; + + var refreshOptions = new MetadataRefreshOptions(_fileSystem); + series = new Series(); + series.Id = Guid.NewGuid(); + series.Name = request.NewSeriesName; + + int year; + if (int.TryParse(request.NewSeriesYear, out year)) + { + series.ProductionYear = year; + } + + var seriesFolderName = series.Name; + if (series.ProductionYear.HasValue) + { + seriesFolderName = string.Format("{0} ({1})", seriesFolderName, series.ProductionYear); + } + + series.Path = Path.Combine(request.TargetFolder, seriesFolderName); + + series.ProviderIds = request.NewSeriesProviderIds; + + await series.RefreshMetadata(refreshOptions, cancellationToken); + } + + if (series == null) + { + // Existing Series + series = (Series)_libraryManager.GetItemById(new Guid(request.SeriesId)); + } + + await OrganizeEpisode(result.OriginalPath, + series, + request.SeasonNumber, + request.EpisodeNumber, + request.EndingEpisodeNumber, + null, + options, + true, + request.RememberCorrection, + result, + cancellationToken).ConfigureAwait(false); + + await _organizationService.SaveResult(result, CancellationToken.None).ConfigureAwait(false); + } + catch (Exception ex) + { + result.Status = FileSortingStatus.Failure; + result.StatusMessage = ex.Message; + } + + return result; + } + + private Task OrganizeEpisode(string sourcePath, + string seriesName, + int? seasonNumber, + int? episodeNumber, + int? endingEpiosdeNumber, + DateTime? premiereDate, + AutoOrganizeOptions options, + bool overwriteExisting, + bool rememberCorrection, + FileOrganizationResult result, + CancellationToken cancellationToken) + { + var series = GetMatchingSeries(seriesName, result, options); + + if (series == null) + { + var msg = string.Format("Unable to find series in library matching name {0}", seriesName); + result.Status = FileSortingStatus.Failure; + result.StatusMessage = msg; + _logger.Warn(msg); + return Task.FromResult(true); + } + + return OrganizeEpisode(sourcePath, + series, + seasonNumber, + episodeNumber, + endingEpiosdeNumber, + premiereDate, + options, + overwriteExisting, + rememberCorrection, + result, + cancellationToken); + } + + private async Task OrganizeEpisode(string sourcePath, + Series series, + int? seasonNumber, + int? episodeNumber, + int? endingEpiosdeNumber, + DateTime? premiereDate, + AutoOrganizeOptions options, + bool overwriteExisting, + bool rememberCorrection, + FileOrganizationResult result, + CancellationToken cancellationToken) + { + _logger.Info("Sorting file {0} into series {1}", sourcePath, series.Path); + + var originalExtractedSeriesString = result.ExtractedName; + + bool isNew = string.IsNullOrWhiteSpace(result.Id); + + if (isNew) + { + await _organizationService.SaveResult(result, cancellationToken); + } + + if (!_organizationService.AddToInProgressList(result, isNew)) + { + throw new Exception("File is currently processed otherwise. Please try again later."); + } + + try + { + // Proceed to sort the file + var newPath = await GetNewPath(sourcePath, series, seasonNumber, episodeNumber, endingEpiosdeNumber, premiereDate, options.TvOptions, cancellationToken).ConfigureAwait(false); + + if (string.IsNullOrEmpty(newPath)) + { + var msg = string.Format("Unable to sort {0} because target path could not be determined.", sourcePath); + throw new Exception(msg); + } + + _logger.Info("Sorting file {0} to new path {1}", sourcePath, newPath); + result.TargetPath = newPath; + + var fileExists = _fileSystem.FileExists(result.TargetPath); + var otherDuplicatePaths = GetOtherDuplicatePaths(result.TargetPath, series, seasonNumber, episodeNumber, endingEpiosdeNumber); + + if (!overwriteExisting) + { + if (options.TvOptions.CopyOriginalFile && fileExists && IsSameEpisode(sourcePath, newPath)) + { + var msg = string.Format("File '{0}' already copied to new path '{1}', stopping organization", sourcePath, newPath); + _logger.Info(msg); + result.Status = FileSortingStatus.SkippedExisting; + result.StatusMessage = msg; + return; + } + + if (fileExists) + { + var msg = string.Format("File '{0}' already exists as '{1}', stopping organization", sourcePath, newPath); + _logger.Info(msg); + result.Status = FileSortingStatus.SkippedExisting; + result.StatusMessage = msg; + result.TargetPath = newPath; + return; + } + + if (otherDuplicatePaths.Count > 0) + { + var msg = string.Format("File '{0}' already exists as these:'{1}'. Stopping organization", sourcePath, string.Join("', '", otherDuplicatePaths)); + _logger.Info(msg); + result.Status = FileSortingStatus.SkippedExisting; + result.StatusMessage = msg; + result.DuplicatePaths = otherDuplicatePaths; + return; + } + } + + PerformFileSorting(options.TvOptions, result); + + if (overwriteExisting) + { + var hasRenamedFiles = false; + + foreach (var path in otherDuplicatePaths) + { + _logger.Debug("Removing duplicate episode {0}", path); + + _libraryMonitor.ReportFileSystemChangeBeginning(path); + + var renameRelatedFiles = !hasRenamedFiles && + string.Equals(Path.GetDirectoryName(path), Path.GetDirectoryName(result.TargetPath), StringComparison.OrdinalIgnoreCase); + + if (renameRelatedFiles) + { + hasRenamedFiles = true; + } + + try + { + DeleteLibraryFile(path, renameRelatedFiles, result.TargetPath); + } + catch (IOException ex) + { + _logger.ErrorException("Error removing duplicate episode", ex, path); + } + finally + { + _libraryMonitor.ReportFileSystemChangeComplete(path, true); + } + } + } + } + catch (Exception ex) + { + result.Status = FileSortingStatus.Failure; + result.StatusMessage = ex.Message; + _logger.Warn(ex.Message); + return; + } + finally + { + _organizationService.RemoveFromInprogressList(result); + } + + if (rememberCorrection) + { + SaveSmartMatchString(originalExtractedSeriesString, series, options); + } + } + + private void SaveSmartMatchString(string matchString, Series series, AutoOrganizeOptions options) + { + if (string.IsNullOrEmpty(matchString) || matchString.Length < 3) + { + return; + } + + SmartMatchInfo info = options.SmartMatchInfos.FirstOrDefault(i => string.Equals(i.ItemName, series.Name, StringComparison.OrdinalIgnoreCase)); + + if (info == null) + { + info = new SmartMatchInfo(); + info.ItemName = series.Name; + info.OrganizerType = FileOrganizerType.Episode; + info.DisplayName = series.Name; + var list = options.SmartMatchInfos.ToList(); + list.Add(info); + options.SmartMatchInfos = list.ToArray(); + } + + if (!info.MatchStrings.Contains(matchString, StringComparer.OrdinalIgnoreCase)) + { + var list = info.MatchStrings.ToList(); + list.Add(matchString); + info.MatchStrings = list.ToArray(); + _config.SaveAutoOrganizeOptions(options); + } + } + + private void DeleteLibraryFile(string path, bool renameRelatedFiles, string targetPath) + { + _fileSystem.DeleteFile(path); + + if (!renameRelatedFiles) + { + return; + } + + // Now find other files + var originalFilenameWithoutExtension = Path.GetFileNameWithoutExtension(path); + var directory = Path.GetDirectoryName(path); + + if (!string.IsNullOrWhiteSpace(originalFilenameWithoutExtension) && !string.IsNullOrWhiteSpace(directory)) + { + // Get all related files, e.g. metadata, images, etc + var files = _fileSystem.GetFilePaths(directory) + .Where(i => (Path.GetFileNameWithoutExtension(i) ?? string.Empty).StartsWith(originalFilenameWithoutExtension, StringComparison.OrdinalIgnoreCase)) + .ToList(); + + var targetFilenameWithoutExtension = Path.GetFileNameWithoutExtension(targetPath); + + foreach (var file in files) + { + directory = Path.GetDirectoryName(file); + var filename = Path.GetFileName(file); + + filename = filename.Replace(originalFilenameWithoutExtension, targetFilenameWithoutExtension, + StringComparison.OrdinalIgnoreCase); + + var destination = Path.Combine(directory, filename); + + _fileSystem.MoveFile(file, destination); + } + } + } + + private List<string> GetOtherDuplicatePaths(string targetPath, + Series series, + int? seasonNumber, + int? episodeNumber, + int? endingEpisodeNumber) + { + // TODO: Support date-naming? + if (!seasonNumber.HasValue || !episodeNumber.HasValue) + { + return new List<string>(); + } + + var episodePaths = series.GetRecursiveChildren() + .OfType<Episode>() + .Where(i => + { + var locationType = i.LocationType; + + // Must be file system based and match exactly + if (locationType != LocationType.Remote && + locationType != LocationType.Virtual && + i.ParentIndexNumber.HasValue && + i.ParentIndexNumber.Value == seasonNumber && + i.IndexNumber.HasValue && + i.IndexNumber.Value == episodeNumber) + { + + if (endingEpisodeNumber.HasValue || i.IndexNumberEnd.HasValue) + { + return endingEpisodeNumber.HasValue && i.IndexNumberEnd.HasValue && + endingEpisodeNumber.Value == i.IndexNumberEnd.Value; + } + + return true; + } + + return false; + }) + .Select(i => i.Path) + .ToList(); + + var folder = Path.GetDirectoryName(targetPath); + var targetFileNameWithoutExtension = _fileSystem.GetFileNameWithoutExtension(targetPath); + + try + { + var filesOfOtherExtensions = _fileSystem.GetFilePaths(folder) + .Where(i => _libraryManager.IsVideoFile(i) && string.Equals(_fileSystem.GetFileNameWithoutExtension(i), targetFileNameWithoutExtension, StringComparison.OrdinalIgnoreCase)); + + episodePaths.AddRange(filesOfOtherExtensions); + } + catch (IOException) + { + // No big deal. Maybe the season folder doesn't already exist. + } + + return episodePaths.Where(i => !string.Equals(i, targetPath, StringComparison.OrdinalIgnoreCase)) + .Distinct(StringComparer.OrdinalIgnoreCase) + .ToList(); + } + + private void PerformFileSorting(TvFileOrganizationOptions options, FileOrganizationResult result) + { + _libraryMonitor.ReportFileSystemChangeBeginning(result.TargetPath); + + _fileSystem.CreateDirectory(Path.GetDirectoryName(result.TargetPath)); + + var targetAlreadyExists = _fileSystem.FileExists(result.TargetPath); + + try + { + if (targetAlreadyExists || options.CopyOriginalFile) + { + _fileSystem.CopyFile(result.OriginalPath, result.TargetPath, true); + } + else + { + _fileSystem.MoveFile(result.OriginalPath, result.TargetPath); + } + + result.Status = FileSortingStatus.Success; + result.StatusMessage = string.Empty; + } + catch (Exception ex) + { + var errorMsg = string.Format("Failed to move file from {0} to {1}: {2}", result.OriginalPath, result.TargetPath, ex.Message); + + result.Status = FileSortingStatus.Failure; + result.StatusMessage = errorMsg; + _logger.ErrorException(errorMsg, ex); + + return; + } + finally + { + _libraryMonitor.ReportFileSystemChangeComplete(result.TargetPath, true); + } + + if (targetAlreadyExists && !options.CopyOriginalFile) + { + try + { + _fileSystem.DeleteFile(result.OriginalPath); + } + catch (Exception ex) + { + _logger.ErrorException("Error deleting {0}", ex, result.OriginalPath); + } + } + } + + private Series GetMatchingSeries(string seriesName, FileOrganizationResult result, AutoOrganizeOptions options) + { + var parsedName = _libraryManager.ParseName(seriesName); + + var yearInName = parsedName.Year; + var nameWithoutYear = parsedName.Name; + + result.ExtractedName = nameWithoutYear; + result.ExtractedYear = yearInName; + + var series = _libraryManager.GetItemList(new InternalItemsQuery + { + IncludeItemTypes = new[] { typeof(Series).Name }, + Recursive = true + }) + .Cast<Series>() + .Select(i => NameUtils.GetMatchScore(nameWithoutYear, yearInName, i)) + .Where(i => i.Item2 > 0) + .OrderByDescending(i => i.Item2) + .Select(i => i.Item1) + .FirstOrDefault(); + + if (series == null) + { + SmartMatchInfo info = options.SmartMatchInfos.FirstOrDefault(e => e.MatchStrings.Contains(nameWithoutYear, StringComparer.OrdinalIgnoreCase)); + + if (info != null) + { + series = _libraryManager.GetItemList(new InternalItemsQuery + { + IncludeItemTypes = new[] { typeof(Series).Name }, + Recursive = true, + Name = info.ItemName + + }).Cast<Series>().FirstOrDefault(); + } + } + + return series; + } + + /// <summary> + /// Gets the new path. + /// </summary> + /// <param name="sourcePath">The source path.</param> + /// <param name="series">The series.</param> + /// <param name="seasonNumber">The season number.</param> + /// <param name="episodeNumber">The episode number.</param> + /// <param name="endingEpisodeNumber">The ending episode number.</param> + /// <param name="premiereDate">The premiere date.</param> + /// <param name="options">The options.</param> + /// <param name="cancellationToken">The cancellation token.</param> + /// <returns>System.String.</returns> + private async Task<string> GetNewPath(string sourcePath, + Series series, + int? seasonNumber, + int? episodeNumber, + int? endingEpisodeNumber, + DateTime? premiereDate, + TvFileOrganizationOptions options, + CancellationToken cancellationToken) + { + var episodeInfo = new EpisodeInfo + { + IndexNumber = episodeNumber, + IndexNumberEnd = endingEpisodeNumber, + MetadataCountryCode = series.GetPreferredMetadataCountryCode(), + MetadataLanguage = series.GetPreferredMetadataLanguage(), + ParentIndexNumber = seasonNumber, + SeriesProviderIds = series.ProviderIds, + PremiereDate = premiereDate + }; + + var searchResults = await _providerManager.GetRemoteSearchResults<Episode, EpisodeInfo>(new RemoteSearchQuery<EpisodeInfo> + { + SearchInfo = episodeInfo + + }, cancellationToken).ConfigureAwait(false); + + var episode = searchResults.FirstOrDefault(); + + if (episode == null) + { + var msg = string.Format("No provider metadata found for {0} season {1} episode {2}", series.Name, seasonNumber, episodeNumber); + _logger.Warn(msg); + throw new Exception(msg); + } + + var episodeName = episode.Name; + + //if (string.IsNullOrWhiteSpace(episodeName)) + //{ + // var msg = string.Format("No provider metadata found for {0} season {1} episode {2}", series.Name, seasonNumber, episodeNumber); + // _logger.Warn(msg); + // return null; + //} + + seasonNumber = seasonNumber ?? episode.ParentIndexNumber; + episodeNumber = episodeNumber ?? episode.IndexNumber; + + var newPath = GetSeasonFolderPath(series, seasonNumber.Value, options); + + // MAX_PATH - trailing <NULL> charachter - drive component: 260 - 1 - 3 = 256 + // Usually newPath would include the drive component, but use 256 to be sure + var maxFilenameLength = 256 - newPath.Length; + + if (!newPath.EndsWith(@"\")) + { + // Remove 1 for missing backslash combining path and filename + maxFilenameLength--; + } + + // Remove additional 4 chars to prevent PathTooLongException for downloaded subtitles (eg. filename.ext.eng.srt) + maxFilenameLength -= 4; + + var episodeFileName = GetEpisodeFileName(sourcePath, series.Name, seasonNumber.Value, episodeNumber.Value, endingEpisodeNumber, episodeName, options, maxFilenameLength); + + if (string.IsNullOrEmpty(episodeFileName)) + { + // cause failure + return string.Empty; + } + + newPath = Path.Combine(newPath, episodeFileName); + + return newPath; + } + + /// <summary> + /// Gets the season folder path. + /// </summary> + /// <param name="series">The series.</param> + /// <param name="seasonNumber">The season number.</param> + /// <param name="options">The options.</param> + /// <returns>System.String.</returns> + private string GetSeasonFolderPath(Series series, int seasonNumber, TvFileOrganizationOptions options) + { + // If there's already a season folder, use that + var season = series + .GetRecursiveChildren(i => i is Season && i.LocationType == LocationType.FileSystem && i.IndexNumber.HasValue && i.IndexNumber.Value == seasonNumber) + .FirstOrDefault(); + + if (season != null) + { + return season.Path; + } + + var path = series.Path; + + if (series.ContainsEpisodesWithoutSeasonFolders) + { + return path; + } + + if (seasonNumber == 0) + { + return Path.Combine(path, _fileSystem.GetValidFilename(options.SeasonZeroFolderName)); + } + + var seasonFolderName = options.SeasonFolderPattern + .Replace("%s", seasonNumber.ToString(_usCulture)) + .Replace("%0s", seasonNumber.ToString("00", _usCulture)) + .Replace("%00s", seasonNumber.ToString("000", _usCulture)); + + return Path.Combine(path, _fileSystem.GetValidFilename(seasonFolderName)); + } + + private string GetEpisodeFileName(string sourcePath, string seriesName, int seasonNumber, int episodeNumber, int? endingEpisodeNumber, string episodeTitle, TvFileOrganizationOptions options, int? maxLength) + { + seriesName = _fileSystem.GetValidFilename(seriesName).Trim(); + + if (string.IsNullOrWhiteSpace(episodeTitle)) + { + episodeTitle = string.Empty; + } + else + { + episodeTitle = _fileSystem.GetValidFilename(episodeTitle).Trim(); + } + + var sourceExtension = (Path.GetExtension(sourcePath) ?? string.Empty).TrimStart('.'); + + var pattern = endingEpisodeNumber.HasValue ? options.MultiEpisodeNamePattern : options.EpisodeNamePattern; + + if (string.IsNullOrWhiteSpace(pattern)) + { + throw new Exception("GetEpisodeFileName: Configured episode name pattern is empty!"); + } + + var result = pattern.Replace("%sn", seriesName) + .Replace("%s.n", seriesName.Replace(" ", ".")) + .Replace("%s_n", seriesName.Replace(" ", "_")) + .Replace("%s", seasonNumber.ToString(_usCulture)) + .Replace("%0s", seasonNumber.ToString("00", _usCulture)) + .Replace("%00s", seasonNumber.ToString("000", _usCulture)) + .Replace("%ext", sourceExtension) + .Replace("%en", "%#1") + .Replace("%e.n", "%#2") + .Replace("%e_n", "%#3"); + + if (endingEpisodeNumber.HasValue) + { + result = result.Replace("%ed", endingEpisodeNumber.Value.ToString(_usCulture)) + .Replace("%0ed", endingEpisodeNumber.Value.ToString("00", _usCulture)) + .Replace("%00ed", endingEpisodeNumber.Value.ToString("000", _usCulture)); + } + + result = result.Replace("%e", episodeNumber.ToString(_usCulture)) + .Replace("%0e", episodeNumber.ToString("00", _usCulture)) + .Replace("%00e", episodeNumber.ToString("000", _usCulture)); + + if (maxLength.HasValue && result.Contains("%#")) + { + // Substract 3 for the temp token length (%#1, %#2 or %#3) + int maxRemainingTitleLength = maxLength.Value - result.Length + 3; + string shortenedEpisodeTitle = string.Empty; + + if (maxRemainingTitleLength > 5) + { + // A title with fewer than 5 letters wouldn't be of much value + shortenedEpisodeTitle = episodeTitle.Substring(0, Math.Min(maxRemainingTitleLength, episodeTitle.Length)); + } + + result = result.Replace("%#1", shortenedEpisodeTitle) + .Replace("%#2", shortenedEpisodeTitle.Replace(" ", ".")) + .Replace("%#3", shortenedEpisodeTitle.Replace(" ", "_")); + } + + if (maxLength.HasValue && result.Length > maxLength.Value) + { + // There may be cases where reducing the title length may still not be sufficient to + // stay below maxLength + var msg = string.Format("Unable to generate an episode file name shorter than {0} characters to constrain to the max path limit", maxLength); + throw new Exception(msg); + } + + return result; + } + + private bool IsSameEpisode(string sourcePath, string newPath) + { + try + { + var sourceFileInfo = _fileSystem.GetFileInfo(sourcePath); + var destinationFileInfo = _fileSystem.GetFileInfo(newPath); + + if (sourceFileInfo.Length == destinationFileInfo.Length) + { + return true; + } + } + catch (FileNotFoundException) + { + return false; + } + catch (IOException) + { + return false; + } + + return false; + } + } +} diff --git a/Emby.Server.Implementations/FileOrganization/Extensions.cs b/Emby.Server.Implementations/FileOrganization/Extensions.cs new file mode 100644 index 000000000..506bc0327 --- /dev/null +++ b/Emby.Server.Implementations/FileOrganization/Extensions.cs @@ -0,0 +1,33 @@ +using MediaBrowser.Common.Configuration; +using MediaBrowser.Model.FileOrganization; +using System.Collections.Generic; + +namespace Emby.Server.Implementations.FileOrganization +{ + public static class ConfigurationExtension + { + public static AutoOrganizeOptions GetAutoOrganizeOptions(this IConfigurationManager manager) + { + return manager.GetConfiguration<AutoOrganizeOptions>("autoorganize"); + } + public static void SaveAutoOrganizeOptions(this IConfigurationManager manager, AutoOrganizeOptions options) + { + manager.SaveConfiguration("autoorganize", options); + } + } + + public class AutoOrganizeOptionsFactory : IConfigurationFactory + { + public IEnumerable<ConfigurationStore> GetConfigurations() + { + return new List<ConfigurationStore> + { + new ConfigurationStore + { + Key = "autoorganize", + ConfigurationType = typeof (AutoOrganizeOptions) + } + }; + } + } +} diff --git a/Emby.Server.Implementations/FileOrganization/FileOrganizationNotifier.cs b/Emby.Server.Implementations/FileOrganization/FileOrganizationNotifier.cs new file mode 100644 index 000000000..2a0176547 --- /dev/null +++ b/Emby.Server.Implementations/FileOrganization/FileOrganizationNotifier.cs @@ -0,0 +1,80 @@ +using MediaBrowser.Controller.FileOrganization; +using MediaBrowser.Controller.Plugins; +using MediaBrowser.Controller.Session; +using MediaBrowser.Model.Events; +using MediaBrowser.Model.FileOrganization; +using MediaBrowser.Model.Logging; +using System; +using System.Threading; +using MediaBrowser.Model.Tasks; + +namespace Emby.Server.Implementations.FileOrganization +{ + /// <summary> + /// Class SessionInfoWebSocketListener + /// </summary> + class FileOrganizationNotifier : IServerEntryPoint + { + private readonly IFileOrganizationService _organizationService; + private readonly ISessionManager _sessionManager; + private readonly ITaskManager _taskManager; + + public FileOrganizationNotifier(ILogger logger, IFileOrganizationService organizationService, ISessionManager sessionManager, ITaskManager taskManager) + { + _organizationService = organizationService; + _sessionManager = sessionManager; + _taskManager = taskManager; + } + + public void Run() + { + _organizationService.ItemAdded += _organizationService_ItemAdded; + _organizationService.ItemRemoved += _organizationService_ItemRemoved; + _organizationService.ItemUpdated += _organizationService_ItemUpdated; + _organizationService.LogReset += _organizationService_LogReset; + + //_taskManager.TaskCompleted += _taskManager_TaskCompleted; + } + + private void _organizationService_LogReset(object sender, EventArgs e) + { + _sessionManager.SendMessageToAdminSessions("AutoOrganize_LogReset", (FileOrganizationResult)null, CancellationToken.None); + } + + private void _organizationService_ItemUpdated(object sender, GenericEventArgs<FileOrganizationResult> e) + { + _sessionManager.SendMessageToAdminSessions("AutoOrganize_ItemUpdated", e.Argument, CancellationToken.None); + } + + private void _organizationService_ItemRemoved(object sender, GenericEventArgs<FileOrganizationResult> e) + { + _sessionManager.SendMessageToAdminSessions("AutoOrganize_ItemRemoved", e.Argument, CancellationToken.None); + } + + private void _organizationService_ItemAdded(object sender, GenericEventArgs<FileOrganizationResult> e) + { + _sessionManager.SendMessageToAdminSessions("AutoOrganize_ItemAdded", e.Argument, CancellationToken.None); + } + + //private void _taskManager_TaskCompleted(object sender, TaskCompletionEventArgs e) + //{ + // var taskWithKey = e.Task.ScheduledTask as IHasKey; + // if (taskWithKey != null && taskWithKey.Key == "AutoOrganize") + // { + // _sessionManager.SendMessageToAdminSessions("AutoOrganize_TaskCompleted", (FileOrganizationResult)null, CancellationToken.None); + // } + //} + + public void Dispose() + { + _organizationService.ItemAdded -= _organizationService_ItemAdded; + _organizationService.ItemRemoved -= _organizationService_ItemRemoved; + _organizationService.ItemUpdated -= _organizationService_ItemUpdated; + _organizationService.LogReset -= _organizationService_LogReset; + + //_taskManager.TaskCompleted -= _taskManager_TaskCompleted; + } + + + } +} diff --git a/Emby.Server.Implementations/FileOrganization/FileOrganizationService.cs b/Emby.Server.Implementations/FileOrganization/FileOrganizationService.cs new file mode 100644 index 000000000..4094e6b9b --- /dev/null +++ b/Emby.Server.Implementations/FileOrganization/FileOrganizationService.cs @@ -0,0 +1,283 @@ +using MediaBrowser.Common.Extensions; +using MediaBrowser.Controller.Configuration; +using MediaBrowser.Controller.FileOrganization; +using MediaBrowser.Controller.Library; +using MediaBrowser.Controller.Net; +using MediaBrowser.Controller.Persistence; +using MediaBrowser.Controller.Providers; +using MediaBrowser.Model.FileOrganization; +using MediaBrowser.Model.Logging; +using MediaBrowser.Model.Querying; +using System; +using System.Collections.Concurrent; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using MediaBrowser.Model.IO; +using MediaBrowser.Controller.Session; +using MediaBrowser.Model.Events; +using MediaBrowser.Common.Events; +using MediaBrowser.Common.IO; +using MediaBrowser.Controller.IO; +using MediaBrowser.Model.Tasks; + +namespace Emby.Server.Implementations.FileOrganization +{ + public class FileOrganizationService : IFileOrganizationService + { + private readonly ITaskManager _taskManager; + private readonly IFileOrganizationRepository _repo; + private readonly ILogger _logger; + private readonly ILibraryMonitor _libraryMonitor; + private readonly ILibraryManager _libraryManager; + private readonly IServerConfigurationManager _config; + private readonly IFileSystem _fileSystem; + private readonly IProviderManager _providerManager; + private readonly ConcurrentDictionary<string, bool> _inProgressItemIds = new ConcurrentDictionary<string, bool>(); + + public event EventHandler<GenericEventArgs<FileOrganizationResult>> ItemAdded; + public event EventHandler<GenericEventArgs<FileOrganizationResult>> ItemUpdated; + public event EventHandler<GenericEventArgs<FileOrganizationResult>> ItemRemoved; + public event EventHandler LogReset; + + public FileOrganizationService(ITaskManager taskManager, IFileOrganizationRepository repo, ILogger logger, ILibraryMonitor libraryMonitor, ILibraryManager libraryManager, IServerConfigurationManager config, IFileSystem fileSystem, IProviderManager providerManager) + { + _taskManager = taskManager; + _repo = repo; + _logger = logger; + _libraryMonitor = libraryMonitor; + _libraryManager = libraryManager; + _config = config; + _fileSystem = fileSystem; + _providerManager = providerManager; + } + + public void BeginProcessNewFiles() + { + _taskManager.CancelIfRunningAndQueue<OrganizerScheduledTask>(); + } + + public Task SaveResult(FileOrganizationResult result, CancellationToken cancellationToken) + { + if (result == null || string.IsNullOrEmpty(result.OriginalPath)) + { + throw new ArgumentNullException("result"); + } + + result.Id = result.OriginalPath.GetMD5().ToString("N"); + + return _repo.SaveResult(result, cancellationToken); + } + + public QueryResult<FileOrganizationResult> GetResults(FileOrganizationResultQuery query) + { + var results = _repo.GetResults(query); + + foreach (var result in results.Items) + { + result.IsInProgress = _inProgressItemIds.ContainsKey(result.Id); + } + + return results; + } + + public FileOrganizationResult GetResult(string id) + { + var result = _repo.GetResult(id); + + if (result != null) + { + result.IsInProgress = _inProgressItemIds.ContainsKey(result.Id); + } + + return result; + } + + public FileOrganizationResult GetResultBySourcePath(string path) + { + if (string.IsNullOrEmpty(path)) + { + throw new ArgumentNullException("path"); + } + + var id = path.GetMD5().ToString("N"); + + return GetResult(id); + } + + public async Task DeleteOriginalFile(string resultId) + { + var result = _repo.GetResult(resultId); + + _logger.Info("Requested to delete {0}", result.OriginalPath); + + if (!AddToInProgressList(result, false)) + { + throw new Exception("Path is currently processed otherwise. Please try again later."); + } + + try + { + _fileSystem.DeleteFile(result.OriginalPath); + } + catch (Exception ex) + { + _logger.ErrorException("Error deleting {0}", ex, result.OriginalPath); + } + finally + { + RemoveFromInprogressList(result); + } + + await _repo.Delete(resultId); + + EventHelper.FireEventIfNotNull(ItemRemoved, this, new GenericEventArgs<FileOrganizationResult>(result), _logger); + } + + private AutoOrganizeOptions GetAutoOrganizeOptions() + { + return _config.GetAutoOrganizeOptions(); + } + + public async Task PerformOrganization(string resultId) + { + var result = _repo.GetResult(resultId); + + if (string.IsNullOrEmpty(result.TargetPath)) + { + throw new ArgumentException("No target path available."); + } + + var organizer = new EpisodeFileOrganizer(this, _config, _fileSystem, _logger, _libraryManager, + _libraryMonitor, _providerManager); + + var organizeResult = await organizer.OrganizeEpisodeFile(result.OriginalPath, GetAutoOrganizeOptions(), true, CancellationToken.None) + .ConfigureAwait(false); + + if (organizeResult.Status != FileSortingStatus.Success) + { + throw new Exception(result.StatusMessage); + } + } + + public async Task ClearLog() + { + await _repo.DeleteAll(); + EventHelper.FireEventIfNotNull(LogReset, this, EventArgs.Empty, _logger); + } + + public async Task PerformEpisodeOrganization(EpisodeFileOrganizationRequest request) + { + var organizer = new EpisodeFileOrganizer(this, _config, _fileSystem, _logger, _libraryManager, + _libraryMonitor, _providerManager); + + var result = await organizer.OrganizeWithCorrection(request, GetAutoOrganizeOptions(), CancellationToken.None).ConfigureAwait(false); + + if (result.Status != FileSortingStatus.Success) + { + throw new Exception(result.StatusMessage); + } + } + + public QueryResult<SmartMatchInfo> GetSmartMatchInfos(FileOrganizationResultQuery query) + { + if (query == null) + { + throw new ArgumentNullException("query"); + } + + var options = GetAutoOrganizeOptions(); + + var items = options.SmartMatchInfos.Skip(query.StartIndex ?? 0).Take(query.Limit ?? Int32.MaxValue).ToArray(); + + return new QueryResult<SmartMatchInfo>() + { + Items = items, + TotalRecordCount = options.SmartMatchInfos.Length + }; + } + + public void DeleteSmartMatchEntry(string itemName, string matchString) + { + if (string.IsNullOrEmpty(itemName)) + { + throw new ArgumentNullException("itemName"); + } + + if (string.IsNullOrEmpty(matchString)) + { + throw new ArgumentNullException("matchString"); + } + + var options = GetAutoOrganizeOptions(); + + SmartMatchInfo info = options.SmartMatchInfos.FirstOrDefault(i => string.Equals(i.ItemName, itemName)); + + if (info != null && info.MatchStrings.Contains(matchString)) + { + var list = info.MatchStrings.ToList(); + list.Remove(matchString); + info.MatchStrings = list.ToArray(); + + if (info.MatchStrings.Length == 0) + { + var infos = options.SmartMatchInfos.ToList(); + infos.Remove(info); + options.SmartMatchInfos = infos.ToArray(); + } + + _config.SaveAutoOrganizeOptions(options); + } + } + + /// <summary> + /// Attempts to add a an item to the list of currently processed items. + /// </summary> + /// <param name="result">The result item.</param> + /// <param name="isNewItem">Passing true will notify the client to reload all items, otherwise only a single item will be refreshed.</param> + /// <returns>True if the item was added, False if the item is already contained in the list.</returns> + public bool AddToInProgressList(FileOrganizationResult result, bool isNewItem) + { + if (string.IsNullOrWhiteSpace(result.Id)) + { + result.Id = result.OriginalPath.GetMD5().ToString("N"); + } + + if (!_inProgressItemIds.TryAdd(result.Id, false)) + { + return false; + } + + result.IsInProgress = true; + + if (isNewItem) + { + EventHelper.FireEventIfNotNull(ItemAdded, this, new GenericEventArgs<FileOrganizationResult>(result), _logger); + } + else + { + EventHelper.FireEventIfNotNull(ItemUpdated, this, new GenericEventArgs<FileOrganizationResult>(result), _logger); + } + + return true; + } + + /// <summary> + /// Removes an item from the list of currently processed items. + /// </summary> + /// <param name="result">The result item.</param> + /// <returns>True if the item was removed, False if the item was not contained in the list.</returns> + public bool RemoveFromInprogressList(FileOrganizationResult result) + { + bool itemValue; + var retval = _inProgressItemIds.TryRemove(result.Id, out itemValue); + + result.IsInProgress = false; + + EventHelper.FireEventIfNotNull(ItemUpdated, this, new GenericEventArgs<FileOrganizationResult>(result), _logger); + + return retval; + } + + } +} diff --git a/Emby.Server.Implementations/FileOrganization/NameUtils.cs b/Emby.Server.Implementations/FileOrganization/NameUtils.cs new file mode 100644 index 000000000..eb22ca4ea --- /dev/null +++ b/Emby.Server.Implementations/FileOrganization/NameUtils.cs @@ -0,0 +1,81 @@ +using MediaBrowser.Model.Extensions; +using MediaBrowser.Controller.Entities; +using System; +using System.Globalization; +using MediaBrowser.Controller.Extensions; + +namespace Emby.Server.Implementations.FileOrganization +{ + public static class NameUtils + { + private static readonly CultureInfo UsCulture = new CultureInfo("en-US"); + + internal static Tuple<T, int> GetMatchScore<T>(string sortedName, int? year, T series) + where T : BaseItem + { + var score = 0; + + var seriesNameWithoutYear = series.Name; + if (series.ProductionYear.HasValue) + { + seriesNameWithoutYear = seriesNameWithoutYear.Replace(series.ProductionYear.Value.ToString(UsCulture), String.Empty); + } + + if (IsNameMatch(sortedName, seriesNameWithoutYear)) + { + score++; + + if (year.HasValue && series.ProductionYear.HasValue) + { + if (year.Value == series.ProductionYear.Value) + { + score++; + } + else + { + // Regardless of name, return a 0 score if the years don't match + return new Tuple<T, int>(series, 0); + } + } + } + + return new Tuple<T, int>(series, score); + } + + + private static bool IsNameMatch(string name1, string name2) + { + name1 = GetComparableName(name1); + name2 = GetComparableName(name2); + + return String.Equals(name1, name2, StringComparison.OrdinalIgnoreCase); + } + + private static string GetComparableName(string name) + { + name = name.RemoveDiacritics(); + + name = " " + name + " "; + + name = name.Replace(".", " ") + .Replace("_", " ") + .Replace(" and ", " ") + .Replace(".and.", " ") + .Replace("&", " ") + .Replace("!", " ") + .Replace("(", " ") + .Replace(")", " ") + .Replace(":", " ") + .Replace(",", " ") + .Replace("-", " ") + .Replace("'", " ") + .Replace("[", " ") + .Replace("]", " ") + .Replace(" a ", String.Empty, StringComparison.OrdinalIgnoreCase) + .Replace(" the ", String.Empty, StringComparison.OrdinalIgnoreCase) + .Replace(" ", String.Empty); + + return name.Trim(); + } + } +} diff --git a/Emby.Server.Implementations/FileOrganization/OrganizerScheduledTask.cs b/Emby.Server.Implementations/FileOrganization/OrganizerScheduledTask.cs new file mode 100644 index 000000000..5be7ba7ad --- /dev/null +++ b/Emby.Server.Implementations/FileOrganization/OrganizerScheduledTask.cs @@ -0,0 +1,101 @@ +using MediaBrowser.Controller.Configuration; +using MediaBrowser.Controller.FileOrganization; +using MediaBrowser.Controller.Library; +using MediaBrowser.Controller.Providers; +using MediaBrowser.Model.FileOrganization; +using MediaBrowser.Model.Logging; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; +using MediaBrowser.Common.IO; +using MediaBrowser.Controller.IO; +using MediaBrowser.Model.IO; +using MediaBrowser.Model.Tasks; + +namespace Emby.Server.Implementations.FileOrganization +{ + public class OrganizerScheduledTask : IScheduledTask, IConfigurableScheduledTask + { + private readonly ILibraryMonitor _libraryMonitor; + private readonly ILibraryManager _libraryManager; + private readonly ILogger _logger; + private readonly IFileSystem _fileSystem; + private readonly IServerConfigurationManager _config; + private readonly IFileOrganizationService _organizationService; + private readonly IProviderManager _providerManager; + + public OrganizerScheduledTask(ILibraryMonitor libraryMonitor, ILibraryManager libraryManager, ILogger logger, IFileSystem fileSystem, IServerConfigurationManager config, IFileOrganizationService organizationService, IProviderManager providerManager) + { + _libraryMonitor = libraryMonitor; + _libraryManager = libraryManager; + _logger = logger; + _fileSystem = fileSystem; + _config = config; + _organizationService = organizationService; + _providerManager = providerManager; + } + + public string Name + { + get { return "Organize new media files"; } + } + + public string Description + { + get { return "Processes new files available in the configured watch folder."; } + } + + public string Category + { + get { return "Library"; } + } + + private AutoOrganizeOptions GetAutoOrganizeOptions() + { + return _config.GetAutoOrganizeOptions(); + } + + public async Task Execute(CancellationToken cancellationToken, IProgress<double> progress) + { + if (GetAutoOrganizeOptions().TvOptions.IsEnabled) + { + await new TvFolderOrganizer(_libraryManager, _logger, _fileSystem, _libraryMonitor, _organizationService, _config, _providerManager) + .Organize(GetAutoOrganizeOptions(), cancellationToken, progress).ConfigureAwait(false); + } + } + + /// <summary> + /// Creates the triggers that define when the task will run + /// </summary> + /// <returns>IEnumerable{BaseTaskTrigger}.</returns> + public IEnumerable<TaskTriggerInfo> GetDefaultTriggers() + { + return new[] { + + // Every so often + new TaskTriggerInfo { Type = TaskTriggerInfo.TriggerInterval, IntervalTicks = TimeSpan.FromMinutes(5).Ticks} + }; + } + + public bool IsHidden + { + get { return !GetAutoOrganizeOptions().TvOptions.IsEnabled; } + } + + public bool IsEnabled + { + get { return GetAutoOrganizeOptions().TvOptions.IsEnabled; } + } + + public bool IsLogged + { + get { return false; } + } + + public string Key + { + get { return "AutoOrganize"; } + } + } +} diff --git a/Emby.Server.Implementations/FileOrganization/TvFolderOrganizer.cs b/Emby.Server.Implementations/FileOrganization/TvFolderOrganizer.cs new file mode 100644 index 000000000..2850c3a61 --- /dev/null +++ b/Emby.Server.Implementations/FileOrganization/TvFolderOrganizer.cs @@ -0,0 +1,210 @@ +using MediaBrowser.Controller.Configuration; +using MediaBrowser.Controller.FileOrganization; +using MediaBrowser.Controller.Library; +using MediaBrowser.Controller.Providers; +using MediaBrowser.Model.FileOrganization; +using MediaBrowser.Model.Logging; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using MediaBrowser.Common.IO; +using MediaBrowser.Controller.IO; +using MediaBrowser.Model.IO; + +namespace Emby.Server.Implementations.FileOrganization +{ + public class TvFolderOrganizer + { + private readonly ILibraryMonitor _libraryMonitor; + private readonly ILibraryManager _libraryManager; + private readonly ILogger _logger; + private readonly IFileSystem _fileSystem; + private readonly IFileOrganizationService _organizationService; + private readonly IServerConfigurationManager _config; + private readonly IProviderManager _providerManager; + + public TvFolderOrganizer(ILibraryManager libraryManager, ILogger logger, IFileSystem fileSystem, ILibraryMonitor libraryMonitor, IFileOrganizationService organizationService, IServerConfigurationManager config, IProviderManager providerManager) + { + _libraryManager = libraryManager; + _logger = logger; + _fileSystem = fileSystem; + _libraryMonitor = libraryMonitor; + _organizationService = organizationService; + _config = config; + _providerManager = providerManager; + } + + private bool EnableOrganization(FileSystemMetadata fileInfo, TvFileOrganizationOptions options) + { + var minFileBytes = options.MinFileSizeMb * 1024 * 1024; + + try + { + return _libraryManager.IsVideoFile(fileInfo.FullName) && fileInfo.Length >= minFileBytes; + } + catch (Exception ex) + { + _logger.ErrorException("Error organizing file {0}", ex, fileInfo.Name); + } + + return false; + } + + public async Task Organize(AutoOrganizeOptions options, CancellationToken cancellationToken, IProgress<double> progress) + { + var watchLocations = options.TvOptions.WatchLocations.ToList(); + + var eligibleFiles = watchLocations.SelectMany(GetFilesToOrganize) + .OrderBy(_fileSystem.GetCreationTimeUtc) + .Where(i => EnableOrganization(i, options.TvOptions)) + .ToList(); + + var processedFolders = new HashSet<string>(); + + progress.Report(10); + + if (eligibleFiles.Count > 0) + { + var numComplete = 0; + + foreach (var file in eligibleFiles) + { + var organizer = new EpisodeFileOrganizer(_organizationService, _config, _fileSystem, _logger, _libraryManager, + _libraryMonitor, _providerManager); + + try + { + var result = await organizer.OrganizeEpisodeFile(file.FullName, options, options.TvOptions.OverwriteExistingEpisodes, cancellationToken).ConfigureAwait(false); + if (result.Status == FileSortingStatus.Success && !processedFolders.Contains(file.DirectoryName, StringComparer.OrdinalIgnoreCase)) + { + processedFolders.Add(file.DirectoryName); + } + } + catch (Exception ex) + { + _logger.ErrorException("Error organizing episode {0}", ex, file.FullName); + } + + numComplete++; + double percent = numComplete; + percent /= eligibleFiles.Count; + + progress.Report(10 + 89 * percent); + } + } + + cancellationToken.ThrowIfCancellationRequested(); + progress.Report(99); + + foreach (var path in processedFolders) + { + var deleteExtensions = options.TvOptions.LeftOverFileExtensionsToDelete + .Select(i => i.Trim().TrimStart('.')) + .Where(i => !string.IsNullOrEmpty(i)) + .Select(i => "." + i) + .ToList(); + + if (deleteExtensions.Count > 0) + { + DeleteLeftOverFiles(path, deleteExtensions); + } + + if (options.TvOptions.DeleteEmptyFolders) + { + if (!IsWatchFolder(path, watchLocations)) + { + DeleteEmptyFolders(path); + } + } + } + + progress.Report(100); + } + + /// <summary> + /// Gets the files to organize. + /// </summary> + /// <param name="path">The path.</param> + /// <returns>IEnumerable{FileInfo}.</returns> + private List<FileSystemMetadata> GetFilesToOrganize(string path) + { + try + { + return _fileSystem.GetFiles(path, true) + .ToList(); + } + catch (IOException ex) + { + _logger.ErrorException("Error getting files from {0}", ex, path); + + return new List<FileSystemMetadata>(); + } + } + + /// <summary> + /// Deletes the left over files. + /// </summary> + /// <param name="path">The path.</param> + /// <param name="extensions">The extensions.</param> + private void DeleteLeftOverFiles(string path, IEnumerable<string> extensions) + { + var eligibleFiles = _fileSystem.GetFiles(path, true) + .Where(i => extensions.Contains(i.Extension, StringComparer.OrdinalIgnoreCase)) + .ToList(); + + foreach (var file in eligibleFiles) + { + try + { + _fileSystem.DeleteFile(file.FullName); + } + catch (Exception ex) + { + _logger.ErrorException("Error deleting file {0}", ex, file.FullName); + } + } + } + + /// <summary> + /// Deletes the empty folders. + /// </summary> + /// <param name="path">The path.</param> + private void DeleteEmptyFolders(string path) + { + try + { + foreach (var d in _fileSystem.GetDirectoryPaths(path)) + { + DeleteEmptyFolders(d); + } + + var entries = _fileSystem.GetFileSystemEntryPaths(path); + + if (!entries.Any()) + { + try + { + _logger.Debug("Deleting empty directory {0}", path); + _fileSystem.DeleteDirectory(path, false); + } + catch (UnauthorizedAccessException) { } + catch (IOException) { } + } + } + catch (UnauthorizedAccessException) { } + } + + /// <summary> + /// Determines if a given folder path is contained in a folder list + /// </summary> + /// <param name="path">The folder path to check.</param> + /// <param name="watchLocations">A list of folders.</param> + private bool IsWatchFolder(string path, IEnumerable<string> watchLocations) + { + return watchLocations.Contains(path, StringComparer.OrdinalIgnoreCase); + } + } +}
\ No newline at end of file |