github/lidarr
1
0
Fork 0
mirror of https://github.com/lidarr/lidarr.git synced 2025-08-14 10:47:08 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

[UI Work] Interactive Import, More Artist Detail

Browse source
This commit is contained in:
Qstick 2017-09-12 23:28:45 -04:00
commit f05332cf6e
42 changed files with 486 additions and 549 deletions
Download patch file Download diff file Expand all files Collapse all files

25
src/Lidarr.Api.V3/Artist/ArtistResource.cs
View file

@ -60,11 +60,6 @@ namespace Lidarr.Api.V3.Artist
//public bool SeasonFolder { get; set; }
//public bool Monitored { get; set; }
//public bool UseSceneNumbering { get; set; }
//public int Runtime { get; set; }
//public int TvdbId { get; set; }
//public int TvRageId { get; set; }
//public int TvMazeId { get; set; }
//public DateTime? FirstAired { get; set; }
public DateTime? LastInfoSync { get; set; }
////public SeriesTypes SeriesType { get; set; }
@ -138,10 +133,6 @@ namespace Lidarr.Api.V3.Artist
//AlternateTitles
SortName = model.SortName,
//TotalEpisodeCount
//EpisodeCount
//EpisodeFileCount
//SizeOnDisk
Status = model.Status,
Overview = model.Overview,
//NextAiring
@ -160,12 +151,6 @@ namespace Lidarr.Api.V3.Artist
AlbumFolder = model.AlbumFolder,
Monitored = model.Monitored,
//UseSceneNumbering = model.UseSceneNumbering,
//Runtime = model.Runtime,
//TvdbId = model.TvdbId,
//TvRageId = model.TvRageId,
//TvMazeId = model.TvMazeId,
//FirstAired = model.FirstAired,
LastInfoSync = model.LastInfoSync,
//SeriesType = model.SeriesType,
CleanName = model.CleanName,
@ -193,10 +178,6 @@ namespace Lidarr.Api.V3.Artist
//AlternateTitles
SortName = resource.SortName,
//TotalEpisodeCount
//EpisodeCount
//EpisodeFileCount
//SizeOnDisk
Status = resource.Status,
Overview = resource.Overview,
//NextAiring
@ -215,12 +196,6 @@ namespace Lidarr.Api.V3.Artist
AlbumFolder = resource.AlbumFolder,
Monitored = resource.Monitored,
//UseSceneNumbering = resource.UseSceneNumbering,
//Runtime = resource.Runtime,
//TvdbId = resource.TvdbId,
//TvRageId = resource.TvRageId,
//TvMazeId = resource.TvMazeId,
//FirstAired = resource.FirstAired,
LastInfoSync = resource.LastInfoSync,
//SeriesType = resource.SeriesType,
CleanName = resource.CleanName,

13
src/Lidarr.Api.V3/ManualImport/ManualImportResource.cs
View file

@ -3,6 +3,7 @@ using NzbDrone.Core.DecisionEngine;
using NzbDrone.Core.MediaFiles.TrackImport.Manual;
using NzbDrone.Core.Qualities;
using Lidarr.Api.V3.Artist;
using Lidarr.Api.V3.Albums;
using Lidarr.Api.V3.Tracks;
using Lidarr.Http.REST;
using System.Collections.Generic;
@ -16,9 +17,9 @@ namespace Lidarr.Api.V3.ManualImport
public string RelativePath { get; set; }
public string Name { get; set; }
public long Size { get; set; }
//public ArtistResource Artist { get; set; }
public int? SeasonNumber { get; set; }
public List<TrackResource> Episodes { get; set; }
public ArtistResource Artist { get; set; }
public AlbumResource Album { get; set; }
public List<TrackResource> Tracks { get; set; }
public QualityModel Quality { get; set; }
public int QualityWeight { get; set; }
public string DownloadId { get; set; }
@ -38,9 +39,9 @@ namespace Lidarr.Api.V3.ManualImport
RelativePath = model.RelativePath,
Name = model.Name,
Size = model.Size,
//Artist = model.,
SeasonNumber = model.SeasonNumber,
//Episodes = model.Episodes.ToResource(),
Artist = model.Artist.ToResource(),
Album = model.Album.ToResource(),
Tracks = model.Tracks.ToResource(),
Quality = model.Quality,
//QualityWeight
DownloadId = model.DownloadId,

6
src/NzbDrone.Api/ManualImport/ManualImportResource.cs
View file

@ -15,9 +15,6 @@ namespace NzbDrone.Api.ManualImport
public string RelativePath { get; set; }
public string Name { get; set; }
public long Size { get; set; }
public SeriesResource Series { get; set; }
public int? SeasonNumber { get; set; }
public List<EpisodeResource> Episodes { get; set; }
public QualityModel Quality { get; set; }
public int QualityWeight { get; set; }
public string DownloadId { get; set; }
@ -38,9 +35,6 @@ namespace NzbDrone.Api.ManualImport
RelativePath = model.RelativePath,
Name = model.Name,
Size = model.Size,
Series = model.Series.ToResource(),
SeasonNumber = model.SeasonNumber,
Episodes = model.Episodes.ToResource(),
Quality = model.Quality,
//QualityWeight
DownloadId = model.DownloadId,

2
src/NzbDrone.Core/MediaFiles/TrackImport/ImportApprovedTracks.cs
View file

@ -84,7 +84,7 @@ namespace NzbDrone.Core.MediaFiles.TrackImport
trackFile.Size = _diskProvider.GetFileSize(localTrack.Path);
trackFile.Quality = localTrack.Quality;
trackFile.MediaInfo = localTrack.MediaInfo;
trackFile.AlbumId = _albumRepository.FindByArtistAndName(localTrack.Artist.Name, Parser.Parser.CleanArtistTitle(localTrack.ParsedTrackInfo.AlbumTitle)).Id;
trackFile.AlbumId = localTrack.Album.Id;
trackFile.ReleaseGroup = localTrack.ParsedTrackInfo.ReleaseGroup;
trackFile.Tracks = localTrack.Tracks;
trackFile.Language = localTrack.Language;

5
src/NzbDrone.Core/MediaFiles/TrackImport/Manual/ManualImportFile.cs
View file

@ -6,8 +6,9 @@ namespace NzbDrone.Core.MediaFiles.TrackImport.Manual
public class ManualImportFile
{
public string Path { get; set; }
public int SeriesId { get; set; }
public List<int> EpisodeIds { get; set; }
public int ArtistId { get; set; }
public int AlbumId { get; set; }
public List<int> TrackIds { get; set; }
public QualityModel Quality { get; set; }
public string DownloadId { get; set; }
}

8
src/NzbDrone.Core/MediaFiles/TrackImport/Manual/ManualImportItem.cs
View file

@ -1,7 +1,7 @@
using System.Collections.Generic;
using NzbDrone.Core.DecisionEngine;
using NzbDrone.Core.Qualities;
using NzbDrone.Core.Tv;
using NzbDrone.Core.Music;
namespace NzbDrone.Core.MediaFiles.TrackImport.Manual
{
@ -11,9 +11,9 @@ namespace NzbDrone.Core.MediaFiles.TrackImport.Manual
public string RelativePath { get; set; }
public string Name { get; set; }
public long Size { get; set; }
public Series Series { get; set; }
public int? SeasonNumber { get; set; }
public List<Episode> Episodes { get; set; }
public Artist Artist { get; set; }
public Album Album { get; set; }
public List<Track> Tracks { get; set; }
public QualityModel Quality { get; set; }
public string DownloadId { get; set; }
public IEnumerable<Rejection> Rejections { get; set; }

270
src/NzbDrone.Core/MediaFiles/TrackImport/Manual/ManualImportService.cs
View file

@ -14,7 +14,7 @@ using NzbDrone.Core.Messaging.Commands;
using NzbDrone.Core.Messaging.Events;
using NzbDrone.Core.Parser;
using NzbDrone.Core.Parser.Model;
using NzbDrone.Core.Tv;
using NzbDrone.Core.Music;
namespace NzbDrone.Core.MediaFiles.TrackImport.Manual
{
@ -29,10 +29,11 @@ namespace NzbDrone.Core.MediaFiles.TrackImport.Manual
private readonly IParsingService _parsingService;
private readonly IDiskScanService _diskScanService;
private readonly IMakeImportDecision _importDecisionMaker;
private readonly ISeriesService _seriesService;
private readonly IEpisodeService _episodeService;
private readonly IArtistService _artistService;
private readonly IAlbumService _albumService;
private readonly ITrackService _trackService;
private readonly IVideoFileInfoReader _videoFileInfoReader;
private readonly IImportApprovedEpisodes _importApprovedEpisodes;
private readonly IImportApprovedTracks _importApprovedTracks;
private readonly ITrackedDownloadService _trackedDownloadService;
private readonly IDownloadedEpisodesImportService _downloadedEpisodesImportService;
private readonly IEventAggregator _eventAggregator;
@ -42,10 +43,11 @@ namespace NzbDrone.Core.MediaFiles.TrackImport.Manual
IParsingService parsingService,
IDiskScanService diskScanService,
IMakeImportDecision importDecisionMaker,
ISeriesService seriesService,
IEpisodeService episodeService,
IArtistService artistService,
IAlbumService albumService,
ITrackService trackService,
IVideoFileInfoReader videoFileInfoReader,
IImportApprovedEpisodes importApprovedEpisodes,
IImportApprovedTracks importApprovedTracks,
ITrackedDownloadService trackedDownloadService,
IDownloadedEpisodesImportService downloadedEpisodesImportService,
IEventAggregator eventAggregator,
@ -55,10 +57,11 @@ namespace NzbDrone.Core.MediaFiles.TrackImport.Manual
_parsingService = parsingService;
_diskScanService = diskScanService;
_importDecisionMaker = importDecisionMaker;
_seriesService = seriesService;
_episodeService = episodeService;
_artistService = artistService;
_albumService = albumService;
_trackService = trackService;
_videoFileInfoReader = videoFileInfoReader;
_importApprovedEpisodes = importApprovedEpisodes;
_importApprovedTracks = importApprovedTracks;
_trackedDownloadService = trackedDownloadService;
_downloadedEpisodesImportService = downloadedEpisodesImportService;
_eventAggregator = eventAggregator;
@ -94,179 +97,176 @@ namespace NzbDrone.Core.MediaFiles.TrackImport.Manual
private List<ManualImportItem> ProcessFolder(string folder, string downloadId)
{
throw new System.NotImplementedException("TODO: This will be rewritten for Music");
//var directoryInfo = new DirectoryInfo(folder);
//var series = _parsingService.GetSeries(directoryInfo.Name);
var directoryInfo = new DirectoryInfo(folder);
var artist = _parsingService.GetArtist(directoryInfo.Name);
//if (series == null && downloadId.IsNotNullOrWhiteSpace())
//{
// var trackedDownload = _trackedDownloadService.Find(downloadId);
// series = trackedDownload.RemoteEpisode.Series;
//}
if (artist == null && downloadId.IsNotNullOrWhiteSpace())
{
var trackedDownload = _trackedDownloadService.Find(downloadId);
artist = trackedDownload.RemoteAlbum.Artist;
}
//if (series == null)
//{
// var files = _diskScanService.GetVideoFiles(folder);
if (artist == null)
{
var files = _diskScanService.GetAudioFiles(folder);
// return files.Select(file => ProcessFile(file, downloadId, folder)).Where(i => i != null).ToList();
//}
return files.Select(file => ProcessFile(file, downloadId, folder)).Where(i => i != null).ToList();
}
//var folderInfo = Parser.Parser.ParseTitle(directoryInfo.Name);
//var seriesFiles = _diskScanService.GetVideoFiles(folder).ToList();
//var decisions = _importDecisionMaker.GetImportDecisions(seriesFiles, series, folderInfo, SceneSource(series, folder));
var folderInfo = Parser.Parser.ParseMusicTitle(directoryInfo.Name);
var artistFiles = _diskScanService.GetAudioFiles(folder).ToList();
var decisions = _importDecisionMaker.GetImportDecisions(artistFiles, artist, folderInfo);
//return decisions.Select(decision => MapItem(decision, folder, downloadId)).ToList();
return decisions.Select(decision => MapItem(decision, folder, downloadId)).ToList();
}
private ManualImportItem ProcessFile(string file, string downloadId, string folder = null)
{
throw new System.NotImplementedException("TODO: This will be rewritten for Music");
//if (folder.IsNullOrWhiteSpace())
//{
// folder = new FileInfo(file).Directory.FullName;
//}
if (folder.IsNullOrWhiteSpace())
{
folder = new FileInfo(file).Directory.FullName;
}
//var relativeFile = folder.GetRelativePath(file);
var relativeFile = folder.GetRelativePath(file);
//var series = _parsingService.GetSeries(relativeFile.Split('\\', '/')[0]);
var artist = _parsingService.GetArtist(relativeFile.Split('\\', '/')[0]);
//if (series == null)
//{
// series = _parsingService.GetSeries(relativeFile);
//}
if (artist == null)
{
artist = _parsingService.GetArtistFromTag(file);
}
//if (series == null && downloadId.IsNotNullOrWhiteSpace())
//{
// var trackedDownload = _trackedDownloadService.Find(downloadId);
// series = trackedDownload.RemoteEpisode.Series;
//}
if (artist == null && downloadId.IsNotNullOrWhiteSpace())
{
var trackedDownload = _trackedDownloadService.Find(downloadId);
artist = trackedDownload.RemoteAlbum.Artist;
}
//if (series == null)
//{
// var localEpisode = new LocalEpisode();
// localEpisode.Path = file;
// localEpisode.Quality = QualityParser.ParseQuality(file);
// localEpisode.Size = _diskProvider.GetFileSize(file);
if (artist == null)
{
var localTrack = new LocalTrack();
localTrack.Path = file;
localTrack.Quality = QualityParser.ParseQuality(file);
localTrack.Size = _diskProvider.GetFileSize(file);
// return MapItem(new ImportDecision(localEpisode, new Rejection("Unknown Series")), folder, downloadId);
//}
return MapItem(new ImportDecision(localTrack, new Rejection("Unknown Artist")), folder, downloadId);
}
//var importDecisions = _importDecisionMaker.GetImportDecisions(new List<string> {file},
// series, null, SceneSource(series, folder));
var importDecisions = _importDecisionMaker.GetImportDecisions(new List<string> { file },
artist, null);
//return importDecisions.Any() ? MapItem(importDecisions.First(), folder, downloadId) : null;
return importDecisions.Any() ? MapItem(importDecisions.First(), folder, downloadId) : null;
}
private bool SceneSource(Series series, string folder)
private bool SceneSource(Artist artist, string folder)
{
return !(series.Path.PathEquals(folder) || series.Path.IsParentPath(folder));
return !(artist.Path.PathEquals(folder) || artist.Path.IsParentPath(folder));
}
private ManualImportItem MapItem(ImportDecision decision, string folder, string downloadId)
{
throw new System.NotImplementedException("TODO: This will be rewritten for Music");
//var item = new ManualImportItem();
var item = new ManualImportItem();
//item.Path = decision.LocalEpisode.Path;
//item.RelativePath = folder.GetRelativePath(decision.LocalEpisode.Path);
//item.Name = Path.GetFileNameWithoutExtension(decision.LocalEpisode.Path);
//item.DownloadId = downloadId;
item.Path = decision.LocalTrack.Path;
item.RelativePath = folder.GetRelativePath(decision.LocalTrack.Path);
item.Name = Path.GetFileNameWithoutExtension(decision.LocalTrack.Path);
item.DownloadId = downloadId;
//if (decision.LocalEpisode.Series != null)
//{
// item.Series = decision.LocalEpisode.Series;
//}
if (decision.LocalTrack.Artist != null)
{
item.Artist = decision.LocalTrack.Artist;
}
//if (decision.LocalEpisode.Episodes.Any())
//{
// item.SeasonNumber = decision.LocalEpisode.SeasonNumber;
// item.Episodes = decision.LocalEpisode.Episodes;
//}
if (decision.LocalTrack.Tracks.Any())
{
item.Tracks = decision.LocalTrack.Tracks;
}
//item.Quality = decision.LocalEpisode.Quality;
//item.Size = _diskProvider.GetFileSize(decision.LocalEpisode.Path);
//item.Rejections = decision.Rejections;
item.Quality = decision.LocalTrack.Quality;
item.Size = _diskProvider.GetFileSize(decision.LocalTrack.Path);
item.Rejections = decision.Rejections;
//return item;
return item;
}
public void Execute(ManualImportCommand message)
{
_logger.ProgressTrace("Manually importing {0} files using mode {1}", message.Files.Count, message.ImportMode);
throw new System.NotImplementedException("TODO: This will be rewritten for Music");
//var imported = new List<ImportResult>();
//var importedTrackedDownload = new List<ManuallyImportedFile>();
var imported = new List<ImportResult>();
var importedTrackedDownload = new List<ManuallyImportedFile>();
//for (int i = 0; i < message.Files.Count; i++)
//{
// _logger.ProgressTrace("Processing file {0} of {1}", i + 1, message.Files.Count);
for (int i = 0; i < message.Files.Count; i++)
{
_logger.ProgressTrace("Processing file {0} of {1}", i + 1, message.Files.Count);
// var file = message.Files[i];
// var series = _seriesService.GetSeries(file.SeriesId);
// var episodes = _episodeService.GetEpisodes(file.EpisodeIds);
// var parsedEpisodeInfo = Parser.Parser.ParsePath(file.Path) ?? new ParsedEpisodeInfo();
// var mediaInfo = _videoFileInfoReader.GetMediaInfo(file.Path);
// var existingFile = series.Path.IsParentPath(file.Path);
var file = message.Files[i];
var artist = _artistService.GetArtist(file.ArtistId);
var album = _albumService.GetAlbum(file.AlbumId);
var tracks = _trackService.GetTracks(file.TrackIds);
var parsedTrackInfo = Parser.Parser.ParseMusicPath(file.Path) ?? new ParsedTrackInfo();
var mediaInfo = _videoFileInfoReader.GetMediaInfo(file.Path);
var existingFile = artist.Path.IsParentPath(file.Path);
// var localEpisode = new LocalEpisode
// {
// ExistingFile = false,
// Episodes = episodes,
// MediaInfo = mediaInfo,
// ParsedEpisodeInfo = parsedEpisodeInfo,
// Path = file.Path,
// Quality = file.Quality,
// Series = series,
// Size = 0
// };
var localTrack = new LocalTrack
{
ExistingFile = false,
Tracks = tracks,
MediaInfo = mediaInfo,
ParsedTrackInfo = parsedTrackInfo,
Path = file.Path,
Quality = file.Quality,
Artist = artist,
Album = album,
Size = 0
};
// //TODO: Cleanup non-tracked downloads
//TODO: Cleanup non-tracked downloads
// var importDecision = new ImportDecision(localEpisode);
var importDecision = new ImportDecision(localTrack);
// if (file.DownloadId.IsNullOrWhiteSpace())
// {
// imported.AddRange(_importApprovedEpisodes.Import(new List<ImportDecision> { importDecision }, !existingFile, null, message.ImportMode));
// }
if (file.DownloadId.IsNullOrWhiteSpace())
{
imported.AddRange(_importApprovedTracks.Import(new List<ImportDecision> { importDecision }, !existingFile, null, message.ImportMode));
}
// else
// {
// var trackedDownload = _trackedDownloadService.Find(file.DownloadId);
// var importResult = _importApprovedEpisodes.Import(new List<ImportDecision> { importDecision }, true, trackedDownload.DownloadItem, message.ImportMode).First();
else
{
var trackedDownload = _trackedDownloadService.Find(file.DownloadId);
var importResult = _importApprovedTracks.Import(new List<ImportDecision> { importDecision }, true, trackedDownload.DownloadItem, message.ImportMode).First();
// imported.Add(importResult);
imported.Add(importResult);
// importedTrackedDownload.Add(new ManuallyImportedFile
// {
// TrackedDownload = trackedDownload,
// ImportResult = importResult
// });
// }
//}
importedTrackedDownload.Add(new ManuallyImportedFile
{
TrackedDownload = trackedDownload,
ImportResult = importResult
});
}
}
//_logger.ProgressTrace("Manually imported {0} files", imported.Count);
_logger.ProgressTrace("Manually imported {0} files", imported.Count);
//foreach (var groupedTrackedDownload in importedTrackedDownload.GroupBy(i => i.TrackedDownload.DownloadItem.DownloadId).ToList())
//{
// var trackedDownload = groupedTrackedDownload.First().TrackedDownload;
foreach (var groupedTrackedDownload in importedTrackedDownload.GroupBy(i => i.TrackedDownload.DownloadItem.DownloadId).ToList())
{
var trackedDownload = groupedTrackedDownload.First().TrackedDownload;
// if (_diskProvider.FolderExists(trackedDownload.DownloadItem.OutputPath.FullPath))
// {
// if (_downloadedEpisodesImportService.ShouldDeleteFolder(
// new DirectoryInfo(trackedDownload.DownloadItem.OutputPath.FullPath),
// trackedDownload.RemoteEpisode.Series) && !trackedDownload.DownloadItem.IsReadOnly)
// {
// _diskProvider.DeleteFolder(trackedDownload.DownloadItem.OutputPath.FullPath, true);
// }
// }
if (_diskProvider.FolderExists(trackedDownload.DownloadItem.OutputPath.FullPath))
{
if (_downloadedEpisodesImportService.ShouldDeleteFolder(
new DirectoryInfo(trackedDownload.DownloadItem.OutputPath.FullPath),
trackedDownload.RemoteEpisode.Series) && !trackedDownload.DownloadItem.IsReadOnly)
{
_diskProvider.DeleteFolder(trackedDownload.DownloadItem.OutputPath.FullPath, true);
}
}
// if (groupedTrackedDownload.Select(c => c.ImportResult).Count(c => c.Result == ImportResultType.Imported) >= Math.Max(1, trackedDownload.RemoteEpisode.Episodes.Count))
// {
// trackedDownload.State = TrackedDownloadStage.Imported;
// _eventAggregator.PublishEvent(new DownloadCompletedEvent(trackedDownload));
// }
//}
if (groupedTrackedDownload.Select(c => c.ImportResult).Count(c => c.Result == ImportResultType.Imported) >= Math.Max(1, trackedDownload.RemoteAlbum.Albums.Count))
{
trackedDownload.State = TrackedDownloadStage.Imported;
_eventAggregator.PublishEvent(new DownloadCompletedEvent(trackedDownload));
}
}
}
}
}

12
src/NzbDrone.Core/Parser/Model/ParsedTrackInfo.cs
View file

@ -15,6 +15,9 @@ namespace NzbDrone.Core.Parser.Model
public string ArtistTitle { get; set; }
public string AlbumTitle { get; set; }
public ArtistTitleInfo ArtistTitleInfo { get; set; }
public string ArtistMBId { get; set; }
public string AlbumMBId { get; set; }
public string TrackMBId { get; set; }
public QualityModel Quality { get; set; }
public int[] TrackNumbers { get; set; }
public Language Language { get; set; }
@ -26,21 +29,18 @@ namespace NzbDrone.Core.Parser.Model
TrackNumbers = new int[0];
}
public override string ToString()
{
string episodeString = "[Unknown Track]";
string trackString = "[Unknown Track]";
if (TrackNumbers != null && TrackNumbers.Any())
{
episodeString = string.Format("T{0}", string.Join("-", TrackNumbers.Select(c => c.ToString("00"))));
trackString = string.Format("T{0}", string.Join("-", TrackNumbers.Select(c => c.ToString("00"))));
}
return string.Format("{0} - {1} {2}", ArtistTitle, episodeString, Quality);
return string.Format("{0} - {1} {2}", ArtistTitle, trackString, Quality);
}
}
}

14
src/NzbDrone.Core/Parser/Parser.cs
View file

@ -336,9 +336,16 @@ namespace NzbDrone.Core.Parser
var trackName = file.Tag.Title;
var trackNumber = file.Tag.Track;
var artist = file.Tag.FirstAlbumArtist;
if (artist.IsNotNullOrWhiteSpace())
{
artist = file.Tag.FirstPerformer;
}
var artistTitleInfo = new ArtistTitleInfo
{
Title = file.Tag.Title,
Title = artist,
Year = (int)file.Tag.Year
};
@ -348,7 +355,10 @@ namespace NzbDrone.Core.Parser
{
Language = Language.English, //TODO Parse from Tag/Mediainfo
AlbumTitle = file.Tag.Album,
ArtistTitle = file.Tag.FirstAlbumArtist,
ArtistTitle = artist,
ArtistMBId = file.Tag.MusicBrainzArtistId,
AlbumMBId = file.Tag.MusicBrainzReleaseId,
TrackMBId = file.Tag.MusicBrainzReleaseType,
Quality = QualityParser.ParseQuality(trackName),
TrackNumbers = temp,
ArtistTitleInfo = artistTitleInfo,

42
src/NzbDrone.Core/Parser/ParsingService.cs
View file

@ -18,6 +18,8 @@ namespace NzbDrone.Core.Parser
LocalEpisode GetLocalEpisode(string filename, Series series);
LocalEpisode GetLocalEpisode(string filename, Series series, ParsedEpisodeInfo folderInfo, bool sceneSource);
Series GetSeries(string title);
Artist GetArtist(string title);
Artist GetArtistFromTag(string file);
RemoteEpisode Map(ParsedEpisodeInfo parsedEpisodeInfo, int tvdbId, int tvRageId, SearchCriteriaBase searchCriteria = null);
RemoteEpisode Map(ParsedEpisodeInfo parsedEpisodeInfo, int seriesId, IEnumerable<int> episodeIds);
RemoteAlbum Map(ParsedAlbumInfo parsedAlbumInfo, SearchCriteriaBase searchCriteria = null);
@ -137,6 +139,44 @@ namespace NzbDrone.Core.Parser
return series;
}
public Artist GetArtist(string title)
{
var parsedAlbumInfo = Parser.ParseAlbumTitle(title);
if (parsedAlbumInfo == null || parsedAlbumInfo.ArtistName.IsNullOrWhiteSpace())
{
return _artistService.FindByName(title);
}
return _artistService.FindByName(parsedAlbumInfo.ArtistName);
}
public Artist GetArtistFromTag(string file)
{
var parsedTrackInfo = Parser.ParseMusicPath(file);
var artist = new Artist();
if (parsedTrackInfo.ArtistMBId.IsNotNullOrWhiteSpace())
{
artist = _artistService.FindById(parsedTrackInfo.ArtistMBId);
if (artist != null)
{
return artist;
}
}
if (parsedTrackInfo == null || parsedTrackInfo.ArtistTitle.IsNullOrWhiteSpace())
{
return null;
}
return _artistService.FindByName(parsedTrackInfo.ArtistTitle);
}
[System.Obsolete("Used for sonarr, not lidarr")]
public RemoteEpisode Map(ParsedEpisodeInfo parsedEpisodeInfo, int tvdbId, int tvRageId, SearchCriteriaBase searchCriteria = null)
{
@ -670,10 +710,12 @@ namespace NzbDrone.Core.Parser
}
var tracks = GetTracks(parsedTrackInfo, artist);
var album = _albumService.FindByTitle(artist.Id, parsedTrackInfo.AlbumTitle);
return new LocalTrack
{
Artist = artist,
Album = album,
Quality = parsedTrackInfo.Quality,
Language = parsedTrackInfo.Language,
Tracks = tracks,