You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
661 lines
25 KiB
661 lines
25 KiB
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using NLog;
|
|
using NzbDrone.Common.Cache;
|
|
using NzbDrone.Common.Extensions;
|
|
using NzbDrone.Common.Http;
|
|
using NzbDrone.Common.Serializer;
|
|
using NzbDrone.Core.Exceptions;
|
|
using NzbDrone.Core.MediaCover;
|
|
using NzbDrone.Core.MetadataSource.SkyHook.Resource;
|
|
using NzbDrone.Core.Music;
|
|
using NzbDrone.Core.Profiles.Metadata;
|
|
|
|
namespace NzbDrone.Core.MetadataSource.SkyHook
|
|
{
|
|
public class SkyHookProxy : IProvideArtistInfo, ISearchForNewArtist, IProvideAlbumInfo, ISearchForNewAlbum, ISearchForNewEntity
|
|
{
|
|
private readonly IHttpClient _httpClient;
|
|
private readonly Logger _logger;
|
|
private readonly IArtistService _artistService;
|
|
private readonly IAlbumService _albumService;
|
|
private readonly IMetadataRequestBuilder _requestBuilder;
|
|
private readonly IMetadataProfileService _metadataProfileService;
|
|
private readonly ICached<HashSet<string>> _cache;
|
|
|
|
private static readonly List<string> NonAudioMedia = new List<string> { "DVD", "DVD-Video", "Blu-ray", "HD-DVD", "VCD", "SVCD", "UMD", "VHS" };
|
|
private static readonly List<string> SkippedTracks = new List<string> { "[data track]" };
|
|
|
|
public SkyHookProxy(IHttpClient httpClient,
|
|
IMetadataRequestBuilder requestBuilder,
|
|
IArtistService artistService,
|
|
IAlbumService albumService,
|
|
Logger logger,
|
|
IMetadataProfileService metadataProfileService,
|
|
ICacheManager cacheManager)
|
|
{
|
|
_httpClient = httpClient;
|
|
_metadataProfileService = metadataProfileService;
|
|
_requestBuilder = requestBuilder;
|
|
_artistService = artistService;
|
|
_albumService = albumService;
|
|
_cache = cacheManager.GetCache<HashSet<string>>(GetType());
|
|
_logger = logger;
|
|
}
|
|
|
|
public HashSet<string> GetChangedArtists(DateTime startTime)
|
|
{
|
|
var startTimeUtc = (DateTimeOffset)DateTime.SpecifyKind(startTime, DateTimeKind.Utc);
|
|
var httpRequest = _requestBuilder.GetRequestBuilder().Create()
|
|
.SetSegment("route", "recent/artist")
|
|
.AddQueryParam("since", startTimeUtc.ToUnixTimeSeconds())
|
|
.Build();
|
|
|
|
httpRequest.SuppressHttpError = true;
|
|
|
|
var httpResponse = _httpClient.Get<RecentUpdatesResource>(httpRequest);
|
|
|
|
if (httpResponse.Resource.Limited)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return new HashSet<string>(httpResponse.Resource.Items);
|
|
}
|
|
|
|
public Artist GetArtistInfo(string foreignArtistId, int metadataProfileId)
|
|
{
|
|
_logger.Debug("Getting Artist with LidarrAPI.MetadataID of {0}", foreignArtistId);
|
|
|
|
var httpRequest = _requestBuilder.GetRequestBuilder().Create()
|
|
.SetSegment("route", "artist/" + foreignArtistId)
|
|
.Build();
|
|
|
|
httpRequest.AllowAutoRedirect = true;
|
|
httpRequest.SuppressHttpError = true;
|
|
|
|
var httpResponse = _httpClient.Get<ArtistResource>(httpRequest);
|
|
|
|
if (httpResponse.HasHttpError)
|
|
{
|
|
if (httpResponse.StatusCode == HttpStatusCode.NotFound)
|
|
{
|
|
throw new ArtistNotFoundException(foreignArtistId);
|
|
}
|
|
else if (httpResponse.StatusCode == HttpStatusCode.BadRequest)
|
|
{
|
|
throw new BadRequestException(foreignArtistId);
|
|
}
|
|
else
|
|
{
|
|
throw new HttpException(httpRequest, httpResponse);
|
|
}
|
|
}
|
|
|
|
var artist = new Artist();
|
|
artist.Metadata = MapArtistMetadata(httpResponse.Resource);
|
|
artist.CleanName = Parser.Parser.CleanArtistName(artist.Metadata.Value.Name);
|
|
artist.SortName = Parser.Parser.NormalizeTitle(artist.Metadata.Value.Name);
|
|
|
|
artist.Albums = FilterAlbums(httpResponse.Resource.Albums, metadataProfileId)
|
|
.Select(x => MapAlbum(x, null)).ToList();
|
|
|
|
return artist;
|
|
}
|
|
|
|
public HashSet<string> GetChangedAlbums(DateTime startTime)
|
|
{
|
|
return _cache.Get("ChangedAlbums", () => GetChangedAlbumsUncached(startTime), TimeSpan.FromMinutes(30));
|
|
}
|
|
|
|
private HashSet<string> GetChangedAlbumsUncached(DateTime startTime)
|
|
{
|
|
var startTimeUtc = (DateTimeOffset)DateTime.SpecifyKind(startTime, DateTimeKind.Utc);
|
|
var httpRequest = _requestBuilder.GetRequestBuilder().Create()
|
|
.SetSegment("route", "recent/album")
|
|
.AddQueryParam("since", startTimeUtc.ToUnixTimeSeconds())
|
|
.Build();
|
|
|
|
httpRequest.SuppressHttpError = true;
|
|
|
|
var httpResponse = _httpClient.Get<RecentUpdatesResource>(httpRequest);
|
|
|
|
if (httpResponse.Resource.Limited)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return new HashSet<string>(httpResponse.Resource.Items);
|
|
}
|
|
|
|
public IEnumerable<AlbumResource> FilterAlbums(IEnumerable<AlbumResource> albums, int metadataProfileId)
|
|
{
|
|
var metadataProfile = _metadataProfileService.Exists(metadataProfileId) ? _metadataProfileService.Get(metadataProfileId) : _metadataProfileService.All().First();
|
|
var primaryTypes = new HashSet<string>(metadataProfile.PrimaryAlbumTypes.Where(s => s.Allowed).Select(s => s.PrimaryAlbumType.Name));
|
|
var secondaryTypes = new HashSet<string>(metadataProfile.SecondaryAlbumTypes.Where(s => s.Allowed).Select(s => s.SecondaryAlbumType.Name));
|
|
var releaseStatuses = new HashSet<string>(metadataProfile.ReleaseStatuses.Where(s => s.Allowed).Select(s => s.ReleaseStatus.Name));
|
|
|
|
return albums.Where(album => primaryTypes.Contains(album.Type) &&
|
|
((!album.SecondaryTypes.Any() && secondaryTypes.Contains("Studio")) ||
|
|
album.SecondaryTypes.Any(x => secondaryTypes.Contains(x))) &&
|
|
album.ReleaseStatuses.Any(x => releaseStatuses.Contains(x)));
|
|
}
|
|
|
|
public Tuple<string, Album, List<ArtistMetadata>> GetAlbumInfo(string foreignAlbumId)
|
|
{
|
|
_logger.Debug("Getting Album with LidarrAPI.MetadataID of {0}", foreignAlbumId);
|
|
|
|
var httpRequest = _requestBuilder.GetRequestBuilder().Create()
|
|
.SetSegment("route", "album/" + foreignAlbumId)
|
|
.Build();
|
|
|
|
httpRequest.AllowAutoRedirect = true;
|
|
httpRequest.SuppressHttpError = true;
|
|
|
|
var httpResponse = _httpClient.Get<AlbumResource>(httpRequest);
|
|
|
|
if (httpResponse.HasHttpError)
|
|
{
|
|
if (httpResponse.StatusCode == HttpStatusCode.NotFound)
|
|
{
|
|
throw new AlbumNotFoundException(foreignAlbumId);
|
|
}
|
|
else if (httpResponse.StatusCode == HttpStatusCode.BadRequest)
|
|
{
|
|
throw new BadRequestException(foreignAlbumId);
|
|
}
|
|
else
|
|
{
|
|
throw new HttpException(httpRequest, httpResponse);
|
|
}
|
|
}
|
|
|
|
var artists = httpResponse.Resource.Artists.Select(MapArtistMetadata).ToList();
|
|
var artistDict = artists.ToDictionary(x => x.ForeignArtistId, x => x);
|
|
var album = MapAlbum(httpResponse.Resource, artistDict);
|
|
album.ArtistMetadata = artistDict[httpResponse.Resource.ArtistId];
|
|
|
|
return new Tuple<string, Album, List<ArtistMetadata>>(httpResponse.Resource.ArtistId, album, artists);
|
|
}
|
|
|
|
public List<Artist> SearchForNewArtist(string title)
|
|
{
|
|
try
|
|
{
|
|
var lowerTitle = title.ToLowerInvariant();
|
|
|
|
if (IsMbidQuery(lowerTitle))
|
|
{
|
|
var slug = lowerTitle.Split(':')[1].Trim();
|
|
|
|
Guid searchGuid;
|
|
|
|
bool isValid = Guid.TryParse(slug, out searchGuid);
|
|
|
|
if (slug.IsNullOrWhiteSpace() || slug.Any(char.IsWhiteSpace) || isValid == false)
|
|
{
|
|
return new List<Artist>();
|
|
}
|
|
|
|
try
|
|
{
|
|
var existingArtist = _artistService.FindById(searchGuid.ToString());
|
|
if (existingArtist != null)
|
|
{
|
|
return new List<Artist> { existingArtist };
|
|
}
|
|
|
|
var metadataProfile = _metadataProfileService.All().First().Id; //Change this to Use last Used profile?
|
|
|
|
return new List<Artist> { GetArtistInfo(searchGuid.ToString(), metadataProfile) };
|
|
}
|
|
catch (ArtistNotFoundException)
|
|
{
|
|
return new List<Artist>();
|
|
}
|
|
}
|
|
|
|
var httpRequest = _requestBuilder.GetRequestBuilder().Create()
|
|
.SetSegment("route", "search")
|
|
.AddQueryParam("type", "artist")
|
|
.AddQueryParam("query", title.ToLower().Trim())
|
|
.Build();
|
|
|
|
var httpResponse = _httpClient.Get<List<ArtistResource>>(httpRequest);
|
|
|
|
return httpResponse.Resource.SelectList(MapSearchResult);
|
|
}
|
|
catch (HttpException)
|
|
{
|
|
throw new SkyHookException("Search for '{0}' failed. Unable to communicate with LidarrAPI.", title);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Warn(ex, ex.Message);
|
|
throw new SkyHookException("Search for '{0}' failed. Invalid response received from LidarrAPI.", title);
|
|
}
|
|
}
|
|
|
|
public List<Album> SearchForNewAlbum(string title, string artist)
|
|
{
|
|
try
|
|
{
|
|
var lowerTitle = title.ToLowerInvariant();
|
|
|
|
if (IsMbidQuery(lowerTitle))
|
|
{
|
|
var slug = lowerTitle.Split(':')[1].Trim();
|
|
|
|
Guid searchGuid;
|
|
|
|
bool isValid = Guid.TryParse(slug, out searchGuid);
|
|
|
|
if (slug.IsNullOrWhiteSpace() || slug.Any(char.IsWhiteSpace) || isValid == false)
|
|
{
|
|
return new List<Album>();
|
|
}
|
|
|
|
try
|
|
{
|
|
var existingAlbum = _albumService.FindById(searchGuid.ToString());
|
|
|
|
if (existingAlbum == null)
|
|
{
|
|
var data = GetAlbumInfo(searchGuid.ToString());
|
|
var album = data.Item2;
|
|
album.Artist = _artistService.FindById(data.Item1) ?? new Artist
|
|
{
|
|
Metadata = data.Item3.Single(x => x.ForeignArtistId == data.Item1)
|
|
};
|
|
|
|
return new List<Album> { album };
|
|
}
|
|
|
|
existingAlbum.Artist = _artistService.GetArtist(existingAlbum.ArtistId);
|
|
return new List<Album> { existingAlbum };
|
|
}
|
|
catch (AlbumNotFoundException)
|
|
{
|
|
return new List<Album>();
|
|
}
|
|
}
|
|
|
|
var httpRequest = _requestBuilder.GetRequestBuilder().Create()
|
|
.SetSegment("route", "search")
|
|
.AddQueryParam("type", "album")
|
|
.AddQueryParam("query", title.ToLower().Trim())
|
|
.AddQueryParam("artist", artist.IsNotNullOrWhiteSpace() ? artist.ToLower().Trim() : string.Empty)
|
|
.AddQueryParam("includeTracks", "1")
|
|
.Build();
|
|
|
|
var httpResponse = _httpClient.Get<List<AlbumResource>>(httpRequest);
|
|
|
|
return httpResponse.Resource.Select(MapSearchResult)
|
|
.Where(x => x != null)
|
|
.ToList();
|
|
}
|
|
catch (HttpException)
|
|
{
|
|
throw new SkyHookException("Search for '{0}' failed. Unable to communicate with LidarrAPI.", title);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Warn(ex, ex.Message);
|
|
throw new SkyHookException("Search for '{0}' failed. Invalid response received from LidarrAPI.", title);
|
|
}
|
|
}
|
|
|
|
public List<Album> SearchForNewAlbumByRecordingIds(List<string> recordingIds)
|
|
{
|
|
var ids = recordingIds.Where(x => x.IsNotNullOrWhiteSpace()).Distinct();
|
|
var httpRequest = _requestBuilder.GetRequestBuilder().Create()
|
|
.SetSegment("route", "search/fingerprint")
|
|
.Build();
|
|
|
|
httpRequest.SetContent(ids.ToJson());
|
|
httpRequest.Headers.ContentType = "application/json";
|
|
|
|
var httpResponse = _httpClient.Post<List<AlbumResource>>(httpRequest);
|
|
|
|
return httpResponse.Resource.Select(MapSearchResult)
|
|
.Where(x => x != null)
|
|
.ToList();
|
|
}
|
|
|
|
public List<object> SearchForNewEntity(string title)
|
|
{
|
|
var lowerTitle = title.ToLowerInvariant();
|
|
|
|
if (IsMbidQuery(lowerTitle))
|
|
{
|
|
var artist = SearchForNewArtist(lowerTitle);
|
|
if (artist.Any())
|
|
{
|
|
return new List<object> { artist.First() };
|
|
}
|
|
|
|
var album = SearchForNewAlbum(lowerTitle, null);
|
|
if (album.Any())
|
|
{
|
|
var result = album.Where(x => x.AlbumReleases.Value.Any()).FirstOrDefault();
|
|
if (result != null)
|
|
{
|
|
return new List<object> { result };
|
|
}
|
|
else
|
|
{
|
|
return new List<object>();
|
|
}
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
var httpRequest = _requestBuilder.GetRequestBuilder().Create()
|
|
.SetSegment("route", "search")
|
|
.AddQueryParam("type", "all")
|
|
.AddQueryParam("query", lowerTitle.Trim())
|
|
.Build();
|
|
|
|
var httpResponse = _httpClient.Get<List<EntityResource>>(httpRequest);
|
|
|
|
return httpResponse.Resource.Select(MapSearchResult)
|
|
.Where(x => x != null)
|
|
.ToList();
|
|
}
|
|
catch (HttpException)
|
|
{
|
|
throw new SkyHookException("Search for '{0}' failed. Unable to communicate with LidarrAPI.", title);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.Warn(ex, ex.Message);
|
|
throw new SkyHookException("Search for '{0}' failed. Invalid response received from LidarrAPI.", title);
|
|
}
|
|
}
|
|
|
|
private static bool IsMbidQuery(string query)
|
|
{
|
|
return query.StartsWith("lidarr:") || query.StartsWith("lidarrid:") || query.StartsWith("mbid:");
|
|
}
|
|
|
|
private Artist MapSearchResult(ArtistResource resource)
|
|
{
|
|
var artist = _artistService.FindById(resource.Id);
|
|
if (artist == null)
|
|
{
|
|
artist = new Artist();
|
|
artist.Metadata = MapArtistMetadata(resource);
|
|
}
|
|
|
|
return artist;
|
|
}
|
|
|
|
private Album MapSearchResult(AlbumResource resource)
|
|
{
|
|
var artists = resource.Artists.Select(MapArtistMetadata).ToDictionary(x => x.ForeignArtistId, x => x);
|
|
|
|
var artist = _artistService.FindById(resource.ArtistId);
|
|
if (artist == null)
|
|
{
|
|
artist = new Artist();
|
|
artist.Metadata = artists[resource.ArtistId];
|
|
}
|
|
|
|
var album = _albumService.FindById(resource.Id) ?? MapAlbum(resource, artists);
|
|
album.Artist = artist;
|
|
album.ArtistMetadata = artist.Metadata.Value;
|
|
|
|
if (!album.AlbumReleases.Value.Any())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return album;
|
|
}
|
|
|
|
private object MapSearchResult(EntityResource resource)
|
|
{
|
|
if (resource.Artist != null)
|
|
{
|
|
return MapSearchResult(resource.Artist);
|
|
}
|
|
else
|
|
{
|
|
return MapSearchResult(resource.Album);
|
|
}
|
|
}
|
|
|
|
private static Album MapAlbum(AlbumResource resource, Dictionary<string, ArtistMetadata> artistDict)
|
|
{
|
|
Album album = new Album();
|
|
album.ForeignAlbumId = resource.Id;
|
|
album.OldForeignAlbumIds = resource.OldIds;
|
|
album.Title = resource.Title;
|
|
album.Overview = resource.Overview;
|
|
album.Disambiguation = resource.Disambiguation;
|
|
album.ReleaseDate = resource.ReleaseDate;
|
|
|
|
if (resource.Images != null)
|
|
{
|
|
album.Images = resource.Images.Select(MapImage).ToList();
|
|
}
|
|
|
|
album.AlbumType = resource.Type;
|
|
album.SecondaryTypes = resource.SecondaryTypes.Select(MapSecondaryTypes).ToList();
|
|
album.Ratings = MapRatings(resource.Rating);
|
|
album.Links = resource.Links?.Select(MapLink).ToList();
|
|
album.Genres = resource.Genres;
|
|
album.CleanTitle = Parser.Parser.CleanArtistName(album.Title);
|
|
|
|
if (resource.Releases != null)
|
|
{
|
|
album.AlbumReleases = resource.Releases.Select(x => MapRelease(x, artistDict)).Where(x => x.TrackCount > 0).ToList();
|
|
|
|
// Monitor the release with most tracks
|
|
var mostTracks = album.AlbumReleases.Value.OrderByDescending(x => x.TrackCount).FirstOrDefault();
|
|
if (mostTracks != null)
|
|
{
|
|
mostTracks.Monitored = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
album.AlbumReleases = new List<AlbumRelease>();
|
|
}
|
|
|
|
album.AnyReleaseOk = true;
|
|
|
|
return album;
|
|
}
|
|
|
|
private static AlbumRelease MapRelease(ReleaseResource resource, Dictionary<string, ArtistMetadata> artistDict)
|
|
{
|
|
AlbumRelease release = new AlbumRelease();
|
|
release.ForeignReleaseId = resource.Id;
|
|
release.OldForeignReleaseIds = resource.OldIds;
|
|
release.Title = resource.Title;
|
|
release.Status = resource.Status;
|
|
release.Label = resource.Label;
|
|
release.Disambiguation = resource.Disambiguation;
|
|
release.Country = resource.Country;
|
|
release.ReleaseDate = resource.ReleaseDate;
|
|
|
|
// Get the complete set of media/tracks returned by the API, adding missing media if necessary
|
|
var allMedia = resource.Media.Select(MapMedium).ToList();
|
|
var allTracks = resource.Tracks.Select(x => MapTrack(x, artistDict));
|
|
if (!allMedia.Any())
|
|
{
|
|
foreach (int n in allTracks.Select(x => x.MediumNumber).Distinct())
|
|
{
|
|
allMedia.Add(new Medium { Name = "Unknown", Number = n, Format = "Unknown" });
|
|
}
|
|
}
|
|
|
|
// Skip non-audio media
|
|
var audioMediaNumbers = allMedia.Where(x => !NonAudioMedia.Contains(x.Format)).Select(x => x.Number);
|
|
|
|
// Get tracks on the audio media and omit any that are skipped
|
|
release.Tracks = allTracks.Where(x => audioMediaNumbers.Contains(x.MediumNumber) && !SkippedTracks.Contains(x.Title)).ToList();
|
|
release.TrackCount = release.Tracks.Value.Count;
|
|
|
|
// Only include the media that contain the tracks we have selected
|
|
var usedMediaNumbers = release.Tracks.Value.Select(track => track.MediumNumber);
|
|
release.Media = allMedia.Where(medium => usedMediaNumbers.Contains(medium.Number)).ToList();
|
|
|
|
release.Duration = release.Tracks.Value.Sum(x => x.Duration);
|
|
|
|
return release;
|
|
}
|
|
|
|
private static Medium MapMedium(MediumResource resource)
|
|
{
|
|
Medium medium = new Medium
|
|
{
|
|
Name = resource.Name,
|
|
Number = resource.Position,
|
|
Format = resource.Format
|
|
};
|
|
|
|
return medium;
|
|
}
|
|
|
|
private static Track MapTrack(TrackResource resource, Dictionary<string, ArtistMetadata> artistDict)
|
|
{
|
|
Track track = new Track
|
|
{
|
|
ArtistMetadata = artistDict[resource.ArtistId],
|
|
Title = resource.TrackName,
|
|
ForeignTrackId = resource.Id,
|
|
OldForeignTrackIds = resource.OldIds,
|
|
ForeignRecordingId = resource.RecordingId,
|
|
OldForeignRecordingIds = resource.OldRecordingIds,
|
|
TrackNumber = resource.TrackNumber,
|
|
AbsoluteTrackNumber = resource.TrackPosition,
|
|
Duration = resource.DurationMs,
|
|
MediumNumber = resource.MediumNumber
|
|
};
|
|
|
|
return track;
|
|
}
|
|
|
|
private static ArtistMetadata MapArtistMetadata(ArtistResource resource)
|
|
{
|
|
ArtistMetadata artist = new ArtistMetadata();
|
|
|
|
artist.Name = resource.ArtistName;
|
|
artist.Aliases = resource.ArtistAliases;
|
|
artist.ForeignArtistId = resource.Id;
|
|
artist.OldForeignArtistIds = resource.OldIds;
|
|
artist.Genres = resource.Genres;
|
|
artist.Overview = resource.Overview;
|
|
artist.Disambiguation = resource.Disambiguation;
|
|
artist.Type = resource.Type;
|
|
artist.Status = MapArtistStatus(resource.Status);
|
|
artist.Ratings = MapRatings(resource.Rating);
|
|
artist.Images = resource.Images?.Select(MapImage).ToList();
|
|
artist.Links = resource.Links?.Select(MapLink).ToList();
|
|
return artist;
|
|
}
|
|
|
|
private static ArtistStatusType MapArtistStatus(string status)
|
|
{
|
|
if (status == null)
|
|
{
|
|
return ArtistStatusType.Continuing;
|
|
}
|
|
|
|
if (status.Equals("ended", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
return ArtistStatusType.Ended;
|
|
}
|
|
|
|
return ArtistStatusType.Continuing;
|
|
}
|
|
|
|
private static Ratings MapRatings(RatingResource rating)
|
|
{
|
|
if (rating == null)
|
|
{
|
|
return new Ratings();
|
|
}
|
|
|
|
return new Ratings
|
|
{
|
|
Votes = rating.Count,
|
|
Value = rating.Value
|
|
};
|
|
}
|
|
|
|
private static MediaCover.MediaCover MapImage(ImageResource arg)
|
|
{
|
|
return new MediaCover.MediaCover
|
|
{
|
|
Url = arg.Url,
|
|
CoverType = MapCoverType(arg.CoverType)
|
|
};
|
|
}
|
|
|
|
private static Links MapLink(LinkResource arg)
|
|
{
|
|
return new Links
|
|
{
|
|
Url = arg.Target,
|
|
Name = arg.Type
|
|
};
|
|
}
|
|
|
|
private static MediaCoverTypes MapCoverType(string coverType)
|
|
{
|
|
switch (coverType.ToLower())
|
|
{
|
|
case "poster":
|
|
return MediaCoverTypes.Poster;
|
|
case "banner":
|
|
return MediaCoverTypes.Banner;
|
|
case "fanart":
|
|
return MediaCoverTypes.Fanart;
|
|
case "cover":
|
|
return MediaCoverTypes.Cover;
|
|
case "disc":
|
|
return MediaCoverTypes.Disc;
|
|
case "logo":
|
|
return MediaCoverTypes.Logo;
|
|
default:
|
|
return MediaCoverTypes.Unknown;
|
|
}
|
|
}
|
|
|
|
public static SecondaryAlbumType MapSecondaryTypes(string albumType)
|
|
{
|
|
switch (albumType.ToLowerInvariant())
|
|
{
|
|
case "compilation":
|
|
return SecondaryAlbumType.Compilation;
|
|
case "soundtrack":
|
|
return SecondaryAlbumType.Soundtrack;
|
|
case "spokenword":
|
|
return SecondaryAlbumType.Spokenword;
|
|
case "interview":
|
|
return SecondaryAlbumType.Interview;
|
|
case "audiobook":
|
|
return SecondaryAlbumType.Audiobook;
|
|
case "live":
|
|
return SecondaryAlbumType.Live;
|
|
case "remix":
|
|
return SecondaryAlbumType.Remix;
|
|
case "dj-mix":
|
|
return SecondaryAlbumType.DJMix;
|
|
case "mixtape/street":
|
|
return SecondaryAlbumType.Mixtape;
|
|
case "demo":
|
|
return SecondaryAlbumType.Demo;
|
|
default:
|
|
return SecondaryAlbumType.Studio;
|
|
}
|
|
}
|
|
}
|
|
}
|