public TrackFile MoveTrackFile(TrackFile trackFile, LocalTrack localTrack)
{
var newFileName = _buildFileNames.BuildTrackFileName(localTrack.Tracks, localTrack.Artist, localTrack.Album, trackFile);
var filePath = _buildFileNames.BuildTrackFilePath(localTrack.Artist, newFileName, Path.GetExtension(localTrack.Path));
EnsureTrackFolder(trackFile, localTrack, filePath);
_logger.Debug("Moving track file: {0} to {1}", trackFile.Path, filePath);
return(TransferFile(trackFile, localTrack.Artist, localTrack.Tracks, filePath, TransferMode.Move));
}
public TrackFile MoveTrackFile(TrackFile trackFile, Artist artist)
{
var tracks = _trackService.GetTracksByFileId(trackFile.Id);
var album = _albumService.GetAlbum(trackFile.AlbumId);
var newFileName = _buildFileNames.BuildTrackFileName(tracks, artist, album, trackFile);
var filePath = _buildFileNames.BuildTrackFilePath(artist, album, newFileName, Path.GetExtension(trackFile.Path));
EnsureTrackFolder(trackFile, artist, album, filePath);
_logger.Debug("Renaming track file: {0} to {1}", trackFile, filePath);
return(TransferFile(trackFile, artist, tracks, filePath, TransferMode.Move));
}
private bool ChangeFileDate(TrackFile trackFile, Artist artist, List <Track> tracks)
{
var trackFilePath = trackFile.Path;
switch (_configService.FileDate)
{
case FileDateType.AlbumReleaseDate:
{
var album = _albumService.GetAlbum(trackFile.AlbumId);
if (!album.ReleaseDate.HasValue)
{
_logger.Debug("Could not create valid date to change file [{0}]", trackFilePath);
return(false);
}
var relDate = album.ReleaseDate.Value;
// avoiding false +ve checks and set date skewing by not using UTC (Windows)
DateTime oldDateTime = _diskProvider.FileGetLastWrite(trackFilePath);
if (OsInfo.IsNotWindows && relDate < EpochTime)
{
_logger.Debug("Setting date of file to 1970-01-01 as actual airdate is before that time and will not be set properly");
relDate = EpochTime;
}
if (!DateTime.Equals(relDate, oldDateTime))
{
try
{
_diskProvider.FileSetLastWriteTime(trackFilePath, relDate);
_logger.Debug("Date of file [{0}] changed from '{1}' to '{2}'", trackFilePath, oldDateTime, relDate);
return(true);
}
catch (Exception ex)
{
_logger.Warn(ex, "Unable to set date of file [" + trackFilePath + "]");
}
}
return(false);
}
}
return(false);
}
public TrackFile CopyTrackFile(TrackFile trackFile, LocalTrack localTrack)
{
var newFileName = _buildFileNames.BuildTrackFileName(localTrack.Tracks, localTrack.Artist, localTrack.Album, trackFile);
var filePath = _buildFileNames.BuildTrackFilePath(localTrack.Artist, localTrack.Album, newFileName, Path.GetExtension(localTrack.Path));
EnsureTrackFolder(trackFile, localTrack, filePath);
if (_configService.CopyUsingHardlinks)
{
_logger.Debug("Hardlinking track file: {0} to {1}", trackFile.Path, filePath);
return(TransferFile(trackFile, localTrack.Artist, localTrack.Tracks, filePath, TransferMode.HardLinkOrCopy));
}
_logger.Debug("Copying track file: {0} to {1}", trackFile.Path, filePath);
return(TransferFile(trackFile, localTrack.Artist, localTrack.Tracks, filePath, TransferMode.Copy));
}
public TrackFileMoveResult UpgradeTrackFile(TrackFile trackFile, LocalTrack localTrack, bool copyOnly = false)
{
var moveFileResult = new TrackFileMoveResult();
var existingFiles = localTrack.Tracks
.Where(e => e.TrackFileId > 0)
.Select(e => e.TrackFile.Value)
.Where(e => e != null)
.GroupBy(e => e.Id)
.ToList();
var rootFolder = _diskProvider.GetParentFolder(localTrack.Artist.Path);
// If there are existing track files and the root folder is missing, throw, so the old file isn't left behind during the import process.
if (existingFiles.Any() && !_diskProvider.FolderExists(rootFolder))
{
throw new RootFolderNotFoundException($"Root folder '{rootFolder}' was not found.");
}
foreach (var existingFile in existingFiles)
{
var file = existingFile.First();
var trackFilePath = file.Path;
var subfolder = rootFolder.GetRelativePath(_diskProvider.GetParentFolder(trackFilePath));
if (_diskProvider.FileExists(trackFilePath))
{
_logger.Debug("Removing existing track file: {0}", file);
_recycleBinProvider.DeleteFile(trackFilePath, subfolder);
}
moveFileResult.OldFiles.Add(file);
_mediaFileService.Delete(file, DeleteMediaFileReason.Upgrade);
}
if (copyOnly)
{
moveFileResult.TrackFile = _trackFileMover.CopyTrackFile(trackFile, localTrack);
}
else
{
moveFileResult.TrackFile = _trackFileMover.MoveTrackFile(trackFile, localTrack);
}
_audioTagService.WriteTags(trackFile, true);
return(moveFileResult);
}
private TrackFile TransferFile(TrackFile trackFile, Artist artist, List <Track> tracks, string destinationFilePath, TransferMode mode)
{
Ensure.That(trackFile, () => trackFile).IsNotNull();
Ensure.That(artist, () => artist).IsNotNull();
Ensure.That(destinationFilePath, () => destinationFilePath).IsValidPath();
var trackFilePath = trackFile.Path;
if (!_diskProvider.FileExists(trackFilePath))
{
throw new FileNotFoundException("Track file path does not exist", trackFilePath);
}
if (trackFilePath == destinationFilePath)
{
throw new SameFilenameException("File not moved, source and destination are the same", trackFilePath);
}
_diskTransferService.TransferFile(trackFilePath, destinationFilePath, mode);
trackFile.Path = destinationFilePath;
_updateTrackFileService.ChangeFileDateForFile(trackFile, artist, tracks);
try
{
_mediaFileAttributeService.SetFolderLastWriteTime(artist.Path, trackFile.DateAdded);
if (artist.AlbumFolder)
{
var albumFolder = Path.GetDirectoryName(destinationFilePath);
_mediaFileAttributeService.SetFolderLastWriteTime(albumFolder, trackFile.DateAdded);
}
}
catch (Exception ex)
{
_logger.Warn(ex, "Unable to set last write time");
}
_mediaFileAttributeService.SetFilePermissions(destinationFilePath);
return(trackFile);
}
private void EnsureTrackFolder(TrackFile trackFile, Artist artist, Album album, string filePath)
{
var trackFolder = Path.GetDirectoryName(filePath);
var albumFolder = _buildFileNames.BuildAlbumPath(artist, album);
var artistFolder = artist.Path;
var rootFolder = new OsPath(artistFolder).Directory.FullPath;
if (!_diskProvider.FolderExists(rootFolder))
{
throw new RootFolderNotFoundException(string.Format("Root folder '{0}' was not found.", rootFolder));
}
var changed = false;
var newEvent = new TrackFolderCreatedEvent(artist, trackFile);
if (!_diskProvider.FolderExists(artistFolder))
{
CreateFolder(artistFolder);
newEvent.ArtistFolder = artistFolder;
changed = true;
}
if (artistFolder != albumFolder && !_diskProvider.FolderExists(albumFolder))
{
CreateFolder(albumFolder);
newEvent.AlbumFolder = albumFolder;
changed = true;
}
if (albumFolder != trackFolder && !_diskProvider.FolderExists(trackFolder))
{
CreateFolder(trackFolder);
newEvent.TrackFolder = trackFolder;
changed = true;
}
if (changed)
{
_eventAggregator.PublishEvent(newEvent);
}
}
public void DeleteTrackFile(TrackFile trackFile, string subfolder = "")
{
var fullPath = trackFile.Path;
if (_diskProvider.FileExists(fullPath))
{
_logger.Info("Deleting track file: {0}", fullPath);
try
{
_recycleBinProvider.DeleteFile(fullPath, subfolder);
}
catch (Exception e)
{
_logger.Error(e, "Unable to delete track file");
throw new NzbDroneClientException(HttpStatusCode.InternalServerError, "Unable to delete track file");
}
}
// Delete the track file from the database to clean it up even if the file was already deleted
_mediaFileService.Delete(trackFile, DeleteMediaFileReason.Manual);
}
public void ChangeFileDateForFile(TrackFile trackFile, Artist artist, List <Track> tracks)
{
ChangeFileDate(trackFile, artist, tracks);
}
private void EnsureTrackFolder(TrackFile trackFile, LocalTrack localTrack, string filePath)
{
EnsureTrackFolder(trackFile, localTrack.Artist, localTrack.Album, filePath);
}
