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); }
private Series GetMatchingSeries(string seriesName, FileOrganizationResult result) { var parsedName = _libraryManager.ParseName(seriesName); var yearInName = parsedName.Year; var nameWithoutYear = parsedName.Name; result.ExtractedName = nameWithoutYear; result.ExtractedYear = yearInName; return _libraryManager.RootFolder.GetRecursiveChildren(i => i is Series) .Cast<Series>() .Select(i => NameUtils.GetMatchScore(nameWithoutYear, yearInName, i)) .Where(i => i.Item2 > 0) .OrderByDescending(i => i.Item2) .Select(i => i.Item1) .FirstOrDefault(); }
public async Task<FileOrganizationResult> OrganizeEpisodeFile(string path, TvFileOrganizationOptions 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 = new FileInfo(path).Length }; var seriesName = TVUtils.GetSeriesNameFromEpisodeFile(path); if (!string.IsNullOrEmpty(seriesName)) { var season = TVUtils.GetSeasonNumberFromEpisodeFile(path); result.ExtractedSeasonNumber = season; if (season.HasValue) { // Passing in true will include a few extra regex's var episode = TVUtils.GetEpisodeNumberFromFile(path, true); result.ExtractedEpisodeNumber = episode; if (episode.HasValue) { _logger.Debug("Extracted information from {0}. Series name {1}, Season {2}, Episode {3}", path, seriesName, season, episode); var endingEpisodeNumber = TVUtils.GetEndingEpisodeNumberFromFile(path); result.ExtractedEndingEpisodeNumber = endingEpisodeNumber; await OrganizeEpisode(path, seriesName, season.Value, episode.Value, endingEpisodeNumber, options, overwriteExisting, 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 season 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 && result.Status != FileSortingStatus.Success) { return previousResult; } } await _organizationService.SaveResult(result, CancellationToken.None).ConfigureAwait(false); return result; }
private Series GetMatchingSeries(string seriesName, FileOrganizationResult result) { int? yearInName; var nameWithoutYear = seriesName; NameParser.ParseName(nameWithoutYear, out nameWithoutYear, out yearInName); result.ExtractedName = nameWithoutYear; result.ExtractedYear = yearInName; return _libraryManager.RootFolder.RecursiveChildren .OfType<Series>() .Select(i => NameUtils.GetMatchScore(nameWithoutYear, yearInName, i)) .Where(i => i.Item2 > 0) .OrderByDescending(i => i.Item2) .Select(i => i.Item1) .FirstOrDefault(); }
private async Task OrganizeEpisode(string sourcePath, Series series, int seasonNumber, int episodeNumber, int? endingEpiosdeNumber, TvFileOrganizationOptions options, bool overwriteExisting, FileOrganizationResult result, CancellationToken cancellationToken) { _logger.Info("Sorting file {0} into series {1}", sourcePath, series.Path); // Proceed to sort the file var newPath = await GetNewPath(sourcePath, series, seasonNumber, episodeNumber, endingEpiosdeNumber, options, cancellationToken).ConfigureAwait(false); if (string.IsNullOrEmpty(newPath)) { var msg = string.Format("Unable to sort {0} because target path could not be determined.", sourcePath); result.Status = FileSortingStatus.Failure; result.StatusMessage = msg; _logger.Warn(msg); return; } _logger.Info("Sorting file {0} to new path {1}", sourcePath, newPath); result.TargetPath = newPath; var fileExists = File.Exists(result.TargetPath); var otherDuplicatePaths = GetOtherDuplicatePaths(result.TargetPath, series, seasonNumber, episodeNumber, endingEpiosdeNumber); if (!overwriteExisting) { if (fileExists || otherDuplicatePaths.Count > 0) { result.Status = FileSortingStatus.SkippedExisting; result.StatusMessage = string.Empty; result.DuplicatePaths = otherDuplicatePaths; return; } if (options.CopyOriginalFile && fileExists && IsSameEpisode(sourcePath, newPath)) { _logger.Info("File {0} already copied to new path {1}, stopping organization", sourcePath, newPath); result.Status = FileSortingStatus.SkippedExisting; result.StatusMessage = string.Empty; return; } } PerformFileSorting(options, result); if (overwriteExisting) { foreach (var path in otherDuplicatePaths) { _logger.Debug("Removing duplicate episode {0}", path); _libraryMonitor.ReportFileSystemChangeBeginning(path); try { File.Delete(path); } catch (IOException ex) { _logger.ErrorException("Error removing duplicate episode", ex, path); } finally { _libraryMonitor.ReportFileSystemChangeComplete(path, true); } } } }
private async Task OrganizeMovie(string sourcePath, string movieName, string movieYear, string targetPath, AutoOrganizeOptions options, bool overwriteExisting, FileOrganizationResult result, CancellationToken cancellationToken) { _logger.Info("Sorting file {0} into movie folder {1}", sourcePath, targetPath); // Proceed to sort the file var newPath = GetNewPath(sourcePath, movieName, movieYear, targetPath, options, true, result, cancellationToken); if (string.IsNullOrEmpty(newPath)) { var msg = string.Format("Unable to sort {0} because target path could not be determined.", sourcePath); result.Status = FileSortingStatus.Failure; result.StatusMessage = msg; _logger.Warn(msg); return; } _logger.Info("Sorting file {0} to new path {1}", sourcePath, newPath); result.TargetPath = newPath; var fileExists = _fileSystem.FileExists(result.TargetPath); if (!overwriteExisting) { if (options.TvOptions.CopyOriginalFile && fileExists) { _logger.Info("File {0} already copied to new path {1}, stopping organization", sourcePath, newPath); result.Status = FileSortingStatus.SkippedExisting; result.StatusMessage = string.Empty; return; } if (fileExists) { result.Status = FileSortingStatus.SkippedExisting; result.StatusMessage = string.Empty; 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); //// } //// } ////} }
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 Controller.Entities.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 Controller.Entities.InternalItemsQuery { IncludeItemTypes = new[] { typeof(Series).Name }, Recursive = true, Name = info.ItemName }).Cast<Series>().FirstOrDefault(); } } return series; }
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}", result.OriginalPath, result.TargetPath); 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); } } }
/// <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; }
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.RootFolder.GetRecursiveChildren(i => i is Series) .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(seriesName, StringComparer.OrdinalIgnoreCase)); if (info != null) { series = _libraryManager.RootFolder .GetRecursiveChildren(i => i is Series) .Cast<Series>() .FirstOrDefault(i => string.Equals(i.Name, info.ItemName, StringComparison.OrdinalIgnoreCase)); } } return series ?? new Series(); }
public async Task SaveResult(FileOrganizationResult result, CancellationToken cancellationToken) { if (result == null) { throw new ArgumentNullException("result"); } cancellationToken.ThrowIfCancellationRequested(); await _writeLock.WaitAsync(cancellationToken).ConfigureAwait(false); IDbTransaction transaction = null; try { transaction = _connection.BeginTransaction(); _saveResultCommand.GetParameter(0).Value = new Guid(result.Id); _saveResultCommand.GetParameter(1).Value = result.OriginalPath; _saveResultCommand.GetParameter(2).Value = result.TargetPath; _saveResultCommand.GetParameter(3).Value = result.Date; _saveResultCommand.GetParameter(4).Value = result.Status.ToString(); _saveResultCommand.GetParameter(5).Value = result.Type.ToString(); _saveResultCommand.GetParameter(6).Value = result.StatusMessage; _saveResultCommand.GetParameter(7).Value = result.ExtractedName; _saveResultCommand.GetParameter(8).Value = result.ExtractedYear; _saveResultCommand.GetParameter(9).Value = result.ExtractedSeasonNumber; _saveResultCommand.GetParameter(10).Value = result.ExtractedEpisodeNumber; _saveResultCommand.GetParameter(11).Value = result.ExtractedEndingEpisodeNumber; _saveResultCommand.GetParameter(12).Value = string.Join("|", result.DuplicatePaths.ToArray()); _saveResultCommand.Transaction = transaction; _saveResultCommand.ExecuteNonQuery(); transaction.Commit(); } catch (OperationCanceledException) { if (transaction != null) { transaction.Rollback(); } throw; } catch (Exception e) { _logger.ErrorException("Failed to save FileOrganizationResult:", e); if (transaction != null) { transaction.Rollback(); } throw; } finally { if (transaction != null) { transaction.Dispose(); } _writeLock.Release(); } }
private void PerformFileSorting(TvFileOrganizationOptions options, FileOrganizationResult result) { _directoryWatchers.TemporarilyIgnore(result.TargetPath); Directory.CreateDirectory(Path.GetDirectoryName(result.TargetPath)); var copy = File.Exists(result.TargetPath); try { if (copy) { File.Copy(result.OriginalPath, result.TargetPath, true); } else { File.Move(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}", result.OriginalPath, result.TargetPath); result.Status = FileSortingStatus.Failure; result.StatusMessage = errorMsg; _logger.ErrorException(errorMsg, ex); return; } finally { _directoryWatchers.RemoveTempIgnore(result.TargetPath); } if (copy) { try { File.Delete(result.OriginalPath); } catch (Exception ex) { _logger.ErrorException("Error deleting {0}", ex, result.OriginalPath); } } }
private void OrganizeEpisode(string sourcePath, Series series, int seasonNumber, int episodeNumber, int? endingEpiosdeNumber, TvFileOrganizationOptions options, bool overwriteExisting, FileOrganizationResult result) { _logger.Info("Sorting file {0} into series {1}", sourcePath, series.Path); // Proceed to sort the file var newPath = GetNewPath(sourcePath, series, seasonNumber, episodeNumber, endingEpiosdeNumber, options); if (string.IsNullOrEmpty(newPath)) { var msg = string.Format("Unable to sort {0} because target path could not be determined.", sourcePath); result.Status = FileSortingStatus.Failure; result.StatusMessage = msg; _logger.Warn(msg); return; } _logger.Info("Sorting file {0} to new path {1}", sourcePath, newPath); result.TargetPath = newPath; var fileExists = File.Exists(result.TargetPath); var otherDuplicatePaths = GetOtherDuplicatePaths(result.TargetPath, series, seasonNumber, episodeNumber, endingEpiosdeNumber); if (!overwriteExisting && (fileExists || otherDuplicatePaths.Count > 0)) { result.Status = FileSortingStatus.SkippedExisting; result.StatusMessage = string.Empty; result.DuplicatePaths = otherDuplicatePaths; return; } PerformFileSorting(options, result); if (overwriteExisting) { foreach (var path in otherDuplicatePaths) { _logger.Debug("Removing duplicate episode {0}", path); try { File.Delete(path); } catch (IOException ex) { _logger.ErrorException("Error removing duplicate episode", ex, path); } } } }
private void OrganizeEpisode(string sourcePath, string seriesName, int seasonNumber, int episodeNumber, int? endingEpiosdeNumber, TvFileOrganizationOptions options, bool overwriteExisting, FileOrganizationResult result) { var series = GetMatchingSeries(seriesName, result); 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; } OrganizeEpisode(sourcePath, series, seasonNumber, episodeNumber, endingEpiosdeNumber, options, overwriteExisting, 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; // 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); result.Status = FileSortingStatus.Failure; result.StatusMessage = msg; _logger.Warn(msg); return; } _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); } } } if (rememberCorrection) { SaveSmartMatchString(originalExtractedSeriesString, series, options); } }
/// <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; }
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 = new FileInfo(path).Length }; 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 Naming.TV.EpisodeResolver(namingOptions, new PatternsLogger()); var episodeInfo = resolver.Resolve(path, false) ?? new 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); return result; }
public FileOrganizationResult GetResult(IDataReader reader) { var index = 0; var result = new FileOrganizationResult { Id = reader.GetGuid(0).ToString("N") }; index++; if (!reader.IsDBNull(index)) { result.OriginalPath = reader.GetString(index); } index++; if (!reader.IsDBNull(index)) { result.TargetPath = reader.GetString(index); } index++; result.FileSize = reader.GetInt64(index); index++; result.Date = reader.GetDateTime(index).ToUniversalTime(); index++; result.Status = (FileSortingStatus)Enum.Parse(typeof(FileSortingStatus), reader.GetString(index), true); index++; result.Type = (FileOrganizerType)Enum.Parse(typeof(FileOrganizerType), reader.GetString(index), true); index++; if (!reader.IsDBNull(index)) { result.StatusMessage = reader.GetString(index); } result.OriginalFileName = Path.GetFileName(result.OriginalPath); index++; if (!reader.IsDBNull(index)) { result.ExtractedName = reader.GetString(index); } index++; if (!reader.IsDBNull(index)) { result.ExtractedYear = reader.GetInt32(index); } index++; if (!reader.IsDBNull(index)) { result.ExtractedSeasonNumber = reader.GetInt32(index); } index++; if (!reader.IsDBNull(index)) { result.ExtractedEpisodeNumber = reader.GetInt32(index); } index++; if (!reader.IsDBNull(index)) { result.ExtractedEndingEpisodeNumber = reader.GetInt32(index); } index++; if (!reader.IsDBNull(index)) { result.DuplicatePaths = reader.GetString(index).Split('|').Where(i => !string.IsNullOrEmpty(i)).ToList(); } return result; }
public async Task SaveResult(FileOrganizationResult result, CancellationToken cancellationToken) { if (result == null) { throw new ArgumentNullException("result"); } cancellationToken.ThrowIfCancellationRequested(); using (var connection = await CreateConnection().ConfigureAwait(false)) { using (var saveResultCommand = connection.CreateCommand()) { saveResultCommand.CommandText = "replace into FileOrganizerResults (ResultId, OriginalPath, TargetPath, FileLength, OrganizationDate, Status, OrganizationType, StatusMessage, ExtractedName, ExtractedYear, ExtractedSeasonNumber, ExtractedEpisodeNumber, ExtractedEndingEpisodeNumber, DuplicatePaths) values (@ResultId, @OriginalPath, @TargetPath, @FileLength, @OrganizationDate, @Status, @OrganizationType, @StatusMessage, @ExtractedName, @ExtractedYear, @ExtractedSeasonNumber, @ExtractedEpisodeNumber, @ExtractedEndingEpisodeNumber, @DuplicatePaths)"; saveResultCommand.Parameters.Add(saveResultCommand, "@ResultId"); saveResultCommand.Parameters.Add(saveResultCommand, "@OriginalPath"); saveResultCommand.Parameters.Add(saveResultCommand, "@TargetPath"); saveResultCommand.Parameters.Add(saveResultCommand, "@FileLength"); saveResultCommand.Parameters.Add(saveResultCommand, "@OrganizationDate"); saveResultCommand.Parameters.Add(saveResultCommand, "@Status"); saveResultCommand.Parameters.Add(saveResultCommand, "@OrganizationType"); saveResultCommand.Parameters.Add(saveResultCommand, "@StatusMessage"); saveResultCommand.Parameters.Add(saveResultCommand, "@ExtractedName"); saveResultCommand.Parameters.Add(saveResultCommand, "@ExtractedYear"); saveResultCommand.Parameters.Add(saveResultCommand, "@ExtractedSeasonNumber"); saveResultCommand.Parameters.Add(saveResultCommand, "@ExtractedEpisodeNumber"); saveResultCommand.Parameters.Add(saveResultCommand, "@ExtractedEndingEpisodeNumber"); saveResultCommand.Parameters.Add(saveResultCommand, "@DuplicatePaths"); IDbTransaction transaction = null; try { transaction = connection.BeginTransaction(); var index = 0; saveResultCommand.GetParameter(index++).Value = new Guid(result.Id); saveResultCommand.GetParameter(index++).Value = result.OriginalPath; saveResultCommand.GetParameter(index++).Value = result.TargetPath; saveResultCommand.GetParameter(index++).Value = result.FileSize; saveResultCommand.GetParameter(index++).Value = result.Date; saveResultCommand.GetParameter(index++).Value = result.Status.ToString(); saveResultCommand.GetParameter(index++).Value = result.Type.ToString(); saveResultCommand.GetParameter(index++).Value = result.StatusMessage; saveResultCommand.GetParameter(index++).Value = result.ExtractedName; saveResultCommand.GetParameter(index++).Value = result.ExtractedYear; saveResultCommand.GetParameter(index++).Value = result.ExtractedSeasonNumber; saveResultCommand.GetParameter(index++).Value = result.ExtractedEpisodeNumber; saveResultCommand.GetParameter(index++).Value = result.ExtractedEndingEpisodeNumber; saveResultCommand.GetParameter(index).Value = string.Join("|", result.DuplicatePaths.ToArray()); saveResultCommand.Transaction = transaction; saveResultCommand.ExecuteNonQuery(); transaction.Commit(); } catch (OperationCanceledException) { if (transaction != null) { transaction.Rollback(); } throw; } catch (Exception e) { Logger.ErrorException("Failed to save FileOrganizationResult:", e); if (transaction != null) { transaction.Rollback(); } throw; } finally { if (transaction != null) { transaction.Dispose(); } } } } }
/// <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="options">The options.</param> /// <returns>System.String.</returns> private string GetNewPath(string sourcePath, string movieName, string movieYear, string targetPath, AutoOrganizeOptions options, bool overwriteExisting, FileOrganizationResult result, CancellationToken cancellationToken) { var folderName = _fileSystem.GetValidFilename(movieName).Trim(); if (!string.IsNullOrEmpty(movieYear)) { folderName = string.Format("{0} ({1})", folderName, movieYear); } var newPath = Path.Combine(targetPath, folderName); var fileName = _fileSystem.GetFileNameWithoutExtension(sourcePath); fileName = string.Format("{0}{1}", fileName, Path.GetExtension(sourcePath)); newPath = Path.Combine(newPath, fileName); return newPath; }