public List <ManualImportItem> GetMediaFiles(string path, string downloadId, FilterFilesType filter, bool replaceExistingFiles)
{
if (downloadId.IsNotNullOrWhiteSpace())
{
var trackedDownload = _trackedDownloadService.Find(downloadId);
if (trackedDownload == null)
{
return(new List <ManualImportItem>());
}
path = trackedDownload.DownloadItem.OutputPath.FullPath;
}
if (!_diskProvider.FolderExists(path))
{
if (!_diskProvider.FileExists(path))
{
return(new List <ManualImportItem>());
}
var decision = _importDecisionMaker.GetImportDecisions(new List <IFileInfo> {
_diskProvider.GetFileInfo(path)
}, null, null, null, null, null, FilterFilesType.None, true, false, !replaceExistingFiles);
var result = MapItem(decision.First(), Path.GetDirectoryName(path), downloadId, replaceExistingFiles, false);
return(new List <ManualImportItem> {
result
});
}
return(ProcessFolder(path, downloadId, filter, replaceExistingFiles));
}
public AudioTag GetTrackMetadata(TrackFile trackfile)
{
var track = trackfile.Tracks.Value[0];
var release = track.AlbumRelease.Value;
var album = release.Album.Value;
var albumartist = album.Artist.Value;
var artist = track.ArtistMetadata.Value;
var cover = album.Images.FirstOrDefault(x => x.CoverType == MediaCoverTypes.Cover);
string imageFile = null;
long imageSize = 0;
if (cover != null)
{
imageFile = _mediaCoverService.GetCoverPath(album.Id, MediaCoverEntity.Album, 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 = track.Title,
Performers = new[] { artist.Name },
AlbumArtists = new[] { albumartist.Name },
Track = (uint)track.AbsoluteTrackNumber,
TrackCount = (uint)release.Tracks.Value.Count(x => x.MediumNumber == track.MediumNumber),
Album = album.Title,
Disc = (uint)track.MediumNumber,
DiscCount = (uint)release.Media.Count,
// We may have omitted media so index in the list isn't the same as medium number
Media = release.Media.SingleOrDefault(x => x.Number == track.MediumNumber).Format,
Date = release.ReleaseDate,
Year = (uint)album.ReleaseDate?.Year,
OriginalReleaseDate = album.ReleaseDate,
OriginalYear = (uint)album.ReleaseDate?.Year,
Publisher = release.Label.FirstOrDefault(),
Genres = album.Genres.Any() ? album.Genres.ToArray() : artist.Genres.ToArray(),
ImageFile = imageFile,
ImageSize = imageSize,
MusicBrainzReleaseCountry = IsoCountries.Find(release.Country.FirstOrDefault())?.TwoLetterCode,
MusicBrainzReleaseStatus = release.Status.ToLower(),
MusicBrainzReleaseType = album.AlbumType.ToLower(),
MusicBrainzReleaseId = release.ForeignReleaseId,
MusicBrainzArtistId = artist.ForeignArtistId,
MusicBrainzReleaseArtistId = albumartist.ForeignArtistId,
MusicBrainzReleaseGroupId = album.ForeignAlbumId,
MusicBrainzTrackId = track.ForeignRecordingId,
MusicBrainzReleaseTrackId = track.ForeignTrackId,
MusicBrainzAlbumComment = album.Disambiguation,
});
}
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 List <ManualImportItem> GetMediaFiles(string path, string downloadId, Author author, FilterFilesType filter, bool replaceExistingFiles)
{
if (downloadId.IsNotNullOrWhiteSpace())
{
var trackedDownload = _trackedDownloadService.Find(downloadId);
if (trackedDownload == null)
{
return(new List <ManualImportItem>());
}
if (trackedDownload.ImportItem == null)
{
trackedDownload.ImportItem = _provideImportItemService.ProvideImportItem(trackedDownload.DownloadItem, trackedDownload.ImportItem);
}
path = trackedDownload.ImportItem.OutputPath.FullPath;
}
if (!_diskProvider.FolderExists(path))
{
if (!_diskProvider.FileExists(path))
{
return(new List <ManualImportItem>());
}
var files = new List <IFileInfo> {
_diskProvider.GetFileInfo(path)
};
var config = new ImportDecisionMakerConfig
{
Filter = FilterFilesType.None,
NewDownload = true,
SingleRelease = false,
IncludeExisting = !replaceExistingFiles,
AddNewAuthors = false,
KeepAllEditions = true
};
var decision = _importDecisionMaker.GetImportDecisions(files, null, null, config);
var result = MapItem(decision.First(), downloadId, replaceExistingFiles, false);
return(new List <ManualImportItem> {
result
});
}
return(ProcessFolder(path, downloadId, author, filter, replaceExistingFiles));
}
public List <ImportResult> ProcessPath(string path, ImportMode importMode = ImportMode.Auto, Author author = null, DownloadClientItem downloadClientItem = null)
{
if (_diskProvider.FolderExists(path))
{
var directoryInfo = _diskProvider.GetDirectoryInfo(path);
if (author == null)
{
return(ProcessFolder(directoryInfo, importMode, downloadClientItem));
}
return(ProcessFolder(directoryInfo, importMode, author, downloadClientItem));
}
if (_diskProvider.FileExists(path))
{
var fileInfo = _diskProvider.GetFileInfo(path);
if (author == null)
{
return(ProcessFile(fileInfo, importMode, downloadClientItem));
}
return(ProcessFile(fileInfo, importMode, author, downloadClientItem));
}
LogInaccessiblePathError(path);
_eventAggregator.PublishEvent(new TrackImportFailedEvent(null, null, true, downloadClientItem));
return(new List <ImportResult>());
}
public IFileInfo[] GetBookFiles(string path, bool allDirectories = true)
{
IEnumerable <IFileInfo> filesOnDisk;
var rootFolder = _rootFolderService.GetBestRootFolder(path);
_logger.Trace(rootFolder.ToJson());
if (rootFolder != null && rootFolder.IsCalibreLibrary && rootFolder.CalibreSettings != null)
{
_logger.Info($"Getting book list from calibre for {path}");
var paths = _calibre.GetAllBookFilePaths(rootFolder.CalibreSettings);
var folderPaths = paths.Where(x => path.IsParentPath(x));
filesOnDisk = folderPaths.Select(x => _diskProvider.GetFileInfo(x));
}
else
{
_logger.Debug("Scanning '{0}' for ebook files", path);
var searchOption = allDirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
filesOnDisk = _diskProvider.GetFileInfos(path, searchOption);
_logger.Trace("{0} files were found in {1}", filesOnDisk.Count(), path);
}
var mediaFileList = filesOnDisk.Where(file => MediaFileExtensions.AllExtensions.Contains(file.Extension))
.ToArray();
_logger.Debug("{0} book files were found in {1}", mediaFileList.Length, path);
return(mediaFileList);
}
public List <ImportResult> ProcessPath(string path, ImportMode importMode = ImportMode.Auto, Artist artist = null, DownloadClientItem downloadClientItem = null)
{
if (_diskProvider.FolderExists(path))
{
var directoryInfo = _diskProvider.GetDirectoryInfo(path);
if (artist == null)
{
return(ProcessFolder(directoryInfo, importMode, downloadClientItem));
}
return(ProcessFolder(directoryInfo, importMode, artist, downloadClientItem));
}
if (_diskProvider.FileExists(path))
{
var fileInfo = _diskProvider.GetFileInfo(path);
if (artist == null)
{
return(ProcessFile(fileInfo, importMode, downloadClientItem));
}
return(ProcessFile(fileInfo, importMode, artist, downloadClientItem));
}
_logger.Error("Import failed, path does not exist or is not accessible by Lidarr: {0}", path);
_eventAggregator.PublishEvent(new TrackImportFailedEvent(null, null, true, downloadClientItem));
return(new List <ImportResult>());
}
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 write_tags_should_update_trackfile_size_and_modified(string filename)
{
Mocker.GetMock <IConfigService>()
.Setup(x => x.ScrubAudioTags)
.Returns(true);
GivenFileCopy(filename);
var file = GivenPopulatedTrackfile(0);
file.Path = _copiedFile;
Subject.WriteTags(file, false, true);
var fileInfo = _diskProvider.GetFileInfo(file.Path);
file.Modified.Should().Be(fileInfo.LastWriteTimeUtc);
file.Size.Should().Be(fileInfo.Length);
}
public void ConvertToLocalUrls(int movieId, IEnumerable <MediaCover> covers, Dictionary <string, FileInfo> fileInfos = null)
{
if (movieId == 0)
{
// Movie isn't in Radarr yet, map via a proxy to circument referrer issues
foreach (var mediaCover in covers)
{
mediaCover.RemoteUrl = mediaCover.Url;
mediaCover.Url = _mediaCoverProxy.RegisterUrl(mediaCover.RemoteUrl);
}
}
else
{
foreach (var mediaCover in covers)
{
var filePath = GetCoverPath(movieId, mediaCover.CoverType);
mediaCover.RemoteUrl = mediaCover.Url;
mediaCover.Url = _configFileProvider.UrlBase + @"/MediaCover/" + movieId + "/" + mediaCover.CoverType.ToString().ToLower() + ".jpg";
FileInfo file;
var fileExists = false;
if (fileInfos != null)
{
fileExists = fileInfos.TryGetValue(filePath, out file);
}
else
{
file = _diskProvider.GetFileInfo(filePath);
fileExists = file.Exists;
}
if (fileExists)
{
var lastWrite = file.LastWriteTimeUtc;
mediaCover.Url += "?lastWrite=" + lastWrite.Ticks;
}
}
}
}
