public BookFile Add(BookFile bookFile)
{
var addedFile = _mediaFileRepository.Insert(bookFile);
_eventAggregator.PublishEvent(new BookFileAddedEvent(addedFile));
return(addedFile);
}
public void WriteTags(BookFile trackfile, bool newDownload, bool force = false)
{
if (!force)
{
if (_configService.WriteAudioTags == WriteAudioTagsType.No ||
(_configService.WriteAudioTags == WriteAudioTagsType.NewFiles && !newDownload))
{
return;
}
}
var newTags = GetTrackMetadata(trackfile);
var path = trackfile.Path;
var diff = ReadAudioTag(path).Diff(newTags);
_rootFolderWatchingService.ReportFileSystemChangeBeginning(path);
if (_configService.ScrubAudioTags)
{
_logger.Debug($"Scrubbing tags for {trackfile}");
RemoveAllTags(path);
}
_logger.Debug($"Writing tags for {trackfile}");
newTags.Write(path);
UpdateTrackfileSizeAndModified(trackfile, path);
_eventAggregator.PublishEvent(new BookFileRetaggedEvent(trackfile.Author.Value, trackfile, diff, _configService.ScrubAudioTags));
}
public void DeleteTrackFile(Author author, BookFile bookFile)
{
var fullPath = bookFile.Path;
var rootFolder = _diskProvider.GetParentFolder(author.Path);
if (!_diskProvider.FolderExists(rootFolder))
{
_logger.Warn("Author's root folder ({0}) doesn't exist.", rootFolder);
throw new NzbDroneClientException(HttpStatusCode.Conflict, "Author's root folder ({0}) doesn't exist.", rootFolder);
}
if (_diskProvider.GetDirectories(rootFolder).Empty())
{
_logger.Warn("Author's root folder ({0}) is empty.", rootFolder);
throw new NzbDroneClientException(HttpStatusCode.Conflict, "Author's root folder ({0}) is empty.", rootFolder);
}
if (_diskProvider.FolderExists(author.Path))
{
var subfolder = _diskProvider.GetParentFolder(author.Path).GetRelativePath(_diskProvider.GetParentFolder(fullPath));
DeleteTrackFile(bookFile, subfolder);
}
else
{
// delete from db even if the author folder is missing
_mediaFileService.Delete(bookFile, DeleteMediaFileReason.Manual);
}
}
public void Delete(BookFile bookFile, DeleteMediaFileReason reason)
{
_mediaFileRepository.Delete(bookFile);
// If the trackfile wasn't mapped to a track, don't publish an event
if (bookFile.EditionId > 0)
{
_eventAggregator.PublishEvent(new BookFileDeletedEvent(bookFile, reason));
}
}
public BookFile CalibreAddAndConvert(BookFile file, CalibreSettings settings)
{
_logger.Trace($"Importing to calibre: {file.Path}");
if (file.CalibreId == 0)
{
var import = _calibre.AddBook(file, settings);
file.CalibreId = import.Id;
}
else
{
_calibre.AddFormat(file, settings);
}
_calibre.SetFields(file, settings);
var updated = _calibre.GetBook(file.CalibreId, settings);
var path = updated.Formats.Values.OrderByDescending(x => x.LastModified).First().Path;
file.Path = path;
_rootFolderWatchingService.ReportFileSystemChangeBeginning(file.Path);
if (settings.OutputFormat.IsNotNullOrWhiteSpace())
{
_logger.Trace($"Getting book data for {file.CalibreId}");
var options = _calibre.GetBookData(file.CalibreId, settings);
var inputFormat = file.Quality.Quality.Name.ToUpper();
options.Conversion_options.Input_fmt = inputFormat;
var formats = settings.OutputFormat.Split(',').Select(x => x.Trim());
foreach (var format in formats)
{
if (format.ToLower() == inputFormat ||
options.Input_formats.Contains(format, StringComparer.OrdinalIgnoreCase))
{
continue;
}
options.Conversion_options.Output_fmt = format;
if (settings.OutputProfile != (int)CalibreProfile.Default)
{
options.Conversion_options.Options.Output_profile = ((CalibreProfile)settings.OutputProfile).ToString();
}
_logger.Trace($"Starting conversion to {format}");
_calibre.ConvertBook(file.CalibreId, options.Conversion_options, settings);
}
}
return(file);
}
public BookFile MoveBookFile(BookFile bookFile, LocalBook localBook)
{
var newFileName = _buildFileNames.BuildBookFileName(localBook.Author, localBook.Edition, bookFile);
var filePath = _buildFileNames.BuildBookFilePath(localBook.Author, localBook.Edition, newFileName, Path.GetExtension(localBook.Path));
EnsureTrackFolder(bookFile, localBook, filePath);
_logger.Debug("Moving book file: {0} to {1}", bookFile.Path, filePath);
return(TransferFile(bookFile, localBook.Author, localBook.Book, filePath, TransferMode.Move));
}
private void WriteTagsInternal(BookFile file, bool updateCover, bool embedMetadata)
{
if (file.CalibreId == 0)
{
_logger.Trace($"No calibre id for {file.Path}, skipping writing tags");
}
var rootFolder = _rootFolderService.GetBestRootFolder(file.Path);
_calibre.SetFields(file, rootFolder.CalibreSettings, updateCover, embedMetadata);
}
public BookFile MoveBookFile(BookFile bookFile, Author author)
{
var edition = _editionService.GetEdition(bookFile.EditionId);
var newFileName = _buildFileNames.BuildBookFileName(author, edition, bookFile);
var filePath = _buildFileNames.BuildBookFilePath(author, edition, newFileName, Path.GetExtension(bookFile.Path));
EnsureBookFolder(bookFile, author, edition.Book.Value, filePath);
_logger.Debug("Renaming book file: {0} to {1}", bookFile, filePath);
return(TransferFile(bookFile, author, bookFile.Edition.Value.Book.Value, filePath, TransferMode.Move));
}
public void WriteTags(BookFile bookFile, bool newDownload, bool force = false)
{
var extension = Path.GetExtension(bookFile.Path);
if (MediaFileExtensions.AudioExtensions.Contains(extension))
{
_audioTagService.WriteTags(bookFile, newDownload, force);
}
else if (bookFile.CalibreId > 0)
{
_eBookTagService.WriteTags(bookFile, newDownload, force);
}
}
private void UpdateTrackfileSizeAndModified(BookFile trackfile, string path)
{
// update the saved file size so that the importer doesn't get confused on the next scan
var fileInfo = _diskProvider.GetFileInfo(path);
trackfile.Size = fileInfo.Length;
trackfile.Modified = fileInfo.LastWriteTimeUtc;
if (trackfile.Id > 0)
{
_mediaFileService.Update(trackfile);
}
}
public void DeleteTrackFile(BookFile bookFile, string subfolder = "")
{
var fullPath = bookFile.Path;
if (_diskProvider.FileExists(fullPath))
{
_logger.Info("Deleting book file: {0}", fullPath);
DeleteFile(bookFile, subfolder);
}
// Delete the track file from the database to clean it up even if the file was already deleted
_mediaFileService.Delete(bookFile, DeleteMediaFileReason.Manual);
}
public AudioTag GetTrackMetadata(BookFile trackfile)
{
var edition = trackfile.Edition.Value;
var book = edition.Book.Value;
var author = book.Author.Value;
var partCount = edition.BookFiles.Value.Count;
var fileTags = ReadAudioTag(trackfile.Path);
var cover = edition.Images.FirstOrDefault(x => x.CoverType == MediaCoverTypes.Cover);
string imageFile = null;
long imageSize = 0;
if (cover != null)
{
imageFile = _mediaCoverService.GetCoverPath(book.Id, MediaCoverEntity.Book, cover.CoverType, cover.Extension, null);
_logger.Trace($"Embedding: {imageFile}");
var fileInfo = _diskProvider.GetFileInfo(imageFile);
if (fileInfo.Exists)
{
imageSize = fileInfo.Length;
}
else
{
imageFile = null;
}
}
return(new AudioTag
{
Title = edition.Title,
Performers = new[] { author.Name },
BookAuthors = new[] { author.Name },
Track = (uint)trackfile.Part,
TrackCount = (uint)partCount,
Book = book.Title,
Disc = fileTags.Disc,
DiscCount = fileTags.DiscCount,
// We may have omitted media so index in the list isn't the same as medium number
Media = fileTags.Media,
Date = edition.ReleaseDate,
Year = (uint)(edition.ReleaseDate?.Year ?? 0),
OriginalReleaseDate = book.ReleaseDate,
OriginalYear = (uint)(book.ReleaseDate?.Year ?? 0),
Publisher = edition.Publisher,
Genres = new string[0],
ImageFile = imageFile,
ImageSize = imageSize,
});
}
public void WriteTags(BookFile bookFile, bool newDownload, bool force = false)
{
if (!force)
{
if (_configService.WriteBookTags == WriteBookTagsType.NewFiles && !newDownload)
{
return;
}
}
_logger.Debug($"Writing tags for {bookFile}");
WriteTagsInternal(bookFile, _configService.UpdateCovers, _configService.EmbedMetadata);
}
public BookFile CopyBookFile(BookFile bookFile, LocalBook localBook)
{
var newFileName = _buildFileNames.BuildBookFileName(localBook.Author, localBook.Edition, bookFile);
var filePath = _buildFileNames.BuildBookFilePath(localBook.Author, localBook.Edition, newFileName, Path.GetExtension(localBook.Path));
EnsureTrackFolder(bookFile, localBook, filePath);
if (_configService.CopyUsingHardlinks)
{
_logger.Debug("Hardlinking book file: {0} to {1}", bookFile.Path, filePath);
return(TransferFile(bookFile, localBook.Author, localBook.Book, filePath, TransferMode.HardLinkOrCopy));
}
_logger.Debug("Copying book file: {0} to {1}", bookFile.Path, filePath);
return(TransferFile(bookFile, localBook.Author, localBook.Book, filePath, TransferMode.Copy));
}
public void WriteTags(BookFile bookFile, bool newDownload, bool force = false)
{
if (!force)
{
if (_configService.WriteBookTags == WriteBookTagsType.NewFiles && !newDownload)
{
return;
}
}
_logger.Debug($"Writing tags for {bookFile}");
var rootFolder = _rootFolderService.GetBestRootFolder(bookFile.Path);
_calibre.SetFields(bookFile, rootFolder.CalibreSettings, _configService.UpdateCovers, _configService.EmbedMetadata);
}
private bool ChangeFileDate(BookFile bookFile, Book book)
{
var bookFilePath = bookFile.Path;
switch (_configService.FileDate)
{
case FileDateType.BookReleaseDate:
{
if (!book.ReleaseDate.HasValue)
{
_logger.Debug("Could not create valid date to change file [{0}]", bookFilePath);
return(false);
}
var relDate = book.ReleaseDate.Value;
// avoiding false +ve checks and set date skewing by not using UTC (Windows)
var oldDateTime = _diskProvider.FileGetLastWrite(bookFilePath);
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(bookFilePath, relDate);
_logger.Debug("Date of file [{0}] changed from '{1}' to '{2}'", bookFilePath, oldDateTime, relDate);
return(true);
}
catch (Exception ex)
{
_logger.Warn(ex, "Unable to set date of file [" + bookFilePath + "]");
}
}
return(false);
}
}
return(false);
}
private void EnsureBookFolder(BookFile bookFile, Author author, Book book, string filePath)
{
var trackFolder = Path.GetDirectoryName(filePath);
var bookFolder = _buildFileNames.BuildBookPath(author);
var authorFolder = author.Path;
var rootFolder = new OsPath(authorFolder).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(author, bookFile);
_rootFolderWatchingService.ReportFileSystemChangeBeginning(authorFolder, bookFolder, trackFolder);
if (!_diskProvider.FolderExists(authorFolder))
{
CreateFolder(authorFolder);
newEvent.AuthorFolder = authorFolder;
changed = true;
}
if (authorFolder != bookFolder && !_diskProvider.FolderExists(bookFolder))
{
CreateFolder(bookFolder);
newEvent.BookFolder = bookFolder;
changed = true;
}
if (bookFolder != trackFolder && !_diskProvider.FolderExists(trackFolder))
{
CreateFolder(trackFolder);
newEvent.TrackFolder = trackFolder;
changed = true;
}
if (changed)
{
_eventAggregator.PublishEvent(newEvent);
}
}
private void DeleteFile(BookFile bookFile, string subfolder = "")
{
var rootFolder = _rootFolderService.GetBestRootFolder(bookFile.Path);
var isCalibre = rootFolder.IsCalibreLibrary && rootFolder.CalibreSettings != null;
try
{
if (!isCalibre)
{
_recycleBinProvider.DeleteFile(bookFile.Path, subfolder);
}
else
{
_calibre.DeleteBook(bookFile, rootFolder.CalibreSettings);
}
}
catch (Exception e)
{
_logger.Error(e, "Unable to delete book file");
throw new NzbDroneClientException(HttpStatusCode.InternalServerError, "Unable to delete book file");
}
}
public void DeleteTrackFile(BookFile bookFile, string subfolder = "")
{
var fullPath = bookFile.Path;
if (_diskProvider.FileExists(fullPath))
{
_logger.Info("Deleting book file: {0}", fullPath);
try
{
_recycleBinProvider.DeleteFile(fullPath, subfolder);
}
catch (Exception e)
{
_logger.Error(e, "Unable to delete book file");
throw new NzbDroneClientException(HttpStatusCode.InternalServerError, "Unable to delete book file");
}
}
// Delete the track file from the database to clean it up even if the file was already deleted
_mediaFileService.Delete(bookFile, DeleteMediaFileReason.Manual);
}
private BookFile TransferFile(BookFile bookFile, Author author, Book book, string destinationFilePath, TransferMode mode)
{
Ensure.That(bookFile, () => bookFile).IsNotNull();
Ensure.That(author, () => author).IsNotNull();
Ensure.That(destinationFilePath, () => destinationFilePath).IsValidPath();
var bookFilePath = bookFile.Path;
if (!_diskProvider.FileExists(bookFilePath))
{
throw new FileNotFoundException("Book file path does not exist", bookFilePath);
}
if (bookFilePath == destinationFilePath)
{
throw new SameFilenameException("File not moved, source and destination are the same", bookFilePath);
}
_rootFolderWatchingService.ReportFileSystemChangeBeginning(bookFilePath, destinationFilePath);
_diskTransferService.TransferFile(bookFilePath, destinationFilePath, mode);
bookFile.Path = destinationFilePath;
_updateBookFileService.ChangeFileDateForFile(bookFile, author, book);
try
{
_mediaFileAttributeService.SetFolderLastWriteTime(author.Path, bookFile.DateAdded);
}
catch (Exception ex)
{
_logger.Warn(ex, "Unable to set last write time");
}
_mediaFileAttributeService.SetFilePermissions(destinationFilePath);
return(bookFile);
}
public BookFileMoveResult UpgradeBookFile(BookFile bookFile, LocalBook localBook, bool copyOnly = false)
{
var moveFileResult = new BookFileMoveResult();
var existingFiles = localBook.Book.BookFiles.Value;
var rootFolderPath = _diskProvider.GetParentFolder(localBook.Author.Path);
var rootFolder = _rootFolderService.GetBestRootFolder(rootFolderPath);
var isCalibre = rootFolder.IsCalibreLibrary && rootFolder.CalibreSettings != null;
var settings = rootFolder.CalibreSettings;
// If there are existing book 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(rootFolderPath))
{
throw new RootFolderNotFoundException($"Root folder '{rootFolderPath}' was not found.");
}
foreach (var file in existingFiles)
{
var bookFilePath = file.Path;
var subfolder = rootFolderPath.GetRelativePath(_diskProvider.GetParentFolder(bookFilePath));
bookFile.CalibreId = file.CalibreId;
if (_diskProvider.FileExists(bookFilePath))
{
_logger.Debug("Removing existing book file: {0} CalibreId: {1}", file, file.CalibreId);
if (!isCalibre)
{
_recycleBinProvider.DeleteFile(bookFilePath, subfolder);
}
else
{
var existing = _calibre.GetBook(file.CalibreId, settings);
var existingFormats = existing.Formats.Keys;
_logger.Debug($"Removing existing formats {existingFormats.ConcatToString()} from calibre");
_calibre.RemoveFormats(file.CalibreId, existingFormats, settings);
}
}
moveFileResult.OldFiles.Add(file);
_mediaFileService.Delete(file, DeleteMediaFileReason.Upgrade);
}
if (!isCalibre)
{
if (copyOnly)
{
moveFileResult.BookFile = _bookFileMover.CopyBookFile(bookFile, localBook);
}
else
{
moveFileResult.BookFile = _bookFileMover.MoveBookFile(bookFile, localBook);
}
_metadataTagService.WriteTags(bookFile, true);
}
else
{
var source = bookFile.Path;
moveFileResult.BookFile = _calibre.AddAndConvert(bookFile, settings);
if (!copyOnly)
{
_diskProvider.DeleteFile(source);
}
}
return(moveFileResult);
}
private void EnsureTrackFolder(BookFile bookFile, LocalBook localBook, string filePath)
{
EnsureBookFolder(bookFile, localBook.Author, localBook.Book, filePath);
}
public AudioTag GetTrackMetadata(BookFile trackfile)
{
return(new AudioTag());
}
public void Update(BookFile bookFile)
{
_mediaFileRepository.Update(bookFile);
}
public void ChangeFileDateForFile(BookFile bookFile, Author author, Book book)
{
ChangeFileDate(bookFile, book);
}
public AudioTag GetTrackMetadata(BookFile trackfile)
{
//TODO do something to get track metadata, for now jsut return existing track metadata
// return new AudioTag();
return(ReadAudioTag(trackfile.Path));
}
