public override IEnumerable <ExtraFile> ProcessFiles(Author author, List <string> filesOnDisk, List <string> importedFiles)
{
_logger.Debug("Looking for existing extra files in {0}", author.Path);
var extraFiles = new List <OtherExtraFile>();
var filterResult = FilterAndClean(author, filesOnDisk, importedFiles);
foreach (var possibleExtraFile in filterResult.FilesOnDisk)
{
var extension = Path.GetExtension(possibleExtraFile);
if (extension.IsNullOrWhiteSpace())
{
_logger.Debug("No extension for file: {0}", possibleExtraFile);
continue;
}
var localTrack = new LocalBook
{
FileTrackInfo = Parser.Parser.ParseMusicPath(possibleExtraFile),
Author = author,
Path = possibleExtraFile
};
try
{
_augmentingService.Augment(localTrack, false);
}
catch (AugmentingFailedException)
{
_logger.Debug("Unable to parse extra file: {0}", possibleExtraFile);
continue;
}
if (localTrack.Book == null)
{
_logger.Debug("Cannot find related book for: {0}", possibleExtraFile);
continue;
}
var extraFile = new OtherExtraFile
{
AuthorId = author.Id,
BookId = localTrack.Book.Id,
RelativePath = author.Path.GetRelativePath(possibleExtraFile),
Extension = extension
};
extraFiles.Add(extraFile);
}
_logger.Info("Found {0} existing other extra files", extraFiles.Count);
_otherExtraFileService.Upsert(extraFiles);
// Return files that were just imported along with files that were
// previously imported so previously imported files aren't imported twice
return(extraFiles.Concat(filterResult.PreviouslyImported));
}
public override IEnumerable <ExtraFile> ProcessFiles(Series series, List <string> filesOnDisk, List <string> importedFiles)
{
_logger.Debug("Looking for existing extra files in {0}", series.Path);
var extraFiles = new List <OtherExtraFile>();
var filterResult = FilterAndClean(series, filesOnDisk, importedFiles);
foreach (var possibleExtraFile in filterResult.FilesOnDisk)
{
var extension = Path.GetExtension(possibleExtraFile);
if (extension.IsNullOrWhiteSpace())
{
_logger.Debug("No extension for file: {0}", possibleExtraFile);
continue;
}
var localEpisode = _parsingService.GetLocalEpisode(possibleExtraFile, series);
if (localEpisode == null)
{
_logger.Debug("Unable to parse extra file: {0}", possibleExtraFile);
continue;
}
if (localEpisode.Episodes.Empty())
{
_logger.Debug("Cannot find related episodes for: {0}", possibleExtraFile);
continue;
}
if (localEpisode.Episodes.DistinctBy(e => e.EpisodeFileId).Count() > 1)
{
_logger.Debug("Extra file: {0} does not match existing files.", possibleExtraFile);
continue;
}
var extraFile = new OtherExtraFile
{
SeriesId = series.Id,
SeasonNumber = localEpisode.SeasonNumber,
EpisodeFileId = localEpisode.Episodes.First().EpisodeFileId,
RelativePath = series.Path.GetRelativePath(possibleExtraFile),
Extension = extension
};
extraFiles.Add(extraFile);
}
_logger.Info("Found {0} existing other extra files", extraFiles.Count);
_otherExtraFileService.Upsert(extraFiles);
// Return files that were just imported along with files that were
// previously imported so previously imported files aren't imported twice
return(extraFiles.Concat(filterResult.PreviouslyImported));
}
public override IEnumerable <ExtraFile> ProcessFiles(Movie movie, List <string> filesOnDisk, List <string> importedFiles)
{
_logger.Debug("Looking for existing metadata in {0}", movie.Path);
var metadataFiles = new List <MetadataFile>();
var filterResult = FilterAndClean(movie, filesOnDisk, importedFiles);
foreach (var possibleMetadataFile in filterResult.FilesOnDisk)
{
// Don't process files that have known Subtitle file extensions (saves a bit of unecessary processing)
if (SubtitleFileExtensions.Extensions.Contains(Path.GetExtension(possibleMetadataFile)))
{
continue;
}
foreach (var consumer in _consumers)
{
var metadata = consumer.FindMetadataFile(movie, possibleMetadataFile);
if (metadata == null)
{
continue;
}
if (metadata.Type == MetadataType.MovieImage ||
metadata.Type == MetadataType.MovieMetadata)
{
var minimalInfo = _parsingService.ParseMinimalPathMovieInfo(possibleMetadataFile);
if (minimalInfo == null)
{
_logger.Debug("Unable to parse extra file: {0}", possibleMetadataFile);
continue;
}
metadata.MovieFileId = movie.MovieFileId;
}
metadata.Extension = Path.GetExtension(possibleMetadataFile);
metadataFiles.Add(metadata);
}
}
_logger.Info("Found {0} existing metadata files", metadataFiles.Count);
_metadataFileService.Upsert(metadataFiles);
// Return files that were just imported along with files that were
// previously imported so previously imported files aren't imported twice
return(metadataFiles.Concat(filterResult.PreviouslyImported));
}
public override IEnumerable <ExtraFile> ProcessFiles(Movie movie, List <string> filesOnDisk, List <string> importedFiles)
{
_logger.Debug("Looking for existing extra files in {0}", movie.Path);
var extraFiles = new List <OtherExtraFile>();
var filterResult = FilterAndClean(movie, filesOnDisk, importedFiles);
foreach (var possibleExtraFile in filterResult.FilesOnDisk)
{
var extension = Path.GetExtension(possibleExtraFile);
if (extension.IsNullOrWhiteSpace())
{
_logger.Debug("No extension for file: {0}", possibleExtraFile);
continue;
}
var minimalInfo = _parsingService.ParseMinimalPathMovieInfo(possibleExtraFile);
if (minimalInfo == null)
{
_logger.Debug("Unable to parse extra file: {0}", possibleExtraFile);
continue;
}
var extraFile = new OtherExtraFile
{
MovieId = movie.Id,
MovieFileId = movie.MovieFileId,
RelativePath = movie.Path.GetRelativePath(possibleExtraFile),
Extension = extension
};
extraFiles.Add(extraFile);
}
_logger.Info("Found {0} existing other extra files", extraFiles.Count);
_otherExtraFileService.Upsert(extraFiles);
// Return files that were just imported along with files that were
// previously imported so previously imported files aren't imported twice
return(extraFiles.Concat(filterResult.PreviouslyImported));
}
public override IEnumerable <ExtraFile> ProcessFiles(Movie movie, List <string> filesOnDisk, List <string> importedFiles)
{
_logger.Debug("Looking for existing subtitle files in {0}", movie.Path);
var subtitleFiles = new List <SubtitleFile>();
var filterResult = FilterAndClean(movie, filesOnDisk, importedFiles);
foreach (var possibleSubtitleFile in filterResult.FilesOnDisk)
{
var extension = Path.GetExtension(possibleSubtitleFile);
if (SubtitleFileExtensions.Extensions.Contains(extension))
{
var minimalInfo = _parsingService.ParseMinimalPathMovieInfo(possibleSubtitleFile);
if (minimalInfo == null)
{
_logger.Debug("Unable to parse subtitle file: {0}", possibleSubtitleFile);
continue;
}
var subtitleFile = new SubtitleFile
{
MovieId = movie.Id,
MovieFileId = movie.MovieFileId,
RelativePath = movie.Path.GetRelativePath(possibleSubtitleFile),
Language = LanguageParser.ParseSubtitleLanguage(possibleSubtitleFile),
Extension = extension
};
subtitleFiles.Add(subtitleFile);
}
}
_logger.Info("Found {0} existing subtitle files", subtitleFiles.Count);
_subtitleFileService.Upsert(subtitleFiles);
// Return files that were just imported along with files that were
// previously imported so previously imported files aren't imported twice
return(subtitleFiles.Concat(filterResult.PreviouslyImported));
}
public override IEnumerable <ExtraFile> ProcessFiles(Artist artist, List <string> filesOnDisk, List <string> importedFiles)
{
_logger.Debug("Looking for existing metadata in {0}", artist.Path);
var metadataFiles = new List <MetadataFile>();
var filterResult = FilterAndClean(artist, filesOnDisk, importedFiles);
foreach (var possibleMetadataFile in filterResult.FilesOnDisk)
{
// Don't process files that have known Subtitle file extensions (saves a bit of unecessary processing)
if (LyricFileExtensions.Extensions.Contains(Path.GetExtension(possibleMetadataFile)))
{
continue;
}
foreach (var consumer in _consumers)
{
var metadata = consumer.FindMetadataFile(artist, possibleMetadataFile);
if (metadata == null)
{
continue;
}
if (metadata.Type == MetadataType.AlbumImage || metadata.Type == MetadataType.AlbumMetadata)
{
var localAlbum = _parsingService.GetLocalAlbum(possibleMetadataFile, artist);
if (localAlbum == null)
{
_logger.Debug("Extra file folder has multiple Albums: {0}", possibleMetadataFile);
continue;
}
metadata.AlbumId = localAlbum.Id;
}
if (metadata.Type == MetadataType.TrackMetadata)
{
var localTrack = new LocalTrack
{
FileTrackInfo = Parser.Parser.ParseMusicPath(possibleMetadataFile),
Artist = artist,
Path = possibleMetadataFile
};
try
{
_augmentingService.Augment(localTrack, false);
}
catch (AugmentingFailedException)
{
_logger.Debug("Unable to parse extra file: {0}", possibleMetadataFile);
continue;
}
if (localTrack.Tracks.Empty())
{
_logger.Debug("Cannot find related tracks for: {0}", possibleMetadataFile);
continue;
}
if (localTrack.Tracks.DistinctBy(e => e.TrackFileId).Count() > 1)
{
_logger.Debug("Extra file: {0} does not match existing files.", possibleMetadataFile);
continue;
}
metadata.TrackFileId = localTrack.Tracks.First().TrackFileId;
}
metadata.Extension = Path.GetExtension(possibleMetadataFile);
metadataFiles.Add(metadata);
}
}
_logger.Info("Found {0} existing metadata files", metadataFiles.Count);
_metadataFileService.Upsert(metadataFiles);
// Return files that were just imported along with files that were
// previously imported so previously imported files aren't imported twice
return(metadataFiles.Concat(filterResult.PreviouslyImported));
}
public override IEnumerable <ExtraFile> ProcessFiles(Series series, List <string> filesOnDisk, List <string> importedFiles)
{
_logger.Debug("Looking for existing metadata in {0}", series.Path);
var metadataFiles = new List <MetadataFile>();
var filterResult = FilterAndClean(series, filesOnDisk, importedFiles);
foreach (var possibleMetadataFile in filterResult.FilesOnDisk)
{
// Don't process files that have known Subtitle file extensions (saves a bit of unecessary processing)
if (SubtitleFileExtensions.Extensions.Contains(Path.GetExtension(possibleMetadataFile)))
{
continue;
}
foreach (var consumer in _consumers)
{
var metadata = consumer.FindMetadataFile(series, possibleMetadataFile);
if (metadata == null)
{
continue;
}
if (metadata.Type == MetadataType.EpisodeImage ||
metadata.Type == MetadataType.EpisodeMetadata)
{
var localEpisode = new LocalEpisode
{
FileEpisodeInfo = Parser.Parser.ParsePath(possibleMetadataFile),
Series = series,
Path = possibleMetadataFile
};
try
{
_aggregationService.Augment(localEpisode, null);
}
catch (AugmentingFailedException)
{
_logger.Debug("Unable to parse extra file: {0}", possibleMetadataFile);
continue;
}
if (localEpisode.Episodes.Empty())
{
_logger.Debug("Cannot find related episodes for: {0}", possibleMetadataFile);
continue;
}
if (localEpisode.Episodes.DistinctBy(e => e.EpisodeFileId).Count() > 1)
{
_logger.Debug("Extra file: {0} does not match existing files.", possibleMetadataFile);
continue;
}
metadata.SeasonNumber = localEpisode.SeasonNumber;
metadata.EpisodeFileId = localEpisode.Episodes.First().EpisodeFileId;
}
metadata.Extension = Path.GetExtension(possibleMetadataFile);
metadataFiles.Add(metadata);
}
}
_logger.Info("Found {0} existing metadata files", metadataFiles.Count);
_metadataFileService.Upsert(metadataFiles);
// Return files that were just imported along with files that were
// previously imported so previously imported files aren't imported twice
return(metadataFiles.Concat(filterResult.PreviouslyImported));
}
public override IEnumerable <ExtraFile> ProcessFiles(Artist artist, List <string> filesOnDisk, List <string> importedFiles)
{
_logger.Debug("Looking for existing extra files in {0}", artist.Path);
var extraFiles = new List <OtherExtraFile>();
var filterResult = FilterAndClean(artist, filesOnDisk, importedFiles);
foreach (var possibleExtraFile in filterResult.FilesOnDisk)
{
var extension = Path.GetExtension(possibleExtraFile);
if (extension.IsNullOrWhiteSpace())
{
_logger.Debug("No extension for file: {0}", possibleExtraFile);
continue;
}
var localTrack = new LocalTrack
{
FileTrackInfo = Parser.Parser.ParseMusicPath(possibleExtraFile),
Artist = artist,
Path = possibleExtraFile
};
try
{
_augmentingService.Augment(localTrack, false);
}
catch (AugmentingFailedException)
{
_logger.Debug("Unable to parse extra file: {0}", possibleExtraFile);
continue;
}
if (localTrack.Tracks.Empty())
{
_logger.Debug("Cannot find related tracks for: {0}", possibleExtraFile);
continue;
}
if (localTrack.Tracks.DistinctBy(e => e.TrackFileId).Count() > 1)
{
_logger.Debug("Extra file: {0} does not match existing files.", possibleExtraFile);
continue;
}
var extraFile = new OtherExtraFile
{
ArtistId = artist.Id,
AlbumId = localTrack.Album.Id,
TrackFileId = localTrack.Tracks.First().TrackFileId,
RelativePath = artist.Path.GetRelativePath(possibleExtraFile),
Extension = extension
};
extraFiles.Add(extraFile);
}
_logger.Info("Found {0} existing other extra files", extraFiles.Count);
_otherExtraFileService.Upsert(extraFiles);
// Return files that were just imported along with files that were
// previously imported so previously imported files aren't imported twice
return(extraFiles.Concat(filterResult.PreviouslyImported));
}
public override IEnumerable <ExtraFile> ProcessFiles(Author author, List <string> filesOnDisk, List <string> importedFiles)
{
_logger.Debug("Looking for existing metadata in {0}", author.Path);
var metadataFiles = new List <MetadataFile>();
var filterResult = FilterAndClean(author, filesOnDisk, importedFiles);
foreach (var possibleMetadataFile in filterResult.FilesOnDisk)
{
foreach (var consumer in _consumers)
{
var metadata = consumer.FindMetadataFile(author, possibleMetadataFile);
if (metadata == null)
{
continue;
}
if (metadata.Type == MetadataType.BookImage || metadata.Type == MetadataType.BookMetadata)
{
var localAlbum = _parsingService.GetLocalAlbum(possibleMetadataFile, author);
if (localAlbum == null)
{
_logger.Debug("Extra file folder has multiple Books: {0}", possibleMetadataFile);
continue;
}
metadata.BookId = localAlbum.Id;
}
if (metadata.Type == MetadataType.BookMetadata)
{
var localTrack = new LocalBook
{
FileTrackInfo = Parser.Parser.ParseMusicPath(possibleMetadataFile),
Author = author,
Path = possibleMetadataFile
};
try
{
_augmentingService.Augment(localTrack, false);
}
catch (AugmentingFailedException)
{
_logger.Debug("Unable to parse extra file: {0}", possibleMetadataFile);
continue;
}
if (localTrack.Book == null)
{
_logger.Debug("Cannot find related book for: {0}", possibleMetadataFile);
continue;
}
}
metadata.Extension = Path.GetExtension(possibleMetadataFile);
metadataFiles.Add(metadata);
}
}
_logger.Info("Found {0} existing metadata files", metadataFiles.Count);
_metadataFileService.Upsert(metadataFiles);
// Return files that were just imported along with files that were
// previously imported so previously imported files aren't imported twice
return(metadataFiles.Concat(filterResult.PreviouslyImported));
}
public override IEnumerable <ExtraFile> ProcessFiles(Series series, List <string> filesOnDisk, List <string> importedFiles)
{
_logger.Debug("Looking for existing subtitle files in {0}", series.Path);
var subtitleFiles = new List <SubtitleFile>();
var filterResult = FilterAndClean(series, filesOnDisk, importedFiles);
foreach (var possibleSubtitleFile in filterResult.FilesOnDisk)
{
var extension = Path.GetExtension(possibleSubtitleFile);
if (SubtitleFileExtensions.Extensions.Contains(extension))
{
var localEpisode = new LocalEpisode
{
FileEpisodeInfo = Parser.Parser.ParsePath(possibleSubtitleFile),
Series = series,
Path = possibleSubtitleFile
};
try
{
_aggregationService.Augment(localEpisode, false);
}
catch (AugmentingFailedException ex)
{
_logger.Debug("Unable to parse extra file: {0}", possibleSubtitleFile);
continue;
}
if (localEpisode.Episodes.Empty())
{
_logger.Debug("Cannot find related episodes for: {0}", possibleSubtitleFile);
continue;
}
if (localEpisode.Episodes.DistinctBy(e => e.EpisodeFileId).Count() > 1)
{
_logger.Debug("Subtitle file: {0} does not match existing files.", possibleSubtitleFile);
continue;
}
var subtitleFile = new SubtitleFile
{
SeriesId = series.Id,
SeasonNumber = localEpisode.SeasonNumber,
EpisodeFileId = localEpisode.Episodes.First().EpisodeFileId,
RelativePath = series.Path.GetRelativePath(possibleSubtitleFile),
Language = LanguageParser.ParseSubtitleLanguage(possibleSubtitleFile),
Extension = extension
};
subtitleFiles.Add(subtitleFile);
}
}
_logger.Info("Found {0} existing subtitle files", subtitleFiles.Count);
_subtitleFileService.Upsert(subtitleFiles);
// Return files that were just imported along with files that were
// previously imported so previously imported files aren't imported twice
return(subtitleFiles.Concat(filterResult.PreviouslyImported));
}