public override HealthCheck Check()
{
var rootFolders = _authorService.AllAuthorPaths()
.Select(s => _rootFolderService.GetBestRootFolderPath(s.Value))
.Distinct();
var missingRootFolders = rootFolders.Where(s => !_diskProvider.FolderExists(s))
.ToList();
missingRootFolders.AddRange(_importListFactory.All()
.Select(s => s.RootFolderPath)
.Distinct()
.Where(s => !_diskProvider.FolderExists(s))
.ToList());
missingRootFolders = missingRootFolders.Distinct().ToList();
if (missingRootFolders.Any())
{
if (missingRootFolders.Count == 1)
{
return(new HealthCheck(GetType(), HealthCheckResult.Error, string.Format(_localizationService.GetLocalizedString("RootFolderCheckSingleMessage"), missingRootFolders.First()), "#missing-root-folder"));
}
var message = string.Format(_localizationService.GetLocalizedString("RootFolderCheckMultipleMessage"), string.Join(" | ", missingRootFolders));
return(new HealthCheck(GetType(), HealthCheckResult.Error, message, "#missing-root-folder"));
}
return(new HealthCheck(GetType()));
}
private void EnsureMovieFolder(MovieFile movieFile, Movie movie, string filePath)
{
var movieFileFolder = Path.GetDirectoryName(filePath);
var movieFolder = movie.Path;
var rootFolder = _rootFolderService.GetBestRootFolderPath(movieFolder);
if (!_diskProvider.FolderExists(rootFolder))
{
throw new RootFolderNotFoundException(string.Format("Root folder '{0}' was not found.", rootFolder));
}
var changed = false;
var newEvent = new MovieFolderCreatedEvent(movie, movieFile);
if (!_diskProvider.FolderExists(movieFolder))
{
CreateFolder(movieFolder);
newEvent.MovieFolder = movieFolder;
changed = true;
}
if (movieFolder != movieFileFolder && !_diskProvider.FolderExists(movieFileFolder))
{
CreateFolder(movieFileFolder);
newEvent.MovieFileFolder = movieFileFolder;
changed = true;
}
if (changed)
{
_eventAggregator.PublishEvent(newEvent);
}
}
public override HealthCheck Check()
{
var rootFolders = _authorService.AllAuthorPaths()
.Select(s => _rootFolderService.GetBestRootFolderPath(s.Value))
.Distinct();
var missingRootFolders = rootFolders.Where(s => !_diskProvider.FolderExists(s))
.ToList();
missingRootFolders.AddRange(_importListFactory.All()
.Select(s => s.RootFolderPath)
.Distinct()
.Where(s => !_diskProvider.FolderExists(s))
.ToList());
missingRootFolders = missingRootFolders.Distinct().ToList();
if (missingRootFolders.Any())
{
if (missingRootFolders.Count == 1)
{
return(new HealthCheck(GetType(), HealthCheckResult.Error, "Missing root folder: " + missingRootFolders.First(), "#missing_root_folder"));
}
var message = string.Format("Multiple root folders are missing: {0}", string.Join(" | ", missingRootFolders));
return(new HealthCheck(GetType(), HealthCheckResult.Error, message, "#missing_root_folder"));
}
return(new HealthCheck(GetType()));
}
public void Scan(Series series)
{
var rootFolder = _rootFolderService.GetBestRootFolderPath(series.Path);
if (!_diskProvider.FolderExists(rootFolder))
{
_logger.Warn("Series' root folder ({0}) doesn't exist.", rootFolder);
_eventAggregator.PublishEvent(new SeriesScanSkippedEvent(series, SeriesScanSkippedReason.RootFolderDoesNotExist));
return;
}
if (_diskProvider.GetDirectories(rootFolder).Empty())
{
_logger.Warn("Series' root folder ({0}) is empty.", rootFolder);
_eventAggregator.PublishEvent(new SeriesScanSkippedEvent(series, SeriesScanSkippedReason.RootFolderIsEmpty));
return;
}
_logger.ProgressInfo("Scanning {0}", series.Title);
if (!_diskProvider.FolderExists(series.Path))
{
if (_configService.CreateEmptySeriesFolders)
{
_logger.Debug("Creating missing series folder: {0}", series.Path);
_diskProvider.CreateFolder(series.Path);
SetPermissions(series.Path);
}
else
{
_logger.Debug("Series folder doesn't exist: {0}", series.Path);
}
CleanMediaFiles(series, new List <string>());
CompletedScanning(series);
return;
}
var videoFilesStopwatch = Stopwatch.StartNew();
var mediaFileList = FilterFiles(series.Path, GetVideoFiles(series.Path)).ToList();
videoFilesStopwatch.Stop();
_logger.Trace("Finished getting episode files for: {0} [{1}]", series, videoFilesStopwatch.Elapsed);
CleanMediaFiles(series, mediaFileList);
var decisionsStopwatch = Stopwatch.StartNew();
var decisions = _importDecisionMaker.GetImportDecisions(mediaFileList, series);
decisionsStopwatch.Stop();
_logger.Trace("Import decisions complete for: {0} [{1}]", series, decisionsStopwatch.Elapsed);
_importApprovedEpisodes.Import(decisions, false);
RemoveEmptySeriesFolder(series.Path);
CompletedScanning(series);
}
private void LinkRootFolderPath(params AuthorResource[] authors)
{
var rootFolders = _rootFolderService.All();
foreach (var author in authors)
{
author.RootFolderPath = _rootFolderService.GetBestRootFolderPath(author.Path, rootFolders);
}
}
public override HealthCheck Check()
{
var rootFolders = _seriesService.GetAllSeriesPaths().Select(s => _rootFolderService.GetBestRootFolderPath(s)).Distinct();
var missingRootFolders = rootFolders.Where(s => !_diskProvider.FolderExists(s))
.ToList();
if (missingRootFolders.Any())
{
if (missingRootFolders.Count == 1)
{
return(new HealthCheck(GetType(), HealthCheckResult.Error, "Missing root folder: " + missingRootFolders.First(), "#missing-root-folder"));
}
var message = string.Format("Multiple root folders are missing: {0}", string.Join(" | ", missingRootFolders));
return(new HealthCheck(GetType(), HealthCheckResult.Error, message, "#missing-root-folder"));
}
return(new HealthCheck(GetType()));
}
private string GetExistingRelativePath(Series series)
{
var rootFolderPath = _rootFolderService.GetBestRootFolderPath(series.Path);
return(rootFolderPath.GetRelativePath(series.Path));
}
private void LinkRootFolderPath(SeriesResource resource)
{
resource.RootFolderPath = _rootFolderService.GetBestRootFolderPath(resource.Path);
}
public void Scan(Artist artist, FilterFilesType filter = FilterFilesType.Known)
{
var rootFolder = _rootFolderService.GetBestRootFolderPath(artist.Path);
if (!_diskProvider.FolderExists(rootFolder))
{
_logger.Warn("Artist' root folder ({0}) doesn't exist.", rootFolder);
_eventAggregator.PublishEvent(new ArtistScanSkippedEvent(artist, ArtistScanSkippedReason.RootFolderDoesNotExist));
return;
}
if (_diskProvider.GetDirectories(rootFolder).Empty())
{
_logger.Warn("Artist' root folder ({0}) is empty.", rootFolder);
_eventAggregator.PublishEvent(new ArtistScanSkippedEvent(artist, ArtistScanSkippedReason.RootFolderIsEmpty));
return;
}
_logger.ProgressInfo("Scanning {0}", artist.Name);
if (!_diskProvider.FolderExists(artist.Path))
{
if (_configService.CreateEmptyArtistFolders)
{
_logger.Debug("Creating missing artist folder: {0}", artist.Path);
_diskProvider.CreateFolder(artist.Path);
SetPermissions(artist.Path);
}
else
{
_logger.Debug("Artist folder doesn't exist: {0}", artist.Path);
}
CleanMediaFiles(artist, new List <string>());
CompletedScanning(artist);
return;
}
var musicFilesStopwatch = Stopwatch.StartNew();
var mediaFileList = FilterFiles(artist.Path, GetAudioFiles(artist.Path)).ToList();
musicFilesStopwatch.Stop();
_logger.Trace("Finished getting track files for: {0} [{1}]", artist, musicFilesStopwatch.Elapsed);
CleanMediaFiles(artist, mediaFileList.Select(x => x.FullName).ToList());
var decisionsStopwatch = Stopwatch.StartNew();
var decisions = _importDecisionMaker.GetImportDecisions(mediaFileList, artist, filter, true);
decisionsStopwatch.Stop();
_logger.Debug("Import decisions complete for: {0} [{1}]", artist, decisionsStopwatch.Elapsed);
var importStopwatch = Stopwatch.StartNew();
_importApprovedTracks.Import(decisions, false);
// decisions may have been filtered to just new files. Anything new and approved will have been inserted.
// Now we need to make sure anything new but not approved gets inserted
// Note that knownFiles will include anything imported just now
var knownFiles = _mediaFileService.GetFilesWithBasePath(artist.Path);
var newFiles = decisions
.ExceptBy(x => x.Item.Path, knownFiles, x => x.Path, PathEqualityComparer.Instance)
.Select(decision => new TrackFile {
Path = decision.Item.Path,
Size = decision.Item.Size,
Modified = decision.Item.Modified,
DateAdded = DateTime.UtcNow,
Quality = decision.Item.Quality,
MediaInfo = decision.Item.FileTrackInfo.MediaInfo
})
.ToList();
_mediaFileService.AddMany(newFiles);
_logger.Debug($"Inserted {newFiles.Count} new unmatched trackfiles");
// finally update info on size/modified for existing files
var updatedFiles = knownFiles
.Join(decisions,
x => x.Path,
x => x.Item.Path,
(file, decision) => new {
File = file,
Item = decision.Item
},
PathEqualityComparer.Instance)
.Where(x => x.File.Size != x.Item.Size ||
Math.Abs((x.File.Modified - x.Item.Modified).TotalSeconds) > 1)
.Select(x => {
x.File.Size = x.Item.Size;
x.File.Modified = x.Item.Modified;
x.File.MediaInfo = x.Item.FileTrackInfo.MediaInfo;
x.File.Quality = x.Item.Quality;
return(x.File);
})
.ToList();
_mediaFileService.Update(updatedFiles);
_logger.Debug($"Updated info for {updatedFiles.Count} known files");
RemoveEmptyArtistFolder(artist.Path);
CompletedScanning(artist);
importStopwatch.Stop();
_logger.Debug("Track import complete for: {0} [{1}]", artist, importStopwatch.Elapsed);
}
private string GetExistingRelativePath(Author author)
{
var rootFolderPath = _rootFolderService.GetBestRootFolderPath(author.Path);
return(rootFolderPath.GetRelativePath(author.Path));
}
private string GetExistingRelativePath(Movie movie)
{
var rootFolderPath = _rootFolderService.GetBestRootFolderPath(movie.Path);
return(rootFolderPath.GetRelativePath(movie.Path));
}
public void Scan(Movie movie)
{
var rootFolder = _rootFolderService.GetBestRootFolderPath(movie.Path);
var movieFolderExists = _diskProvider.FolderExists(movie.Path);
if (!movieFolderExists)
{
if (!_diskProvider.FolderExists(rootFolder))
{
_logger.Warn("Movie's root folder ({0}) doesn't exist.", rootFolder);
_eventAggregator.PublishEvent(new MovieScanSkippedEvent(movie, MovieScanSkippedReason.RootFolderDoesNotExist));
return;
}
if (_diskProvider.FolderEmpty(rootFolder))
{
_logger.Warn("Movie's root folder ({0}) is empty.", rootFolder);
_eventAggregator.PublishEvent(new MovieScanSkippedEvent(movie, MovieScanSkippedReason.RootFolderIsEmpty));
return;
}
}
_logger.ProgressInfo("Scanning disk for {0}", movie.Title);
if (!movieFolderExists)
{
if (_configService.CreateEmptyMovieFolders)
{
if (_configService.DeleteEmptyFolders)
{
_logger.Debug("Not creating missing movie folder: {0} because delete empty series folders is enabled", movie.Path);
}
else
{
_logger.Debug("Creating missing series folder: {0}", movie.Path);
_diskProvider.CreateFolder(movie.Path);
SetPermissions(movie.Path);
}
}
else
{
_logger.Debug("Movies folder doesn't exist: {0}", movie.Path);
}
CleanMediaFiles(movie, new List <string>());
CompletedScanning(movie);
return;
}
var videoFilesStopwatch = Stopwatch.StartNew();
var mediaFileList = FilterPaths(movie.Path, GetVideoFiles(movie.Path)).ToList();
videoFilesStopwatch.Stop();
_logger.Trace("Finished getting movie files for: {0} [{1}]", movie, videoFilesStopwatch.Elapsed);
CleanMediaFiles(movie, mediaFileList);
var decisionsStopwatch = Stopwatch.StartNew();
var decisions = _importDecisionMaker.GetImportDecisions(mediaFileList, movie);
decisionsStopwatch.Stop();
_logger.Trace("Import decisions complete for: {0} [{1}]", movie, decisionsStopwatch.Elapsed);
_importApprovedMovies.Import(decisions, false);
RemoveEmptyMovieFolder(movie.Path);
CompletedScanning(movie);
}
public void Scan(Movie movie)
{
var rootFolder = _rootFolderService.GetBestRootFolderPath(movie.Path);
var movieFolderExists = _diskProvider.FolderExists(movie.Path);
if (!movieFolderExists)
{
if (!_diskProvider.FolderExists(rootFolder))
{
_logger.Warn("Movie's root folder ({0}) doesn't exist.", rootFolder);
_eventAggregator.PublishEvent(new MovieScanSkippedEvent(movie, MovieScanSkippedReason.RootFolderDoesNotExist));
return;
}
if (_diskProvider.FolderEmpty(rootFolder))
{
_logger.Warn("Movie's root folder ({0}) is empty.", rootFolder);
_eventAggregator.PublishEvent(new MovieScanSkippedEvent(movie, MovieScanSkippedReason.RootFolderIsEmpty));
return;
}
}
_logger.ProgressInfo("Scanning disk for {0}", movie.Title);
if (!movieFolderExists)
{
if (_configService.CreateEmptyMovieFolders)
{
if (_configService.DeleteEmptyFolders)
{
_logger.Debug("Not creating missing movie folder: {0} because delete empty movie folders is enabled", movie.Path);
}
else
{
_logger.Debug("Creating missing movie folder: {0}", movie.Path);
_diskProvider.CreateFolder(movie.Path);
SetPermissions(movie.Path);
}
}
else
{
_logger.Debug("Movie's folder doesn't exist: {0}", movie.Path);
}
CleanMediaFiles(movie, new List <string>());
CompletedScanning(movie);
return;
}
var videoFilesStopwatch = Stopwatch.StartNew();
var mediaFileList = FilterPaths(movie.Path, GetVideoFiles(movie.Path)).ToList();
videoFilesStopwatch.Stop();
_logger.Trace("Finished getting movie files for: {0} [{1}]", movie, videoFilesStopwatch.Elapsed);
CleanMediaFiles(movie, mediaFileList);
var movieFiles = _mediaFileService.GetFilesByMovie(movie.Id);
var unmappedFiles = MediaFileService.FilterExistingFiles(mediaFileList, movieFiles, movie);
var decisionsStopwatch = Stopwatch.StartNew();
var decisions = _importDecisionMaker.GetImportDecisions(unmappedFiles, movie, false);
decisionsStopwatch.Stop();
_logger.Trace("Import decisions complete for: {0} [{1}]", movie, decisionsStopwatch.Elapsed);
_importApprovedMovies.Import(decisions, false);
// Update existing files that have a different file size
var fileInfoStopwatch = Stopwatch.StartNew();
var filesToUpdate = new List <MovieFile>();
foreach (var file in movieFiles)
{
var path = Path.Combine(movie.Path, file.RelativePath);
var fileSize = _diskProvider.GetFileSize(path);
if (file.Size == fileSize)
{
continue;
}
file.Size = fileSize;
if (!_updateMediaInfoService.Update(file, movie))
{
filesToUpdate.Add(file);
}
}
// Update any files that had a file size change, but didn't get media info updated.
if (filesToUpdate.Any())
{
_mediaFileService.Update(filesToUpdate);
}
fileInfoStopwatch.Stop();
_logger.Trace("Reprocessing existing files complete for: {0} [{1}]", movie, decisionsStopwatch.Elapsed);
RemoveEmptyMovieFolder(movie.Path);
CompletedScanning(movie);
}
private string GetExistingRelativePath(Artist artist)
{
var rootFolderPath = _rootFolderService.GetBestRootFolderPath(artist.Path);
return(rootFolderPath.GetRelativePath(artist.Path));
}