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