jellyfin-server/MediaBrowser.Api/ItemLookupService.cs

using MediaBrowser.Common.Extensions;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Net;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Providers;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.IO;
using MediaBrowser.Model.IO;
using MediaBrowser.Model.Serialization;
using MediaBrowser.Model.Services;

namespace MediaBrowser.Api
{
    [Route("/Items/{Id}/ExternalIdInfos", "GET", Summary = "Gets external id infos for an item")]
    [Authenticated(Roles = "Admin")]
    public class GetExternalIdInfos : IReturn<List<ExternalIdInfo>>
    {
        /// <summary>
        /// Gets or sets the id.
        /// </summary>
        /// <value>The id.</value>
        [ApiMember(Name = "Id", Description = "Item Id", IsRequired = true, DataType = "string", ParameterType = "path", Verb = "GET")]
        public string Id { get; set; }
    }

    [Route("/Items/RemoteSearch/Movie", "POST")]
    [Authenticated]
    public class GetMovieRemoteSearchResults : RemoteSearchQuery<MovieInfo>, IReturn<List<RemoteSearchResult>>
    {
    }

    [Route("/Items/RemoteSearch/Trailer", "POST")]
    [Authenticated]
    public class GetTrailerRemoteSearchResults : RemoteSearchQuery<TrailerInfo>, IReturn<List<RemoteSearchResult>>
    {
    }

    [Route("/Items/RemoteSearch/AdultVideo", "POST")]
    [Authenticated]
    public class GetAdultVideoRemoteSearchResults : RemoteSearchQuery<ItemLookupInfo>, IReturn<List<RemoteSearchResult>>
    {
    }

    [Route("/Items/RemoteSearch/Series", "POST")]
    [Authenticated]
    public class GetSeriesRemoteSearchResults : RemoteSearchQuery<SeriesInfo>, IReturn<List<RemoteSearchResult>>
    {
    }

    [Route("/Items/RemoteSearch/Game", "POST")]
    [Authenticated]
    public class GetGameRemoteSearchResults : RemoteSearchQuery<GameInfo>, IReturn<List<RemoteSearchResult>>
    {
    }

    [Route("/Items/RemoteSearch/BoxSet", "POST")]
    [Authenticated]
    public class GetBoxSetRemoteSearchResults : RemoteSearchQuery<BoxSetInfo>, IReturn<List<RemoteSearchResult>>
    {
    }

    [Route("/Items/RemoteSearch/MusicArtist", "POST")]
    [Authenticated]
    public class GetMusicArtistRemoteSearchResults : RemoteSearchQuery<ArtistInfo>, IReturn<List<RemoteSearchResult>>
    {
    }

    [Route("/Items/RemoteSearch/MusicAlbum", "POST")]
    [Authenticated]
    public class GetMusicAlbumRemoteSearchResults : RemoteSearchQuery<AlbumInfo>, IReturn<List<RemoteSearchResult>>
    {
    }

    [Route("/Items/RemoteSearch/Person", "POST")]
    [Authenticated(Roles = "Admin")]
    public class GetPersonRemoteSearchResults : RemoteSearchQuery<PersonLookupInfo>, IReturn<List<RemoteSearchResult>>
    {
    }

    [Route("/Items/RemoteSearch/Image", "GET", Summary = "Gets a remote image")]
    public class GetRemoteSearchImage
    {
        [ApiMember(Name = "ImageUrl", Description = "The image url", IsRequired = true, DataType = "string", ParameterType = "query", Verb = "GET")]
        public string ImageUrl { get; set; }

        [ApiMember(Name = "ProviderName", IsRequired = true, DataType = "string", ParameterType = "query", Verb = "GET")]
        public string ProviderName { get; set; }
    }

    [Route("/Items/RemoteSearch/Apply/{Id}", "POST", Summary = "Applies search criteria to an item and refreshes metadata")]
    [Authenticated(Roles = "Admin")]
    public class ApplySearchCriteria : RemoteSearchResult, IReturnVoid
    {
        [ApiMember(Name = "Id", Description = "The item id", IsRequired = true, DataType = "string", ParameterType = "query", Verb = "POST")]
        public string Id { get; set; }

        [ApiMember(Name = "ReplaceAllImages", Description = "Whether or not to replace all images", IsRequired = false, DataType = "boolean", ParameterType = "query", Verb = "POST")]
        public bool ReplaceAllImages { get; set; }

        public ApplySearchCriteria()
        {
            ReplaceAllImages = true;
        }
    }

    public class ItemLookupService : BaseApiService
    {
        private readonly IProviderManager _providerManager;
        private readonly IServerApplicationPaths _appPaths;
        private readonly IFileSystem _fileSystem;
        private readonly ILibraryManager _libraryManager;
        private readonly IJsonSerializer _json;

        public ItemLookupService(IProviderManager providerManager, IServerApplicationPaths appPaths, IFileSystem fileSystem, ILibraryManager libraryManager, IJsonSerializer json)
        {
            _providerManager = providerManager;
            _appPaths = appPaths;
            _fileSystem = fileSystem;
            _libraryManager = libraryManager;
            _json = json;
        }

        public object Get(GetExternalIdInfos request)
        {
            var item = _libraryManager.GetItemById(request.Id);

            var infos = _providerManager.GetExternalIdInfos(item).ToList();

            return ToOptimizedResult(infos);
        }

        public async Task<object> Post(GetTrailerRemoteSearchResults request)
        {
            var result = await _providerManager.GetRemoteSearchResults<Trailer, TrailerInfo>(request, CancellationToken.None).ConfigureAwait(false);

            return ToOptimizedResult(result);
        }

        public async Task<object> Post(GetMovieRemoteSearchResults request)
        {
            var result = await _providerManager.GetRemoteSearchResults<Movie, MovieInfo>(request, CancellationToken.None).ConfigureAwait(false);

            return ToOptimizedResult(result);
        }

        public async Task<object> Post(GetSeriesRemoteSearchResults request)
        {
            var result = await _providerManager.GetRemoteSearchResults<Series, SeriesInfo>(request, CancellationToken.None).ConfigureAwait(false);

            return ToOptimizedResult(result);
        }

        public async Task<object> Post(GetGameRemoteSearchResults request)
        {
            var result = await _providerManager.GetRemoteSearchResults<Game, GameInfo>(request, CancellationToken.None).ConfigureAwait(false);

            return ToOptimizedResult(result);
        }

        public async Task<object> Post(GetBoxSetRemoteSearchResults request)
        {
            var result = await _providerManager.GetRemoteSearchResults<BoxSet, BoxSetInfo>(request, CancellationToken.None).ConfigureAwait(false);

            return ToOptimizedResult(result);
        }

        public async Task<object> Post(GetPersonRemoteSearchResults request)
        {
            var result = await _providerManager.GetRemoteSearchResults<Person, PersonLookupInfo>(request, CancellationToken.None).ConfigureAwait(false);

            return ToOptimizedResult(result);
        }

        public async Task<object> Post(GetMusicAlbumRemoteSearchResults request)
        {
            var result = await _providerManager.GetRemoteSearchResults<MusicAlbum, AlbumInfo>(request, CancellationToken.None).ConfigureAwait(false);

            return ToOptimizedResult(result);
        }

        public async Task<object> Post(GetMusicArtistRemoteSearchResults request)
        {
            var result = await _providerManager.GetRemoteSearchResults<MusicArtist, ArtistInfo>(request, CancellationToken.None).ConfigureAwait(false);

            return ToOptimizedResult(result);
        }

        public Task<object> Get(GetRemoteSearchImage request)
        {
            return GetRemoteImage(request);
        }

        public void Post(ApplySearchCriteria request)
        {
            var item = _libraryManager.GetItemById(new Guid(request.Id));

            //foreach (var key in request.ProviderIds)
            //{
            //    var value = key.Value;

            //    if (!string.IsNullOrWhiteSpace(value))
            //    {
            //        item.SetProviderId(key.Key, value);
            //    }
            //}
            Logger.Info("Setting provider id's to item {0}-{1}: {2}", item.Id, item.Name, _json.SerializeToString(request.ProviderIds));

            // Since the refresh process won't erase provider Ids, we need to set this explicitly now.
            item.ProviderIds = request.ProviderIds;
            //item.ProductionYear = request.ProductionYear;
            //item.Name = request.Name;

            var task = _providerManager.RefreshFullItem(item, new MetadataRefreshOptions(_fileSystem)
            {
                MetadataRefreshMode = MetadataRefreshMode.FullRefresh,
                ImageRefreshMode = ImageRefreshMode.FullRefresh,
                ReplaceAllMetadata = true,
                ReplaceAllImages = request.ReplaceAllImages,
                SearchResult = request

            }, CancellationToken.None);
            Task.WaitAll(task);
        }

        /// <summary>
        /// Gets the remote image.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>Task{System.Object}.</returns>
        private async Task<object> GetRemoteImage(GetRemoteSearchImage request)
        {
            var urlHash = request.ImageUrl.GetMD5();
            var pointerCachePath = GetFullCachePath(urlHash.ToString());

            string contentPath;

            try
            {
                using (var reader = new StreamReader(pointerCachePath))
                {
                    contentPath = await reader.ReadToEndAsync().ConfigureAwait(false);
                }

                if (_fileSystem.FileExists(contentPath))
                {
                    return await ResultFactory.GetStaticFileResult(Request, contentPath).ConfigureAwait(false);
                }
            }
            catch (DirectoryNotFoundException)
            {
                // Means the file isn't cached yet
            }
            catch (FileNotFoundException)
            {
                // Means the file isn't cached yet
            }

            await DownloadImage(request.ProviderName, request.ImageUrl, urlHash, pointerCachePath).ConfigureAwait(false);

            // Read the pointer file again
            using (var reader = new StreamReader(pointerCachePath))
            {
                contentPath = await reader.ReadToEndAsync().ConfigureAwait(false);
            }

            return await ResultFactory.GetStaticFileResult(Request, contentPath).ConfigureAwait(false);
        }

        /// <summary>
        /// Downloads the image.
        /// </summary>
        /// <param name="providerName">Name of the provider.</param>
        /// <param name="url">The URL.</param>
        /// <param name="urlHash">The URL hash.</param>
        /// <param name="pointerCachePath">The pointer cache path.</param>
        /// <returns>Task.</returns>
        private async Task DownloadImage(string providerName, string url, Guid urlHash, string pointerCachePath)
        {
            var result = await _providerManager.GetSearchImage(providerName, url, CancellationToken.None).ConfigureAwait(false);

            var ext = result.ContentType.Split('/').Last();

            var fullCachePath = GetFullCachePath(urlHash + "." + ext);

            _fileSystem.CreateDirectory(Path.GetDirectoryName(fullCachePath));
            using (var stream = result.Content)
            {
                using (var filestream = _fileSystem.GetFileStream(fullCachePath, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read, true))
                {
                    await stream.CopyToAsync(filestream).ConfigureAwait(false);
                }
            }

            _fileSystem.CreateDirectory(Path.GetDirectoryName(pointerCachePath));
            using (var writer = new StreamWriter(pointerCachePath))
            {
                await writer.WriteAsync(fullCachePath).ConfigureAwait(false);
            }
        }

        /// <summary>
        /// Gets the full cache path.
        /// </summary>
        /// <param name="filename">The filename.</param>
        /// <returns>System.String.</returns>
        private string GetFullCachePath(string filename)
        {
            return Path.Combine(_appPaths.CachePath, "remote-images", filename.Substring(0, 1), filename);
        }

    }
}