mirror of
https://github.com/jellyfin/jellyfin.git
synced 2026-07-15 10:43:30 +01:00
move additional classes to new server lib
This commit is contained in:
Luke Pulverenti
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
33
Emby.Server.Implementations/FileOrganization/Extensions.cs
Normal file
33
Emby.Server.Implementations/FileOrganization/Extensions.cs
Normal file
@@ -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)
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
81
Emby.Server.Implementations/FileOrganization/NameUtils.cs
Normal file
81
Emby.Server.Implementations/FileOrganization/NameUtils.cs
Normal file
@@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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"; }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user