jellyfin/MediaBrowser.Api/BaseApiService.cs

419 lines
15 KiB
C#
Raw Normal View History

using System;
using System.IO;
using System.Linq;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Dto;
2015-01-24 19:03:55 +00:00
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
2013-03-16 05:52:33 +00:00
using MediaBrowser.Controller.Library;
2013-12-07 15:52:38 +00:00
using MediaBrowser.Controller.Net;
2014-03-25 21:13:55 +00:00
using MediaBrowser.Controller.Session;
2015-01-24 19:03:55 +00:00
using MediaBrowser.Model.Entities;
2019-02-08 21:59:28 +00:00
using MediaBrowser.Model.Querying;
2020-03-24 15:12:06 +00:00
using MediaBrowser.Model.Services;
using Microsoft.Extensions.Logging;
2013-03-16 05:52:33 +00:00
namespace MediaBrowser.Api
{
/// <summary>
/// Class BaseApiService
/// </summary>
public abstract class BaseApiService : IService, IRequiresRequest
2013-03-16 05:52:33 +00:00
{
public BaseApiService(
2020-05-15 00:11:34 +00:00
ILogger<BaseApiService> logger,
IServerConfigurationManager serverConfigurationManager,
IHttpResultFactory httpResultFactory)
{
Logger = logger;
ServerConfigurationManager = serverConfigurationManager;
ResultFactory = httpResultFactory;
}
/// <summary>
/// Gets the logger.
/// </summary>
/// <value>The logger.</value>
2020-05-15 00:11:34 +00:00
protected ILogger<BaseApiService> Logger { get; }
/// <summary>
/// Gets or sets the server configuration manager.
/// </summary>
/// <value>The server configuration manager.</value>
protected IServerConfigurationManager ServerConfigurationManager { get; }
2015-01-22 16:41:34 +00:00
/// <summary>
/// Gets the HTTP result factory.
/// </summary>
/// <value>The HTTP result factory.</value>
protected IHttpResultFactory ResultFactory { get; }
/// <summary>
/// Gets or sets the request context.
/// </summary>
/// <value>The request context.</value>
2013-12-07 15:52:38 +00:00
public IRequest Request { get; set; }
public string GetHeader(string name) => Request.Headers[name];
2017-08-19 19:43:35 +00:00
public static string[] SplitValue(string value, char delim)
{
2020-04-05 18:44:14 +00:00
return value == null
? Array.Empty<string>()
: value.Split(new[] { delim }, StringSplitOptions.RemoveEmptyEntries);
2017-08-19 19:43:35 +00:00
}
2018-09-12 17:26:21 +00:00
public static Guid[] GetGuids(string value)
{
2019-02-02 22:55:47 +00:00
if (value == null)
{
return Array.Empty<Guid>();
}
2019-02-02 23:15:28 +00:00
return value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
2019-02-02 22:55:47 +00:00
.Select(i => new Guid(i))
.ToArray();
2018-09-12 17:26:21 +00:00
}
/// <summary>
/// To the optimized result.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="result">The result.</param>
/// <returns>System.Object.</returns>
protected object ToOptimizedResult<T>(T result)
where T : class
{
2018-09-12 17:26:21 +00:00
return ResultFactory.GetResult(Request, result);
}
2018-09-12 17:26:21 +00:00
protected void AssertCanUpdateUser(IAuthorizationContext authContext, IUserManager userManager, Guid userId, bool restrictUserPreferences)
2015-03-16 01:48:25 +00:00
{
2016-11-10 14:41:24 +00:00
var auth = authContext.GetAuthorizationInfo(Request);
2015-03-16 01:48:25 +00:00
2018-09-12 17:26:21 +00:00
var authenticatedUser = auth.User;
2015-03-16 01:48:25 +00:00
// If they're going to update the record of another user, they must be an administrator
2020-04-05 18:44:14 +00:00
if ((!userId.Equals(auth.UserId) && !authenticatedUser.Policy.IsAdministrator)
|| (restrictUserPreferences && !authenticatedUser.Policy.EnableUserPreferenceAccess))
2015-03-16 01:48:25 +00:00
{
2020-04-05 18:44:14 +00:00
throw new SecurityException("Unauthorized access.");
2015-03-16 01:48:25 +00:00
}
}
2016-05-06 04:50:39 +00:00
2014-03-25 21:13:55 +00:00
/// <summary>
/// Gets the session.
/// </summary>
/// <returns>SessionInfo.</returns>
2018-09-12 17:26:21 +00:00
protected SessionInfo GetSession(ISessionContext sessionContext)
2014-03-25 21:13:55 +00:00
{
2018-09-12 17:26:21 +00:00
var session = sessionContext.GetSession(Request);
2014-06-25 15:12:39 +00:00
if (session == null)
{
throw new ArgumentException("Session not found.");
}
return session;
2014-03-25 21:13:55 +00:00
}
2016-11-10 14:41:24 +00:00
protected DtoOptions GetDtoOptions(IAuthorizationContext authContext, object request)
2015-01-24 19:03:55 +00:00
{
var options = new DtoOptions();
2019-02-08 21:59:28 +00:00
if (request is IHasItemFields hasFields)
2015-01-24 19:03:55 +00:00
{
2017-08-19 19:43:35 +00:00
options.Fields = hasFields.GetItemFields();
2015-01-24 19:03:55 +00:00
}
2020-04-05 16:48:22 +00:00
if (!options.ContainsField(ItemFields.RecursiveItemCount)
|| !options.ContainsField(ItemFields.ChildCount))
2016-12-13 07:36:30 +00:00
{
2018-09-12 17:26:21 +00:00
var client = authContext.GetAuthorizationInfo(Request).Client ?? string.Empty;
if (client.IndexOf("kodi", StringComparison.OrdinalIgnoreCase) != -1 ||
client.IndexOf("wmc", StringComparison.OrdinalIgnoreCase) != -1 ||
client.IndexOf("media center", StringComparison.OrdinalIgnoreCase) != -1 ||
client.IndexOf("classic", StringComparison.OrdinalIgnoreCase) != -1)
{
2019-02-08 21:59:28 +00:00
int oldLen = options.Fields.Length;
var arr = new ItemFields[oldLen + 1];
options.Fields.CopyTo(arr, 0);
2020-04-05 16:48:22 +00:00
arr[oldLen] = ItemFields.RecursiveItemCount;
2019-02-08 21:59:28 +00:00
options.Fields = arr;
2018-09-12 17:26:21 +00:00
}
2016-12-13 07:36:30 +00:00
2018-09-12 17:26:21 +00:00
if (client.IndexOf("kodi", StringComparison.OrdinalIgnoreCase) != -1 ||
client.IndexOf("wmc", StringComparison.OrdinalIgnoreCase) != -1 ||
client.IndexOf("media center", StringComparison.OrdinalIgnoreCase) != -1 ||
client.IndexOf("classic", StringComparison.OrdinalIgnoreCase) != -1 ||
client.IndexOf("roku", StringComparison.OrdinalIgnoreCase) != -1 ||
client.IndexOf("samsung", StringComparison.OrdinalIgnoreCase) != -1 ||
client.IndexOf("androidtv", StringComparison.OrdinalIgnoreCase) != -1)
{
2019-02-08 21:59:28 +00:00
int oldLen = options.Fields.Length;
var arr = new ItemFields[oldLen + 1];
options.Fields.CopyTo(arr, 0);
2020-04-05 16:48:22 +00:00
arr[oldLen] = ItemFields.ChildCount;
2019-02-08 21:59:28 +00:00
options.Fields = arr;
2018-09-12 17:26:21 +00:00
}
2016-12-13 07:36:30 +00:00
}
2019-02-02 22:55:47 +00:00
if (request is IHasDtoOptions hasDtoOptions)
2015-01-24 19:03:55 +00:00
{
options.EnableImages = hasDtoOptions.EnableImages ?? true;
if (hasDtoOptions.ImageTypeLimit.HasValue)
{
options.ImageTypeLimit = hasDtoOptions.ImageTypeLimit.Value;
}
2019-03-13 21:32:52 +00:00
2016-08-17 19:28:43 +00:00
if (hasDtoOptions.EnableUserData.HasValue)
{
options.EnableUserData = hasDtoOptions.EnableUserData.Value;
}
2015-01-24 19:03:55 +00:00
if (!string.IsNullOrWhiteSpace(hasDtoOptions.EnableImageTypes))
{
2019-02-26 19:47:23 +00:00
options.ImageTypes = hasDtoOptions.EnableImageTypes.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(v => (ImageType)Enum.Parse(typeof(ImageType), v, true))
.ToArray();
2015-01-24 19:03:55 +00:00
}
}
return options;
}
2017-05-22 04:54:02 +00:00
protected MusicArtist GetArtist(string name, ILibraryManager libraryManager, DtoOptions dtoOptions)
{
2016-05-06 04:50:39 +00:00
if (name.IndexOf(BaseItem.SlugChar) != -1)
{
2017-06-13 06:33:29 +00:00
var result = GetItemFromSlugName<MusicArtist>(libraryManager, name, dtoOptions);
2013-06-11 03:31:00 +00:00
2016-05-06 04:50:39 +00:00
if (result != null)
{
return result;
}
}
2017-05-22 04:54:02 +00:00
return libraryManager.GetArtist(name, dtoOptions);
}
2017-05-22 04:54:02 +00:00
protected Studio GetStudio(string name, ILibraryManager libraryManager, DtoOptions dtoOptions)
{
2016-05-06 04:50:39 +00:00
if (name.IndexOf(BaseItem.SlugChar) != -1)
2016-03-25 04:08:22 +00:00
{
2017-06-13 06:33:29 +00:00
var result = GetItemFromSlugName<Studio>(libraryManager, name, dtoOptions);
2016-05-06 04:50:39 +00:00
if (result != null)
{
return result;
}
}
2016-05-06 04:50:39 +00:00
return libraryManager.GetStudio(name);
}
2017-05-22 04:54:02 +00:00
protected Genre GetGenre(string name, ILibraryManager libraryManager, DtoOptions dtoOptions)
{
2016-05-06 04:50:39 +00:00
if (name.IndexOf(BaseItem.SlugChar) != -1)
{
2017-06-13 06:33:29 +00:00
var result = GetItemFromSlugName<Genre>(libraryManager, name, dtoOptions);
2016-05-06 04:50:39 +00:00
if (result != null)
{
return result;
}
}
2016-05-06 04:50:39 +00:00
return libraryManager.GetGenre(name);
}
2017-05-22 04:54:02 +00:00
protected MusicGenre GetMusicGenre(string name, ILibraryManager libraryManager, DtoOptions dtoOptions)
2013-07-01 18:17:55 +00:00
{
2016-05-06 04:50:39 +00:00
if (name.IndexOf(BaseItem.SlugChar) != -1)
2013-07-01 18:17:55 +00:00
{
2017-06-13 06:33:29 +00:00
var result = GetItemFromSlugName<MusicGenre>(libraryManager, name, dtoOptions);
2016-03-25 04:08:22 +00:00
2016-05-06 04:50:39 +00:00
if (result != null)
2013-07-01 18:17:55 +00:00
{
2016-05-06 04:50:39 +00:00
return result;
}
}
2013-07-01 18:17:55 +00:00
2016-05-06 04:50:39 +00:00
return libraryManager.GetMusicGenre(name);
2013-07-01 18:17:55 +00:00
}
2017-05-22 04:54:02 +00:00
protected Person GetPerson(string name, ILibraryManager libraryManager, DtoOptions dtoOptions)
{
2016-05-06 04:50:39 +00:00
if (name.IndexOf(BaseItem.SlugChar) != -1)
{
2017-06-13 06:33:29 +00:00
var result = GetItemFromSlugName<Person>(libraryManager, name, dtoOptions);
2016-05-06 04:50:39 +00:00
if (result != null)
{
return result;
}
}
2016-05-06 04:50:39 +00:00
return libraryManager.GetPerson(name);
}
2013-08-03 14:38:56 +00:00
2017-06-13 06:33:29 +00:00
private T GetItemFromSlugName<T>(ILibraryManager libraryManager, string name, DtoOptions dtoOptions)
where T : BaseItem, new()
{
2020-04-06 03:12:25 +00:00
var result = libraryManager.GetItemList(new InternalItemsQuery
2017-06-13 06:33:29 +00:00
{
Name = name.Replace(BaseItem.SlugChar, '&'),
IncludeItemTypes = new[] { typeof(T).Name },
DtoOptions = dtoOptions
2020-04-06 03:12:25 +00:00
}).OfType<T>().FirstOrDefault();
result ??= libraryManager.GetItemList(new InternalItemsQuery
2017-06-13 06:33:29 +00:00
{
2020-04-05 16:45:01 +00:00
Name = name.Replace(BaseItem.SlugChar, '/'),
IncludeItemTypes = new[] { typeof(T).Name },
DtoOptions = dtoOptions
2017-06-13 06:33:29 +00:00
2020-04-06 03:12:25 +00:00
}).OfType<T>().FirstOrDefault();
result ??= libraryManager.GetItemList(new InternalItemsQuery
2017-06-13 06:33:29 +00:00
{
2020-04-05 16:45:01 +00:00
Name = name.Replace(BaseItem.SlugChar, '?'),
IncludeItemTypes = new[] { typeof(T).Name },
DtoOptions = dtoOptions
2017-06-13 06:33:29 +00:00
2020-04-05 16:45:01 +00:00
}).OfType<T>().FirstOrDefault();
2017-06-13 06:33:29 +00:00
2018-09-12 17:26:21 +00:00
return result;
2017-06-13 06:33:29 +00:00
}
/// <summary>
/// Gets the path segment at the specified index.
/// </summary>
/// <param name="index">The index of the path segment.</param>
/// <returns>The path segment at the specified index.</returns>
/// <exception cref="IndexOutOfRangeException" >Path doesn't contain enough segments.</exception>
/// <exception cref="InvalidDataException" >Path doesn't start with the base url.</exception>
protected internal ReadOnlySpan<char> GetPathValue(int index)
2015-01-22 16:41:34 +00:00
{
static void ThrowIndexOutOfRangeException()
2019-12-05 16:44:46 +00:00
=> throw new IndexOutOfRangeException("Path doesn't contain enough segments.");
static void ThrowInvalidDataException()
2019-12-05 16:44:46 +00:00
=> throw new InvalidDataException("Path doesn't start with the base url.");
2015-01-22 16:41:34 +00:00
ReadOnlySpan<char> path = Request.PathInfo;
2019-11-13 09:35:55 +00:00
// Remove the protocol part from the url
int pos = path.LastIndexOf("://");
if (pos != -1)
2019-11-13 09:35:55 +00:00
{
path = path.Slice(pos + 3);
2019-11-13 09:35:55 +00:00
}
// Remove the query string
pos = path.LastIndexOf('?');
if (pos != -1)
2015-01-22 16:41:34 +00:00
{
path = path.Slice(0, pos);
}
// Remove the domain
pos = path.IndexOf('/');
if (pos != -1)
{
path = path.Slice(pos);
}
// Remove base url
string baseUrl = ServerConfigurationManager.Configuration.BaseUrl;
int baseUrlLen = baseUrl.Length;
if (baseUrlLen != 0)
{
if (path.StartsWith(baseUrl, StringComparison.OrdinalIgnoreCase))
2019-11-13 09:35:55 +00:00
{
path = path.Slice(baseUrlLen);
}
else
{
// The path doesn't start with the base url,
// how did we get here?
ThrowInvalidDataException();
2019-11-13 09:35:55 +00:00
}
2015-01-22 16:41:34 +00:00
}
// Remove leading /
path = path.Slice(1);
2016-10-22 14:51:48 +00:00
// Backwards compatibility
const string Emby = "emby/";
if (path.StartsWith(Emby, StringComparison.OrdinalIgnoreCase))
{
path = path.Slice(Emby.Length);
}
2016-10-22 14:51:48 +00:00
const string MediaBrowser = "mediabrowser/";
if (path.StartsWith(MediaBrowser, StringComparison.OrdinalIgnoreCase))
{
path = path.Slice(MediaBrowser.Length);
}
2016-10-22 14:51:48 +00:00
// Skip segments until we are at the right index
for (int i = 0; i < index; i++)
2016-10-22 14:51:48 +00:00
{
pos = path.IndexOf('/');
if (pos == -1)
{
ThrowIndexOutOfRangeException();
}
path = path.Slice(pos + 1);
2016-10-22 14:51:48 +00:00
}
// Remove the rest
pos = path.IndexOf('/');
if (pos != -1)
{
path = path.Slice(0, pos);
}
2016-10-22 14:51:48 +00:00
return path;
2015-01-22 16:41:34 +00:00
}
2013-08-03 14:38:56 +00:00
/// <summary>
/// Gets the name of the item by.
/// </summary>
2017-05-22 04:54:02 +00:00
protected BaseItem GetItemByName(string name, string type, ILibraryManager libraryManager, DtoOptions dtoOptions)
2013-08-03 14:38:56 +00:00
{
2019-03-13 21:32:52 +00:00
if (type.Equals("Person", StringComparison.OrdinalIgnoreCase))
2013-08-03 14:38:56 +00:00
{
2019-03-13 21:32:52 +00:00
return GetPerson(name, libraryManager, dtoOptions);
2013-08-03 14:38:56 +00:00
}
2019-03-13 21:32:52 +00:00
else if (type.Equals("Artist", StringComparison.OrdinalIgnoreCase))
2013-08-03 14:38:56 +00:00
{
2019-03-13 21:32:52 +00:00
return GetArtist(name, libraryManager, dtoOptions);
2013-08-03 14:38:56 +00:00
}
2019-03-13 21:32:52 +00:00
else if (type.Equals("Genre", StringComparison.OrdinalIgnoreCase))
2013-08-03 14:38:56 +00:00
{
2019-03-13 21:32:52 +00:00
return GetGenre(name, libraryManager, dtoOptions);
2013-08-03 14:38:56 +00:00
}
2019-03-13 21:32:52 +00:00
else if (type.Equals("MusicGenre", StringComparison.OrdinalIgnoreCase))
2013-08-03 14:38:56 +00:00
{
2019-03-13 21:32:52 +00:00
return GetMusicGenre(name, libraryManager, dtoOptions);
2013-08-03 14:38:56 +00:00
}
2019-03-13 21:32:52 +00:00
else if (type.Equals("Studio", StringComparison.OrdinalIgnoreCase))
2013-08-03 14:38:56 +00:00
{
2019-03-13 21:32:52 +00:00
return GetStudio(name, libraryManager, dtoOptions);
2013-08-03 14:38:56 +00:00
}
2019-03-13 21:32:52 +00:00
else if (type.Equals("Year", StringComparison.OrdinalIgnoreCase))
2013-08-03 14:38:56 +00:00
{
2019-03-13 21:32:52 +00:00
return libraryManager.GetYear(int.Parse(name));
2013-08-03 14:38:56 +00:00
}
2019-03-13 21:32:52 +00:00
throw new ArgumentException("Invalid type", nameof(type));
2013-08-03 14:38:56 +00:00
}
2013-03-16 05:52:33 +00:00
}
}