private bool ChangeFileDate(MovieFile movieFile, Movie movie)
{
var movieFilePath = Path.Combine(movie.Path, movieFile.RelativePath);
switch (_configService.FileDate)
{
case FileDateType.Release:
{
var airDate = movie.PhysicalRelease;
if (airDate.HasValue == false)
{
return(false);
}
return(ChangeFileDate(movieFilePath, airDate.Value));
}
case FileDateType.Cinemas:
{
var airDate = movie.InCinemas;
if (airDate.HasValue == false)
{
return(false);
}
return(ChangeFileDate(movieFilePath, airDate.Value));
}
}
return(false);
}
private void EnsureMovieFolder(MovieFile movieFile, Movie movie, string filePath)
{
var movieFolder = Path.GetDirectoryName(filePath);
//movie.Path = movieFolder;
var rootFolder = new OsPath(movieFolder).Directory.FullPath;
var fileName = Path.GetFileName(filePath);
if (!_diskProvider.FolderExists(rootFolder))
{
throw new DirectoryNotFoundException(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 (changed)
{
_eventAggregator.PublishEvent(newEvent);
}
}
public void Delete(MovieFile movieFile, DeleteMediaFileReason reason)
{
//Little hack so we have the movie attached for the event consumers
movieFile.Movie.LazyLoad();
movieFile.Path = Path.Combine(movieFile.Movie.Value.Path, movieFile.RelativePath);
_mediaFileRepository.Delete(movieFile);
_eventAggregator.PublishEvent(new MovieFileDeletedEvent(movieFile, reason));
}
private MovieFile TransferFile(MovieFile movieFile, Movie movie, string destinationFilePath, TransferMode mode)
{
Ensure.That(movieFile, () => movieFile).IsNotNull();
Ensure.That(movie, () => movie).IsNotNull();
Ensure.That(destinationFilePath, () => destinationFilePath).IsValidPath();
var movieFilePath = movieFile.Path ?? Path.Combine(movie.Path, movieFile.RelativePath);
if (!_diskProvider.FileExists(movieFilePath))
{
throw new FileNotFoundException("Movie file path does not exist", movieFilePath);
}
if (movieFilePath == destinationFilePath)
{
throw new SameFilenameException("File not moved, source and destination are the same", movieFilePath);
}
_diskTransferService.TransferFile(movieFilePath, destinationFilePath, mode);
var oldMoviePath = movie.Path;
var newMoviePath = new OsPath(destinationFilePath).Directory.FullPath.TrimEnd(Path.DirectorySeparatorChar);
movie.Path = newMoviePath;
if (oldMoviePath != newMoviePath)
{
_movieService.UpdateMovie(movie);
}
movieFile.RelativePath = movie.Path.GetRelativePath(destinationFilePath);
_updateMovieFileService.ChangeFileDateForFile(movieFile, movie);
try
{
_mediaFileAttributeService.SetFolderLastWriteTime(movie.Path, movieFile.DateAdded);
}
catch (Exception ex)
{
_logger.Warn(ex, "Unable to set last write time");
}
_mediaFileAttributeService.SetFilePermissions(destinationFilePath);
if (oldMoviePath != newMoviePath)
{
if (_diskProvider.GetFiles(oldMoviePath, SearchOption.AllDirectories).Count() == 0)
{
_recycleBinProvider.DeleteFolder(oldMoviePath);
}
}
return(movieFile);
}
public MovieFile MoveMovieFile(MovieFile movieFile, Movie movie)
{
var newFileName = _buildFileNames.BuildFileName(movie, movieFile);
var filePath = _buildFileNames.BuildFilePath(movie, newFileName, Path.GetExtension(movieFile.RelativePath));
EnsureMovieFolder(movieFile, movie, filePath);
_logger.Debug("Renaming movie file: {0} to {1}", movieFile, filePath);
return(TransferFile(movieFile, movie, filePath, TransferMode.Move));
}
public MovieFile MoveMovieFile(MovieFile movieFile, LocalMovie localMovie)
{
var newFileName = _buildFileNames.BuildFileName(localMovie.Movie, movieFile);
var filePath = _buildFileNames.BuildFilePath(localMovie.Movie, newFileName, Path.GetExtension(localMovie.Path));
EnsureMovieFolder(movieFile, localMovie, filePath);
_logger.Debug("Moving movie file: {0} to {1}", movieFile.Path, filePath);
return(TransferFile(movieFile, localMovie.Movie, filePath, TransferMode.Move));
}
public void Delete(MovieFile movieFile, DeleteMediaFileReason reason)
{
//Little hack so we have the movie attached for the event consumers
if (movieFile.Movie == null)
{
movieFile.Movie = _movieRepository.Get(movieFile.MovieId);
}
movieFile.Path = Path.Combine(movieFile.Movie.Path, movieFile.RelativePath);
_mediaFileRepository.Delete(movieFile);
_eventAggregator.PublishEvent(new MovieFileDeletedEvent(movieFile, reason));
}
public MovieFile Add(MovieFile movieFile)
{
var addedFile = _mediaFileRepository.Insert(movieFile);
if (addedFile.Movie == null)
{
addedFile.Movie = _movieRepository.Get(movieFile.MovieId);
}
_eventAggregator.PublishEvent(new MovieFileAddedEvent(addedFile));
return(addedFile);
}
public MovieFile Add(MovieFile movieFile)
{
var addedFile = _mediaFileRepository.Insert(movieFile);
addedFile.Movie.LazyLoad();
if (addedFile.Movie == null || addedFile.Movie.Value == null)
{
_logger.Error("Movie is null for the file {0}. Please run the houskeeping command to ensure movies and files are linked correctly.");
}
//_movieService.SetFileId(addedFile.Movie.Value, addedFile); //Should not be necessary, but sometimes below fails?
_eventAggregator.PublishEvent(new MovieFileAddedEvent(addedFile));
return(addedFile);
}
public MovieFile CopyMovieFile(MovieFile movieFile, LocalMovie localMovie)
{
var newFileName = _buildFileNames.BuildFileName(localMovie.Movie, movieFile);
var filePath = _buildFileNames.BuildFilePath(localMovie.Movie, newFileName, Path.GetExtension(localMovie.Path));
EnsureMovieFolder(movieFile, localMovie, filePath);
if (_configService.CopyUsingHardlinks)
{
_logger.Debug("Hardlinking movie file: {0} to {1}", movieFile.Path, filePath);
return(TransferFile(movieFile, localMovie.Movie, filePath, TransferMode.HardLinkOrCopy));
}
_logger.Debug("Copying movie file: {0} to {1}", movieFile.Path, filePath);
return(TransferFile(movieFile, localMovie.Movie, filePath, TransferMode.Copy));
}
public MovieFileMoveResult UpgradeMovieFile(MovieFile movieFile, LocalMovie localMovie, bool copyOnly = false)
{
_logger.Trace("Upgrading existing movie file.");
var moveFileResult = new MovieFileMoveResult();
var existingFile = localMovie.Movie.MovieFile;
if (existingFile != null)
{
var movieFilePath = Path.Combine(localMovie.Movie.Path, existingFile.RelativePath);
if (_diskProvider.FileExists(movieFilePath))
{
_logger.Debug("Removing existing movie file: {0}", existingFile);
_recycleBinProvider.DeleteFile(movieFilePath);
}
moveFileResult.OldFiles.Add(existingFile);
_mediaFileService.Delete(existingFile, DeleteMediaFileReason.Upgrade);
}
//Temporary for correctly getting path
localMovie.Movie.MovieFileId = 1;
localMovie.Movie.MovieFile = movieFile;
if (copyOnly)
{
moveFileResult.MovieFile = _movieFileMover.CopyMovieFile(movieFile, localMovie);
}
else
{
moveFileResult.MovieFile = _movieFileMover.MoveMovieFile(movieFile, localMovie);
}
localMovie.Movie.MovieFileId = existingFile?.Id ?? 0;
localMovie.Movie.MovieFile = existingFile;
//_movieFileRenamer.RenameMoviePath(localMovie.Movie, false);
return(moveFileResult);
}
public MovieFileMoveResult UpgradeMovieFile(MovieFile movieFile, LocalMovie localMovie, bool copyOnly = false)
{
_logger.Trace("Upgrading existing movie file.");
var moveFileResult = new MovieFileMoveResult();
var existingFile = localMovie.Movie.MovieFileId > 0 ? localMovie.Movie.MovieFile : null;
var rootFolder = _diskProvider.GetParentFolder(localMovie.Movie.Path);
// If there are existing movie files and the root folder is missing, throw, so the old file isn't left behind during the import process.
if (existingFile != null && !_diskProvider.FolderExists(rootFolder))
{
throw new RootFolderNotFoundException($"Root folder '{rootFolder}' was not found.");
}
if (existingFile != null)
{
var movieFilePath = Path.Combine(localMovie.Movie.Path, existingFile.RelativePath);
var subfolder = rootFolder.GetRelativePath(_diskProvider.GetParentFolder(movieFilePath));
if (_diskProvider.FileExists(movieFilePath))
{
_logger.Debug("Removing existing movie file: {0}", existingFile);
_recycleBinProvider.DeleteFile(movieFilePath, subfolder);
}
moveFileResult.OldFiles.Add(existingFile);
_mediaFileService.Delete(existingFile, DeleteMediaFileReason.Upgrade);
}
if (copyOnly)
{
moveFileResult.MovieFile = _movieFileMover.CopyMovieFile(movieFile, localMovie);
}
else
{
moveFileResult.MovieFile = _movieFileMover.MoveMovieFile(movieFile, localMovie);
}
return(moveFileResult);
}
public void DeleteMovieFile(Movie movie, MovieFile movieFile)
{
var fullPath = Path.Combine(movie.Path, movieFile.RelativePath);
var rootFolder = _diskProvider.GetParentFolder(movie.Path);
if (!_diskProvider.FolderExists(rootFolder))
{
_logger.Warn("Movie's root folder ({0}) doesn't exist.", rootFolder);
throw new NzbDroneClientException(HttpStatusCode.Conflict, "Movie's root folder ({0}) doesn't exist.", rootFolder);
}
if (_diskProvider.GetDirectories(rootFolder).Empty())
{
_logger.Warn("Movie's root folder ({0}) is empty.", rootFolder);
throw new NzbDroneClientException(HttpStatusCode.Conflict, "Movie's root folder ({0}) is empty.", rootFolder);
}
if (_diskProvider.FolderExists(movie.Path) && _diskProvider.FileExists(fullPath))
{
_logger.Info("Deleting movie file: {0}", fullPath);
var subfolder = _diskProvider.GetParentFolder(movie.Path).GetRelativePath(_diskProvider.GetParentFolder(fullPath));
try
{
_recycleBinProvider.DeleteFile(fullPath, subfolder);
}
catch (Exception e)
{
_logger.Error(e, "Unable to delete movie file");
throw new NzbDroneClientException(HttpStatusCode.InternalServerError, "Unable to delete movie file");
}
}
// Delete the movie file from the database to clean it up even if the file was already deleted
_mediaFileService.Delete(movieFile, DeleteMediaFileReason.Manual);
_eventAggregator.PublishEvent(new DeleteCompletedEvent());
}
private MovieFile TransferFile(MovieFile movieFile, Movie movie, string destinationFilePath, TransferMode mode)
{
Ensure.That(movieFile, () => movieFile).IsNotNull();
Ensure.That(movie, () => movie).IsNotNull();
Ensure.That(destinationFilePath, () => destinationFilePath).IsValidPath();
var movieFilePath = movieFile.Path ?? Path.Combine(movie.Path, movieFile.RelativePath);
if (!_diskProvider.FileExists(movieFilePath))
{
throw new FileNotFoundException("Movie file path does not exist", movieFilePath);
}
if (movieFilePath == destinationFilePath)
{
throw new SameFilenameException("File not moved, source and destination are the same", movieFilePath);
}
_diskTransferService.TransferFile(movieFilePath, destinationFilePath, mode);
movieFile.RelativePath = movie.Path.GetRelativePath(destinationFilePath);
_updateMovieFileService.ChangeFileDateForFile(movieFile, movie);
try
{
_mediaFileAttributeService.SetFolderLastWriteTime(movie.Path, movieFile.DateAdded);
}
catch (Exception ex)
{
_logger.Warn(ex, "Unable to set last write time");
}
_mediaFileAttributeService.SetFilePermissions(destinationFilePath);
return(movieFile);
}
private void EnsureMovieFolder(MovieFile movieFile, LocalMovie localMovie, string filePath)
{
EnsureMovieFolder(movieFile, localMovie.Movie, filePath);
}
public void Update(MovieFile movieFile)
{
_mediaFileRepository.Update(movieFile);
}
public void ChangeFileDateForFile(MovieFile movieFile, Movie movie)
{
ChangeFileDate(movieFile, movie);
}
private MovieFile TransferFile(MovieFile movieFile, Movie movie, string destinationFilePath, TransferMode mode)
{
Ensure.That(movieFile, () => movieFile).IsNotNull();
Ensure.That(movie, () => movie).IsNotNull();
Ensure.That(destinationFilePath, () => destinationFilePath).IsValidPath();
var movieFilePath = movieFile.Path ?? Path.Combine(movie.Path, movieFile.RelativePath);
if (!_diskProvider.FileExists(movieFilePath))
{
throw new FileNotFoundException("Movie file path does not exist", movieFilePath);
}
if (movieFilePath == destinationFilePath)
{
throw new SameFilenameException("File not moved, source and destination are the same", movieFilePath);
}
_diskTransferService.TransferFile(movieFilePath, destinationFilePath, mode);
var oldMoviePath = movie.Path;
var newMoviePath = new OsPath(destinationFilePath).Directory.FullPath.TrimEnd(Path.DirectorySeparatorChar);
movie.Path = newMoviePath; //We update it when everything went well!
movieFile.RelativePath = movie.Path.GetRelativePath(destinationFilePath);
_updateMovieFileService.ChangeFileDateForFile(movieFile, movie);
try
{
_mediaFileAttributeService.SetFolderLastWriteTime(movie.Path, movieFile.DateAdded);
}
catch (Exception ex)
{
_logger.Warn(ex, "Unable to set last write time");
}
_mediaFileAttributeService.SetFilePermissions(destinationFilePath);
if (oldMoviePath != newMoviePath && _diskProvider.FolderExists(oldMoviePath))
{
//Let's move the old files before deleting the old folder. We could just do move folder, but the main file (movie file) is already moved, so eh.
var files = _diskProvider.GetFiles(oldMoviePath, SearchOption.AllDirectories);
foreach (var file in files)
{
try
{
var destFile = Path.Combine(newMoviePath, oldMoviePath.GetRelativePath(file));
_diskProvider.EnsureFolder(Path.GetDirectoryName(destFile));
_diskProvider.MoveFile(file, destFile);
}
catch (Exception e)
{
_logger.Warn(e, "Error while trying to move extra file {0} to new folder. Maybe it already exists? (Manual cleanup necessary!).", oldMoviePath.GetRelativePath(file));
}
}
if (_diskProvider.GetFiles(oldMoviePath, SearchOption.AllDirectories).Count() == 0)
{
_recycleBinProvider.DeleteFolder(oldMoviePath);
}
}
//Only update the movie path if we were successfull!
if (oldMoviePath != newMoviePath)
{
_movieService.UpdateMovie(movie);
}
return(movieFile);
}