Cutlery/Kyoo
1
0
Fork 0
mirror of https://github.com/zoriya/Kyoo.git synced 2025-05-24 02:02:36 -04:00
Code Issues Packages Projects Releases Wiki Activity

Switch to file scopped namespaces

Browse Source
This commit is contained in:
Zoe Roux 2024-03-23 00:14:34 +01:00
parent 35e37bbe76
commit 18e301f26a
No known key found for this signature in database
99 changed files with 8936 additions and 9141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
back/.editorconfig
View File

@ -16,6 +16,8 @@ dotnet_diagnostic.IDE0055.severity = none
dotnet_diagnostic.IDE0058.severity = none dotnet_diagnostic.IDE0058.severity = none
dotnet_diagnostic.IDE0130.severity = none dotnet_diagnostic.IDE0130.severity = none
# Convert to file-scoped namespace
csharp_style_namespace_declarations = file_scoped:warning
# Sort using and Import directives with System.* appearing first # Sort using and Import directives with System.* appearing first
dotnet_sort_system_directives_first = true dotnet_sort_system_directives_first = true
csharp_using_directive_placement = outside_namespace:warning csharp_using_directive_placement = outside_namespace:warning

95
back/src/Kyoo.Abstractions/Controllers/ILibraryManager.cs
View File

@ -18,64 +18,63 @@
using Kyoo.Abstractions.Models; using Kyoo.Abstractions.Models;
namespace Kyoo.Abstractions.Controllers namespace Kyoo.Abstractions.Controllers;
/// <summary>
/// An interface to interact with the database. Every repository is mapped through here.
/// </summary>
public interface ILibraryManager
{ {
IRepository<T> Repository<T>()
where T : IResource, IQuery;
/// <summary> /// <summary>
/// An interface to interact with the database. Every repository is mapped through here. /// The repository that handle libraries items (a wrapper around shows and collections).
/// </summary> /// </summary>
public interface ILibraryManager IRepository<ILibraryItem> LibraryItems { get; }
{
IRepository<T> Repository<T>()
where T : IResource, IQuery;
/// <summary> /// <summary>
/// The repository that handle libraries items (a wrapper around shows and collections). /// The repository that handle new items.
/// </summary> /// </summary>
IRepository<ILibraryItem> LibraryItems { get; } IRepository<INews> News { get; }
/// <summary> /// <summary>
/// The repository that handle new items. /// The repository that handle watched items.
/// </summary> /// </summary>
IRepository<INews> News { get; } IWatchStatusRepository WatchStatus { get; }
/// <summary> /// <summary>
/// The repository that handle watched items. /// The repository that handle collections.
/// </summary> /// </summary>
IWatchStatusRepository WatchStatus { get; } IRepository<Collection> Collections { get; }
/// <summary> /// <summary>
/// The repository that handle collections. /// The repository that handle shows.
/// </summary> /// </summary>
IRepository<Collection> Collections { get; } IRepository<Movie> Movies { get; }
/// <summary> /// <summary>
/// The repository that handle shows. /// The repository that handle shows.
/// </summary> /// </summary>
IRepository<Movie> Movies { get; } IRepository<Show> Shows { get; }
/// <summary> /// <summary>
/// The repository that handle shows. /// The repository that handle seasons.
/// </summary> /// </summary>
IRepository<Show> Shows { get; } IRepository<Season> Seasons { get; }
/// <summary> /// <summary>
/// The repository that handle seasons. /// The repository that handle episodes.
/// </summary> /// </summary>
IRepository<Season> Seasons { get; } IRepository<Episode> Episodes { get; }
/// <summary> /// <summary>
/// The repository that handle episodes. /// The repository that handle studios.
/// </summary> /// </summary>
IRepository<Episode> Episodes { get; } IRepository<Studio> Studios { get; }
/// <summary> /// <summary>
/// The repository that handle studios. /// The repository that handle users.
/// </summary> /// </summary>
IRepository<Studio> Studios { get; } IRepository<User> Users { get; }
/// <summary>
/// The repository that handle users.
/// </summary>
IRepository<User> Users { get; }
}
} }

41
back/src/Kyoo.Abstractions/Controllers/IPermissionValidator.cs
View File

@ -19,29 +19,28 @@
using Kyoo.Abstractions.Models.Permissions; using Kyoo.Abstractions.Models.Permissions;
using Microsoft.AspNetCore.Mvc.Filters; using Microsoft.AspNetCore.Mvc.Filters;
namespace Kyoo.Abstractions.Controllers namespace Kyoo.Abstractions.Controllers;
/// <summary>
/// A service to validate permissions.
/// </summary>
public interface IPermissionValidator
{ {
/// <summary> /// <summary>
/// A service to validate permissions. /// Create an IAuthorizationFilter that will be used to validate permissions.
/// This can registered with any lifetime.
/// </summary> /// </summary>
public interface IPermissionValidator /// <param name="attribute">The permission attribute to validate.</param>
{ /// <returns>An authorization filter used to validate the permission.</returns>
/// <summary> IFilterMetadata Create(PermissionAttribute attribute);
/// Create an IAuthorizationFilter that will be used to validate permissions.
/// This can registered with any lifetime.
/// </summary>
/// <param name="attribute">The permission attribute to validate.</param>
/// <returns>An authorization filter used to validate the permission.</returns>
IFilterMetadata Create(PermissionAttribute attribute);
/// <summary> /// <summary>
/// Create an IAuthorizationFilter that will be used to validate permissions. /// Create an IAuthorizationFilter that will be used to validate permissions.
/// This can registered with any lifetime. /// This can registered with any lifetime.
/// </summary> /// </summary>
/// <param name="attribute"> /// <param name="attribute">
/// A partial attribute to validate. See <see cref="PartialPermissionAttribute"/>. /// A partial attribute to validate. See <see cref="PartialPermissionAttribute"/>.
/// </param> /// </param>
/// <returns>An authorization filter used to validate the permission.</returns> /// <returns>An authorization filter used to validate the permission.</returns>
IFilterMetadata Create(PartialPermissionAttribute attribute); IFilterMetadata Create(PartialPermissionAttribute attribute);
}
} }

71
back/src/Kyoo.Abstractions/Controllers/IPlugin.cs
View File

@ -21,46 +21,45 @@ using System.Collections.Generic;
using Autofac; using Autofac;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
namespace Kyoo.Abstractions.Controllers namespace Kyoo.Abstractions.Controllers;
/// <summary>
/// A common interface used to discord plugins
/// </summary>
/// <remarks>
/// You can inject services in the IPlugin constructor.
/// You should only inject well known services like an ILogger, IConfiguration or IWebHostEnvironment.
/// </remarks>
public interface IPlugin
{ {
/// <summary> /// <summary>
/// A common interface used to discord plugins /// The name of the plugin
/// </summary> /// </summary>
/// <remarks> string Name { get; }
/// You can inject services in the IPlugin constructor.
/// You should only inject well known services like an ILogger, IConfiguration or IWebHostEnvironment. /// <summary>
/// </remarks> /// An optional configuration step to allow a plugin to change asp net configurations.
public interface IPlugin /// </summary>
/// <seealso cref="SA"/>
IEnumerable<IStartupAction> ConfigureSteps => ArraySegment<IStartupAction>.Empty;
/// <summary>
/// A configure method that will be run on plugin's startup.
/// </summary>
/// <param name="builder">The autofac service container to register services.</param>
void Configure(ContainerBuilder builder)
{ {
/// <summary> // Skipped
/// The name of the plugin }
/// </summary>
string Name { get; }
/// <summary> /// <summary>
/// An optional configuration step to allow a plugin to change asp net configurations. /// A configure method that will be run on plugin's startup.
/// </summary> /// This is available for libraries that build upon a <see cref="IServiceCollection"/>, for more precise
/// <seealso cref="SA"/> /// configuration use <see cref="Configure(Autofac.ContainerBuilder)"/>.
IEnumerable<IStartupAction> ConfigureSteps => ArraySegment<IStartupAction>.Empty; /// </summary>
/// <param name="services">A service container to register new services.</param>
/// <summary> void Configure(IServiceCollection services)
/// A configure method that will be run on plugin's startup. {
/// </summary> // Skipped
/// <param name="builder">The autofac service container to register services.</param>
void Configure(ContainerBuilder builder)
{
// Skipped
}
/// <summary>
/// A configure method that will be run on plugin's startup.
/// This is available for libraries that build upon a <see cref="IServiceCollection"/>, for more precise
/// configuration use <see cref="Configure(Autofac.ContainerBuilder)"/>.
/// </summary>
/// <param name="services">A service container to register new services.</param>
void Configure(IServiceCollection services)
{
// Skipped
}
} }
} }

79
back/src/Kyoo.Abstractions/Controllers/IPluginManager.cs
View File

@ -20,51 +20,50 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using Kyoo.Abstractions.Models.Exceptions; using Kyoo.Abstractions.Models.Exceptions;
namespace Kyoo.Abstractions.Controllers namespace Kyoo.Abstractions.Controllers;
/// <summary>
/// A manager to load plugins and retrieve information from them.
/// </summary>
public interface IPluginManager
{ {
/// <summary> /// <summary>
/// A manager to load plugins and retrieve information from them. /// Get a single plugin that match the type and name given.
/// </summary> /// </summary>
public interface IPluginManager /// <param name="name">The name of the plugin</param>
{ /// <typeparam name="T">The type of the plugin</typeparam>
/// <summary> /// <exception cref="ItemNotFoundException">If no plugins match the query</exception>
/// Get a single plugin that match the type and name given. /// <returns>A plugin that match the queries</returns>
/// </summary> public T GetPlugin<T>(string name);
/// <param name="name">The name of the plugin</param>
/// <typeparam name="T">The type of the plugin</typeparam>
/// <exception cref="ItemNotFoundException">If no plugins match the query</exception>
/// <returns>A plugin that match the queries</returns>
public T GetPlugin<T>(string name);
/// <summary> /// <summary>
/// Get all plugins of the given type. /// Get all plugins of the given type.
/// </summary> /// </summary>
/// <typeparam name="T">The type of plugins to get</typeparam> /// <typeparam name="T">The type of plugins to get</typeparam>
/// <returns>A list of plugins matching the given type or an empty list of none match.</returns> /// <returns>A list of plugins matching the given type or an empty list of none match.</returns>
public ICollection<T> GetPlugins<T>(); public ICollection<T> GetPlugins<T>();
/// <summary> /// <summary>
/// Get all plugins currently running on Kyoo. This also includes deleted plugins if the app as not been restarted. /// Get all plugins currently running on Kyoo. This also includes deleted plugins if the app as not been restarted.
/// </summary> /// </summary>
/// <returns>All plugins currently loaded.</returns> /// <returns>All plugins currently loaded.</returns>
public ICollection<IPlugin> GetAllPlugins(); public ICollection<IPlugin> GetAllPlugins();
/// <summary> /// <summary>
/// Load plugins and their dependencies from the plugin directory. /// Load plugins and their dependencies from the plugin directory.
/// </summary> /// </summary>
/// <param name="plugins"> /// <param name="plugins">
/// An initial plugin list to use. /// An initial plugin list to use.
/// You should not try to put plugins from the plugins directory here as they will get automatically loaded. /// You should not try to put plugins from the plugins directory here as they will get automatically loaded.
/// </param> /// </param>
public void LoadPlugins(ICollection<IPlugin> plugins); public void LoadPlugins(ICollection<IPlugin> plugins);
/// <summary> /// <summary>
/// Load plugins and their dependencies from the plugin directory. /// Load plugins and their dependencies from the plugin directory.
/// </summary> /// </summary>
/// <param name="plugins"> /// <param name="plugins">
/// An initial plugin list to use. /// An initial plugin list to use.
/// You should not try to put plugins from the plugins directory here as they will get automatically loaded. /// You should not try to put plugins from the plugins directory here as they will get automatically loaded.
/// </param> /// </param>
public void LoadPlugins(params Type[] plugins); public void LoadPlugins(params Type[] plugins);
}
} }

472
back/src/Kyoo.Abstractions/Controllers/IRepository.cs
View File

@ -23,249 +23,245 @@ using Kyoo.Abstractions.Models;
using Kyoo.Abstractions.Models.Exceptions; using Kyoo.Abstractions.Models.Exceptions;
using Kyoo.Abstractions.Models.Utils; using Kyoo.Abstractions.Models.Utils;
namespace Kyoo.Abstractions.Controllers namespace Kyoo.Abstractions.Controllers;
/// <summary>
/// A common repository for every resources.
/// </summary>
/// <typeparam name="T">The resource's type that this repository manage.</typeparam>
public interface IRepository<T> : IBaseRepository
where T : IResource, IQuery
{ {
/// <summary> /// <summary>
/// A common repository for every resources. /// The event handler type for all events of this repository.
/// </summary> /// </summary>
/// <typeparam name="T">The resource's type that this repository manage.</typeparam> /// <param name="resource">The resource created/modified/deleted</param>
public interface IRepository<T> : IBaseRepository /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
where T : IResource, IQuery public delegate Task ResourceEventHandler(T resource);
{
/// <summary>
/// The event handler type for all events of this repository.
/// </summary>
/// <param name="resource">The resource created/modified/deleted</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public delegate Task ResourceEventHandler(T resource);
/// <summary>
/// Get a resource from it's ID.
/// </summary>
/// <param name="id">The id of the resource</param>
/// <param name="include">The related fields to include.</param>
/// <exception cref="ItemNotFoundException">If the item could not be found.</exception>
/// <returns>The resource found</returns>
Task<T> Get(Guid id, Include<T>? include = default);
/// <summary>
/// Get a resource from it's slug.
/// </summary>
/// <param name="slug">The slug of the resource</param>
/// <param name="include">The related fields to include.</param>
/// <exception cref="ItemNotFoundException">If the item could not be found.</exception>
/// <returns>The resource found</returns>
Task<T> Get(string slug, Include<T>? include = default);
/// <summary>
/// Get the first resource that match the predicate.
/// </summary>
/// <param name="filter">A predicate to filter the resource.</param>
/// <param name="include">The related fields to include.</param>
/// <param name="sortBy">A custom sort method to handle cases where multiples items match the filters.</param>
/// <param name="reverse">Reverse the sort.</param>
/// <param name="afterId">Select the first element after this id if it was in a list.</param>
/// <exception cref="ItemNotFoundException">If the item could not be found.</exception>
/// <returns>The resource found</returns>
Task<T> Get(
Filter<T> filter,
Include<T>? include = default,
Sort<T>? sortBy = default,
bool reverse = false,
Guid? afterId = default
);
/// <summary>
/// Get a resource from it's ID or null if it is not found.
/// </summary>
/// <param name="id">The id of the resource</param>
/// <param name="include">The related fields to include.</param>
/// <returns>The resource found</returns>
Task<T?> GetOrDefault(Guid id, Include<T>? include = default);
/// <summary>
/// Get a resource from it's slug or null if it is not found.
/// </summary>
/// <param name="slug">The slug of the resource</param>
/// <param name="include">The related fields to include.</param>
/// <returns>The resource found</returns>
Task<T?> GetOrDefault(string slug, Include<T>? include = default);
/// <summary>
/// Get the first resource that match the predicate or null if it is not found.
/// </summary>
/// <param name="filter">A predicate to filter the resource.</param>
/// <param name="include">The related fields to include.</param>
/// <param name="sortBy">A custom sort method to handle cases where multiples items match the filters.</param>
/// <param name="reverse">Reverse the sort.</param>
/// <param name="afterId">Select the first element after this id if it was in a list.</param>
/// <returns>The resource found</returns>
Task<T?> GetOrDefault(
Filter<T>? filter,
Include<T>? include = default,
Sort<T>? sortBy = default,
bool reverse = false,
Guid? afterId = default
);
/// <summary>
/// Search for resources with the database.
/// </summary>
/// <param name="query">The query string.</param>
/// <param name="include">The related fields to include.</param>
/// <returns>A list of resources found</returns>
Task<ICollection<T>> Search(string query, Include<T>? include = default);
/// <summary>
/// Get every resources that match all filters
/// </summary>
/// <param name="filter">A filter predicate</param>
/// <param name="sort">Sort information about the query (sort by, sort order)</param>
/// <param name="include">The related fields to include.</param>
/// <param name="limit">How pagination should be done (where to start and how many to return)</param>
/// <returns>A list of resources that match every filters</returns>
Task<ICollection<T>> GetAll(
Filter<T>? filter = null,
Sort<T>? sort = default,
Include<T>? include = default,
Pagination? limit = default
);
/// <summary>
/// Get the number of resources that match the filter's predicate.
/// </summary>
/// <param name="filter">A filter predicate</param>
/// <returns>How many resources matched that filter</returns>
Task<int> GetCount(Filter<T>? filter = null);
/// <summary>
/// Map a list of ids to a list of items (keep the order).
/// </summary>
/// <param name="ids">The list of items id.</param>
/// <param name="include">The related fields to include.</param>
/// <returns>A list of resources mapped from ids.</returns>
Task<ICollection<T>> FromIds(IList<Guid> ids, Include<T>? include = default);
/// <summary>
/// Create a new resource.
/// </summary>
/// <param name="obj">The item to register</param>
/// <returns>The resource registers and completed by database's information (related items and so on)</returns>
Task<T> Create(T obj);
/// <summary>
/// Create a new resource if it does not exist already. If it does, the existing value is returned instead.
/// </summary>
/// <param name="obj">The object to create</param>
/// <returns>The newly created item or the existing value if it existed.</returns>
Task<T> CreateIfNotExists(T obj);
/// <summary>
/// Called when a resource has been created.
/// </summary>
static event ResourceEventHandler OnCreated;
/// <summary>
/// Callback that should be called after a resource has been created.
/// </summary>
/// <param name="obj">The resource newly created.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected static Task OnResourceCreated(T obj) =>
OnCreated?.Invoke(obj) ?? Task.CompletedTask;
/// <summary>
/// Edit a resource and replace every property
/// </summary>
/// <param name="edited">The resource to edit, it's ID can't change.</param>
/// <exception cref="ItemNotFoundException">If the item is not found</exception>
/// <returns>The resource edited and completed by database's information (related items and so on)</returns>
Task<T> Edit(T edited);
/// <summary>
/// Edit only specific properties of a resource
/// </summary>
/// <param name="id">The id of the resource to edit</param>
/// <param name="patch">
/// A method that will be called when you need to update every properties that you want to
/// persist.
/// </param>
/// <exception cref="ItemNotFoundException">If the item is not found</exception>
/// <returns>The resource edited and completed by database's information (related items and so on)</returns>
Task<T> Patch(Guid id, Func<T, T> patch);
/// <summary>
/// Called when a resource has been edited.
/// </summary>
static event ResourceEventHandler OnEdited;
/// <summary>
/// Callback that should be called after a resource has been edited.
/// </summary>
/// <param name="obj">The resource newly edited.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected static Task OnResourceEdited(T obj) =>
OnEdited?.Invoke(obj) ?? Task.CompletedTask;
/// <summary>
/// Delete a resource by it's ID
/// </summary>
/// <param name="id">The ID of the resource</param>
/// <exception cref="ItemNotFoundException">If the item is not found</exception>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
Task Delete(Guid id);
/// <summary>
/// Delete a resource by it's slug
/// </summary>
/// <param name="slug">The slug of the resource</param>
/// <exception cref="ItemNotFoundException">If the item is not found</exception>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
Task Delete(string slug);
/// <summary>
/// Delete a resource
/// </summary>
/// <param name="obj">The resource to delete</param>
/// <exception cref="ItemNotFoundException">If the item is not found</exception>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
Task Delete(T obj);
/// <summary>
/// Delete all resources that match the predicate.
/// </summary>
/// <param name="filter">A predicate to filter resources to delete. Every resource that match this will be deleted.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
Task DeleteAll(Filter<T> filter);
/// <summary>
/// Called when a resource has been edited.
/// </summary>
static event ResourceEventHandler OnDeleted;
/// <summary>
/// Callback that should be called after a resource has been deleted.
/// </summary>
/// <param name="obj">The resource newly deleted.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected static Task OnResourceDeleted(T obj) =>
OnDeleted?.Invoke(obj) ?? Task.CompletedTask;
}
/// <summary> /// <summary>
/// A base class for repositories. Every service implementing this will be handled by the <see cref="ILibraryManager"/>. /// Get a resource from it's ID.
/// </summary> /// </summary>
public interface IBaseRepository /// <param name="id">The id of the resource</param>
{ /// <param name="include">The related fields to include.</param>
/// <summary> /// <exception cref="ItemNotFoundException">If the item could not be found.</exception>
/// The type for witch this repository is responsible or null if non applicable. /// <returns>The resource found</returns>
/// </summary> Task<T> Get(Guid id, Include<T>? include = default);
Type RepositoryType { get; }
}
public interface IUserRepository : IRepository<User> /// <summary>
{ /// Get a resource from it's slug.
Task<User?> GetByExternalId(string provider, string id); /// </summary>
Task<User> AddExternalToken(Guid userId, string provider, ExternalToken token); /// <param name="slug">The slug of the resource</param>
Task<User> DeleteExternalToken(Guid userId, string provider); /// <param name="include">The related fields to include.</param>
} /// <exception cref="ItemNotFoundException">If the item could not be found.</exception>
/// <returns>The resource found</returns>
Task<T> Get(string slug, Include<T>? include = default);
/// <summary>
/// Get the first resource that match the predicate.
/// </summary>
/// <param name="filter">A predicate to filter the resource.</param>
/// <param name="include">The related fields to include.</param>
/// <param name="sortBy">A custom sort method to handle cases where multiples items match the filters.</param>
/// <param name="reverse">Reverse the sort.</param>
/// <param name="afterId">Select the first element after this id if it was in a list.</param>
/// <exception cref="ItemNotFoundException">If the item could not be found.</exception>
/// <returns>The resource found</returns>
Task<T> Get(
Filter<T> filter,
Include<T>? include = default,
Sort<T>? sortBy = default,
bool reverse = false,
Guid? afterId = default
);
/// <summary>
/// Get a resource from it's ID or null if it is not found.
/// </summary>
/// <param name="id">The id of the resource</param>
/// <param name="include">The related fields to include.</param>
/// <returns>The resource found</returns>
Task<T?> GetOrDefault(Guid id, Include<T>? include = default);
/// <summary>
/// Get a resource from it's slug or null if it is not found.
/// </summary>
/// <param name="slug">The slug of the resource</param>
/// <param name="include">The related fields to include.</param>
/// <returns>The resource found</returns>
Task<T?> GetOrDefault(string slug, Include<T>? include = default);
/// <summary>
/// Get the first resource that match the predicate or null if it is not found.
/// </summary>
/// <param name="filter">A predicate to filter the resource.</param>
/// <param name="include">The related fields to include.</param>
/// <param name="sortBy">A custom sort method to handle cases where multiples items match the filters.</param>
/// <param name="reverse">Reverse the sort.</param>
/// <param name="afterId">Select the first element after this id if it was in a list.</param>
/// <returns>The resource found</returns>
Task<T?> GetOrDefault(
Filter<T>? filter,
Include<T>? include = default,
Sort<T>? sortBy = default,
bool reverse = false,
Guid? afterId = default
);
/// <summary>
/// Search for resources with the database.
/// </summary>
/// <param name="query">The query string.</param>
/// <param name="include">The related fields to include.</param>
/// <returns>A list of resources found</returns>
Task<ICollection<T>> Search(string query, Include<T>? include = default);
/// <summary>
/// Get every resources that match all filters
/// </summary>
/// <param name="filter">A filter predicate</param>
/// <param name="sort">Sort information about the query (sort by, sort order)</param>
/// <param name="include">The related fields to include.</param>
/// <param name="limit">How pagination should be done (where to start and how many to return)</param>
/// <returns>A list of resources that match every filters</returns>
Task<ICollection<T>> GetAll(
Filter<T>? filter = null,
Sort<T>? sort = default,
Include<T>? include = default,
Pagination? limit = default
);
/// <summary>
/// Get the number of resources that match the filter's predicate.
/// </summary>
/// <param name="filter">A filter predicate</param>
/// <returns>How many resources matched that filter</returns>
Task<int> GetCount(Filter<T>? filter = null);
/// <summary>
/// Map a list of ids to a list of items (keep the order).
/// </summary>
/// <param name="ids">The list of items id.</param>
/// <param name="include">The related fields to include.</param>
/// <returns>A list of resources mapped from ids.</returns>
Task<ICollection<T>> FromIds(IList<Guid> ids, Include<T>? include = default);
/// <summary>
/// Create a new resource.
/// </summary>
/// <param name="obj">The item to register</param>
/// <returns>The resource registers and completed by database's information (related items and so on)</returns>
Task<T> Create(T obj);
/// <summary>
/// Create a new resource if it does not exist already. If it does, the existing value is returned instead.
/// </summary>
/// <param name="obj">The object to create</param>
/// <returns>The newly created item or the existing value if it existed.</returns>
Task<T> CreateIfNotExists(T obj);
/// <summary>
/// Called when a resource has been created.
/// </summary>
static event ResourceEventHandler OnCreated;
/// <summary>
/// Callback that should be called after a resource has been created.
/// </summary>
/// <param name="obj">The resource newly created.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected static Task OnResourceCreated(T obj) => OnCreated?.Invoke(obj) ?? Task.CompletedTask;
/// <summary>
/// Edit a resource and replace every property
/// </summary>
/// <param name="edited">The resource to edit, it's ID can't change.</param>
/// <exception cref="ItemNotFoundException">If the item is not found</exception>
/// <returns>The resource edited and completed by database's information (related items and so on)</returns>
Task<T> Edit(T edited);
/// <summary>
/// Edit only specific properties of a resource
/// </summary>
/// <param name="id">The id of the resource to edit</param>
/// <param name="patch">
/// A method that will be called when you need to update every properties that you want to
/// persist.
/// </param>
/// <exception cref="ItemNotFoundException">If the item is not found</exception>
/// <returns>The resource edited and completed by database's information (related items and so on)</returns>
Task<T> Patch(Guid id, Func<T, T> patch);
/// <summary>
/// Called when a resource has been edited.
/// </summary>
static event ResourceEventHandler OnEdited;
/// <summary>
/// Callback that should be called after a resource has been edited.
/// </summary>
/// <param name="obj">The resource newly edited.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected static Task OnResourceEdited(T obj) => OnEdited?.Invoke(obj) ?? Task.CompletedTask;
/// <summary>
/// Delete a resource by it's ID
/// </summary>
/// <param name="id">The ID of the resource</param>
/// <exception cref="ItemNotFoundException">If the item is not found</exception>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
Task Delete(Guid id);
/// <summary>
/// Delete a resource by it's slug
/// </summary>
/// <param name="slug">The slug of the resource</param>
/// <exception cref="ItemNotFoundException">If the item is not found</exception>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
Task Delete(string slug);
/// <summary>
/// Delete a resource
/// </summary>
/// <param name="obj">The resource to delete</param>
/// <exception cref="ItemNotFoundException">If the item is not found</exception>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
Task Delete(T obj);
/// <summary>
/// Delete all resources that match the predicate.
/// </summary>
/// <param name="filter">A predicate to filter resources to delete. Every resource that match this will be deleted.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
Task DeleteAll(Filter<T> filter);
/// <summary>
/// Called when a resource has been edited.
/// </summary>
static event ResourceEventHandler OnDeleted;
/// <summary>
/// Callback that should be called after a resource has been deleted.
/// </summary>
/// <param name="obj">The resource newly deleted.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected static Task OnResourceDeleted(T obj) => OnDeleted?.Invoke(obj) ?? Task.CompletedTask;
}
/// <summary>
/// A base class for repositories. Every service implementing this will be handled by the <see cref="ILibraryManager"/>.
/// </summary>
public interface IBaseRepository
{
/// <summary>
/// The type for witch this repository is responsible or null if non applicable.
/// </summary>
Type RepositoryType { get; }
}
public interface IUserRepository : IRepository<User>
{
Task<User?> GetByExternalId(string provider, string id);
Task<User> AddExternalToken(Guid userId, string provider, ExternalToken token);
Task<User> DeleteExternalToken(Guid userId, string provider);
} }

95
back/src/Kyoo.Abstractions/Controllers/IThumbnailsManager.cs
View File

@ -21,59 +21,58 @@ using System.IO;
using System.Threading.Tasks; using System.Threading.Tasks;
using Kyoo.Abstractions.Models; using Kyoo.Abstractions.Models;
namespace Kyoo.Abstractions.Controllers namespace Kyoo.Abstractions.Controllers;
/// <summary>
/// Download images and retrieve the path of those images for a resource.
/// </summary>
public interface IThumbnailsManager
{ {
/// <summary> /// <summary>
/// Download images and retrieve the path of those images for a resource. /// Download images of a specified item.
/// If no images is available to download, do nothing and silently return.
/// </summary> /// </summary>
public interface IThumbnailsManager /// <param name="item">
{ /// The item to cache images.
/// <summary> /// </param>
/// Download images of a specified item. /// <typeparam name="T">The type of the item</typeparam>
/// If no images is available to download, do nothing and silently return. /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
/// </summary> Task DownloadImages<T>(T item)
/// <param name="item"> where T : IThumbnails;
/// The item to cache images.
/// </param>
/// <typeparam name="T">The type of the item</typeparam>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
Task DownloadImages<T>(T item)
where T : IThumbnails;
/// <summary> /// <summary>
/// Retrieve the local path of an image of the given item. /// Retrieve the local path of an image of the given item.
/// </summary> /// </summary>
/// <param name="item">The item to retrieve the poster from.</param> /// <param name="item">The item to retrieve the poster from.</param>
/// <param name="image">The ID of the image.</param> /// <param name="image">The ID of the image.</param>
/// <param name="quality">The quality of the image</param> /// <param name="quality">The quality of the image</param>
/// <typeparam name="T">The type of the item</typeparam> /// <typeparam name="T">The type of the item</typeparam>
/// <returns>The path of the image for the given resource or null if it does not exists.</returns> /// <returns>The path of the image for the given resource or null if it does not exists.</returns>
string GetImagePath<T>(T item, string image, ImageQuality quality) string GetImagePath<T>(T item, string image, ImageQuality quality)
where T : IThumbnails; where T : IThumbnails;
/// <summary> /// <summary>
/// Delete images associated with the item. /// Delete images associated with the item.
/// </summary> /// </summary>
/// <param name="item"> /// <param name="item">
/// The item with cached images. /// The item with cached images.
/// </param> /// </param>
/// <typeparam name="T">The type of the item</typeparam> /// <typeparam name="T">The type of the item</typeparam>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
Task DeleteImages<T>(T item) Task DeleteImages<T>(T item)
where T : IThumbnails; where T : IThumbnails;
/// <summary> /// <summary>
/// Set the user's profile picture /// Set the user's profile picture
/// </summary> /// </summary>
/// <param name="userId">The id of the user. </param> /// <param name="userId">The id of the user. </param>
/// <returns>The byte stream of the image. Null if no image exist.</returns> /// <returns>The byte stream of the image. Null if no image exist.</returns>
Task<Stream> GetUserImage(Guid userId); Task<Stream> GetUserImage(Guid userId);
/// <summary> /// <summary>
/// Set the user's profile picture /// Set the user's profile picture
/// </summary> /// </summary>
/// <param name="userId">The id of the user. </param> /// <param name="userId">The id of the user. </param>
/// <param name="image">The byte stream of the image. Null to delete the image.</param> /// <param name="image">The byte stream of the image. Null to delete the image.</param>
Task SetUserImage(Guid userId, Stream? image); Task SetUserImage(Guid userId, Stream? image);
}
} }

446
back/src/Kyoo.Abstractions/Controllers/StartupAction.cs
View File

@ -19,256 +19,252 @@
using System; using System;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
namespace Kyoo.Abstractions.Controllers namespace Kyoo.Abstractions.Controllers;
/// <summary>
/// A list of constant priorities used for <see cref="IStartupAction"/>'s <see cref="IStartupAction.Priority"/>.
/// It also contains helper methods for creating new <see cref="StartupAction"/>.
/// </summary>
public static class SA
{ {
/// <summary> /// <summary>
/// A list of constant priorities used for <see cref="IStartupAction"/>'s <see cref="IStartupAction.Priority"/>. /// The highest predefined priority existing for <see cref="StartupAction"/>.
/// It also contains helper methods for creating new <see cref="StartupAction"/>.
/// </summary> /// </summary>
public static class SA public const int Before = 5000;
/// <summary>
/// Items defining routing (see IApplicationBuilder.UseRouting use this priority.
/// </summary>
public const int Routing = 4000;
/// <summary>
/// Actions defining new static files router use this priority.
/// </summary>
public const int StaticFiles = 3000;
/// <summary>
/// Actions calling IApplicationBuilder.UseAuthentication use this priority.
/// </summary>
public const int Authentication = 2000;
/// <summary>
/// Actions calling IApplicationBuilder.UseAuthorization use this priority.
/// </summary>
public const int Authorization = 1000;
/// <summary>
/// Action adding endpoint should use this priority (with a negative modificator if there is a catchall).
/// </summary>
public const int Endpoint = 0;
/// <summary>
/// The lowest predefined priority existing for <see cref="StartupAction"/>.
/// It should run after all other actions.
/// </summary>
public const int After = -1000;
/// <summary>
/// Create a new <see cref="StartupAction"/>.
/// </summary>
/// <param name="action">The action to run</param>
/// <param name="priority">The priority of the new action</param>
/// <returns>A new <see cref="StartupAction"/></returns>
public static StartupAction New(Action action, int priority) => new(action, priority);
/// <summary>
/// Create a new <see cref="StartupAction"/>.
/// </summary>
/// <param name="action">The action to run</param>
/// <param name="priority">The priority of the new action</param>
/// <typeparam name="T">A dependency that this action will use.</typeparam>
/// <returns>A new <see cref="StartupAction"/></returns>
public static StartupAction<T> New<T>(Action<T> action, int priority)
where T : notnull => new(action, priority);
/// <summary>
/// Create a new <see cref="StartupAction"/>.
/// </summary>
/// <param name="action">The action to run</param>
/// <param name="priority">The priority of the new action</param>
/// <typeparam name="T">A dependency that this action will use.</typeparam>
/// <typeparam name="T2">A second dependency that this action will use.</typeparam>
/// <returns>A new <see cref="StartupAction"/></returns>
public static StartupAction<T, T2> New<T, T2>(Action<T, T2> action, int priority)
where T : notnull
where T2 : notnull => new(action, priority);
/// <summary>
/// Create a new <see cref="StartupAction"/>.
/// </summary>
/// <param name="action">The action to run</param>
/// <param name="priority">The priority of the new action</param>
/// <typeparam name="T">A dependency that this action will use.</typeparam>
/// <typeparam name="T2">A second dependency that this action will use.</typeparam>
/// <typeparam name="T3">A third dependency that this action will use.</typeparam>
/// <returns>A new <see cref="StartupAction"/></returns>
public static StartupAction<T, T2, T3> New<T, T2, T3>(Action<T, T2, T3> action, int priority)
where T : notnull
where T2 : notnull
where T3 : notnull => new(action, priority);
/// <summary>
/// A <see cref="IStartupAction"/> with no dependencies.
/// </summary>
public class StartupAction : IStartupAction
{ {
/// <summary> /// <summary>
/// The highest predefined priority existing for <see cref="StartupAction"/>. /// The action to execute at startup.
/// </summary> /// </summary>
public const int Before = 5000; private readonly Action _action;
/// <summary> /// <inheritdoc />
/// Items defining routing (see IApplicationBuilder.UseRouting use this priority. public int Priority { get; }
/// </summary>
public const int Routing = 4000;
/// <summary>
/// Actions defining new static files router use this priority.
/// </summary>
public const int StaticFiles = 3000;
/// <summary>
/// Actions calling IApplicationBuilder.UseAuthentication use this priority.
/// </summary>
public const int Authentication = 2000;
/// <summary>
/// Actions calling IApplicationBuilder.UseAuthorization use this priority.
/// </summary>
public const int Authorization = 1000;
/// <summary>
/// Action adding endpoint should use this priority (with a negative modificator if there is a catchall).
/// </summary>
public const int Endpoint = 0;
/// <summary>
/// The lowest predefined priority existing for <see cref="StartupAction"/>.
/// It should run after all other actions.
/// </summary>
public const int After = -1000;
/// <summary> /// <summary>
/// Create a new <see cref="StartupAction"/>. /// Create a new <see cref="StartupAction"/>.
/// </summary> /// </summary>
/// <param name="action">The action to run</param> /// <param name="action">The action to execute on startup.</param>
/// <param name="priority">The priority of the new action</param> /// <param name="priority">The priority of this action (see <see cref="Priority"/>).</param>
/// <returns>A new <see cref="StartupAction"/></returns> public StartupAction(Action action, int priority)
public static StartupAction New(Action action, int priority) => new(action, priority);
/// <summary>
/// Create a new <see cref="StartupAction"/>.
/// </summary>
/// <param name="action">The action to run</param>
/// <param name="priority">The priority of the new action</param>
/// <typeparam name="T">A dependency that this action will use.</typeparam>
/// <returns>A new <see cref="StartupAction"/></returns>
public static StartupAction<T> New<T>(Action<T> action, int priority)
where T : notnull => new(action, priority);
/// <summary>
/// Create a new <see cref="StartupAction"/>.
/// </summary>
/// <param name="action">The action to run</param>
/// <param name="priority">The priority of the new action</param>
/// <typeparam name="T">A dependency that this action will use.</typeparam>
/// <typeparam name="T2">A second dependency that this action will use.</typeparam>
/// <returns>A new <see cref="StartupAction"/></returns>
public static StartupAction<T, T2> New<T, T2>(Action<T, T2> action, int priority)
where T : notnull
where T2 : notnull => new(action, priority);
/// <summary>
/// Create a new <see cref="StartupAction"/>.
/// </summary>
/// <param name="action">The action to run</param>
/// <param name="priority">The priority of the new action</param>
/// <typeparam name="T">A dependency that this action will use.</typeparam>
/// <typeparam name="T2">A second dependency that this action will use.</typeparam>
/// <typeparam name="T3">A third dependency that this action will use.</typeparam>
/// <returns>A new <see cref="StartupAction"/></returns>
public static StartupAction<T, T2, T3> New<T, T2, T3>(
Action<T, T2, T3> action,
int priority
)
where T : notnull
where T2 : notnull
where T3 : notnull => new(action, priority);
/// <summary>
/// A <see cref="IStartupAction"/> with no dependencies.
/// </summary>
public class StartupAction : IStartupAction
{ {
/// <summary> _action = action;
/// The action to execute at startup. Priority = priority;
/// </summary>
private readonly Action _action;
/// <inheritdoc />
public int Priority { get; }
/// <summary>
/// Create a new <see cref="StartupAction"/>.
/// </summary>
/// <param name="action">The action to execute on startup.</param>
/// <param name="priority">The priority of this action (see <see cref="Priority"/>).</param>
public StartupAction(Action action, int priority)
{
_action = action;
Priority = priority;
}
/// <inheritdoc />
public void Run(IServiceProvider provider)
{
_action.Invoke();
}
} }
/// <summary> /// <inheritdoc />
/// A <see cref="IStartupAction"/> with one dependencies. public void Run(IServiceProvider provider)
/// </summary>
/// <typeparam name="T">The dependency to use.</typeparam>
public class StartupAction<T> : IStartupAction
where T : notnull
{ {
/// <summary> _action.Invoke();
/// The action to execute at startup.
/// </summary>
private readonly Action<T> _action;
/// <inheritdoc />
public int Priority { get; }
/// <summary>
/// Create a new <see cref="StartupAction{T}"/>.
/// </summary>
/// <param name="action">The action to execute on startup.</param>
/// <param name="priority">The priority of this action (see <see cref="Priority"/>).</param>
public StartupAction(Action<T> action, int priority)
{
_action = action;
Priority = priority;
}
/// <inheritdoc />
public void Run(IServiceProvider provider)
{
_action.Invoke(provider.GetRequiredService<T>());
}
}
/// <summary>
/// A <see cref="IStartupAction"/> with two dependencies.
/// </summary>
/// <typeparam name="T">The dependency to use.</typeparam>
/// <typeparam name="T2">The second dependency to use.</typeparam>
public class StartupAction<T, T2> : IStartupAction
where T : notnull
where T2 : notnull
{
/// <summary>
/// The action to execute at startup.
/// </summary>
private readonly Action<T, T2> _action;
/// <inheritdoc />
public int Priority { get; }
/// <summary>
/// Create a new <see cref="StartupAction{T, T2}"/>.
/// </summary>
/// <param name="action">The action to execute on startup.</param>
/// <param name="priority">The priority of this action (see <see cref="Priority"/>).</param>
public StartupAction(Action<T, T2> action, int priority)
{
_action = action;
Priority = priority;
}
/// <inheritdoc />
public void Run(IServiceProvider provider)
{
_action.Invoke(provider.GetRequiredService<T>(), provider.GetRequiredService<T2>());
}
}
/// <summary>
/// A <see cref="IStartupAction"/> with three dependencies.
/// </summary>
/// <typeparam name="T">The dependency to use.</typeparam>
/// <typeparam name="T2">The second dependency to use.</typeparam>
/// <typeparam name="T3">The third dependency to use.</typeparam>
public class StartupAction<T, T2, T3> : IStartupAction
where T : notnull
where T2 : notnull
where T3 : notnull
{
/// <summary>
/// The action to execute at startup.
/// </summary>
private readonly Action<T, T2, T3> _action;
/// <inheritdoc />
public int Priority { get; }
/// <summary>
/// Create a new <see cref="StartupAction{T, T2, T3}"/>.
/// </summary>
/// <param name="action">The action to execute on startup.</param>
/// <param name="priority">The priority of this action (see <see cref="Priority"/>).</param>
public StartupAction(Action<T, T2, T3> action, int priority)
{
_action = action;
Priority = priority;
}
/// <inheritdoc />
public void Run(IServiceProvider provider)
{
_action.Invoke(
provider.GetRequiredService<T>(),
provider.GetRequiredService<T2>(),
provider.GetRequiredService<T3>()
);
}
} }
} }
/// <summary> /// <summary>
/// An action executed on kyoo's startup to initialize the asp-net container. /// A <see cref="IStartupAction"/> with one dependencies.
/// </summary> /// </summary>
/// <remarks> /// <typeparam name="T">The dependency to use.</typeparam>
/// This is the base interface, see <see cref="SA.StartupAction"/> for a simpler use of this. public class StartupAction<T> : IStartupAction
/// </remarks> where T : notnull
public interface IStartupAction
{ {
/// <summary> /// <summary>
/// The priority of this action. The actions will be executed on descending priority order. /// The action to execute at startup.
/// If two actions have the same priority, their order is undefined.
/// </summary> /// </summary>
int Priority { get; } private readonly Action<T> _action;
/// <inheritdoc />
public int Priority { get; }
/// <summary> /// <summary>
/// Run this action to configure the container, a service provider containing all services can be used. /// Create a new <see cref="StartupAction{T}"/>.
/// </summary> /// </summary>
/// <param name="provider">The service provider containing all services can be used.</param> /// <param name="action">The action to execute on startup.</param>
void Run(IServiceProvider provider); /// <param name="priority">The priority of this action (see <see cref="Priority"/>).</param>
public StartupAction(Action<T> action, int priority)
{
_action = action;
Priority = priority;
}
/// <inheritdoc />
public void Run(IServiceProvider provider)
{
_action.Invoke(provider.GetRequiredService<T>());
}
}
/// <summary>
/// A <see cref="IStartupAction"/> with two dependencies.
/// </summary>
/// <typeparam name="T">The dependency to use.</typeparam>
/// <typeparam name="T2">The second dependency to use.</typeparam>
public class StartupAction<T, T2> : IStartupAction
where T : notnull
where T2 : notnull
{
/// <summary>
/// The action to execute at startup.
/// </summary>
private readonly Action<T, T2> _action;
/// <inheritdoc />
public int Priority { get; }
/// <summary>
/// Create a new <see cref="StartupAction{T, T2}"/>.
/// </summary>
/// <param name="action">The action to execute on startup.</param>
/// <param name="priority">The priority of this action (see <see cref="Priority"/>).</param>
public StartupAction(Action<T, T2> action, int priority)
{
_action = action;
Priority = priority;
}
/// <inheritdoc />
public void Run(IServiceProvider provider)
{
_action.Invoke(provider.GetRequiredService<T>(), provider.GetRequiredService<T2>());
}
}
/// <summary>
/// A <see cref="IStartupAction"/> with three dependencies.
/// </summary>
/// <typeparam name="T">The dependency to use.</typeparam>
/// <typeparam name="T2">The second dependency to use.</typeparam>
/// <typeparam name="T3">The third dependency to use.</typeparam>
public class StartupAction<T, T2, T3> : IStartupAction
where T : notnull
where T2 : notnull
where T3 : notnull
{
/// <summary>
/// The action to execute at startup.
/// </summary>
private readonly Action<T, T2, T3> _action;
/// <inheritdoc />
public int Priority { get; }
/// <summary>
/// Create a new <see cref="StartupAction{T, T2, T3}"/>.
/// </summary>
/// <param name="action">The action to execute on startup.</param>
/// <param name="priority">The priority of this action (see <see cref="Priority"/>).</param>
public StartupAction(Action<T, T2, T3> action, int priority)
{
_action = action;
Priority = priority;
}
/// <inheritdoc />
public void Run(IServiceProvider provider)
{
_action.Invoke(
provider.GetRequiredService<T>(),
provider.GetRequiredService<T2>(),
provider.GetRequiredService<T3>()
);
}
} }
} }
/// <summary>
/// An action executed on kyoo's startup to initialize the asp-net container.
/// </summary>
/// <remarks>
/// This is the base interface, see <see cref="SA.StartupAction"/> for a simpler use of this.
/// </remarks>
public interface IStartupAction
{
/// <summary>
/// The priority of this action. The actions will be executed on descending priority order.
/// If two actions have the same priority, their order is undefined.
/// </summary>
int Priority { get; }
/// <summary>
/// Run this action to configure the container, a service provider containing all services can be used.
/// </summary>
/// <param name="provider">The service provider containing all services can be used.</param>
void Run(IServiceProvider provider);
}

63
back/src/Kyoo.Abstractions/Extensions.cs
View File

@ -23,43 +23,42 @@ using System.Security.Claims;
using Kyoo.Abstractions.Models.Exceptions; using Kyoo.Abstractions.Models.Exceptions;
using Kyoo.Authentication.Models; using Kyoo.Authentication.Models;
namespace Kyoo.Authentication namespace Kyoo.Authentication;
/// <summary>
/// Extension methods.
/// </summary>
public static class Extensions
{ {
/// <summary> /// <summary>
/// Extension methods. /// Get the permissions of an user.
/// </summary> /// </summary>
public static class Extensions /// <param name="user">The user</param>
/// <returns>The list of permissions</returns>
public static ICollection<string> GetPermissions(this ClaimsPrincipal user)
{ {
/// <summary> return user.Claims.FirstOrDefault(x => x.Type == Claims.Permissions)?.Value.Split(',')
/// Get the permissions of an user. ?? Array.Empty<string>();
/// </summary> }
/// <param name="user">The user</param>
/// <returns>The list of permissions</returns>
public static ICollection<string> GetPermissions(this ClaimsPrincipal user)
{
return user.Claims.FirstOrDefault(x => x.Type == Claims.Permissions)?.Value.Split(',')
?? Array.Empty<string>();
}
/// <summary> /// <summary>
/// Get the id of the current user or null if unlogged or invalid. /// Get the id of the current user or null if unlogged or invalid.
/// </summary> /// </summary>
/// <param name="user">The user.</param> /// <param name="user">The user.</param>
/// <returns>The id of the user or null.</returns> /// <returns>The id of the user or null.</returns>
public static Guid? GetId(this ClaimsPrincipal user) public static Guid? GetId(this ClaimsPrincipal user)
{ {
Claim? value = user.FindFirst(Claims.Id); Claim? value = user.FindFirst(Claims.Id);
if (Guid.TryParse(value?.Value, out Guid id)) if (Guid.TryParse(value?.Value, out Guid id))
return id; return id;
return null; return null;
} }
public static Guid GetIdOrThrow(this ClaimsPrincipal user) public static Guid GetIdOrThrow(this ClaimsPrincipal user)
{ {
Guid? ret = user.GetId(); Guid? ret = user.GetId();
if (ret == null) if (ret == null)
throw new UnauthorizedException(); throw new UnauthorizedException();
return ret.Value; return ret.Value;
}
} }
} }

51
back/src/Kyoo.Abstractions/Models/Attributes/ApiDefinitionAttribute.cs
View File

@ -18,35 +18,34 @@
using System; using System;
namespace Kyoo.Abstractions.Models.Attributes namespace Kyoo.Abstractions.Models.Attributes;
/// <summary>
/// An attribute to specify on apis to specify it's documentation's name and category.
/// If this is applied on a method, the specified method will be exploded from the controller's page and be
/// included on the specified tag page.
/// </summary>
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class ApiDefinitionAttribute : Attribute
{ {
/// <summary> /// <summary>
/// An attribute to specify on apis to specify it's documentation's name and category. /// The public name of this api.
/// If this is applied on a method, the specified method will be exploded from the controller's page and be
/// included on the specified tag page.
/// </summary> /// </summary>
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)] public string Name { get; }
public class ApiDefinitionAttribute : Attribute
/// <summary>
/// The name of the group in witch this API is. You can also specify a custom sort order using the following
/// format: <code>order:name</code>. Everything before the first <c>:</c> will be removed but kept for
/// th alphabetical ordering.
/// </summary>
public string? Group { get; set; }
/// <summary>
/// Create a new <see cref="ApiDefinitionAttribute"/>.
/// </summary>
/// <param name="name">The name of the api that will be used on the documentation page.</param>
public ApiDefinitionAttribute(string name)
{ {
/// <summary> Name = name;
/// The public name of this api.
/// </summary>
public string Name { get; }
/// <summary>
/// The name of the group in witch this API is. You can also specify a custom sort order using the following
/// format: <code>order:name</code>. Everything before the first <c>:</c> will be removed but kept for
/// th alphabetical ordering.
/// </summary>
public string? Group { get; set; }
/// <summary>
/// Create a new <see cref="ApiDefinitionAttribute"/>.
/// </summary>
/// <param name="name">The name of the api that will be used on the documentation page.</param>
public ApiDefinitionAttribute(string name)
{
Name = name;
}
} }
} }

15
back/src/Kyoo.Abstractions/Models/Attributes/ComputedAttribute.cs
View File

@ -18,11 +18,10 @@
using System; using System;
namespace Kyoo.Abstractions.Models.Attributes namespace Kyoo.Abstractions.Models.Attributes;
{
/// <summary> /// <summary>
/// An attribute to inform that the property is computed automatically and can't be assigned manually. /// An attribute to inform that the property is computed automatically and can't be assigned manually.
/// </summary> /// </summary>
[AttributeUsage(AttributeTargets.Property)] [AttributeUsage(AttributeTargets.Property)]
public class ComputedAttribute : NotMergeableAttribute { } public class ComputedAttribute : NotMergeableAttribute { }
}

55
back/src/Kyoo.Abstractions/Models/Attributes/LoadableRelationAttribute.cs
View File

@ -18,37 +18,36 @@
using System; using System;
namespace Kyoo.Abstractions.Models.Attributes namespace Kyoo.Abstractions.Models.Attributes;
/// <summary>
/// The targeted relation can be loaded.
/// </summary>
[AttributeUsage(AttributeTargets.Property)]
public class LoadableRelationAttribute : Attribute
{ {
/// <summary> /// <summary>
/// The targeted relation can be loaded. /// The name of the field containing the related resource's ID.
/// </summary> /// </summary>
[AttributeUsage(AttributeTargets.Property)] public string? RelationID { get; }
public class LoadableRelationAttribute : Attribute
public string? Sql { get; set; }
public string? On { get; set; }
public string? Projected { get; set; }
/// <summary>
/// Create a new <see cref="LoadableRelationAttribute"/>.
/// </summary>
public LoadableRelationAttribute() { }
/// <summary>
/// Create a new <see cref="LoadableRelationAttribute"/> with a baking relationID field.
/// </summary>
/// <param name="relationID">The name of the RelationID field.</param>
public LoadableRelationAttribute(string relationID)
{ {
/// <summary> RelationID = relationID;
/// The name of the field containing the related resource's ID.
/// </summary>
public string? RelationID { get; }
public string? Sql { get; set; }
public string? On { get; set; }
public string? Projected { get; set; }
/// <summary>
/// Create a new <see cref="LoadableRelationAttribute"/>.
/// </summary>
public LoadableRelationAttribute() { }
/// <summary>
/// Create a new <see cref="LoadableRelationAttribute"/> with a baking relationID field.
/// </summary>
/// <param name="relationID">The name of the RelationID field.</param>
public LoadableRelationAttribute(string relationID)
{
RelationID = relationID;
}
} }
} }

31
back/src/Kyoo.Abstractions/Models/Attributes/NotMergeableAttribute.cs
View File

@ -18,23 +18,22 @@
using System; using System;
namespace Kyoo.Abstractions.Models.Attributes namespace Kyoo.Abstractions.Models.Attributes;
/// <summary>
/// Specify that a property can't be merged.
/// </summary>
[AttributeUsage(AttributeTargets.Property)]
public class NotMergeableAttribute : Attribute { }
/// <summary>
/// An interface with a method called when this object is merged.
/// </summary>
public interface IOnMerge
{ {
/// <summary> /// <summary>
/// Specify that a property can't be merged. /// This function is called after the object has been merged.
/// </summary> /// </summary>
[AttributeUsage(AttributeTargets.Property)] /// <param name="merged">The object that has been merged with this.</param>
public class NotMergeableAttribute : Attribute { } void OnMerge(object merged);
/// <summary>
/// An interface with a method called when this object is merged.
/// </summary>
public interface IOnMerge
{
/// <summary>
/// This function is called after the object has been merged.
/// </summary>
/// <param name="merged">The object that has been merged with this.</param>
void OnMerge(object merged);
}
} }

117
back/src/Kyoo.Abstractions/Models/Attributes/Permission/PartialPermissionAttribute.cs
View File

@ -21,68 +21,67 @@ using Kyoo.Abstractions.Controllers;
using Microsoft.AspNetCore.Mvc.Filters; using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
namespace Kyoo.Abstractions.Models.Permissions namespace Kyoo.Abstractions.Models.Permissions;
/// <summary>
/// Specify one part of a permissions needed for the API (the kind or the type).
/// </summary>
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
public class PartialPermissionAttribute : Attribute, IFilterFactory
{ {
/// <summary> /// <summary>
/// Specify one part of a permissions needed for the API (the kind or the type). /// The needed permission type.
/// </summary> /// </summary>
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)] public string? Type { get; }
public class PartialPermissionAttribute : Attribute, IFilterFactory
/// <summary>
/// The needed permission kind.
/// </summary>
public Kind? Kind { get; }
/// <summary>
/// The group of this permission.
/// </summary>
public Group Group { get; set; }
/// <summary>
/// Ask a permission to run an action.
/// </summary>
/// <remarks>
/// With this attribute, you can only specify a type or a kind.
/// To have a valid permission attribute, you must specify the kind and the permission using two attributes.
/// Those attributes can be dispatched at different places (one on the class, one on the method for example).
/// If you don't put exactly two of those attributes, the permission attribute will be ill-formed and will
/// lead to unspecified behaviors.
/// </remarks>
/// <param name="type">The type of the action</param>
public PartialPermissionAttribute(string type)
{ {
/// <summary> Type = type.ToLower();
/// The needed permission type.
/// </summary>
public string? Type { get; }
/// <summary>
/// The needed permission kind.
/// </summary>
public Kind? Kind { get; }
/// <summary>
/// The group of this permission.
/// </summary>
public Group Group { get; set; }
/// <summary>
/// Ask a permission to run an action.
/// </summary>
/// <remarks>
/// With this attribute, you can only specify a type or a kind.
/// To have a valid permission attribute, you must specify the kind and the permission using two attributes.
/// Those attributes can be dispatched at different places (one on the class, one on the method for example).
/// If you don't put exactly two of those attributes, the permission attribute will be ill-formed and will
/// lead to unspecified behaviors.
/// </remarks>
/// <param name="type">The type of the action</param>
public PartialPermissionAttribute(string type)
{
Type = type.ToLower();
}
/// <summary>
/// Ask a permission to run an action.
/// </summary>
/// <remarks>
/// With this attribute, you can only specify a type or a kind.
/// To have a valid permission attribute, you must specify the kind and the permission using two attributes.
/// Those attributes can be dispatched at different places (one on the class, one on the method for example).
/// If you don't put exactly two of those attributes, the permission attribute will be ill-formed and will
/// lead to unspecified behaviors.
/// </remarks>
/// <param name="permission">The kind of permission needed.</param>
public PartialPermissionAttribute(Kind permission)
{
Kind = permission;
}
/// <inheritdoc />
public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
{
return serviceProvider.GetRequiredService<IPermissionValidator>().Create(this);
}
/// <inheritdoc />
public bool IsReusable => true;
} }
/// <summary>
/// Ask a permission to run an action.
/// </summary>
/// <remarks>
/// With this attribute, you can only specify a type or a kind.
/// To have a valid permission attribute, you must specify the kind and the permission using two attributes.
/// Those attributes can be dispatched at different places (one on the class, one on the method for example).
/// If you don't put exactly two of those attributes, the permission attribute will be ill-formed and will
/// lead to unspecified behaviors.
/// </remarks>
/// <param name="permission">The kind of permission needed.</param>
public PartialPermissionAttribute(Kind permission)
{
Kind = permission;
}
/// <inheritdoc />
public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
{
return serviceProvider.GetRequiredService<IPermissionValidator>().Create(this);
}
/// <inheritdoc />
public bool IsReusable => true;
} }

199
back/src/Kyoo.Abstractions/Models/Attributes/Permission/PermissionAttribute.cs
View File

@ -21,117 +21,116 @@ using Kyoo.Abstractions.Controllers;
using Microsoft.AspNetCore.Mvc.Filters; using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
namespace Kyoo.Abstractions.Models.Permissions namespace Kyoo.Abstractions.Models.Permissions;
/// <summary>
/// The kind of permission needed.
/// </summary>
public enum Kind
{ {
/// <summary> /// <summary>
/// Allow the user to read for this kind of data.
/// </summary>
Read,
/// <summary>
/// Allow the user to write for this kind of data.
/// </summary>
Write,
/// <summary>
/// Allow the user to create this kind of data.
/// </summary>
Create,
/// <summary>
/// Allow the user to delete this kind of data.
/// </summary>
Delete,
/// <summary>
/// Allow the user to play this file.
/// </summary>
Play,
}
/// <summary>
/// The group of the permission.
/// </summary>
public enum Group
{
/// <summary>
/// Default group indicating no value.
/// </summary>
None,
/// <summary>
/// Allow all operations on basic items types.
/// </summary>
Overall,
/// <summary>
/// Allow operation on sensitive items like libraries path, configurations and so on.
/// </summary>
Admin
}
/// <summary>
/// Specify permissions needed for the API.
/// </summary>
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
public class PermissionAttribute : Attribute, IFilterFactory
{
/// <summary>
/// The needed permission as string.
/// </summary>
public string Type { get; }
/// <summary>
/// The needed permission kind.
/// </summary>
public Kind Kind { get; }
/// <summary>
/// The group of this permission.
/// </summary>
public Group Group { get; }
/// <summary>
/// Ask a permission to run an action.
/// </summary>
/// <param name="type">
/// The type of the action
/// </param>
/// <param name="permission">
/// The kind of permission needed. /// The kind of permission needed.
/// </summary> /// </param>
public enum Kind /// <param name="group">
/// The group of this permission (allow grouped permission like overall.read
/// for all read permissions of this group).
/// </param>
public PermissionAttribute(string type, Kind permission, Group group = Group.Overall)
{ {
/// <summary> Type = type.ToLower();
/// Allow the user to read for this kind of data. Kind = permission;
/// </summary> Group = group;
Read,
/// <summary>
/// Allow the user to write for this kind of data.
/// </summary>
Write,
/// <summary>
/// Allow the user to create this kind of data.
/// </summary>
Create,
/// <summary>
/// Allow the user to delete this kind of data.
/// </summary>
Delete,
/// <summary>
/// Allow the user to play this file.
/// </summary>
Play,
} }
/// <summary> /// <inheritdoc />
/// The group of the permission. public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
/// </summary>
public enum Group
{ {
/// <summary> return serviceProvider.GetRequiredService<IPermissionValidator>().Create(this);
/// Default group indicating no value.
/// </summary>
None,
/// <summary>
/// Allow all operations on basic items types.
/// </summary>
Overall,
/// <summary>
/// Allow operation on sensitive items like libraries path, configurations and so on.
/// </summary>
Admin
} }
/// <inheritdoc />
public bool IsReusable => true;
/// <summary> /// <summary>
/// Specify permissions needed for the API. /// Return this permission attribute as a string.
/// </summary> /// </summary>
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)] /// <returns>The string representation.</returns>
public class PermissionAttribute : Attribute, IFilterFactory public string AsPermissionString()
{ {
/// <summary> return Type;
/// The needed permission as string.
/// </summary>
public string Type { get; }
/// <summary>
/// The needed permission kind.
/// </summary>
public Kind Kind { get; }
/// <summary>
/// The group of this permission.
/// </summary>
public Group Group { get; }
/// <summary>
/// Ask a permission to run an action.
/// </summary>
/// <param name="type">
/// The type of the action
/// </param>
/// <param name="permission">
/// The kind of permission needed.
/// </param>
/// <param name="group">
/// The group of this permission (allow grouped permission like overall.read
/// for all read permissions of this group).
/// </param>
public PermissionAttribute(string type, Kind permission, Group group = Group.Overall)
{
Type = type.ToLower();
Kind = permission;
Group = group;
}
/// <inheritdoc />
public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
{
return serviceProvider.GetRequiredService<IPermissionValidator>().Create(this);
}
/// <inheritdoc />
public bool IsReusable => true;
/// <summary>
/// Return this permission attribute as a string.
/// </summary>
/// <returns>The string representation.</returns>
public string AsPermissionString()
{
return Type;
}
} }
} }

17
back/src/Kyoo.Abstractions/Models/Attributes/Permission/UserOnlyAttribute.cs
View File

@ -18,14 +18,13 @@
using System; using System;
namespace Kyoo.Abstractions.Models.Permissions namespace Kyoo.Abstractions.Models.Permissions;
/// <summary>
/// The annotated route can only be accessed by a logged in user.
/// </summary>
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
public class UserOnlyAttribute : Attribute
{ {
/// <summary> // TODO: Implement a Filter Attribute to make this work. For now, this attribute is only useful as documentation.
/// The annotated route can only be accessed by a logged in user.
/// </summary>
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
public class UserOnlyAttribute : Attribute
{
// TODO: Implement a Filter Attribute to make this work. For now, this attribute is only useful as documentation.
}
} }

51
back/src/Kyoo.Abstractions/Models/Exceptions/DuplicatedItemException.cs
View File

@ -19,35 +19,34 @@
using System; using System;
using System.Runtime.Serialization; using System.Runtime.Serialization;
namespace Kyoo.Abstractions.Models.Exceptions namespace Kyoo.Abstractions.Models.Exceptions;
/// <summary>
/// An exception raised when an item already exists in the database.
/// </summary>
[Serializable]
public class DuplicatedItemException : Exception
{ {
/// <summary> /// <summary>
/// An exception raised when an item already exists in the database. /// The existing object.
/// </summary> /// </summary>
[Serializable] public object? Existing { get; }
public class DuplicatedItemException : Exception
/// <summary>
/// Create a new <see cref="DuplicatedItemException"/> with the default message.
/// </summary>
/// <param name="existing">The existing object.</param>
public DuplicatedItemException(object? existing = null)
: base("Already exists in the database.")
{ {
/// <summary> Existing = existing;
/// The existing object.
/// </summary>
public object? Existing { get; }
/// <summary>
/// Create a new <see cref="DuplicatedItemException"/> with the default message.
/// </summary>
/// <param name="existing">The existing object.</param>
public DuplicatedItemException(object? existing = null)
: base("Already exists in the database.")
{
Existing = existing;
}
/// <summary>
/// The serialization constructor.
/// </summary>
/// <param name="info">Serialization infos</param>
/// <param name="context">The serialization context</param>
protected DuplicatedItemException(SerializationInfo info, StreamingContext context)
: base(info, context) { }
} }
/// <summary>
/// The serialization constructor.
/// </summary>
/// <param name="info">Serialization infos</param>
/// <param name="context">The serialization context</param>
protected DuplicatedItemException(SerializationInfo info, StreamingContext context)
: base(info, context) { }
} }

47
back/src/Kyoo.Abstractions/Models/Exceptions/ItemNotFoundException.cs
View File

@ -19,33 +19,32 @@
using System; using System;
using System.Runtime.Serialization; using System.Runtime.Serialization;
namespace Kyoo.Abstractions.Models.Exceptions namespace Kyoo.Abstractions.Models.Exceptions;
/// <summary>
/// An exception raised when an item could not be found.
/// </summary>
[Serializable]
public class ItemNotFoundException : Exception
{ {
/// <summary> /// <summary>
/// An exception raised when an item could not be found. /// Create a default <see cref="ItemNotFoundException"/> with no message.
/// </summary> /// </summary>
[Serializable] public ItemNotFoundException()
public class ItemNotFoundException : Exception : base("Item not found") { }
{
/// <summary>
/// Create a default <see cref="ItemNotFoundException"/> with no message.
/// </summary>
public ItemNotFoundException()
: base("Item not found") { }
/// <summary> /// <summary>
/// Create a new <see cref="ItemNotFoundException"/> with a message /// Create a new <see cref="ItemNotFoundException"/> with a message
/// </summary> /// </summary>
/// <param name="message">The message of the exception</param> /// <param name="message">The message of the exception</param>
public ItemNotFoundException(string message) public ItemNotFoundException(string message)
: base(message) { } : base(message) { }
/// <summary> /// <summary>
/// The serialization constructor /// The serialization constructor
/// </summary> /// </summary>
/// <param name="info">Serialization infos</param> /// <param name="info">Serialization infos</param>
/// <param name="context">The serialization context</param> /// <param name="context">The serialization context</param>
protected ItemNotFoundException(SerializationInfo info, StreamingContext context) protected ItemNotFoundException(SerializationInfo info, StreamingContext context)
: base(info, context) { } : base(info, context) { }
}
} }

21
back/src/Kyoo.Abstractions/Models/Exceptions/UnauthorizedException.cs
View File

@ -19,18 +19,17 @@
using System; using System;
using System.Runtime.Serialization; using System.Runtime.Serialization;
namespace Kyoo.Abstractions.Models.Exceptions namespace Kyoo.Abstractions.Models.Exceptions;
[Serializable]
public class UnauthorizedException : Exception
{ {
[Serializable] public UnauthorizedException()
public class UnauthorizedException : Exception : base("User not authenticated or token invalid.") { }
{
public UnauthorizedException()
: base("User not authenticated or token invalid.") { }
public UnauthorizedException(string message) public UnauthorizedException(string message)
: base(message) { } : base(message) { }
protected UnauthorizedException(SerializationInfo info, StreamingContext context) protected UnauthorizedException(SerializationInfo info, StreamingContext context)
: base(info, context) { } : base(info, context) { }
}
} }

49
back/src/Kyoo.Abstractions/Models/Genre.cs
View File

@ -16,30 +16,29 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with Kyoo. If not, see <https://www.gnu.org/licenses/>. // along with Kyoo. If not, see <https://www.gnu.org/licenses/>.
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// A genre that allow one to specify categories for shows.
/// </summary>
public enum Genre
{ {
/// <summary> Action,
/// A genre that allow one to specify categories for shows. Adventure,
/// </summary> Animation,
public enum Genre Comedy,
{ Crime,
Action, Documentary,
Adventure, Drama,
Animation, Family,
Comedy, Fantasy,
Crime, History,
Documentary, Horror,
Drama, Music,
Family, Mystery,
Fantasy, Romance,
History, ScienceFiction,
Horror, Thriller,
Music, War,
Mystery, Western,
Romance,
ScienceFiction,
Thriller,
War,
Western,
}
} }

25
back/src/Kyoo.Abstractions/Models/MetadataID.cs
View File

@ -16,21 +16,20 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with Kyoo. If not, see <https://www.gnu.org/licenses/>. // along with Kyoo. If not, see <https://www.gnu.org/licenses/>.
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// ID and link of an item on an external provider.
/// </summary>
public class MetadataId
{ {
/// <summary> /// <summary>
/// ID and link of an item on an external provider. /// The ID of the resource on the external provider.
/// </summary> /// </summary>
public class MetadataId public string DataId { get; set; }
{
/// <summary>
/// The ID of the resource on the external provider.
/// </summary>
public string DataId { get; set; }
/// <summary> /// <summary>
/// The URL of the resource on the external provider. /// The URL of the resource on the external provider.
/// </summary> /// </summary>
public string? Link { get; set; } public string? Link { get; set; }
}
} }

151
back/src/Kyoo.Abstractions/Models/Page.cs
View File

@ -20,93 +20,86 @@ using System.Collections.Generic;
using System.Linq; using System.Linq;
using Kyoo.Utils; using Kyoo.Utils;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// A page of resource that contains information about the pagination of resources.
/// </summary>
/// <typeparam name="T">The type of resource contained in this page.</typeparam>
public class Page<T>
where T : IResource
{ {
/// <summary> /// <summary>
/// A page of resource that contains information about the pagination of resources. /// The link of the current page.
/// </summary> /// </summary>
/// <typeparam name="T">The type of resource contained in this page.</typeparam> public string This { get; }
public class Page<T>
where T : IResource /// <summary>
/// The link of the first page.
/// </summary>
public string First { get; }
/// <summary>
/// The link of the previous page.
/// </summary>
public string? Previous { get; }
/// <summary>
/// The link of the next page.
/// </summary>
public string? Next { get; }
/// <summary>
/// The number of items in the current page.
/// </summary>
public int Count => Items.Count;
/// <summary>
/// The list of items in the page.
/// </summary>
public ICollection<T> Items { get; }
/// <summary>
/// Create a new <see cref="Page{T}"/>.
/// </summary>
/// <param name="items">The list of items in the page.</param>
/// <param name="this">The link of the current page.</param>
/// <param name="previous">The link of the previous page.</param>
/// <param name="next">The link of the next page.</param>
/// <param name="first">The link of the first page.</param>
public Page(ICollection<T> items, string @this, string? previous, string? next, string first)
{ {
/// <summary> Items = items;
/// The link of the current page. This = @this;
/// </summary> Previous = previous;
public string This { get; } Next = next;
First = first;
}
/// <summary> /// <summary>
/// The link of the first page. /// Create a new <see cref="Page{T}"/> and compute the urls.
/// </summary> /// </summary>
public string First { get; } /// <param name="items">The list of items in the page.</param>
/// <param name="url">The base url of the resources available from this page.</param>
/// <summary> /// <param name="query">The list of query strings of the current page</param>
/// The link of the previous page. /// <param name="limit">The number of items requested for the current page.</param>
/// </summary> public Page(ICollection<T> items, string url, Dictionary<string, string> query, int limit)
public string? Previous { get; } {
Items = items;
/// <summary> This = url + query.ToQueryString();
/// The link of the next page. if (items.Count > 0 && query.ContainsKey("afterID"))
/// </summary>
public string? Next { get; }
/// <summary>
/// The number of items in the current page.
/// </summary>
public int Count => Items.Count;
/// <summary>
/// The list of items in the page.
/// </summary>
public ICollection<T> Items { get; }
/// <summary>
/// Create a new <see cref="Page{T}"/>.
/// </summary>
/// <param name="items">The list of items in the page.</param>
/// <param name="this">The link of the current page.</param>
/// <param name="previous">The link of the previous page.</param>
/// <param name="next">The link of the next page.</param>
/// <param name="first">The link of the first page.</param>
public Page(
ICollection<T> items,
string @this,
string? previous,
string? next,
string first
)
{ {
Items = items; query["afterID"] = items.First().Id.ToString();
This = @this; query["reverse"] = "true";
Previous = previous; Previous = url + query.ToQueryString();
Next = next;
First = first;
} }
query.Remove("reverse");
/// <summary> if (items.Count == limit && limit > 0)
/// Create a new <see cref="Page{T}"/> and compute the urls.
/// </summary>
/// <param name="items">The list of items in the page.</param>
/// <param name="url">The base url of the resources available from this page.</param>
/// <param name="query">The list of query strings of the current page</param>
/// <param name="limit">The number of items requested for the current page.</param>
public Page(ICollection<T> items, string url, Dictionary<string, string> query, int limit)
{ {
Items = items; query["afterID"] = items.Last().Id.ToString();
This = url + query.ToQueryString(); Next = url + query.ToQueryString();
if (items.Count > 0 && query.ContainsKey("afterID"))
{
query["afterID"] = items.First().Id.ToString();
query["reverse"] = "true";
Previous = url + query.ToQueryString();
}
query.Remove("reverse");
if (items.Count == limit && limit > 0)
{
query["afterID"] = items.Last().Id.ToString();
Next = url + query.ToQueryString();
}
query.Remove("afterID");
First = url + query.ToQueryString();
} }
query.Remove("afterID");
First = url + query.ToQueryString();
} }
} }

115
back/src/Kyoo.Abstractions/Models/Resources/Collection.cs
View File

@ -23,69 +23,68 @@ using System.Text.Json.Serialization;
using Kyoo.Abstractions.Controllers; using Kyoo.Abstractions.Controllers;
using Kyoo.Utils; using Kyoo.Utils;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// A class representing collections of <see cref="Show"/>.
/// </summary>
public class Collection : IQuery, IResource, IMetadata, IThumbnails, IAddedDate, ILibraryItem
{ {
public static Sort DefaultSort => new Sort<Collection>.By(nameof(Collection.Name));
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[MaxLength(256)]
public string Slug { get; set; }
/// <summary> /// <summary>
/// A class representing collections of <see cref="Show"/>. /// The name of this collection.
/// </summary> /// </summary>
public class Collection : IQuery, IResource, IMetadata, IThumbnails, IAddedDate, ILibraryItem public string Name { get; set; }
/// <summary>
/// The description of this collection.
/// </summary>
public string? Overview { get; set; }
/// <inheritdoc />
public DateTime AddedDate { get; set; }
/// <inheritdoc />
public Image? Poster { get; set; }
/// <inheritdoc />
public Image? Thumbnail { get; set; }
/// <inheritdoc />
public Image? Logo { get; set; }
/// <summary>
/// The list of movies contained in this collection.
/// </summary>
[JsonIgnore]
public ICollection<Movie>? Movies { get; set; }
/// <summary>
/// The list of shows contained in this collection.
/// </summary>
[JsonIgnore]
public ICollection<Show>? Shows { get; set; }
/// <inheritdoc />
public Dictionary<string, MetadataId> ExternalId { get; set; } = new();
public Collection() { }
[JsonConstructor]
public Collection(string name)
{ {
public static Sort DefaultSort => new Sort<Collection>.By(nameof(Collection.Name)); if (name != null)
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[MaxLength(256)]
public string Slug { get; set; }
/// <summary>
/// The name of this collection.
/// </summary>
public string Name { get; set; }
/// <summary>
/// The description of this collection.
/// </summary>
public string? Overview { get; set; }
/// <inheritdoc />
public DateTime AddedDate { get; set; }
/// <inheritdoc />
public Image? Poster { get; set; }
/// <inheritdoc />
public Image? Thumbnail { get; set; }
/// <inheritdoc />
public Image? Logo { get; set; }
/// <summary>
/// The list of movies contained in this collection.
/// </summary>
[JsonIgnore]
public ICollection<Movie>? Movies { get; set; }
/// <summary>
/// The list of shows contained in this collection.
/// </summary>
[JsonIgnore]
public ICollection<Show>? Shows { get; set; }
/// <inheritdoc />
public Dictionary<string, MetadataId> ExternalId { get; set; } = new();
public Collection() { }
[JsonConstructor]
public Collection(string name)
{ {
if (name != null) Slug = Utility.ToSlug(name);
{ Name = name;
Slug = Utility.ToSlug(name);
Name = name;
}
} }
} }
} }

466
back/src/Kyoo.Abstractions/Models/Resources/Episode.cs
View File

@ -26,280 +26,274 @@ using EntityFrameworkCore.Projectables;
using Kyoo.Abstractions.Controllers; using Kyoo.Abstractions.Controllers;
using Kyoo.Abstractions.Models.Attributes; using Kyoo.Abstractions.Models.Attributes;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// A class to represent a single show's episode.
/// </summary>
public class Episode : IQuery, IResource, IMetadata, IThumbnails, IAddedDate, INews
{ {
/// <summary> // Use absolute numbers by default and fallback to season/episodes if it does not exists.
/// A class to represent a single show's episode. public static Sort DefaultSort =>
/// </summary> new Sort<Episode>.Conglomerate(
public class Episode : IQuery, IResource, IMetadata, IThumbnails, IAddedDate, INews new Sort<Episode>.By(x => x.AbsoluteNumber),
new Sort<Episode>.By(x => x.SeasonNumber),
new Sort<Episode>.By(x => x.EpisodeNumber)
);
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[Computed]
[MaxLength(256)]
public string Slug
{ {
// Use absolute numbers by default and fallback to season/episodes if it does not exists. get
public static Sort DefaultSort =>
new Sort<Episode>.Conglomerate(
new Sort<Episode>.By(x => x.AbsoluteNumber),
new Sort<Episode>.By(x => x.SeasonNumber),
new Sort<Episode>.By(x => x.EpisodeNumber)
);
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[Computed]
[MaxLength(256)]
public string Slug
{ {
get if (ShowSlug != null || Show?.Slug != null)
{ return GetSlug(ShowSlug ?? Show!.Slug, SeasonNumber, EpisodeNumber, AbsoluteNumber);
if (ShowSlug != null || Show?.Slug != null) return GetSlug(ShowId.ToString(), SeasonNumber, EpisodeNumber, AbsoluteNumber);
return GetSlug( }
ShowSlug ?? Show!.Slug, private set
SeasonNumber, {
EpisodeNumber, Match match = Regex.Match(value, @"(?<show>.+)-s(?<season>\d+)e(?<episode>\d+)");
AbsoluteNumber
);
return GetSlug(ShowId.ToString(), SeasonNumber, EpisodeNumber, AbsoluteNumber);
}
private set
{
Match match = Regex.Match(value, @"(?<show>.+)-s(?<season>\d+)e(?<episode>\d+)");
if (match.Success)
{
ShowSlug = match.Groups["show"].Value;
SeasonNumber = int.Parse(match.Groups["season"].Value);
EpisodeNumber = int.Parse(match.Groups["episode"].Value);
}
else
{
match = Regex.Match(value, @"(?<show>.+)-(?<absolute>\d+)");
if (match.Success) if (match.Success)
{ {
ShowSlug = match.Groups["show"].Value; ShowSlug = match.Groups["show"].Value;
SeasonNumber = int.Parse(match.Groups["season"].Value); AbsoluteNumber = int.Parse(match.Groups["absolute"].Value);
EpisodeNumber = int.Parse(match.Groups["episode"].Value);
} }
else else
{ ShowSlug = value;
match = Regex.Match(value, @"(?<show>.+)-(?<absolute>\d+)"); SeasonNumber = null;
if (match.Success) EpisodeNumber = null;
{
ShowSlug = match.Groups["show"].Value;
AbsoluteNumber = int.Parse(match.Groups["absolute"].Value);
}
else
ShowSlug = value;
SeasonNumber = null;
EpisodeNumber = null;
}
} }
} }
}
/// <summary> /// <summary>
/// The slug of the Show that contain this episode. If this is not set, this episode is ill-formed. /// The slug of the Show that contain this episode. If this is not set, this episode is ill-formed.
/// </summary> /// </summary>
[JsonIgnore] [JsonIgnore]
public string? ShowSlug { private get; set; } public string? ShowSlug { private get; set; }
/// <summary> /// <summary>
/// The ID of the Show containing this episode. /// The ID of the Show containing this episode.
/// </summary> /// </summary>
public Guid ShowId { get; set; } public Guid ShowId { get; set; }
/// <summary> /// <summary>
/// The show that contains this episode. /// The show that contains this episode.
/// </summary> /// </summary>
[LoadableRelation(nameof(ShowId))] [LoadableRelation(nameof(ShowId))]
public Show? Show { get; set; } public Show? Show { get; set; }
/// <summary> /// <summary>
/// The ID of the Season containing this episode. /// The ID of the Season containing this episode.
/// </summary> /// </summary>
public Guid? SeasonId { get; set; } public Guid? SeasonId { get; set; }
/// <summary> /// <summary>
/// The season that contains this episode. /// The season that contains this episode.
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// This can be null if the season is unknown and the episode is only identified /// This can be null if the season is unknown and the episode is only identified
/// by it's <see cref="AbsoluteNumber"/>. /// by it's <see cref="AbsoluteNumber"/>.
/// </remarks> /// </remarks>
[LoadableRelation(nameof(SeasonId))] [LoadableRelation(nameof(SeasonId))]
public Season? Season { get; set; } public Season? Season { get; set; }
/// <summary> /// <summary>
/// The season in witch this episode is in. /// The season in witch this episode is in.
/// </summary> /// </summary>
public int? SeasonNumber { get; set; } public int? SeasonNumber { get; set; }
/// <summary> /// <summary>
/// The number of this episode in it's season. /// The number of this episode in it's season.
/// </summary> /// </summary>
public int? EpisodeNumber { get; set; } public int? EpisodeNumber { get; set; }
/// <summary> /// <summary>
/// The absolute number of this episode. It's an episode number that is not reset to 1 after a new season. /// The absolute number of this episode. It's an episode number that is not reset to 1 after a new season.
/// </summary> /// </summary>
public int? AbsoluteNumber { get; set; } public int? AbsoluteNumber { get; set; }
/// <summary> /// <summary>
/// The path of the video file for this episode. /// The path of the video file for this episode.
/// </summary> /// </summary>
public string Path { get; set; } public string Path { get; set; }
/// <summary> /// <summary>
/// The title of this episode. /// The title of this episode.
/// </summary> /// </summary>
public string? Name { get; set; } public string? Name { get; set; }
/// <summary> /// <summary>
/// The overview of this episode. /// The overview of this episode.
/// </summary> /// </summary>
public string? Overview { get; set; } public string? Overview { get; set; }
/// <summary> /// <summary>
/// How long is this episode? (in minutes) /// How long is this episode? (in minutes)
/// </summary> /// </summary>
public int? Runtime { get; set; } public int? Runtime { get; set; }
/// <summary> /// <summary>
/// The release date of this episode. It can be null if unknown. /// The release date of this episode. It can be null if unknown.
/// </summary> /// </summary>
public DateTime? ReleaseDate { get; set; } public DateTime? ReleaseDate { get; set; }
/// <inheritdoc /> /// <inheritdoc />
public DateTime AddedDate { get; set; } public DateTime AddedDate { get; set; }
/// <inheritdoc /> /// <inheritdoc />
public Image? Poster { get; set; } public Image? Poster { get; set; }
/// <inheritdoc /> /// <inheritdoc />
public Image? Thumbnail { get; set; } public Image? Thumbnail { get; set; }
/// <inheritdoc /> /// <inheritdoc />
public Image? Logo { get; set; } public Image? Logo { get; set; }
/// <inheritdoc /> /// <inheritdoc />
public Dictionary<string, MetadataId> ExternalId { get; set; } = new(); public Dictionary<string, MetadataId> ExternalId { get; set; } = new();
/// <summary> /// <summary>
/// The previous episode that should be seen before viewing this one. /// The previous episode that should be seen before viewing this one.
/// </summary> /// </summary>
[Projectable(UseMemberBody = nameof(_PreviousEpisode), OnlyOnInclude = true)] [Projectable(UseMemberBody = nameof(_PreviousEpisode), OnlyOnInclude = true)]
[LoadableRelation( [LoadableRelation(
// language=PostgreSQL // language=PostgreSQL
Sql = """ Sql = """
select select
pe.* -- Episode as pe pe.* -- Episode as pe
from from
episodes as "pe" episodes as "pe"
where where
pe.show_id = "this".show_id pe.show_id = "this".show_id
and (pe.absolute_number < "this".absolute_number and (pe.absolute_number < "this".absolute_number
or pe.season_number < "this".season_number or pe.season_number < "this".season_number
or (pe.season_number = "this".season_number or (pe.season_number = "this".season_number
and e.episode_number < "this".episode_number)) and e.episode_number < "this".episode_number))
order by order by
pe.absolute_number desc nulls last, pe.absolute_number desc nulls last,
pe.season_number desc, pe.season_number desc,
pe.episode_number desc pe.episode_number desc
limit 1 limit 1
""" """
)] )]
public Episode? PreviousEpisode { get; set; } public Episode? PreviousEpisode { get; set; }
private Episode? _PreviousEpisode => private Episode? _PreviousEpisode =>
Show! Show!
.Episodes!.OrderBy(x => x.AbsoluteNumber == null) .Episodes!.OrderBy(x => x.AbsoluteNumber == null)
.ThenByDescending(x => x.AbsoluteNumber) .ThenByDescending(x => x.AbsoluteNumber)
.ThenByDescending(x => x.SeasonNumber) .ThenByDescending(x => x.SeasonNumber)
.ThenByDescending(x => x.EpisodeNumber) .ThenByDescending(x => x.EpisodeNumber)
.FirstOrDefault(x => .FirstOrDefault(x =>
x.AbsoluteNumber < AbsoluteNumber x.AbsoluteNumber < AbsoluteNumber
|| x.SeasonNumber < SeasonNumber || x.SeasonNumber < SeasonNumber
|| (x.SeasonNumber == SeasonNumber && x.EpisodeNumber < EpisodeNumber) || (x.SeasonNumber == SeasonNumber && x.EpisodeNumber < EpisodeNumber)
); );
/// <summary> /// <summary>
/// The next episode to watch after this one. /// The next episode to watch after this one.
/// </summary> /// </summary>
[Projectable(UseMemberBody = nameof(_NextEpisode), OnlyOnInclude = true)] [Projectable(UseMemberBody = nameof(_NextEpisode), OnlyOnInclude = true)]
[LoadableRelation( [LoadableRelation(
// language=PostgreSQL // language=PostgreSQL
Sql = """ Sql = """
select select
ne.* -- Episode as ne ne.* -- Episode as ne
from from
episodes as "ne" episodes as "ne"
where where
ne.show_id = "this".show_id ne.show_id = "this".show_id
and (ne.absolute_number > "this".absolute_number and (ne.absolute_number > "this".absolute_number
or ne.season_number > "this".season_number or ne.season_number > "this".season_number
or (ne.season_number = "this".season_number or (ne.season_number = "this".season_number
and e.episode_number > "this".episode_number)) and e.episode_number > "this".episode_number))
order by order by
ne.absolute_number, ne.absolute_number,
ne.season_number, ne.season_number,
ne.episode_number ne.episode_number
limit 1 limit 1
""" """
)] )]
public Episode? NextEpisode { get; set; } public Episode? NextEpisode { get; set; }
private Episode? _NextEpisode => private Episode? _NextEpisode =>
Show! Show!
.Episodes!.OrderBy(x => x.AbsoluteNumber) .Episodes!.OrderBy(x => x.AbsoluteNumber)
.ThenBy(x => x.SeasonNumber) .ThenBy(x => x.SeasonNumber)
.ThenBy(x => x.EpisodeNumber) .ThenBy(x => x.EpisodeNumber)
.FirstOrDefault(x => .FirstOrDefault(x =>
x.AbsoluteNumber > AbsoluteNumber x.AbsoluteNumber > AbsoluteNumber
|| x.SeasonNumber > SeasonNumber || x.SeasonNumber > SeasonNumber
|| (x.SeasonNumber == SeasonNumber && x.EpisodeNumber > EpisodeNumber) || (x.SeasonNumber == SeasonNumber && x.EpisodeNumber > EpisodeNumber)
); );
[JsonIgnore] [JsonIgnore]
public ICollection<EpisodeWatchStatus>? Watched { get; set; } public ICollection<EpisodeWatchStatus>? Watched { get; set; }
/// <summary> /// <summary>
/// Metadata of what an user as started/planned to watch. /// Metadata of what an user as started/planned to watch.
/// </summary> /// </summary>
[Projectable(UseMemberBody = nameof(_WatchStatus), OnlyOnInclude = true)] [Projectable(UseMemberBody = nameof(_WatchStatus), OnlyOnInclude = true)]
[LoadableRelation( [LoadableRelation(
Sql = "episode_watch_status", Sql = "episode_watch_status",
On = "episode_id = \"this\".id and \"relation\".user_id = [current_user]" On = "episode_id = \"this\".id and \"relation\".user_id = [current_user]"
)] )]
public EpisodeWatchStatus? WatchStatus { get; set; } public EpisodeWatchStatus? WatchStatus { get; set; }
// There is a global query filter to filter by user so we just need to do single. // There is a global query filter to filter by user so we just need to do single.
private EpisodeWatchStatus? _WatchStatus => Watched!.FirstOrDefault(); private EpisodeWatchStatus? _WatchStatus => Watched!.FirstOrDefault();
/// <summary> /// <summary>
/// Links to watch this episode. /// Links to watch this episode.
/// </summary> /// </summary>
public VideoLinks Links => public VideoLinks Links =>
new() { Direct = $"/episode/{Slug}/direct", Hls = $"/episode/{Slug}/master.m3u8", }; new() { Direct = $"/episode/{Slug}/direct", Hls = $"/episode/{Slug}/master.m3u8", };
/// <summary> /// <summary>
/// Get the slug of an episode. /// Get the slug of an episode.
/// </summary> /// </summary>
/// <param name="showSlug">The slug of the show. It can't be null.</param> /// <param name="showSlug">The slug of the show. It can't be null.</param>
/// <param name="seasonNumber"> /// <param name="seasonNumber">
/// The season in which the episode is. /// The season in which the episode is.
/// If this is a movie or if the episode should be referred by it's absolute number, set this to null. /// If this is a movie or if the episode should be referred by it's absolute number, set this to null.
/// </param> /// </param>
/// <param name="episodeNumber"> /// <param name="episodeNumber">
/// The number of the episode in it's season. /// The number of the episode in it's season.
/// If this is a movie or if the episode should be referred by it's absolute number, set this to null. /// If this is a movie or if the episode should be referred by it's absolute number, set this to null.
/// </param> /// </param>
/// <param name="absoluteNumber"> /// <param name="absoluteNumber">
/// The absolute number of this show. /// The absolute number of this show.
/// If you don't know it or this is a movie, use null /// If you don't know it or this is a movie, use null
/// </param> /// </param>
/// <returns>The slug corresponding to the given arguments</returns> /// <returns>The slug corresponding to the given arguments</returns>
public static string GetSlug( public static string GetSlug(
string showSlug, string showSlug,
int? seasonNumber, int? seasonNumber,
int? episodeNumber, int? episodeNumber,
int? absoluteNumber = null int? absoluteNumber = null
) )
{
return seasonNumber switch
{ {
return seasonNumber switch null when absoluteNumber == null => showSlug,
{ null => $"{showSlug}-{absoluteNumber}",
null when absoluteNumber == null => showSlug, _ => $"{showSlug}-s{seasonNumber}e{episodeNumber}"
null => $"{showSlug}-{absoluteNumber}", };
_ => $"{showSlug}-s{seasonNumber}e{episodeNumber}"
};
}
} }
} }

17
back/src/Kyoo.Abstractions/Models/Resources/Interfaces/IAddedDate.cs
View File

@ -18,16 +18,15 @@
using System; using System;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// An interface applied to resources.
/// </summary>
public interface IAddedDate
{ {
/// <summary> /// <summary>
/// An interface applied to resources. /// The date at which this resource was added to kyoo.
/// </summary> /// </summary>
public interface IAddedDate public DateTime AddedDate { get; set; }
{
/// <summary>
/// The date at which this resource was added to kyoo.
/// </summary>
public DateTime AddedDate { get; set; }
}
} }

17
back/src/Kyoo.Abstractions/Models/Resources/Interfaces/IMetadata.cs
View File

@ -18,16 +18,15 @@
using System.Collections.Generic; using System.Collections.Generic;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// An interface applied to resources containing external metadata.
/// </summary>
public interface IMetadata
{ {
/// <summary> /// <summary>
/// An interface applied to resources containing external metadata. /// The link to metadata providers that this show has. See <see cref="MetadataId"/> for more information.
/// </summary> /// </summary>
public interface IMetadata public Dictionary<string, MetadataId> ExternalId { get; set; }
{
/// <summary>
/// The link to metadata providers that this show has. See <see cref="MetadataId"/> for more information.
/// </summary>
public Dictionary<string, MetadataId> ExternalId { get; set; }
}
} }

45
back/src/Kyoo.Abstractions/Models/Resources/Interfaces/IResource.cs
View File

@ -20,31 +20,30 @@ using System;
using System.ComponentModel.DataAnnotations; using System.ComponentModel.DataAnnotations;
using Kyoo.Abstractions.Controllers; using Kyoo.Abstractions.Controllers;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// An interface to represent a resource that can be retrieved from the database.
/// </summary>
public interface IResource : IQuery
{ {
/// <summary> /// <summary>
/// An interface to represent a resource that can be retrieved from the database. /// A unique ID for this type of resource. This can't be changed and duplicates are not allowed.
/// </summary> /// </summary>
public interface IResource : IQuery /// <remarks>
{ /// You don't need to specify an ID manually when creating a new resource,
/// <summary> /// this field is automatically assigned by the <see cref="IRepository{T}"/>.
/// A unique ID for this type of resource. This can't be changed and duplicates are not allowed. /// </remarks>
/// </summary> public Guid Id { get; set; }
/// <remarks>
/// You don't need to specify an ID manually when creating a new resource,
/// this field is automatically assigned by the <see cref="IRepository{T}"/>.
/// </remarks>
public Guid Id { get; set; }
/// <summary> /// <summary>
/// A human-readable identifier that can be used instead of an ID. /// A human-readable identifier that can be used instead of an ID.
/// A slug must be unique for a type of resource but it can be changed. /// A slug must be unique for a type of resource but it can be changed.
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// There is no setter for a slug since it can be computed from other fields. /// There is no setter for a slug since it can be computed from other fields.
/// For example, a season slug is {ShowSlug}-s{SeasonNumber}. /// For example, a season slug is {ShowSlug}-s{SeasonNumber}.
/// </remarks> /// </remarks>
[MaxLength(256)] [MaxLength(256)]
public string Slug { get; } public string Slug { get; }
}
} }

178
back/src/Kyoo.Abstractions/Models/Resources/Interfaces/IThumbnails.cs
View File

@ -23,105 +23,101 @@ using System.Globalization;
using System.Text.Json.Serialization; using System.Text.Json.Serialization;
using Kyoo.Abstractions.Models.Attributes; using Kyoo.Abstractions.Models.Attributes;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// An interface representing items that contains images (like posters, thumbnails, logo, banners...)
/// </summary>
public interface IThumbnails
{ {
/// <summary> /// <summary>
/// An interface representing items that contains images (like posters, thumbnails, logo, banners...) /// A poster is a 2/3 format image with the cover of the resource.
/// </summary> /// </summary>
public interface IThumbnails public Image? Poster { get; set; }
{
/// <summary>
/// A poster is a 2/3 format image with the cover of the resource.
/// </summary>
public Image? Poster { get; set; }
/// <summary>
/// A thumbnail is a 16/9 format image, it could ether be used as a background or as a preview but it usually
/// is not an official image.
/// </summary>
public Image? Thumbnail { get; set; }
/// <summary>
/// A logo is a small image representing the resource.
/// </summary>
public Image? Logo { get; set; }
}
[TypeConverter(typeof(ImageConvertor))]
[SqlFirstColumn(nameof(Source))]
public class Image
{
/// <summary>
/// The original image from another server.
/// </summary>
public string Source { get; set; }
/// <summary>
/// A hash to display as placeholder while the image is loading.
/// </summary>
[MaxLength(32)]
public string Blurhash { get; set; }
public Image() { }
[JsonConstructor]
public Image(string source, string? blurhash = null)
{
Source = source;
Blurhash = blurhash ?? "000000";
}
public class ImageConvertor : TypeConverter
{
/// <inheritdoc />
public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType)
{
if (sourceType == typeof(string))
return true;
return base.CanConvertFrom(context, sourceType);
}
/// <inheritdoc />
public override object ConvertFrom(
ITypeDescriptorContext? context,
CultureInfo? culture,
object value
)
{
if (value is not string source)
return base.ConvertFrom(context, culture, value)!;
return new Image(source);
}
/// <inheritdoc />
public override bool CanConvertTo(
ITypeDescriptorContext? context,
Type? destinationType
)
{
return false;
}
}
}
/// <summary> /// <summary>
/// The quality of an image /// A thumbnail is a 16/9 format image, it could ether be used as a background or as a preview but it usually
/// is not an official image.
/// </summary> /// </summary>
public enum ImageQuality public Image? Thumbnail { get; set; }
/// <summary>
/// A logo is a small image representing the resource.
/// </summary>
public Image? Logo { get; set; }
}
[TypeConverter(typeof(ImageConvertor))]
[SqlFirstColumn(nameof(Source))]
public class Image
{
/// <summary>
/// The original image from another server.
/// </summary>
public string Source { get; set; }
/// <summary>
/// A hash to display as placeholder while the image is loading.
/// </summary>
[MaxLength(32)]
public string Blurhash { get; set; }
public Image() { }
[JsonConstructor]
public Image(string source, string? blurhash = null)
{ {
/// <summary> Source = source;
/// Small Blurhash = blurhash ?? "000000";
/// </summary> }
Low,
/// <summary> public class ImageConvertor : TypeConverter
/// Medium {
/// </summary> /// <inheritdoc />
Medium, public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType)
{
if (sourceType == typeof(string))
return true;
return base.CanConvertFrom(context, sourceType);
}
/// <summary> /// <inheritdoc />
/// Large public override object ConvertFrom(
/// </summary> ITypeDescriptorContext? context,
High, CultureInfo? culture,
object value
)
{
if (value is not string source)
return base.ConvertFrom(context, culture, value)!;
return new Image(source);
}
/// <inheritdoc />
public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destinationType)
{
return false;
}
} }
} }
/// <summary>
/// The quality of an image
/// </summary>
public enum ImageQuality
{
/// <summary>
/// Small
/// </summary>
Low,
/// <summary>
/// Medium
/// </summary>
Medium,
/// <summary>
/// Large
/// </summary>
High,
}

303
back/src/Kyoo.Abstractions/Models/Resources/Movie.cs
View File

@ -27,163 +27,162 @@ using Kyoo.Abstractions.Controllers;
using Kyoo.Abstractions.Models.Attributes; using Kyoo.Abstractions.Models.Attributes;
using Kyoo.Utils; using Kyoo.Utils;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// A series or a movie.
/// </summary>
public class Movie
: IQuery,
IResource,
IMetadata,
IThumbnails,
IAddedDate,
ILibraryItem,
INews,
IWatchlist
{ {
public static Sort DefaultSort => new Sort<Movie>.By(x => x.Name);
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[MaxLength(256)]
public string Slug { get; set; }
/// <summary> /// <summary>
/// A series or a movie. /// The title of this show.
/// </summary> /// </summary>
public class Movie public string Name { get; set; }
: IQuery,
IResource, /// <summary>
IMetadata, /// A catchphrase for this movie.
IThumbnails, /// </summary>
IAddedDate, public string? Tagline { get; set; }
ILibraryItem,
INews, /// <summary>
IWatchlist /// The list of alternative titles of this show.
/// </summary>
public string[] Aliases { get; set; } = Array.Empty<string>();
/// <summary>
/// The path of the movie video file.
/// </summary>
public string Path { get; set; }
/// <summary>
/// The summary of this show.
/// </summary>
public string? Overview { get; set; }
/// <summary>
/// A list of tags that match this movie.
/// </summary>
public string[] Tags { get; set; } = Array.Empty<string>();
/// <summary>
/// The list of genres (themes) this show has.
/// </summary>
public Genre[] Genres { get; set; } = Array.Empty<Genre>();
/// <summary>
/// Is this show airing, not aired yet or finished?
/// </summary>
public Status Status { get; set; }
/// <summary>
/// How well this item is rated? (from 0 to 100).
/// </summary>
public int Rating { get; set; }
/// <summary>
/// How long is this movie? (in minutes)
/// </summary>
public int? Runtime { get; set; }
/// <summary>
/// The date this movie aired.
/// </summary>
public DateTime? AirDate { get; set; }
/// <inheritdoc />
public DateTime AddedDate { get; set; }
/// <inheritdoc />
public Image? Poster { get; set; }
/// <inheritdoc />
public Image? Thumbnail { get; set; }
/// <inheritdoc />
public Image? Logo { get; set; }
[JsonIgnore]
[Column("air_date")]
public DateTime? StartAir => AirDate;
[JsonIgnore]
[Column("air_date")]
public DateTime? EndAir => AirDate;
/// <summary>
/// A video of a few minutes that tease the content.
/// </summary>
public string? Trailer { get; set; }
/// <inheritdoc />
public Dictionary<string, MetadataId> ExternalId { get; set; } = new();
/// <summary>
/// The ID of the Studio that made this show.
/// </summary>
[JsonIgnore]
public Guid? StudioId { get; set; }
/// <summary>
/// The Studio that made this show.
/// </summary>
[LoadableRelation(nameof(StudioId))]
public Studio? Studio { get; set; }
/// <summary>
/// The list of collections that contains this show.
/// </summary>
[JsonIgnore]
public ICollection<Collection>? Collections { get; set; }
/// <summary>
/// Links to watch this movie.
/// </summary>
public VideoLinks Links =>
new() { Direct = $"/movie/{Slug}/direct", Hls = $"/movie/{Slug}/master.m3u8", };
[JsonIgnore]
public ICollection<MovieWatchStatus>? Watched { get; set; }
/// <summary>
/// Metadata of what an user as started/planned to watch.
/// </summary>
[Projectable(UseMemberBody = nameof(_WatchStatus), OnlyOnInclude = true)]
[LoadableRelation(
Sql = "movie_watch_status",
On = "movie_id = \"this\".id and \"relation\".user_id = [current_user]"
)]
public MovieWatchStatus? WatchStatus { get; set; }
// There is a global query filter to filter by user so we just need to do single.
private MovieWatchStatus? _WatchStatus => Watched!.FirstOrDefault();
public Movie() { }
[JsonConstructor]
public Movie(string name)
{ {
public static Sort DefaultSort => new Sort<Movie>.By(x => x.Name); if (name != null)
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[MaxLength(256)]
public string Slug { get; set; }
/// <summary>
/// The title of this show.
/// </summary>
public string Name { get; set; }
/// <summary>
/// A catchphrase for this movie.
/// </summary>
public string? Tagline { get; set; }
/// <summary>
/// The list of alternative titles of this show.
/// </summary>
public string[] Aliases { get; set; } = Array.Empty<string>();
/// <summary>
/// The path of the movie video file.
/// </summary>
public string Path { get; set; }
/// <summary>
/// The summary of this show.
/// </summary>
public string? Overview { get; set; }
/// <summary>
/// A list of tags that match this movie.
/// </summary>
public string[] Tags { get; set; } = Array.Empty<string>();
/// <summary>
/// The list of genres (themes) this show has.
/// </summary>
public Genre[] Genres { get; set; } = Array.Empty<Genre>();
/// <summary>
/// Is this show airing, not aired yet or finished?
/// </summary>
public Status Status { get; set; }
/// <summary>
/// How well this item is rated? (from 0 to 100).
/// </summary>
public int Rating { get; set; }
/// <summary>
/// How long is this movie? (in minutes)
/// </summary>
public int? Runtime { get; set; }
/// <summary>
/// The date this movie aired.
/// </summary>
public DateTime? AirDate { get; set; }
/// <inheritdoc />
public DateTime AddedDate { get; set; }
/// <inheritdoc />
public Image? Poster { get; set; }
/// <inheritdoc />
public Image? Thumbnail { get; set; }
/// <inheritdoc />
public Image? Logo { get; set; }
[JsonIgnore]
[Column("air_date")]
public DateTime? StartAir => AirDate;
[JsonIgnore]
[Column("air_date")]
public DateTime? EndAir => AirDate;
/// <summary>
/// A video of a few minutes that tease the content.
/// </summary>
public string? Trailer { get; set; }
/// <inheritdoc />
public Dictionary<string, MetadataId> ExternalId { get; set; } = new();
/// <summary>
/// The ID of the Studio that made this show.
/// </summary>
[JsonIgnore]
public Guid? StudioId { get; set; }
/// <summary>
/// The Studio that made this show.
/// </summary>
[LoadableRelation(nameof(StudioId))]
public Studio? Studio { get; set; }
/// <summary>
/// The list of collections that contains this show.
/// </summary>
[JsonIgnore]
public ICollection<Collection>? Collections { get; set; }
/// <summary>
/// Links to watch this movie.
/// </summary>
public VideoLinks Links =>
new() { Direct = $"/movie/{Slug}/direct", Hls = $"/movie/{Slug}/master.m3u8", };
[JsonIgnore]
public ICollection<MovieWatchStatus>? Watched { get; set; }
/// <summary>
/// Metadata of what an user as started/planned to watch.
/// </summary>
[Projectable(UseMemberBody = nameof(_WatchStatus), OnlyOnInclude = true)]
[LoadableRelation(
Sql = "movie_watch_status",
On = "movie_id = \"this\".id and \"relation\".user_id = [current_user]"
)]
public MovieWatchStatus? WatchStatus { get; set; }
// There is a global query filter to filter by user so we just need to do single.
private MovieWatchStatus? _WatchStatus => Watched!.FirstOrDefault();
public Movie() { }
[JsonConstructor]
public Movie(string name)
{ {
if (name != null) Slug = Utility.ToSlug(name);
{ Name = name;
Slug = Utility.ToSlug(name);
Name = name;
}
} }
} }
} }

227
back/src/Kyoo.Abstractions/Models/Resources/Season.cs
View File

@ -26,124 +26,123 @@ using EntityFrameworkCore.Projectables;
using Kyoo.Abstractions.Controllers; using Kyoo.Abstractions.Controllers;
using Kyoo.Abstractions.Models.Attributes; using Kyoo.Abstractions.Models.Attributes;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// A season of a <see cref="Show"/>.
/// </summary>
public class Season : IQuery, IResource, IMetadata, IThumbnails, IAddedDate
{ {
/// <summary> public static Sort DefaultSort => new Sort<Season>.By(x => x.SeasonNumber);
/// A season of a <see cref="Show"/>.
/// </summary> /// <inheritdoc />
public class Season : IQuery, IResource, IMetadata, IThumbnails, IAddedDate public Guid Id { get; set; }
/// <inheritdoc />
[Computed]
[MaxLength(256)]
public string Slug
{ {
public static Sort DefaultSort => new Sort<Season>.By(x => x.SeasonNumber); get
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[Computed]
[MaxLength(256)]
public string Slug
{ {
get if (ShowSlug == null && Show == null)
{ return $"{ShowId}-s{SeasonNumber}";
if (ShowSlug == null && Show == null) return $"{ShowSlug ?? Show?.Slug}-s{SeasonNumber}";
return $"{ShowId}-s{SeasonNumber}";
return $"{ShowSlug ?? Show?.Slug}-s{SeasonNumber}";
}
private set
{
Match match = Regex.Match(value, @"(?<show>.+)-s(?<season>\d+)");
if (!match.Success)
throw new ArgumentException(
"Invalid season slug. Format: {showSlug}-s{seasonNumber}"
);
ShowSlug = match.Groups["show"].Value;
SeasonNumber = int.Parse(match.Groups["season"].Value);
}
} }
private set
{
Match match = Regex.Match(value, @"(?<show>.+)-s(?<season>\d+)");
/// <summary> if (!match.Success)
/// The slug of the Show that contain this episode. If this is not set, this season is ill-formed. throw new ArgumentException(
/// </summary> "Invalid season slug. Format: {showSlug}-s{seasonNumber}"
[JsonIgnore] );
public string? ShowSlug { private get; set; } ShowSlug = match.Groups["show"].Value;
SeasonNumber = int.Parse(match.Groups["season"].Value);
/// <summary> }
/// The ID of the Show containing this season.
/// </summary>
public Guid ShowId { get; set; }
/// <summary>
/// The show that contains this season.
/// </summary>
[LoadableRelation(nameof(ShowId))]
public Show? Show { get; set; }
/// <summary>
/// The number of this season. This can be set to 0 to indicate specials.
/// </summary>
public int SeasonNumber { get; set; }
/// <summary>
/// The title of this season.
/// </summary>
public string? Name { get; set; }
/// <summary>
/// A quick overview of this season.
/// </summary>
public string? Overview { get; set; }
/// <summary>
/// The starting air date of this season.
/// </summary>
public DateTime? StartDate { get; set; }
/// <inheritdoc />
public DateTime AddedDate { get; set; }
/// <summary>
/// The ending date of this season.
/// </summary>
public DateTime? EndDate { get; set; }
/// <inheritdoc />
public Image? Poster { get; set; }
/// <inheritdoc />
public Image? Thumbnail { get; set; }
/// <inheritdoc />
public Image? Logo { get; set; }
/// <inheritdoc />
public Dictionary<string, MetadataId> ExternalId { get; set; } = new();
/// <summary>
/// The list of episodes that this season contains.
/// </summary>
[JsonIgnore]
public ICollection<Episode>? Episodes { get; set; }
/// <summary>
/// The number of episodes in this season.
/// </summary>
[Projectable(UseMemberBody = nameof(_EpisodesCount), OnlyOnInclude = true)]
[NotMapped]
[LoadableRelation(
// language=PostgreSQL
Projected = """
(
select
count(*)::int
from
episodes as e
where
e.season_id = id) as episodes_count
"""
)]
public int EpisodesCount { get; set; }
private int _EpisodesCount => Episodes!.Count;
} }
/// <summary>
/// The slug of the Show that contain this episode. If this is not set, this season is ill-formed.
/// </summary>
[JsonIgnore]
public string? ShowSlug { private get; set; }
/// <summary>
/// The ID of the Show containing this season.
/// </summary>
public Guid ShowId { get; set; }
/// <summary>
/// The show that contains this season.
/// </summary>
[LoadableRelation(nameof(ShowId))]
public Show? Show { get; set; }
/// <summary>
/// The number of this season. This can be set to 0 to indicate specials.
/// </summary>
public int SeasonNumber { get; set; }
/// <summary>
/// The title of this season.
/// </summary>
public string? Name { get; set; }
/// <summary>
/// A quick overview of this season.
/// </summary>
public string? Overview { get; set; }
/// <summary>
/// The starting air date of this season.
/// </summary>
public DateTime? StartDate { get; set; }
/// <inheritdoc />
public DateTime AddedDate { get; set; }
/// <summary>
/// The ending date of this season.
/// </summary>
public DateTime? EndDate { get; set; }
/// <inheritdoc />
public Image? Poster { get; set; }
/// <inheritdoc />
public Image? Thumbnail { get; set; }
/// <inheritdoc />
public Image? Logo { get; set; }
/// <inheritdoc />
public Dictionary<string, MetadataId> ExternalId { get; set; } = new();
/// <summary>
/// The list of episodes that this season contains.
/// </summary>
[JsonIgnore]
public ICollection<Episode>? Episodes { get; set; }
/// <summary>
/// The number of episodes in this season.
/// </summary>
[Projectable(UseMemberBody = nameof(_EpisodesCount), OnlyOnInclude = true)]
[NotMapped]
[LoadableRelation(
// language=PostgreSQL
Projected = """
(
select
count(*)::int
from
episodes as e
where
e.season_id = id) as episodes_count
"""
)]
public int EpisodesCount { get; set; }
private int _EpisodesCount => Episodes!.Count;
} }

417
back/src/Kyoo.Abstractions/Models/Resources/Show.cs
View File

@ -27,254 +27,253 @@ using Kyoo.Abstractions.Controllers;
using Kyoo.Abstractions.Models.Attributes; using Kyoo.Abstractions.Models.Attributes;
using Kyoo.Utils; using Kyoo.Utils;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// A series or a movie.
/// </summary>
public class Show
: IQuery,
IResource,
IMetadata,
IOnMerge,
IThumbnails,
IAddedDate,
ILibraryItem,
IWatchlist
{ {
public static Sort DefaultSort => new Sort<Show>.By(x => x.Name);
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[MaxLength(256)]
public string Slug { get; set; }
/// <summary> /// <summary>
/// A series or a movie. /// The title of this show.
/// </summary> /// </summary>
public class Show public string Name { get; set; }
: IQuery,
IResource,
IMetadata,
IOnMerge,
IThumbnails,
IAddedDate,
ILibraryItem,
IWatchlist
{
public static Sort DefaultSort => new Sort<Show>.By(x => x.Name);
/// <inheritdoc /> /// <summary>
public Guid Id { get; set; } /// A catchphrase for this show.
/// </summary>
public string? Tagline { get; set; }
/// <inheritdoc /> /// <summary>
[MaxLength(256)] /// The list of alternative titles of this show.
public string Slug { get; set; } /// </summary>
public List<string> Aliases { get; set; } = new();
/// <summary> /// <summary>
/// The title of this show. /// The summary of this show.
/// </summary> /// </summary>
public string Name { get; set; } public string? Overview { get; set; }
/// <summary> /// <summary>
/// A catchphrase for this show. /// A list of tags that match this movie.
/// </summary> /// </summary>
public string? Tagline { get; set; } public List<string> Tags { get; set; } = new();
/// <summary> /// <summary>
/// The list of alternative titles of this show. /// The list of genres (themes) this show has.
/// </summary> /// </summary>
public List<string> Aliases { get; set; } = new(); public List<Genre> Genres { get; set; } = new();
/// <summary> /// <summary>
/// The summary of this show. /// Is this show airing, not aired yet or finished?
/// </summary> /// </summary>
public string? Overview { get; set; } public Status Status { get; set; }
/// <summary> /// <summary>
/// A list of tags that match this movie. /// How well this item is rated? (from 0 to 100).
/// </summary> /// </summary>
public List<string> Tags { get; set; } = new(); public int Rating { get; set; }
/// <summary> /// <summary>
/// The list of genres (themes) this show has. /// The date this show started airing. It can be null if this is unknown.
/// </summary> /// </summary>
public List<Genre> Genres { get; set; } = new(); public DateTime? StartAir { get; set; }
/// <summary> /// <summary>
/// Is this show airing, not aired yet or finished? /// The date this show finished airing.
/// </summary> /// It can also be null if this is unknown.
public Status Status { get; set; } /// </summary>
public DateTime? EndAir { get; set; }
/// <summary> /// <inheritdoc />
/// How well this item is rated? (from 0 to 100). public DateTime AddedDate { get; set; }
/// </summary>
public int Rating { get; set; }
/// <summary> /// <inheritdoc />
/// The date this show started airing. It can be null if this is unknown. public Image? Poster { get; set; }
/// </summary>
public DateTime? StartAir { get; set; }
/// <summary> /// <inheritdoc />
/// The date this show finished airing. public Image? Thumbnail { get; set; }
/// It can also be null if this is unknown.
/// </summary>
public DateTime? EndAir { get; set; }
/// <inheritdoc /> /// <inheritdoc />
public DateTime AddedDate { get; set; } public Image? Logo { get; set; }
/// <inheritdoc /> /// <summary>
public Image? Poster { get; set; } /// A video of a few minutes that tease the content.
/// </summary>
public string? Trailer { get; set; }
/// <inheritdoc /> [JsonIgnore]
public Image? Thumbnail { get; set; } [Column("start_air")]
public DateTime? AirDate => StartAir;
/// <inheritdoc /> /// <inheritdoc />
public Image? Logo { get; set; } public Dictionary<string, MetadataId> ExternalId { get; set; } = new();
/// <summary> /// <summary>
/// A video of a few minutes that tease the content. /// The ID of the Studio that made this show.
/// </summary> /// </summary>
public string? Trailer { get; set; } public Guid? StudioId { get; set; }
[JsonIgnore] /// <summary>
[Column("start_air")] /// The Studio that made this show.
public DateTime? AirDate => StartAir; /// </summary>
[LoadableRelation(nameof(StudioId))]
public Studio? Studio { get; set; }
/// <inheritdoc /> /// <summary>
public Dictionary<string, MetadataId> ExternalId { get; set; } = new(); /// The different seasons in this show. If this is a movie, this list is always null or empty.
/// </summary>
[JsonIgnore]
public ICollection<Season>? Seasons { get; set; }
/// <summary> /// <summary>
/// The ID of the Studio that made this show. /// The list of episodes in this show.
/// </summary> /// If this is a movie, there will be a unique episode (with the seasonNumber and episodeNumber set to null).
public Guid? StudioId { get; set; } /// Having an episode is necessary to store metadata and tracks.
/// </summary>
[JsonIgnore]
public ICollection<Episode>? Episodes { get; set; }
/// <summary> /// <summary>
/// The Studio that made this show. /// The list of collections that contains this show.
/// </summary> /// </summary>
[LoadableRelation(nameof(StudioId))] [JsonIgnore]
public Studio? Studio { get; set; } public ICollection<Collection>? Collections { get; set; }
/// <summary> /// <summary>
/// The different seasons in this show. If this is a movie, this list is always null or empty. /// The first episode of this show.
/// </summary> /// </summary>
[JsonIgnore] [Projectable(UseMemberBody = nameof(_FirstEpisode), OnlyOnInclude = true)]
public ICollection<Season>? Seasons { get; set; } [LoadableRelation(
// language=PostgreSQL
/// <summary> Sql = """
/// The list of episodes in this show. select
/// If this is a movie, there will be a unique episode (with the seasonNumber and episodeNumber set to null). fe.* -- Episode as fe
/// Having an episode is necessary to store metadata and tracks. from (
/// </summary>
[JsonIgnore]
public ICollection<Episode>? Episodes { get; set; }
/// <summary>
/// The list of collections that contains this show.
/// </summary>
[JsonIgnore]
public ICollection<Collection>? Collections { get; set; }
/// <summary>
/// The first episode of this show.
/// </summary>
[Projectable(UseMemberBody = nameof(_FirstEpisode), OnlyOnInclude = true)]
[LoadableRelation(
// language=PostgreSQL
Sql = """
select select
fe.* -- Episode as fe e.*,
from ( row_number() over (partition by e.show_id order by e.absolute_number, e.season_number, e.episode_number) as number
select from
e.*, episodes as e) as "fe"
row_number() over (partition by e.show_id order by e.absolute_number, e.season_number, e.episode_number) as number where
from fe.number <= 1
episodes as e) as "fe" """,
On = "show_id = \"this\".id"
)]
public Episode? FirstEpisode { get; set; }
private Episode? _FirstEpisode =>
Episodes!
.OrderBy(x => x.AbsoluteNumber)
.ThenBy(x => x.SeasonNumber)
.ThenBy(x => x.EpisodeNumber)
.FirstOrDefault();
/// <summary>
/// The number of episodes in this show.
/// </summary>
[Projectable(UseMemberBody = nameof(_EpisodesCount), OnlyOnInclude = true)]
[NotMapped]
[LoadableRelation(
// language=PostgreSQL
Projected = """
(
select
count(*)::int
from
episodes as e
where where
fe.number <= 1 e.show_id = "this".id) as episodes_count
""", """
On = "show_id = \"this\".id" )]
)] public int EpisodesCount { get; set; }
public Episode? FirstEpisode { get; set; }
private Episode? _FirstEpisode => private int _EpisodesCount => Episodes!.Count;
Episodes!
.OrderBy(x => x.AbsoluteNumber)
.ThenBy(x => x.SeasonNumber)
.ThenBy(x => x.EpisodeNumber)
.FirstOrDefault();
/// <summary> [JsonIgnore]
/// The number of episodes in this show. public ICollection<ShowWatchStatus>? Watched { get; set; }
/// </summary>
[Projectable(UseMemberBody = nameof(_EpisodesCount), OnlyOnInclude = true)]
[NotMapped]
[LoadableRelation(
// language=PostgreSQL
Projected = """
(
select
count(*)::int
from
episodes as e
where
e.show_id = "this".id) as episodes_count
"""
)]
public int EpisodesCount { get; set; }
private int _EpisodesCount => Episodes!.Count; /// <summary>
/// Metadata of what an user as started/planned to watch.
/// </summary>
[Projectable(UseMemberBody = nameof(_WatchStatus), OnlyOnInclude = true)]
[LoadableRelation(
Sql = "show_watch_status",
On = "show_id = \"this\".id and \"relation\".user_id = [current_user]"
)]
public ShowWatchStatus? WatchStatus { get; set; }
[JsonIgnore] // There is a global query filter to filter by user so we just need to do single.
public ICollection<ShowWatchStatus>? Watched { get; set; } private ShowWatchStatus? _WatchStatus => Watched!.FirstOrDefault();
/// <summary> /// <inheritdoc />
/// Metadata of what an user as started/planned to watch. public void OnMerge(object merged)
/// </summary> {
[Projectable(UseMemberBody = nameof(_WatchStatus), OnlyOnInclude = true)] if (Seasons != null)
[LoadableRelation(
Sql = "show_watch_status",
On = "show_id = \"this\".id and \"relation\".user_id = [current_user]"
)]
public ShowWatchStatus? WatchStatus { get; set; }
// There is a global query filter to filter by user so we just need to do single.
private ShowWatchStatus? _WatchStatus => Watched!.FirstOrDefault();
/// <inheritdoc />
public void OnMerge(object merged)
{ {
if (Seasons != null) foreach (Season season in Seasons)
{ season.Show = this;
foreach (Season season in Seasons)
season.Show = this;
}
if (Episodes != null)
{
foreach (Episode episode in Episodes)
episode.Show = this;
}
} }
public Show() { } if (Episodes != null)
[JsonConstructor]
public Show(string name)
{ {
if (name != null) foreach (Episode episode in Episodes)
{ episode.Show = this;
Slug = Utility.ToSlug(name);
Name = name;
}
} }
} }
/// <summary> public Show() { }
/// The enum containing show's status.
/// </summary> [JsonConstructor]
public enum Status public Show(string name)
{ {
/// <summary> if (name != null)
/// The status of the show is not known. {
/// </summary> Slug = Utility.ToSlug(name);
Unknown, Name = name;
}
/// <summary>
/// The show has finished airing.
/// </summary>
Finished,
/// <summary>
/// The show is still actively airing.
/// </summary>
Airing,
/// <summary>
/// This show has not aired yet but has been announced.
/// </summary>
Planned
} }
} }
/// <summary>
/// The enum containing show's status.
/// </summary>
public enum Status
{
/// <summary>
/// The status of the show is not known.
/// </summary>
Unknown,
/// <summary>
/// The show has finished airing.
/// </summary>
Finished,
/// <summary>
/// The show is still actively airing.
/// </summary>
Airing,
/// <summary>
/// This show has not aired yet but has been announced.
/// </summary>
Planned
}

95
back/src/Kyoo.Abstractions/Models/Resources/Studio.cs
View File

@ -23,59 +23,58 @@ using System.Text.Json.Serialization;
using Kyoo.Abstractions.Controllers; using Kyoo.Abstractions.Controllers;
using Kyoo.Utils; using Kyoo.Utils;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// A studio that make shows.
/// </summary>
public class Studio : IQuery, IResource, IMetadata
{ {
public static Sort DefaultSort => new Sort<Studio>.By(x => x.Name);
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[MaxLength(256)]
public string Slug { get; set; }
/// <summary> /// <summary>
/// A studio that make shows. /// The name of this studio.
/// </summary> /// </summary>
public class Studio : IQuery, IResource, IMetadata public string Name { get; set; }
/// <summary>
/// The list of shows that are made by this studio.
/// </summary>
[JsonIgnore]
public ICollection<Show>? Shows { get; set; }
/// <summary>
/// The list of movies that are made by this studio.
/// </summary>
[JsonIgnore]
public ICollection<Movie>? Movies { get; set; }
/// <inheritdoc />
public Dictionary<string, MetadataId> ExternalId { get; set; } = new();
/// <summary>
/// Create a new, empty, <see cref="Studio"/>.
/// </summary>
public Studio() { }
/// <summary>
/// Create a new <see cref="Studio"/> with a specific name, the slug is calculated automatically.
/// </summary>
/// <param name="name">The name of the studio.</param>
[JsonConstructor]
public Studio(string name)
{ {
public static Sort DefaultSort => new Sort<Studio>.By(x => x.Name); if (name != null)
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[MaxLength(256)]
public string Slug { get; set; }
/// <summary>
/// The name of this studio.
/// </summary>
public string Name { get; set; }
/// <summary>
/// The list of shows that are made by this studio.
/// </summary>
[JsonIgnore]
public ICollection<Show>? Shows { get; set; }
/// <summary>
/// The list of movies that are made by this studio.
/// </summary>
[JsonIgnore]
public ICollection<Movie>? Movies { get; set; }
/// <inheritdoc />
public Dictionary<string, MetadataId> ExternalId { get; set; } = new();
/// <summary>
/// Create a new, empty, <see cref="Studio"/>.
/// </summary>
public Studio() { }
/// <summary>
/// Create a new <see cref="Studio"/> with a specific name, the slug is calculated automatically.
/// </summary>
/// <param name="name">The name of the studio.</param>
[JsonConstructor]
public Studio(string name)
{ {
if (name != null) Slug = Utility.ToSlug(name);
{ Name = name;
Slug = Utility.ToSlug(name);
Name = name;
}
} }
} }
} }

167
back/src/Kyoo.Abstractions/Models/Resources/User.cs
View File

@ -23,95 +23,94 @@ using System.Text.Json.Serialization;
using Kyoo.Abstractions.Controllers; using Kyoo.Abstractions.Controllers;
using Kyoo.Utils; using Kyoo.Utils;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// A single user of the app.
/// </summary>
public class User : IQuery, IResource, IAddedDate
{ {
public static Sort DefaultSort => new Sort<User>.By(x => x.Username);
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[MaxLength(256)]
public string Slug { get; set; }
/// <summary> /// <summary>
/// A single user of the app. /// A username displayed to the user.
/// </summary> /// </summary>
public class User : IQuery, IResource, IAddedDate public string Username { get; set; }
/// <summary>
/// The user email address.
/// </summary>
public string Email { get; set; }
/// <summary>
/// The user password (hashed, it can't be read like that). The hashing format is implementation defined.
/// </summary>
[JsonIgnore]
public string? Password { get; set; }
/// <summary>
/// Does the user can sign-in with a password or only via oidc?
/// </summary>
public bool HasPassword => Password != null;
/// <summary>
/// The list of permissions of the user. The format of this is implementation dependent.
/// </summary>
public string[] Permissions { get; set; } = Array.Empty<string>();
/// <inheritdoc />
public DateTime AddedDate { get; set; }
/// <summary>
/// User settings
/// </summary>
public Dictionary<string, string> Settings { get; set; } = new();
/// <summary>
/// User accounts on other services.
/// </summary>
public Dictionary<string, ExternalToken> ExternalId { get; set; } = new();
public User() { }
[JsonConstructor]
public User(string username)
{ {
public static Sort DefaultSort => new Sort<User>.By(x => x.Username); if (username != null)
/// <inheritdoc />
public Guid Id { get; set; }
/// <inheritdoc />
[MaxLength(256)]
public string Slug { get; set; }
/// <summary>
/// A username displayed to the user.
/// </summary>
public string Username { get; set; }
/// <summary>
/// The user email address.
/// </summary>
public string Email { get; set; }
/// <summary>
/// The user password (hashed, it can't be read like that). The hashing format is implementation defined.
/// </summary>
[JsonIgnore]
public string? Password { get; set; }
/// <summary>
/// Does the user can sign-in with a password or only via oidc?
/// </summary>
public bool HasPassword => Password != null;
/// <summary>
/// The list of permissions of the user. The format of this is implementation dependent.
/// </summary>
public string[] Permissions { get; set; } = Array.Empty<string>();
/// <inheritdoc />
public DateTime AddedDate { get; set; }
/// <summary>
/// User settings
/// </summary>
public Dictionary<string, string> Settings { get; set; } = new();
/// <summary>
/// User accounts on other services.
/// </summary>
public Dictionary<string, ExternalToken> ExternalId { get; set; } = new();
public User() { }
[JsonConstructor]
public User(string username)
{ {
if (username != null) Slug = Utility.ToSlug(username);
{ Username = username;
Slug = Utility.ToSlug(username);
Username = username;
}
} }
} }
}
public class ExternalToken
{ public class ExternalToken
/// <summary> {
/// The id of this user on the external service. /// <summary>
/// </summary> /// The id of this user on the external service.
public string Id { get; set; } /// </summary>
public string Id { get; set; }
/// <summary>
/// The username on the external service. /// <summary>
/// </summary> /// The username on the external service.
public string Username { get; set; } /// </summary>
public string Username { get; set; }
/// <summary>
/// The link to the user profile on this website. Null if it does not exist. /// <summary>
/// </summary> /// The link to the user profile on this website. Null if it does not exist.
public string? ProfileUrl { get; set; } /// </summary>
public string? ProfileUrl { get; set; }
/// <summary>
/// A jwt token used to interact with the service. /// <summary>
/// Do not forget to refresh it when using it if necessary. /// A jwt token used to interact with the service.
/// </summary> /// Do not forget to refresh it when using it if necessary.
public JwtToken Token { get; set; } /// </summary>
} public JwtToken Token { get; set; }
} }

403
back/src/Kyoo.Abstractions/Models/Resources/WatchStatus.cs
View File

@ -20,214 +20,213 @@ using System;
using System.Text.Json.Serialization; using System.Text.Json.Serialization;
using Kyoo.Abstractions.Models.Attributes; using Kyoo.Abstractions.Models.Attributes;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// Has the user started watching, is it planned?
/// </summary>
public enum WatchStatus
{ {
/// <summary>
/// The user has already watched this.
/// </summary>
Completed,
/// <summary>
/// The user started watching this but has not finished.
/// </summary>
Watching,
/// <summary>
/// The user does not plan to continue watching.
/// </summary>
Droped,
/// <summary>
/// The user has not started watching this but plans to.
/// </summary>
Planned,
}
/// <summary>
/// Metadata of what an user as started/planned to watch.
/// </summary>
[SqlFirstColumn(nameof(UserId))]
public class MovieWatchStatus : IAddedDate
{
/// <summary>
/// The ID of the user that started watching this episode.
/// </summary>
public Guid UserId { get; set; }
/// <summary>
/// The user that started watching this episode.
/// </summary>
[JsonIgnore]
public User User { get; set; }
/// <summary>
/// The ID of the movie started.
/// </summary>
public Guid MovieId { get; set; }
/// <summary>
/// The <see cref="Movie"/> started.
/// </summary>
[JsonIgnore]
public Movie Movie { get; set; }
/// <inheritdoc/>
public DateTime AddedDate { get; set; }
/// <summary>
/// The date at which this item was played.
/// </summary>
public DateTime? PlayedDate { get; set; }
/// <summary> /// <summary>
/// Has the user started watching, is it planned? /// Has the user started watching, is it planned?
/// </summary> /// </summary>
public enum WatchStatus public WatchStatus Status { get; set; }
{
/// <summary>
/// The user has already watched this.
/// </summary>
Completed,
/// <summary>
/// The user started watching this but has not finished.
/// </summary>
Watching,
/// <summary>
/// The user does not plan to continue watching.
/// </summary>
Droped,
/// <summary>
/// The user has not started watching this but plans to.
/// </summary>
Planned,
}
/// <summary> /// <summary>
/// Metadata of what an user as started/planned to watch. /// Where the player has stopped watching the movie (in seconds).
/// </summary> /// </summary>
[SqlFirstColumn(nameof(UserId))] /// <remarks>
public class MovieWatchStatus : IAddedDate /// Null if the status is not Watching.
{ /// </remarks>
/// <summary> public int? WatchedTime { get; set; }
/// The ID of the user that started watching this episode.
/// </summary>
public Guid UserId { get; set; }
/// <summary> /// <summary>
/// The user that started watching this episode. /// Where the player has stopped watching the movie (in percentage between 0 and 100).
/// </summary> /// </summary>
[JsonIgnore] /// <remarks>
public User User { get; set; } /// Null if the status is not Watching.
/// </remarks>
/// <summary> public int? WatchedPercent { get; set; }
/// The ID of the movie started. }
/// </summary>
public Guid MovieId { get; set; } [SqlFirstColumn(nameof(UserId))]
public class EpisodeWatchStatus : IAddedDate
/// <summary> {
/// The <see cref="Movie"/> started. /// <summary>
/// </summary> /// The ID of the user that started watching this episode.
[JsonIgnore] /// </summary>
public Movie Movie { get; set; } public Guid UserId { get; set; }
/// <inheritdoc/> /// <summary>
public DateTime AddedDate { get; set; } /// The user that started watching this episode.
/// </summary>
/// <summary> [JsonIgnore]
/// The date at which this item was played. public User User { get; set; }
/// </summary>
public DateTime? PlayedDate { get; set; } /// <summary>
/// The ID of the episode started.
/// <summary> /// </summary>
/// Has the user started watching, is it planned? public Guid? EpisodeId { get; set; }
/// </summary>
public WatchStatus Status { get; set; } /// <summary>
/// The <see cref="Episode"/> started.
/// <summary> /// </summary>
/// Where the player has stopped watching the movie (in seconds). [JsonIgnore]
/// </summary> public Episode Episode { get; set; }
/// <remarks>
/// Null if the status is not Watching. /// <inheritdoc/>
/// </remarks> public DateTime AddedDate { get; set; }
public int? WatchedTime { get; set; }
/// <summary>
/// <summary> /// The date at which this item was played.
/// Where the player has stopped watching the movie (in percentage between 0 and 100). /// </summary>
/// </summary> public DateTime? PlayedDate { get; set; }
/// <remarks>
/// Null if the status is not Watching. /// <summary>
/// </remarks> /// Has the user started watching, is it planned?
public int? WatchedPercent { get; set; } /// </summary>
} public WatchStatus Status { get; set; }
[SqlFirstColumn(nameof(UserId))] /// <summary>
public class EpisodeWatchStatus : IAddedDate /// Where the player has stopped watching the episode (in seconds).
{ /// </summary>
/// <summary> /// <remarks>
/// The ID of the user that started watching this episode. /// Null if the status is not Watching.
/// </summary> /// </remarks>
public Guid UserId { get; set; } public int? WatchedTime { get; set; }
/// <summary> /// <summary>
/// The user that started watching this episode. /// Where the player has stopped watching the episode (in percentage between 0 and 100).
/// </summary> /// </summary>
[JsonIgnore] /// <remarks>
public User User { get; set; } /// Null if the status is not Watching or if the next episode is not started.
/// </remarks>
/// <summary> public int? WatchedPercent { get; set; }
/// The ID of the episode started. }
/// </summary>
public Guid? EpisodeId { get; set; } [SqlFirstColumn(nameof(UserId))]
public class ShowWatchStatus : IAddedDate
/// <summary> {
/// The <see cref="Episode"/> started. /// <summary>
/// </summary> /// The ID of the user that started watching this episode.
[JsonIgnore] /// </summary>
public Episode Episode { get; set; } public Guid UserId { get; set; }
/// <inheritdoc/> /// <summary>
public DateTime AddedDate { get; set; } /// The user that started watching this episode.
/// </summary>
/// <summary> [JsonIgnore]
/// The date at which this item was played. public User User { get; set; }
/// </summary>
public DateTime? PlayedDate { get; set; } /// <summary>
/// The ID of the show started.
/// <summary> /// </summary>
/// Has the user started watching, is it planned? public Guid ShowId { get; set; }
/// </summary>
public WatchStatus Status { get; set; } /// <summary>
/// The <see cref="Show"/> started.
/// <summary> /// </summary>
/// Where the player has stopped watching the episode (in seconds). [JsonIgnore]
/// </summary> public Show Show { get; set; }
/// <remarks>
/// Null if the status is not Watching. /// <inheritdoc/>
/// </remarks> public DateTime AddedDate { get; set; }
public int? WatchedTime { get; set; }
/// <summary>
/// <summary> /// The date at which this item was played.
/// Where the player has stopped watching the episode (in percentage between 0 and 100). /// </summary>
/// </summary> public DateTime? PlayedDate { get; set; }
/// <remarks>
/// Null if the status is not Watching or if the next episode is not started. /// <summary>
/// </remarks> /// Has the user started watching, is it planned?
public int? WatchedPercent { get; set; } /// </summary>
} public WatchStatus Status { get; set; }
[SqlFirstColumn(nameof(UserId))] /// <summary>
public class ShowWatchStatus : IAddedDate /// The number of episodes the user has not seen.
{ /// </summary>
/// <summary> public int UnseenEpisodesCount { get; set; }
/// The ID of the user that started watching this episode.
/// </summary> /// <summary>
public Guid UserId { get; set; } /// The ID of the episode started.
/// </summary>
/// <summary> public Guid? NextEpisodeId { get; set; }
/// The user that started watching this episode.
/// </summary> /// <summary>
[JsonIgnore] /// The next <see cref="Episode"/> to watch.
public User User { get; set; } /// </summary>
public Episode? NextEpisode { get; set; }
/// <summary>
/// The ID of the show started. /// <summary>
/// </summary> /// Where the player has stopped watching the episode (in seconds).
public Guid ShowId { get; set; } /// </summary>
/// <remarks>
/// <summary> /// Null if the status is not Watching or if the next episode is not started.
/// The <see cref="Show"/> started. /// </remarks>
/// </summary> public int? WatchedTime { get; set; }
[JsonIgnore]
public Show Show { get; set; } /// <summary>
/// Where the player has stopped watching the episode (in percentage between 0 and 100).
/// <inheritdoc/> /// </summary>
public DateTime AddedDate { get; set; } /// <remarks>
/// Null if the status is not Watching or if the next episode is not started.
/// <summary> /// </remarks>
/// The date at which this item was played. public int? WatchedPercent { get; set; }
/// </summary>
public DateTime? PlayedDate { get; set; }
/// <summary>
/// Has the user started watching, is it planned?
/// </summary>
public WatchStatus Status { get; set; }
/// <summary>
/// The number of episodes the user has not seen.
/// </summary>
public int UnseenEpisodesCount { get; set; }
/// <summary>
/// The ID of the episode started.
/// </summary>
public Guid? NextEpisodeId { get; set; }
/// <summary>
/// The next <see cref="Episode"/> to watch.
/// </summary>
public Episode? NextEpisode { get; set; }
/// <summary>
/// Where the player has stopped watching the episode (in seconds).
/// </summary>
/// <remarks>
/// Null if the status is not Watching or if the next episode is not started.
/// </remarks>
public int? WatchedTime { get; set; }
/// <summary>
/// Where the player has stopped watching the episode (in percentage between 0 and 100).
/// </summary>
/// <remarks>
/// Null if the status is not Watching or if the next episode is not started.
/// </remarks>
public int? WatchedPercent { get; set; }
}
} }

53
back/src/Kyoo.Abstractions/Models/SearchPage.cs
View File

@ -18,37 +18,36 @@
using System.Collections.Generic; using System.Collections.Generic;
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// Results of a search request.
/// </summary>
/// <typeparam name="T">The search item's type.</typeparam>
public class SearchPage<T> : Page<T>
where T : IResource
{ {
/// <summary> public SearchPage(
/// Results of a search request. SearchResult result,
/// </summary> string @this,
/// <typeparam name="T">The search item's type.</typeparam> string? previous,
public class SearchPage<T> : Page<T> string? next,
where T : IResource string first
)
: base(result.Items, @this, previous, next, first)
{ {
public SearchPage( Query = result.Query;
SearchResult result, }
string @this,
string? previous,
string? next,
string first
)
: base(result.Items, @this, previous, next, first)
{
Query = result.Query;
}
/// <summary> /// <summary>
/// The query of the search request. /// The query of the search request.
/// </summary> /// </summary>
public string? Query { get; init; } public string? Query { get; init; }
public class SearchResult public class SearchResult
{ {
public string? Query { get; set; } public string? Query { get; set; }
public ICollection<T> Items { get; set; } public ICollection<T> Items { get; set; }
}
} }
} }

57
back/src/Kyoo.Abstractions/Models/Utils/Claims.cs
View File

@ -16,41 +16,40 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with Kyoo. If not, see <https://www.gnu.org/licenses/>. // along with Kyoo. If not, see <https://www.gnu.org/licenses/>.
namespace Kyoo.Authentication.Models namespace Kyoo.Authentication.Models;
/// <summary>
/// List of well known claims of kyoo
/// </summary>
public static class Claims
{ {
/// <summary> /// <summary>
/// List of well known claims of kyoo /// The id of the user
/// </summary> /// </summary>
public static class Claims public static string Id => "id";
{
/// <summary>
/// The id of the user
/// </summary>
public static string Id => "id";
/// <summary> /// <summary>
/// The name of the user /// The name of the user
/// </summary> /// </summary>
public static string Name => "name"; public static string Name => "name";
/// <summary> /// <summary>
/// The email of the user. /// The email of the user.
/// </summary> /// </summary>
public static string Email => "email"; public static string Email => "email";
/// <summary> /// <summary>
/// The list of permissions that the user has. /// The list of permissions that the user has.
/// </summary> /// </summary>
public static string Permissions => "permissions"; public static string Permissions => "permissions";
/// <summary> /// <summary>
/// The type of the token (either "access" or "refresh"). /// The type of the token (either "access" or "refresh").
/// </summary> /// </summary>
public static string Type => "type"; public static string Type => "type";
/// <summary> /// <summary>
/// A guid used to identify a specific refresh token. This is only useful for the server to revokate tokens. /// A guid used to identify a specific refresh token. This is only useful for the server to revokate tokens.
/// </summary> /// </summary>
public static string Guid => "guid"; public static string Guid => "guid";
}
} }

61
back/src/Kyoo.Abstractions/Models/Utils/Constants.cs
View File

@ -18,43 +18,42 @@
using Kyoo.Abstractions.Models.Attributes; using Kyoo.Abstractions.Models.Attributes;
namespace Kyoo.Abstractions.Models.Utils namespace Kyoo.Abstractions.Models.Utils;
/// <summary>
/// A class containing constant numbers.
/// </summary>
public static class Constants
{ {
/// <summary> /// <summary>
/// A class containing constant numbers. /// A property to use on a Microsoft.AspNet.MVC.Route.Order property to mark it as an alternative route
/// that won't be included on the swagger.
/// </summary> /// </summary>
public static class Constants public const int AlternativeRoute = 1;
{
/// <summary>
/// A property to use on a Microsoft.AspNet.MVC.Route.Order property to mark it as an alternative route
/// that won't be included on the swagger.
/// </summary>
public const int AlternativeRoute = 1;
/// <summary> /// <summary>
/// A group name for <see cref="ApiDefinitionAttribute"/>. It should be used for endpoints used by users. /// A group name for <see cref="ApiDefinitionAttribute"/>. It should be used for endpoints used by users.
/// </summary> /// </summary>
public const string UsersGroup = "0:Users"; public const string UsersGroup = "0:Users";
/// <summary> /// <summary>
/// A group name for <see cref="ApiDefinitionAttribute"/>. It should be used for main resources of kyoo. /// A group name for <see cref="ApiDefinitionAttribute"/>. It should be used for main resources of kyoo.
/// </summary> /// </summary>
public const string ResourcesGroup = "1:Resources"; public const string ResourcesGroup = "1:Resources";
/// <summary> /// <summary>
/// A group name for <see cref="ApiDefinitionAttribute"/>. /// A group name for <see cref="ApiDefinitionAttribute"/>.
/// It should be used for sub resources of kyoo that help define the main resources. /// It should be used for sub resources of kyoo that help define the main resources.
/// </summary> /// </summary>
public const string MetadataGroup = "2:Metadata"; public const string MetadataGroup = "2:Metadata";
/// <summary> /// <summary>
/// A group name for <see cref="ApiDefinitionAttribute"/>. It should be used for endpoints useful for playback. /// A group name for <see cref="ApiDefinitionAttribute"/>. It should be used for endpoints useful for playback.
/// </summary> /// </summary>
public const string WatchGroup = "3:Watch"; public const string WatchGroup = "3:Watch";
/// <summary> /// <summary>
/// A group name for <see cref="ApiDefinitionAttribute"/>. It should be used for endpoints used by admins. /// A group name for <see cref="ApiDefinitionAttribute"/>. It should be used for endpoints used by admins.
/// </summary> /// </summary>
public const string AdminGroup = "4:Admin"; public const string AdminGroup = "4:Admin";
}
} }

413
back/src/Kyoo.Abstractions/Models/Utils/Identifier.cs
View File

@ -24,225 +24,222 @@ using System.Linq;
using System.Linq.Expressions; using System.Linq.Expressions;
using System.Reflection; using System.Reflection;
namespace Kyoo.Abstractions.Models.Utils namespace Kyoo.Abstractions.Models.Utils;
/// <summary>
/// A class that represent a resource. It is made to be used as a parameter in a query and not used somewhere else
/// on the application.
/// This class allow routes to be used via ether IDs or Slugs, this is suitable for every <see cref="IResource"/>.
/// </summary>
[TypeConverter(typeof(IdentifierConvertor))]
public class Identifier
{ {
/// <summary> /// <summary>
/// A class that represent a resource. It is made to be used as a parameter in a query and not used somewhere else /// The ID of the resource or null if the slug is specified.
/// on the application.
/// This class allow routes to be used via ether IDs or Slugs, this is suitable for every <see cref="IResource"/>.
/// </summary> /// </summary>
[TypeConverter(typeof(IdentifierConvertor))] private readonly Guid? _id;
public class Identifier
/// <summary>
/// The slug of the resource or null if the id is specified.
/// </summary>
private readonly string? _slug;
/// <summary>
/// Create a new <see cref="Identifier"/> for the given id.
/// </summary>
/// <param name="id">The id of the resource.</param>
public Identifier(Guid id)
{ {
/// <summary> _id = id;
/// The ID of the resource or null if the slug is specified. }
/// </summary>
private readonly Guid? _id;
/// <summary> /// <summary>
/// The slug of the resource or null if the id is specified. /// Create a new <see cref="Identifier"/> for the given slug.
/// </summary> /// </summary>
private readonly string? _slug; /// <param name="slug">The slug of the resource.</param>
public Identifier(string slug)
{
_slug = slug;
}
/// <summary> /// <summary>
/// Create a new <see cref="Identifier"/> for the given id. /// Pattern match out of the identifier to a resource.
/// </summary> /// </summary>
/// <param name="id">The id of the resource.</param> /// <param name="idFunc">The function to match the ID to a type <typeparamref name="T"/>.</param>
public Identifier(Guid id) /// <param name="slugFunc">The function to match the slug to a type <typeparamref name="T"/>.</param>
/// <typeparam name="T">The return type that will be converted to from an ID or a slug.</typeparam>
/// <returns>
/// The result of the <paramref name="idFunc"/> or <paramref name="slugFunc"/> depending on the pattern.
/// </returns>
/// <example>
/// Example usage:
/// <code lang="csharp">
/// T ret = await identifier.Match(
/// id => _repository.GetOrDefault(id),
/// slug => _repository.GetOrDefault(slug)
/// );
/// </code>
/// </example>
public T Match<T>(Func<Guid, T> idFunc, Func<string, T> slugFunc)
{
return _id.HasValue ? idFunc(_id.Value) : slugFunc(_slug!);
}
/// <summary>
/// Match a custom type to an identifier. This can be used for wrapped resources (see example for more details).
/// </summary>
/// <param name="idGetter">An expression to retrieve an ID from the type <typeparamref name="T"/>.</param>
/// <param name="slugGetter">An expression to retrieve a slug from the type <typeparamref name="T"/>.</param>
/// <typeparam name="T">The type to match against this identifier.</typeparam>
/// <returns>An expression to match the type <typeparamref name="T"/> to this identifier.</returns>
/// <example>
/// <code lang="csharp">
/// identifier.Matcher&lt;Season&gt;(x => x.ShowID, x => x.Show.Slug)
/// </code>
/// </example>
public Filter<T> Matcher<T>(
Expression<Func<T, Guid>> idGetter,
Expression<Func<T, string>> slugGetter
)
{
ConstantExpression self = Expression.Constant(_id.HasValue ? _id.Value : _slug);
BinaryExpression equal = Expression.Equal(
_id.HasValue ? idGetter.Body : slugGetter.Body,
self
);
ICollection<ParameterExpression> parameters = _id.HasValue
? idGetter.Parameters
: slugGetter.Parameters;
Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(equal, parameters);
return new Filter<T>.Lambda(lambda);
}
/// <summary>
/// A matcher overload for nullable IDs. See
/// <see cref="Matcher{T}(Expression{Func{T,Guid}},Expression{Func{T,string}})"/>
/// for more details.
/// </summary>
/// <param name="idGetter">An expression to retrieve an ID from the type <typeparamref name="T"/>.</param>
/// <param name="slugGetter">An expression to retrieve a slug from the type <typeparamref name="T"/>.</param>
/// <typeparam name="T">The type to match against this identifier.</typeparam>
/// <returns>An expression to match the type <typeparamref name="T"/> to this identifier.</returns>
public Filter<T> Matcher<T>(
Expression<Func<T, Guid?>> idGetter,
Expression<Func<T, string>> slugGetter
)
{
ConstantExpression self = Expression.Constant(_id.HasValue ? _id.Value : _slug);
BinaryExpression equal = Expression.Equal(
_id.HasValue ? idGetter.Body : slugGetter.Body,
self
);
ICollection<ParameterExpression> parameters = _id.HasValue
? idGetter.Parameters
: slugGetter.Parameters;
Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(equal, parameters);
return new Filter<T>.Lambda(lambda);
}
/// <summary>
/// Return true if this <see cref="Identifier"/> match a resource.
/// </summary>
/// <param name="resource">The resource to match</param>
/// <returns>
/// <c>true</c> if the <paramref name="resource"/> match this identifier, <c>false</c> otherwise.
/// </returns>
public bool IsSame(IResource resource)
{
return Match(id => resource.Id == id, slug => resource.Slug == slug);
}
/// <summary>
/// Return a filter to get this <see cref="Identifier"/> match a given resource.
/// </summary>
/// <typeparam name="T">The type of resource to match against.</typeparam>
/// <returns>
/// <c>true</c> if the given resource match this identifier, <c>false</c> otherwise.
/// </returns>
public Filter<T> IsSame<T>()
where T : IResource
{
return _id.HasValue ? new Filter<T>.Eq("Id", _id.Value) : new Filter<T>.Eq("Slug", _slug!);
}
public bool Is(Guid uid)
{
return _id.HasValue && _id.Value == uid;
}
public bool Is(string slug)
{
return !_id.HasValue && _slug == slug;
}
private Expression<Func<T, bool>> _IsSameExpression<T>()
where T : IResource
{
return _id.HasValue ? x => x.Id == _id.Value : x => x.Slug == _slug;
}
/// <summary>
/// Return an expression that return true if this <see cref="Identifier"/> is containing in a collection.
/// </summary>
/// <param name="listGetter">An expression to retrieve the list to check.</param>
/// <typeparam name="T">The type that contain the list to check.</typeparam>
/// <typeparam name="T2">The type of resource to check this identifier against.</typeparam>
/// <returns>An expression to check if this <see cref="Identifier"/> is contained.</returns>
public Filter<T> IsContainedIn<T, T2>(Expression<Func<T, IEnumerable<T2>?>> listGetter)
where T2 : IResource
{
MethodInfo method = typeof(Enumerable)
.GetMethods()
.Where(x => x.Name == nameof(Enumerable.Any))
.FirstOrDefault(x => x.GetParameters().Length == 2)!
.MakeGenericMethod(typeof(T2));
MethodCallExpression call = Expression.Call(
null,
method,
listGetter.Body,
_IsSameExpression<T2>()
);
Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(
call,
listGetter.Parameters
);
return new Filter<T>.Lambda(lambda);
}
/// <inheritdoc />
public override string ToString()
{
return _id.HasValue ? _id.Value.ToString() : _slug!;
}
/// <summary>
/// A custom <see cref="TypeConverter"/> used to convert int or strings to an <see cref="Identifier"/>.
/// </summary>
public class IdentifierConvertor : TypeConverter
{
/// <inheritdoc />
public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType)
{ {
_id = id; if (sourceType == typeof(Guid) || sourceType == typeof(string))
} return true;
return base.CanConvertFrom(context, sourceType);
/// <summary>
/// Create a new <see cref="Identifier"/> for the given slug.
/// </summary>
/// <param name="slug">The slug of the resource.</param>
public Identifier(string slug)
{
_slug = slug;
}
/// <summary>
/// Pattern match out of the identifier to a resource.
/// </summary>
/// <param name="idFunc">The function to match the ID to a type <typeparamref name="T"/>.</param>
/// <param name="slugFunc">The function to match the slug to a type <typeparamref name="T"/>.</param>
/// <typeparam name="T">The return type that will be converted to from an ID or a slug.</typeparam>
/// <returns>
/// The result of the <paramref name="idFunc"/> or <paramref name="slugFunc"/> depending on the pattern.
/// </returns>
/// <example>
/// Example usage:
/// <code lang="csharp">
/// T ret = await identifier.Match(
/// id => _repository.GetOrDefault(id),
/// slug => _repository.GetOrDefault(slug)
/// );
/// </code>
/// </example>
public T Match<T>(Func<Guid, T> idFunc, Func<string, T> slugFunc)
{
return _id.HasValue ? idFunc(_id.Value) : slugFunc(_slug!);
}
/// <summary>
/// Match a custom type to an identifier. This can be used for wrapped resources (see example for more details).
/// </summary>
/// <param name="idGetter">An expression to retrieve an ID from the type <typeparamref name="T"/>.</param>
/// <param name="slugGetter">An expression to retrieve a slug from the type <typeparamref name="T"/>.</param>
/// <typeparam name="T">The type to match against this identifier.</typeparam>
/// <returns>An expression to match the type <typeparamref name="T"/> to this identifier.</returns>
/// <example>
/// <code lang="csharp">
/// identifier.Matcher&lt;Season&gt;(x => x.ShowID, x => x.Show.Slug)
/// </code>
/// </example>
public Filter<T> Matcher<T>(
Expression<Func<T, Guid>> idGetter,
Expression<Func<T, string>> slugGetter
)
{
ConstantExpression self = Expression.Constant(_id.HasValue ? _id.Value : _slug);
BinaryExpression equal = Expression.Equal(
_id.HasValue ? idGetter.Body : slugGetter.Body,
self
);
ICollection<ParameterExpression> parameters = _id.HasValue
? idGetter.Parameters
: slugGetter.Parameters;
Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(equal, parameters);
return new Filter<T>.Lambda(lambda);
}
/// <summary>
/// A matcher overload for nullable IDs. See
/// <see cref="Matcher{T}(Expression{Func{T,Guid}},Expression{Func{T,string}})"/>
/// for more details.
/// </summary>
/// <param name="idGetter">An expression to retrieve an ID from the type <typeparamref name="T"/>.</param>
/// <param name="slugGetter">An expression to retrieve a slug from the type <typeparamref name="T"/>.</param>
/// <typeparam name="T">The type to match against this identifier.</typeparam>
/// <returns>An expression to match the type <typeparamref name="T"/> to this identifier.</returns>
public Filter<T> Matcher<T>(
Expression<Func<T, Guid?>> idGetter,
Expression<Func<T, string>> slugGetter
)
{
ConstantExpression self = Expression.Constant(_id.HasValue ? _id.Value : _slug);
BinaryExpression equal = Expression.Equal(
_id.HasValue ? idGetter.Body : slugGetter.Body,
self
);
ICollection<ParameterExpression> parameters = _id.HasValue
? idGetter.Parameters
: slugGetter.Parameters;
Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(equal, parameters);
return new Filter<T>.Lambda(lambda);
}
/// <summary>
/// Return true if this <see cref="Identifier"/> match a resource.
/// </summary>
/// <param name="resource">The resource to match</param>
/// <returns>
/// <c>true</c> if the <paramref name="resource"/> match this identifier, <c>false</c> otherwise.
/// </returns>
public bool IsSame(IResource resource)
{
return Match(id => resource.Id == id, slug => resource.Slug == slug);
}
/// <summary>
/// Return a filter to get this <see cref="Identifier"/> match a given resource.
/// </summary>
/// <typeparam name="T">The type of resource to match against.</typeparam>
/// <returns>
/// <c>true</c> if the given resource match this identifier, <c>false</c> otherwise.
/// </returns>
public Filter<T> IsSame<T>()
where T : IResource
{
return _id.HasValue
? new Filter<T>.Eq("Id", _id.Value)
: new Filter<T>.Eq("Slug", _slug!);
}
public bool Is(Guid uid)
{
return _id.HasValue && _id.Value == uid;
}
public bool Is(string slug)
{
return !_id.HasValue && _slug == slug;
}
private Expression<Func<T, bool>> _IsSameExpression<T>()
where T : IResource
{
return _id.HasValue ? x => x.Id == _id.Value : x => x.Slug == _slug;
}
/// <summary>
/// Return an expression that return true if this <see cref="Identifier"/> is containing in a collection.
/// </summary>
/// <param name="listGetter">An expression to retrieve the list to check.</param>
/// <typeparam name="T">The type that contain the list to check.</typeparam>
/// <typeparam name="T2">The type of resource to check this identifier against.</typeparam>
/// <returns>An expression to check if this <see cref="Identifier"/> is contained.</returns>
public Filter<T> IsContainedIn<T, T2>(Expression<Func<T, IEnumerable<T2>?>> listGetter)
where T2 : IResource
{
MethodInfo method = typeof(Enumerable)
.GetMethods()
.Where(x => x.Name == nameof(Enumerable.Any))
.FirstOrDefault(x => x.GetParameters().Length == 2)!
.MakeGenericMethod(typeof(T2));
MethodCallExpression call = Expression.Call(
null,
method,
listGetter.Body,
_IsSameExpression<T2>()
);
Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(
call,
listGetter.Parameters
);
return new Filter<T>.Lambda(lambda);
} }
/// <inheritdoc /> /// <inheritdoc />
public override string ToString() public override object ConvertFrom(
ITypeDescriptorContext? context,
CultureInfo? culture,
object value
)
{ {
return _id.HasValue ? _id.Value.ToString() : _slug!; if (value is Guid id)
} return new Identifier(id);
if (value is not string slug)
/// <summary> return base.ConvertFrom(context, culture, value)!;
/// A custom <see cref="TypeConverter"/> used to convert int or strings to an <see cref="Identifier"/>. return Guid.TryParse(slug, out id) ? new Identifier(id) : new Identifier(slug);
/// </summary>
public class IdentifierConvertor : TypeConverter
{
/// <inheritdoc />
public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType)
{
if (sourceType == typeof(Guid) || sourceType == typeof(string))
return true;
return base.CanConvertFrom(context, sourceType);
}
/// <inheritdoc />
public override object ConvertFrom(
ITypeDescriptorContext? context,
CultureInfo? culture,
object value
)
{
if (value is Guid id)
return new Identifier(id);
if (value is not string slug)
return base.ConvertFrom(context, culture, value)!;
return Guid.TryParse(slug, out id) ? new Identifier(id) : new Identifier(slug);
}
} }
} }
} }

93
back/src/Kyoo.Abstractions/Models/Utils/Pagination.cs
View File

@ -18,56 +18,55 @@
using System; using System;
namespace Kyoo.Abstractions.Controllers namespace Kyoo.Abstractions.Controllers;
/// <summary>
/// Information about the pagination. How many items should be displayed and where to start.
/// </summary>
public class Pagination
{ {
/// <summary> /// <summary>
/// Information about the pagination. How many items should be displayed and where to start. /// The count of items to return.
/// </summary> /// </summary>
public class Pagination public int Limit { get; set; }
/// <summary>
/// Where to start? Using the given sort.
/// </summary>
public Guid? AfterID { get; set; }
/// <summary>
/// Should the previous page be returned instead of the next?
/// </summary>
public bool Reverse { get; set; }
/// <summary>
/// Create a new <see cref="Pagination"/> with default values.
/// </summary>
public Pagination()
{ {
/// <summary> Limit = 50;
/// The count of items to return. AfterID = null;
/// </summary> Reverse = false;
public int Limit { get; set; }
/// <summary>
/// Where to start? Using the given sort.
/// </summary>
public Guid? AfterID { get; set; }
/// <summary>
/// Should the previous page be returned instead of the next?
/// </summary>
public bool Reverse { get; set; }
/// <summary>
/// Create a new <see cref="Pagination"/> with default values.
/// </summary>
public Pagination()
{
Limit = 50;
AfterID = null;
Reverse = false;
}
/// <summary>
/// Create a new <see cref="Pagination"/> instance.
/// </summary>
/// <param name="count">Set the <see cref="Limit"/> value</param>
/// <param name="afterID">Set the <see cref="AfterID"/> value. If not specified, it will start from the start</param>
/// <param name="reverse">Should the previous page be returned instead of the next?</param>
public Pagination(int count, Guid? afterID = null, bool reverse = false)
{
Limit = count;
AfterID = afterID;
Reverse = reverse;
}
/// <summary>
/// Implicitly create a new pagination from a limit number.
/// </summary>
/// <param name="limit">Set the <see cref="Limit"/> value</param>
/// <returns>A new <see cref="Pagination"/> instance</returns>
public static implicit operator Pagination(int limit) => new(limit);
} }
/// <summary>
/// Create a new <see cref="Pagination"/> instance.
/// </summary>
/// <param name="count">Set the <see cref="Limit"/> value</param>
/// <param name="afterID">Set the <see cref="AfterID"/> value. If not specified, it will start from the start</param>
/// <param name="reverse">Should the previous page be returned instead of the next?</param>
public Pagination(int count, Guid? afterID = null, bool reverse = false)
{
Limit = count;
AfterID = afterID;
Reverse = reverse;
}
/// <summary>
/// Implicitly create a new pagination from a limit number.
/// </summary>
/// <param name="limit">Set the <see cref="Limit"/> value</param>
/// <returns>A new <see cref="Pagination"/> instance</returns>
public static implicit operator Pagination(int limit) => new(limit);
} }

58
back/src/Kyoo.Abstractions/Models/Utils/RequestError.cs
View File

@ -19,42 +19,38 @@
using System; using System;
using System.Linq; using System.Linq;
namespace Kyoo.Abstractions.Models.Utils namespace Kyoo.Abstractions.Models.Utils;
/// <summary>
/// The list of errors that where made in the request.
/// </summary>
public class RequestError
{ {
/// <summary> /// <summary>
/// The list of errors that where made in the request. /// The list of errors that where made in the request.
/// </summary> /// </summary>
public class RequestError /// <example><c>["InvalidFilter: no field 'startYear' on a collection"]</c></example>
public string[] Errors { get; set; }
/// <summary>
/// Create a new <see cref="RequestError"/> with one error.
/// </summary>
/// <param name="error">The error to specify in the response.</param>
public RequestError(string error)
{ {
/// <summary> if (error == null)
/// The list of errors that where made in the request. throw new ArgumentNullException(nameof(error));
/// </summary> Errors = new[] { error };
/// <example><c>["InvalidFilter: no field 'startYear' on a collection"]</c></example> }
public string[] Errors { get; set; }
/// <summary> /// <summary>
/// Create a new <see cref="RequestError"/> with one error. /// Create a new <see cref="RequestError"/> with multiple errors.
/// </summary> /// </summary>
/// <param name="error">The error to specify in the response.</param> /// <param name="errors">The errors to specify in the response.</param>
public RequestError(string error) public RequestError(string[] errors)
{ {
if (error == null) if (errors == null || !errors.Any())
throw new ArgumentNullException(nameof(error)); throw new ArgumentException("Errors must be non null and not empty", nameof(errors));
Errors = new[] { error }; Errors = errors;
}
/// <summary>
/// Create a new <see cref="RequestError"/> with multiple errors.
/// </summary>
/// <param name="errors">The errors to specify in the response.</param>
public RequestError(string[] errors)
{
if (errors == null || !errors.Any())
throw new ArgumentException(
"Errors must be non null and not empty",
nameof(errors)
);
Errors = errors;
}
} }
} }

25
back/src/Kyoo.Abstractions/Models/Utils/SearchPagination.cs
View File

@ -16,21 +16,20 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with Kyoo. If not, see <https://www.gnu.org/licenses/>. // along with Kyoo. If not, see <https://www.gnu.org/licenses/>.
namespace Kyoo.Abstractions.Controllers namespace Kyoo.Abstractions.Controllers;
/// <summary>
/// Information about the pagination. How many items should be displayed and where to start.
/// </summary>
public class SearchPagination
{ {
/// <summary> /// <summary>
/// Information about the pagination. How many items should be displayed and where to start. /// The count of items to return.
/// </summary> /// </summary>
public class SearchPagination public int Limit { get; set; } = 50;
{
/// <summary>
/// The count of items to return.
/// </summary>
public int Limit { get; set; } = 50;
/// <summary> /// <summary>
/// Where to start? How many items to skip? /// Where to start? How many items to skip?
/// </summary> /// </summary>
public int? Skip { get; set; } public int? Skip { get; set; }
}
} }

188
back/src/Kyoo.Abstractions/Models/Utils/Sort.cs
View File

@ -25,111 +25,109 @@ using Kyoo.Abstractions.Models;
using Kyoo.Abstractions.Models.Attributes; using Kyoo.Abstractions.Models.Attributes;
using Kyoo.Utils; using Kyoo.Utils;
namespace Kyoo.Abstractions.Controllers namespace Kyoo.Abstractions.Controllers;
{
public record Sort;
public record Sort;
/// <summary>
/// Information about how a query should be sorted. What factor should decide the sort and in which order.
/// </summary>
/// <typeparam name="T">For witch type this sort applies</typeparam>
public record Sort<T> : Sort
where T : IQuery
{
/// <summary> /// <summary>
/// Information about how a query should be sorted. What factor should decide the sort and in which order. /// Sort by a specific key
/// </summary> /// </summary>
/// <typeparam name="T">For witch type this sort applies</typeparam> /// <param name="Key">The sort keys. This members will be used to sort the results.</param>
public record Sort<T> : Sort /// <param name="Desendant">
where T : IQuery /// If this is set to true, items will be sorted in descend order else, they will be sorted in ascendant order.
/// </param>
public record By(string Key, bool Desendant = false) : Sort<T>
{ {
/// <summary> /// <summary>
/// Sort by a specific key /// Sort by a specific key
/// </summary> /// </summary>
/// <param name="Key">The sort keys. This members will be used to sort the results.</param> /// <param name="key">The sort keys. This members will be used to sort the results.</param>
/// <param name="Desendant"> /// <param name="desendant">
/// If this is set to true, items will be sorted in descend order else, they will be sorted in ascendant order. /// If this is set to true, items will be sorted in descend order else, they will be sorted in ascendant order.
/// </param> /// </param>
public record By(string Key, bool Desendant = false) : Sort<T> public By(Expression<Func<T, object?>> key, bool desendant = false)
: this(Utility.GetPropertyName(key), desendant) { }
}
/// <summary>
/// Sort by multiple keys.
/// </summary>
/// <param name="List">The list of keys to sort by.</param>
public record Conglomerate(params Sort<T>[] List) : Sort<T>;
/// <summary>Sort randomly items</summary>
public record Random(uint Seed) : Sort<T>
{
public Random()
: this(0)
{ {
/// <summary> uint seed = BitConverter.ToUInt32(
/// Sort by a specific key BitConverter.GetBytes(new System.Random().Next(int.MinValue, int.MaxValue)),
/// </summary> 0
/// <param name="key">The sort keys. This members will be used to sort the results.</param> );
/// <param name="desendant"> Seed = seed;
/// If this is set to true, items will be sorted in descend order else, they will be sorted in ascendant order.
/// </param>
public By(Expression<Func<T, object?>> key, bool desendant = false)
: this(Utility.GetPropertyName(key), desendant) { }
}
/// <summary>
/// Sort by multiple keys.
/// </summary>
/// <param name="List">The list of keys to sort by.</param>
public record Conglomerate(params Sort<T>[] List) : Sort<T>;
/// <summary>Sort randomly items</summary>
public record Random(uint Seed) : Sort<T>
{
public Random()
: this(0)
{
uint seed = BitConverter.ToUInt32(
BitConverter.GetBytes(new System.Random().Next(int.MinValue, int.MaxValue)),
0
);
Seed = seed;
}
}
/// <summary>The default sort method for the given type.</summary>
public record Default : Sort<T>
{
public void Deconstruct(out Sort<T> value)
{
value = (Sort<T>)T.DefaultSort;
}
}
/// <summary>
/// Create a new <see cref="Sort{T}"/> instance from a key's name (case insensitive).
/// </summary>
/// <param name="sortBy">A key name with an optional order specifier. Format: "key:asc", "key:desc" or "key".</param>
/// <param name="seed">The random seed.</param>
/// <exception cref="ArgumentException">An invalid key or sort specifier as been given.</exception>
/// <returns>A <see cref="Sort{T}"/> for the given string</returns>
public static Sort<T> From(string? sortBy, uint seed)
{
if (string.IsNullOrEmpty(sortBy) || sortBy == "default")
return new Default();
if (sortBy == "random")
return new Random(seed);
if (sortBy.Contains(','))
return new Conglomerate(sortBy.Split(',').Select(x => From(x, seed)).ToArray());
if (sortBy.StartsWith("random:"))
return new Random(uint.Parse(sortBy["random:".Length..]));
string key = sortBy.Contains(':') ? sortBy[..sortBy.IndexOf(':')] : sortBy;
string? order = sortBy.Contains(':') ? sortBy[(sortBy.IndexOf(':') + 1)..] : null;
bool desendant = order switch
{
"desc" => true,
"asc" => false,
null => false,
_
=> throw new ValidationException(
$"The sort order, if set, should be :asc or :desc but it was :{order}."
)
};
Type[] types =
typeof(T).GetCustomAttribute<OneOfAttribute>()?.Types ?? new[] { typeof(T) };
PropertyInfo? property = types
.Select(x =>
x.GetProperty(
key,
BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance
)
)
.FirstOrDefault(x => x != null);
if (property == null)
throw new ValidationException("The given sort key is not valid.");
return new By(property.Name, desendant);
} }
} }
/// <summary>The default sort method for the given type.</summary>
public record Default : Sort<T>
{
public void Deconstruct(out Sort<T> value)
{
value = (Sort<T>)T.DefaultSort;
}
}
/// <summary>
/// Create a new <see cref="Sort{T}"/> instance from a key's name (case insensitive).
/// </summary>
/// <param name="sortBy">A key name with an optional order specifier. Format: "key:asc", "key:desc" or "key".</param>
/// <param name="seed">The random seed.</param>
/// <exception cref="ArgumentException">An invalid key or sort specifier as been given.</exception>
/// <returns>A <see cref="Sort{T}"/> for the given string</returns>
public static Sort<T> From(string? sortBy, uint seed)
{
if (string.IsNullOrEmpty(sortBy) || sortBy == "default")
return new Default();
if (sortBy == "random")
return new Random(seed);
if (sortBy.Contains(','))
return new Conglomerate(sortBy.Split(',').Select(x => From(x, seed)).ToArray());
if (sortBy.StartsWith("random:"))
return new Random(uint.Parse(sortBy["random:".Length..]));
string key = sortBy.Contains(':') ? sortBy[..sortBy.IndexOf(':')] : sortBy;
string? order = sortBy.Contains(':') ? sortBy[(sortBy.IndexOf(':') + 1)..] : null;
bool desendant = order switch
{
"desc" => true,
"asc" => false,
null => false,
_
=> throw new ValidationException(
$"The sort order, if set, should be :asc or :desc but it was :{order}."
)
};
Type[] types = typeof(T).GetCustomAttribute<OneOfAttribute>()?.Types ?? new[] { typeof(T) };
PropertyInfo? property = types
.Select(x =>
x.GetProperty(
key,
BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance
)
)
.FirstOrDefault(x => x != null);
if (property == null)
throw new ValidationException("The given sort key is not valid.");
return new By(property.Name, desendant);
}
} }

25
back/src/Kyoo.Abstractions/Models/VideoLinks.cs
View File

@ -16,21 +16,20 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with Kyoo. If not, see <https://www.gnu.org/licenses/>. // along with Kyoo. If not, see <https://www.gnu.org/licenses/>.
namespace Kyoo.Abstractions.Models namespace Kyoo.Abstractions.Models;
/// <summary>
/// The links to see a movie or an episode.
/// </summary>
public class VideoLinks
{ {
/// <summary> /// <summary>
/// The links to see a movie or an episode. /// The direct link to the unprocessed video (pristine quality).
/// </summary> /// </summary>
public class VideoLinks public string Direct { get; set; }
{
/// <summary>
/// The direct link to the unprocessed video (pristine quality).
/// </summary>
public string Direct { get; set; }
/// <summary> /// <summary>
/// The link to an HLS master playlist containing all qualities available for this video. /// The link to an HLS master playlist containing all qualities available for this video.
/// </summary> /// </summary>
public string Hls { get; set; } public string Hls { get; set; }
}
} }

91
back/src/Kyoo.Abstractions/Module.cs
View File

@ -21,56 +21,55 @@ using Autofac.Builder;
using Kyoo.Abstractions.Controllers; using Kyoo.Abstractions.Controllers;
using Kyoo.Utils; using Kyoo.Utils;
namespace Kyoo.Abstractions namespace Kyoo.Abstractions;
/// <summary>
/// A static class with helper functions to setup external modules
/// </summary>
public static class Module
{ {
/// <summary> /// <summary>
/// A static class with helper functions to setup external modules /// Register a new repository to the container.
/// </summary> /// </summary>
public static class Module /// <param name="builder">The container</param>
/// <typeparam name="T">The type of the repository.</typeparam>
/// <remarks>
/// If your repository implements a special interface, please use <see cref="RegisterRepository{T,T2}"/>
/// </remarks>
/// <returns>The initial container.</returns>
public static IRegistrationBuilder<
T,
ConcreteReflectionActivatorData,
SingleRegistrationStyle
> RegisterRepository<T>(this ContainerBuilder builder)
where T : IBaseRepository
{ {
/// <summary> return builder
/// Register a new repository to the container. .RegisterType<T>()
/// </summary> .AsSelf()
/// <param name="builder">The container</param> .As<IBaseRepository>()
/// <typeparam name="T">The type of the repository.</typeparam> .As(Utility.GetGenericDefinition(typeof(T), typeof(IRepository<>))!)
/// <remarks> .InstancePerLifetimeScope();
/// If your repository implements a special interface, please use <see cref="RegisterRepository{T,T2}"/> }
/// </remarks>
/// <returns>The initial container.</returns>
public static IRegistrationBuilder<
T,
ConcreteReflectionActivatorData,
SingleRegistrationStyle
> RegisterRepository<T>(this ContainerBuilder builder)
where T : IBaseRepository
{
return builder
.RegisterType<T>()
.AsSelf()
.As<IBaseRepository>()
.As(Utility.GetGenericDefinition(typeof(T), typeof(IRepository<>))!)
.InstancePerLifetimeScope();
}
/// <summary> /// <summary>
/// Register a new repository with a custom mapping to the container. /// Register a new repository with a custom mapping to the container.
/// </summary> /// </summary>
/// <param name="builder">The container</param> /// <param name="builder">The container</param>
/// <typeparam name="T">The custom mapping you have for your repository.</typeparam> /// <typeparam name="T">The custom mapping you have for your repository.</typeparam>
/// <typeparam name="T2">The type of the repository.</typeparam> /// <typeparam name="T2">The type of the repository.</typeparam>
/// <remarks> /// <remarks>
/// If your repository does not implements a special interface, please use <see cref="RegisterRepository{T}"/> /// If your repository does not implements a special interface, please use <see cref="RegisterRepository{T}"/>
/// </remarks> /// </remarks>
/// <returns>The initial container.</returns> /// <returns>The initial container.</returns>
public static IRegistrationBuilder< public static IRegistrationBuilder<
T2, T2,
ConcreteReflectionActivatorData, ConcreteReflectionActivatorData,
SingleRegistrationStyle SingleRegistrationStyle
> RegisterRepository<T, T2>(this ContainerBuilder builder) > RegisterRepository<T, T2>(this ContainerBuilder builder)
where T : notnull where T : notnull
where T2 : IBaseRepository, T where T2 : IBaseRepository, T
{ {
return builder.RegisterRepository<T2>().AsSelf().As<T>(); return builder.RegisterRepository<T2>().AsSelf().As<T>();
}
} }
} }

75
back/src/Kyoo.Abstractions/Utility/EnumerableExtensions.cs
View File

@ -19,53 +19,52 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
namespace Kyoo.Utils namespace Kyoo.Utils;
/// <summary>
/// A set of extensions class for enumerable.
/// </summary>
public static class EnumerableExtensions
{ {
/// <summary> /// <summary>
/// A set of extensions class for enumerable. /// If the enumerable is empty, execute an action.
/// </summary> /// </summary>
public static class EnumerableExtensions /// <param name="self">The enumerable to check</param>
/// <param name="action">The action to execute is the list is empty</param>
/// <typeparam name="T">The type of items inside the list</typeparam>
/// <returns>The iterator proxied, there is no dual iterations.</returns>
public static IEnumerable<T> IfEmpty<T>(this IEnumerable<T> self, Action action)
{ {
/// <summary> static IEnumerable<T> Generator(IEnumerable<T> self, Action action)
/// If the enumerable is empty, execute an action.
/// </summary>
/// <param name="self">The enumerable to check</param>
/// <param name="action">The action to execute is the list is empty</param>
/// <typeparam name="T">The type of items inside the list</typeparam>
/// <returns>The iterator proxied, there is no dual iterations.</returns>
public static IEnumerable<T> IfEmpty<T>(this IEnumerable<T> self, Action action)
{ {
static IEnumerable<T> Generator(IEnumerable<T> self, Action action) using IEnumerator<T> enumerator = self.GetEnumerator();
if (!enumerator.MoveNext())
{ {
using IEnumerator<T> enumerator = self.GetEnumerator(); action();
yield break;
if (!enumerator.MoveNext())
{
action();
yield break;
}
do
{
yield return enumerator.Current;
} while (enumerator.MoveNext());
} }
return Generator(self, action); do
{
yield return enumerator.Current;
} while (enumerator.MoveNext());
} }
/// <summary> return Generator(self, action);
/// A foreach used as a function with a little specificity: the list can be null. }
/// </summary>
/// <param name="self">The list to enumerate. If this is null, the function result in a no-op</param> /// <summary>
/// <param name="action">The action to execute for each arguments</param> /// A foreach used as a function with a little specificity: the list can be null.
/// <typeparam name="T">The type of items in the list</typeparam> /// </summary>
public static void ForEach<T>(this IEnumerable<T>? self, Action<T> action) /// <param name="self">The list to enumerate. If this is null, the function result in a no-op</param>
{ /// <param name="action">The action to execute for each arguments</param>
if (self == null) /// <typeparam name="T">The type of items in the list</typeparam>
return; public static void ForEach<T>(this IEnumerable<T>? self, Action<T> action)
foreach (T i in self) {
action(i); if (self == null)
} return;
foreach (T i in self)
action(i);
} }
} }

195
back/src/Kyoo.Abstractions/Utility/Merger.cs
View File

@ -22,113 +22,112 @@ using System.Linq;
using System.Reflection; using System.Reflection;
using Kyoo.Abstractions.Models.Attributes; using Kyoo.Abstractions.Models.Attributes;
namespace Kyoo.Utils namespace Kyoo.Utils;
/// <summary>
/// A class containing helper methods to merge objects.
/// </summary>
public static class Merger
{ {
/// <summary> /// <summary>
/// A class containing helper methods to merge objects. /// Merge two dictionary, if the same key is found on both dictionary, the values of the second one is kept.
/// </summary> /// </summary>
public static class Merger /// <param name="first">The first dictionary to merge</param>
/// <param name="second">The second dictionary to merge</param>
/// <param name="hasChanged">
/// <c>true</c> if a new items has been added to the dictionary, <c>false</c> otherwise.
/// </param>
/// <typeparam name="T">The type of the keys in dictionaries</typeparam>
/// <typeparam name="T2">The type of values in the dictionaries</typeparam>
/// <returns>
/// A dictionary with the missing elements of <paramref name="second"/>
/// set to those of <paramref name="first"/>.
/// </returns>
public static IDictionary<T, T2>? CompleteDictionaries<T, T2>(
IDictionary<T, T2>? first,
IDictionary<T, T2>? second,
out bool hasChanged
)
{ {
/// <summary> if (first == null)
/// Merge two dictionary, if the same key is found on both dictionary, the values of the second one is kept.
/// </summary>
/// <param name="first">The first dictionary to merge</param>
/// <param name="second">The second dictionary to merge</param>
/// <param name="hasChanged">
/// <c>true</c> if a new items has been added to the dictionary, <c>false</c> otherwise.
/// </param>
/// <typeparam name="T">The type of the keys in dictionaries</typeparam>
/// <typeparam name="T2">The type of values in the dictionaries</typeparam>
/// <returns>
/// A dictionary with the missing elements of <paramref name="second"/>
/// set to those of <paramref name="first"/>.
/// </returns>
public static IDictionary<T, T2>? CompleteDictionaries<T, T2>(
IDictionary<T, T2>? first,
IDictionary<T, T2>? second,
out bool hasChanged
)
{ {
if (first == null) hasChanged = true;
{
hasChanged = true;
return second;
}
hasChanged = false;
if (second == null)
return first;
hasChanged = second.Any(x =>
!first.ContainsKey(x.Key) || x.Value?.Equals(first[x.Key]) == false
);
foreach ((T key, T2 value) in first)
second.TryAdd(key, value);
return second; return second;
} }
/// <summary> hasChanged = false;
/// Set every non-default values of seconds to the corresponding property of second. if (second == null)
/// Dictionaries are handled like anonymous objects with a property per key/pair value
/// At the end, the OnMerge method of first will be called if first is a <see cref="IOnMerge"/>
/// </summary>
/// <example>
/// {id: 0, slug: "test"}, {id: 4, slug: "foo"} -> {id: 4, slug: "foo"}
/// </example>
/// <param name="first">
/// The object to complete
/// </param>
/// <param name="second">
/// Missing fields of first will be completed by fields of this item. If second is null, the function no-op.
/// </param>
/// <param name="where">
/// Filter fields that will be merged
/// </param>
/// <typeparam name="T">Fields of T will be completed</typeparam>
/// <returns><paramref name="first"/></returns>
public static T Complete<T>(T first, T? second, Func<PropertyInfo, bool>? where = null)
{
if (second == null)
return first;
Type type = typeof(T);
IEnumerable<PropertyInfo> properties = type.GetProperties()
.Where(x =>
x is { CanRead: true, CanWrite: true }
&& Attribute.GetCustomAttribute(x, typeof(NotMergeableAttribute)) == null
);
if (where != null)
properties = properties.Where(where);
foreach (PropertyInfo property in properties)
{
object? value = property.GetValue(second);
if (value?.Equals(property.GetValue(first)) == true)
continue;
if (Utility.IsOfGenericType(property.PropertyType, typeof(IDictionary<,>)))
{
Type[] dictionaryTypes = Utility
.GetGenericDefinition(property.PropertyType, typeof(IDictionary<,>))!
.GenericTypeArguments;
object?[] parameters = { property.GetValue(first), value, false };
object newDictionary = Utility.RunGenericMethod<object>(
typeof(Merger),
nameof(CompleteDictionaries),
dictionaryTypes,
parameters
)!;
if ((bool)parameters[2]!)
property.SetValue(first, newDictionary);
}
else
property.SetValue(first, value);
}
if (first is IOnMerge merge)
merge.OnMerge(second);
return first; return first;
hasChanged = second.Any(x =>
!first.ContainsKey(x.Key) || x.Value?.Equals(first[x.Key]) == false
);
foreach ((T key, T2 value) in first)
second.TryAdd(key, value);
return second;
}
/// <summary>
/// Set every non-default values of seconds to the corresponding property of second.
/// Dictionaries are handled like anonymous objects with a property per key/pair value
/// At the end, the OnMerge method of first will be called if first is a <see cref="IOnMerge"/>
/// </summary>
/// <example>
/// {id: 0, slug: "test"}, {id: 4, slug: "foo"} -> {id: 4, slug: "foo"}
/// </example>
/// <param name="first">
/// The object to complete
/// </param>
/// <param name="second">
/// Missing fields of first will be completed by fields of this item. If second is null, the function no-op.
/// </param>
/// <param name="where">
/// Filter fields that will be merged
/// </param>
/// <typeparam name="T">Fields of T will be completed</typeparam>
/// <returns><paramref name="first"/></returns>
public static T Complete<T>(T first, T? second, Func<PropertyInfo, bool>? where = null)
{
if (second == null)
return first;
Type type = typeof(T);
IEnumerable<PropertyInfo> properties = type.GetProperties()
.Where(x =>
x is { CanRead: true, CanWrite: true }
&& Attribute.GetCustomAttribute(x, typeof(NotMergeableAttribute)) == null
);
if (where != null)
properties = properties.Where(where);
foreach (PropertyInfo property in properties)
{
object? value = property.GetValue(second);
if (value?.Equals(property.GetValue(first)) == true)
continue;
if (Utility.IsOfGenericType(property.PropertyType, typeof(IDictionary<,>)))
{
Type[] dictionaryTypes = Utility
.GetGenericDefinition(property.PropertyType, typeof(IDictionary<,>))!
.GenericTypeArguments;
object?[] parameters = { property.GetValue(first), value, false };
object newDictionary = Utility.RunGenericMethod<object>(
typeof(Merger),
nameof(CompleteDictionaries),
dictionaryTypes,
parameters
)!;
if ((bool)parameters[2]!)
property.SetValue(first, newDictionary);
}
else
property.SetValue(first, value);
} }
if (first is IOnMerge merge)
merge.OnMerge(second);
return first;
} }
} }

621
back/src/Kyoo.Abstractions/Utility/Utility.cs
View File

@ -25,341 +25,338 @@ using System.Reflection;
using System.Text; using System.Text;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
namespace Kyoo.Utils namespace Kyoo.Utils;
/// <summary>
/// A set of utility functions that can be used everywhere.
/// </summary>
public static class Utility
{ {
/// <summary> /// <summary>
/// A set of utility functions that can be used everywhere. /// Convert a string to snake case. Stollen from
/// https://github.com/efcore/EFCore.NamingConventions/blob/main/EFCore.NamingConventions/Internal/SnakeCaseNameRewriter.cs
/// </summary> /// </summary>
public static class Utility /// <param name="name">The string to convert.</param>
/// <returns>The string in snake case</returns>
public static string ToSnakeCase(this string name)
{ {
/// <summary> StringBuilder builder = new(name.Length + Math.Min(2, name.Length / 5));
/// Convert a string to snake case. Stollen from UnicodeCategory? previousCategory = default;
/// https://github.com/efcore/EFCore.NamingConventions/blob/main/EFCore.NamingConventions/Internal/SnakeCaseNameRewriter.cs
/// </summary> for (int currentIndex = 0; currentIndex < name.Length; currentIndex++)
/// <param name="name">The string to convert.</param>
/// <returns>The string in snake case</returns>
public static string ToSnakeCase(this string name)
{ {
StringBuilder builder = new(name.Length + Math.Min(2, name.Length / 5)); char currentChar = name[currentIndex];
UnicodeCategory? previousCategory = default; if (currentChar == '_')
for (int currentIndex = 0; currentIndex < name.Length; currentIndex++)
{ {
char currentChar = name[currentIndex]; builder.Append('_');
if (currentChar == '_') previousCategory = null;
{ continue;
builder.Append('_'); }
previousCategory = null;
continue;
}
UnicodeCategory currentCategory = char.GetUnicodeCategory(currentChar); UnicodeCategory currentCategory = char.GetUnicodeCategory(currentChar);
switch (currentCategory) switch (currentCategory)
{ {
case UnicodeCategory.UppercaseLetter: case UnicodeCategory.UppercaseLetter:
case UnicodeCategory.TitlecaseLetter: case UnicodeCategory.TitlecaseLetter:
if ( if (
previousCategory == UnicodeCategory.SpaceSeparator previousCategory == UnicodeCategory.SpaceSeparator
|| previousCategory == UnicodeCategory.LowercaseLetter || previousCategory == UnicodeCategory.LowercaseLetter
|| ( || (
previousCategory != UnicodeCategory.DecimalDigitNumber previousCategory != UnicodeCategory.DecimalDigitNumber
&& previousCategory != null && previousCategory != null
&& currentIndex > 0 && currentIndex > 0
&& currentIndex + 1 < name.Length && currentIndex + 1 < name.Length
&& char.IsLower(name[currentIndex + 1]) && char.IsLower(name[currentIndex + 1])
)
) )
{ )
builder.Append('_'); {
} builder.Append('_');
}
currentChar = char.ToLowerInvariant(currentChar); currentChar = char.ToLowerInvariant(currentChar);
break; break;
case UnicodeCategory.LowercaseLetter: case UnicodeCategory.LowercaseLetter:
case UnicodeCategory.DecimalDigitNumber: case UnicodeCategory.DecimalDigitNumber:
if (previousCategory == UnicodeCategory.SpaceSeparator) if (previousCategory == UnicodeCategory.SpaceSeparator)
{ {
builder.Append('_'); builder.Append('_');
} }
break; break;
default: default:
if (previousCategory != null) if (previousCategory != null)
{ {
previousCategory = UnicodeCategory.SpaceSeparator; previousCategory = UnicodeCategory.SpaceSeparator;
} }
continue; continue;
}
builder.Append(currentChar);
previousCategory = currentCategory;
} }
return builder.ToString(); builder.Append(currentChar);
previousCategory = currentCategory;
} }
/// <summary> return builder.ToString();
/// Is the lambda expression a member (like x => x.Body). }
/// </summary>
/// <param name="ex">The expression that should be checked</param>
/// <returns>True if the expression is a member, false otherwise</returns>
public static bool IsPropertyExpression(LambdaExpression ex)
{
return ex.Body is MemberExpression
|| (
ex.Body.NodeType == ExpressionType.Convert
&& ((UnaryExpression)ex.Body).Operand is MemberExpression
);
}
/// <summary> /// <summary>
/// Get the name of a property. Useful for selectors as members ex: Load(x => x.Shows) /// Is the lambda expression a member (like x => x.Body).
/// </summary> /// </summary>
/// <param name="ex">The expression</param> /// <param name="ex">The expression that should be checked</param>
/// <returns>The name of the expression</returns> /// <returns>True if the expression is a member, false otherwise</returns>
/// <exception cref="ArgumentException">If the expression is not a property, ArgumentException is thrown.</exception> public static bool IsPropertyExpression(LambdaExpression ex)
public static string GetPropertyName(LambdaExpression ex) {
{ return ex.Body is MemberExpression
if (!IsPropertyExpression(ex)) || (
throw new ArgumentException($"{ex} is not a property expression.");
MemberExpression? member =
ex.Body.NodeType == ExpressionType.Convert ex.Body.NodeType == ExpressionType.Convert
? ((UnaryExpression)ex.Body).Operand as MemberExpression && ((UnaryExpression)ex.Body).Operand is MemberExpression
: ex.Body as MemberExpression;
return member!.Member.Name;
}
/// <summary>
/// Slugify a string (Replace spaces by -, Uniformize accents)
/// </summary>
/// <param name="str">The string to slugify</param>
/// <returns>The slug version of the given string</returns>
public static string ToSlug(string str)
{
str = str.ToLowerInvariant();
string normalizedString = str.Normalize(NormalizationForm.FormD);
StringBuilder stringBuilder = new();
foreach (char c in normalizedString)
{
UnicodeCategory unicodeCategory = CharUnicodeInfo.GetUnicodeCategory(c);
if (unicodeCategory != UnicodeCategory.NonSpacingMark)
stringBuilder.Append(c);
}
str = stringBuilder.ToString().Normalize(NormalizationForm.FormC);
str = Regex.Replace(str, @"\s", "-", RegexOptions.Compiled);
str = Regex.Replace(str, @"[^\w\s\p{Pd}]", string.Empty, RegexOptions.Compiled);
str = str.Trim('-', '_');
str = Regex.Replace(str, @"([-_]){2,}", "$1", RegexOptions.Compiled);
return str;
}
/// <summary>
/// Return every <see cref="Type"/> in the inheritance tree of the parameter (interfaces are not returned)
/// </summary>
/// <param name="self">The starting type</param>
/// <returns>A list of types</returns>
public static IEnumerable<Type> GetInheritanceTree(this Type self)
{
for (Type? type = self; type != null; type = type.BaseType)
yield return type;
}
/// <summary>
/// Check if <paramref name="type"/> inherit from a generic type <paramref name="genericType"/>.
/// </summary>
/// <param name="type">The type to check</param>
/// <param name="genericType">The generic type to check against (Only generic types are supported like typeof(IEnumerable&lt;&gt;).</param>
/// <returns>True if obj inherit from genericType. False otherwise</returns>
public static bool IsOfGenericType(Type type, Type genericType)
{
if (!genericType.IsGenericType)
throw new ArgumentException($"{nameof(genericType)} is not a generic type.");
IEnumerable<Type> types = genericType.IsInterface
? type.GetInterfaces()
: type.GetInheritanceTree();
return types
.Prepend(type)
.Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == genericType);
}
/// <summary>
/// Get the generic definition of <paramref name="genericType"/>.
/// For example, calling this function with List&lt;string&gt; and typeof(IEnumerable&lt;&gt;) will return IEnumerable&lt;string&gt;
/// </summary>
/// <param name="type">The type to check</param>
/// <param name="genericType">The generic type to check against (Only generic types are supported like typeof(IEnumerable&lt;&gt;).</param>
/// <returns>The generic definition of genericType that type inherit or null if type does not implement the generic type.</returns>
/// <exception cref="ArgumentException"><paramref name="genericType"/> must be a generic type</exception>
public static Type? GetGenericDefinition(Type type, Type genericType)
{
if (!genericType.IsGenericType)
throw new ArgumentException($"{nameof(genericType)} is not a generic type.");
IEnumerable<Type> types = genericType.IsInterface
? type.GetInterfaces()
: type.GetInheritanceTree();
return types
.Prepend(type)
.FirstOrDefault(x =>
x.IsGenericType && x.GetGenericTypeDefinition() == genericType
);
}
/// <summary>
/// Retrieve a method from an <see cref="Type"/> with the given name and respect the
/// amount of parameters and generic parameters. This works for polymorphic methods.
/// </summary>
/// <param name="type">
/// The type owning the method. For non static methods, this is the <c>this</c>.
/// </param>
/// <param name="flag">
/// The binding flags of the method. This allow you to specify public/private and so on.
/// </param>
/// <param name="name">
/// The name of the method.
/// </param>
/// <param name="generics">
/// The list of generic parameters.
/// </param>
/// <param name="args">
/// The list of parameters.
/// </param>
/// <exception cref="ArgumentException">No method match the given constraints.</exception>
/// <returns>The method handle of the matching method.</returns>
public static MethodInfo GetMethod(
Type type,
BindingFlags flag,
string name,
Type[] generics,
object?[] args
)
{
MethodInfo[] methods = type.GetMethods(flag | BindingFlags.Public)
.Where(x => x.Name == name)
.Where(x => x.GetGenericArguments().Length == generics.Length)
.Where(x => x.GetParameters().Length == args.Length)
.IfEmpty(() =>
{
throw new ArgumentException(
$"A method named {name} with "
+ $"{args.Length} arguments and {generics.Length} generic "
+ $"types could not be found on {type.Name}."
);
})
// TODO this won't work but I don't know why.
// .Where(x =>
// {
// int i = 0;
// return x.GetGenericArguments().All(y => y.IsAssignableFrom(generics[i++]));
// })
// .IfEmpty(() => throw new NullReferenceException($"No method {name} match the generics specified."))
// TODO this won't work for Type<T> because T is specified in arguments but not in the parameters type.
// .Where(x =>
// {
// int i = 0;
// return x.GetParameters().All(y => y.ParameterType.IsInstanceOfType(args[i++]));
// })
// .IfEmpty(() => throw new NullReferenceException($"No method {name} match the parameters's types."))
.Take(2)
.ToArray();
if (methods.Length == 1)
return methods[0];
throw new ArgumentException(
$"Multiple methods named {name} match the generics and parameters constraints."
); );
} }
/// <summary> /// <summary>
/// Run a generic static method for a runtime <see cref="Type"/>. /// Get the name of a property. Useful for selectors as members ex: Load(x => x.Shows)
/// </summary> /// </summary>
/// <example> /// <param name="ex">The expression</param>
/// To run Merger.MergeLists{T} for a List where you don't know the type at compile type, /// <returns>The name of the expression</returns>
/// you could do: /// <exception cref="ArgumentException">If the expression is not a property, ArgumentException is thrown.</exception>
/// <code lang="C#"> public static string GetPropertyName(LambdaExpression ex)
/// Utility.RunGenericMethod&lt;object&gt;( {
/// typeof(Utility), if (!IsPropertyExpression(ex))
/// nameof(MergeLists), throw new ArgumentException($"{ex} is not a property expression.");
/// enumerableType, MemberExpression? member =
/// oldValue, newValue, equalityComparer) ex.Body.NodeType == ExpressionType.Convert
/// </code> ? ((UnaryExpression)ex.Body).Operand as MemberExpression
/// </example> : ex.Body as MemberExpression;
/// <param name="owner">The type that owns the method. For non static methods, the type of <c>this</c>.</param> return member!.Member.Name;
/// <param name="methodName">The name of the method. You should use the <c>nameof</c> keyword.</param> }
/// <param name="type">The generic type to run the method with.</param>
/// <param name="args">The list of arguments of the method</param>
/// <typeparam name="T">
/// The return type of the method. You can put <see cref="object"/> for an unknown one.
/// </typeparam>
/// <exception cref="ArgumentException">No method match the given constraints.</exception>
/// <returns>The return of the method you wanted to run.</returns>
/// <seealso cref="RunGenericMethod{T}(System.Type,string,System.Type[],object[])"/>
public static T? RunGenericMethod<T>(
Type owner,
string methodName,
Type type,
params object[] args
)
{
return RunGenericMethod<T>(owner, methodName, new[] { type }, args);
}
/// <summary> /// <summary>
/// Run a generic static method for a multiple runtime <see cref="Type"/>. /// Slugify a string (Replace spaces by -, Uniformize accents)
/// If your generic method only needs one type, see /// </summary>
/// <see cref="RunGenericMethod{T}(System.Type,string,System.Type,object[])"/> /// <param name="str">The string to slugify</param>
/// </summary> /// <returns>The slug version of the given string</returns>
/// <example> public static string ToSlug(string str)
/// To run Merger.MergeLists{T} for a List where you don't know the type at compile type, {
/// you could do: str = str.ToLowerInvariant();
/// <code>
/// Utility.RunGenericMethod&lt;object&gt;( string normalizedString = str.Normalize(NormalizationForm.FormD);
/// typeof(Utility), StringBuilder stringBuilder = new();
/// nameof(MergeLists), foreach (char c in normalizedString)
/// enumerableType,
/// oldValue, newValue, equalityComparer)
/// </code>
/// </example>
/// <param name="owner">The type that owns the method. For non static methods, the type of <c>this</c>.</param>
/// <param name="methodName">The name of the method. You should use the <c>nameof</c> keyword.</param>
/// <param name="types">The list of generic types to run the method with.</param>
/// <param name="args">The list of arguments of the method</param>
/// <typeparam name="T">
/// The return type of the method. You can put <see cref="object"/> for an unknown one.
/// </typeparam>
/// <exception cref="ArgumentException">No method match the given constraints.</exception>
/// <returns>The return of the method you wanted to run.</returns>
/// <seealso cref="RunGenericMethod{T}(System.Type,string,System.Type,object[])"/>
public static T? RunGenericMethod<T>(
Type owner,
string methodName,
Type[] types,
params object?[] args
)
{ {
if (types.Length < 1) UnicodeCategory unicodeCategory = CharUnicodeInfo.GetUnicodeCategory(c);
if (unicodeCategory != UnicodeCategory.NonSpacingMark)
stringBuilder.Append(c);
}
str = stringBuilder.ToString().Normalize(NormalizationForm.FormC);
str = Regex.Replace(str, @"\s", "-", RegexOptions.Compiled);
str = Regex.Replace(str, @"[^\w\s\p{Pd}]", string.Empty, RegexOptions.Compiled);
str = str.Trim('-', '_');
str = Regex.Replace(str, @"([-_]){2,}", "$1", RegexOptions.Compiled);
return str;
}
/// <summary>
/// Return every <see cref="Type"/> in the inheritance tree of the parameter (interfaces are not returned)
/// </summary>
/// <param name="self">The starting type</param>
/// <returns>A list of types</returns>
public static IEnumerable<Type> GetInheritanceTree(this Type self)
{
for (Type? type = self; type != null; type = type.BaseType)
yield return type;
}
/// <summary>
/// Check if <paramref name="type"/> inherit from a generic type <paramref name="genericType"/>.
/// </summary>
/// <param name="type">The type to check</param>
/// <param name="genericType">The generic type to check against (Only generic types are supported like typeof(IEnumerable&lt;&gt;).</param>
/// <returns>True if obj inherit from genericType. False otherwise</returns>
public static bool IsOfGenericType(Type type, Type genericType)
{
if (!genericType.IsGenericType)
throw new ArgumentException($"{nameof(genericType)} is not a generic type.");
IEnumerable<Type> types = genericType.IsInterface
? type.GetInterfaces()
: type.GetInheritanceTree();
return types
.Prepend(type)
.Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == genericType);
}
/// <summary>
/// Get the generic definition of <paramref name="genericType"/>.
/// For example, calling this function with List&lt;string&gt; and typeof(IEnumerable&lt;&gt;) will return IEnumerable&lt;string&gt;
/// </summary>
/// <param name="type">The type to check</param>
/// <param name="genericType">The generic type to check against (Only generic types are supported like typeof(IEnumerable&lt;&gt;).</param>
/// <returns>The generic definition of genericType that type inherit or null if type does not implement the generic type.</returns>
/// <exception cref="ArgumentException"><paramref name="genericType"/> must be a generic type</exception>
public static Type? GetGenericDefinition(Type type, Type genericType)
{
if (!genericType.IsGenericType)
throw new ArgumentException($"{nameof(genericType)} is not a generic type.");
IEnumerable<Type> types = genericType.IsInterface
? type.GetInterfaces()
: type.GetInheritanceTree();
return types
.Prepend(type)
.FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == genericType);
}
/// <summary>
/// Retrieve a method from an <see cref="Type"/> with the given name and respect the
/// amount of parameters and generic parameters. This works for polymorphic methods.
/// </summary>
/// <param name="type">
/// The type owning the method. For non static methods, this is the <c>this</c>.
/// </param>
/// <param name="flag">
/// The binding flags of the method. This allow you to specify public/private and so on.
/// </param>
/// <param name="name">
/// The name of the method.
/// </param>
/// <param name="generics">
/// The list of generic parameters.
/// </param>
/// <param name="args">
/// The list of parameters.
/// </param>
/// <exception cref="ArgumentException">No method match the given constraints.</exception>
/// <returns>The method handle of the matching method.</returns>
public static MethodInfo GetMethod(
Type type,
BindingFlags flag,
string name,
Type[] generics,
object?[] args
)
{
MethodInfo[] methods = type.GetMethods(flag | BindingFlags.Public)
.Where(x => x.Name == name)
.Where(x => x.GetGenericArguments().Length == generics.Length)
.Where(x => x.GetParameters().Length == args.Length)
.IfEmpty(() =>
{
throw new ArgumentException( throw new ArgumentException(
$"The {nameof(types)} array is empty. At least one type is needed." $"A method named {name} with "
+ $"{args.Length} arguments and {generics.Length} generic "
+ $"types could not be found on {type.Name}."
); );
MethodInfo method = GetMethod(owner, BindingFlags.Static, methodName, types, args); })
return (T?)method.MakeGenericMethod(types).Invoke(null, args); // TODO this won't work but I don't know why.
} // .Where(x =>
// {
// int i = 0;
// return x.GetGenericArguments().All(y => y.IsAssignableFrom(generics[i++]));
// })
// .IfEmpty(() => throw new NullReferenceException($"No method {name} match the generics specified."))
/// <summary> // TODO this won't work for Type<T> because T is specified in arguments but not in the parameters type.
/// Convert a dictionary to a query string. // .Where(x =>
/// </summary> // {
/// <param name="query">The list of query parameters.</param> // int i = 0;
/// <returns>A valid query string with all items in the dictionary.</returns> // return x.GetParameters().All(y => y.ParameterType.IsInstanceOfType(args[i++]));
public static string ToQueryString(this Dictionary<string, string> query) // })
{ // .IfEmpty(() => throw new NullReferenceException($"No method {name} match the parameters's types."))
if (!query.Any()) .Take(2)
return string.Empty; .ToArray();
return "?" + string.Join('&', query.Select(x => $"{x.Key}={x.Value}"));
} if (methods.Length == 1)
return methods[0];
throw new ArgumentException(
$"Multiple methods named {name} match the generics and parameters constraints."
);
}
/// <summary>
/// Run a generic static method for a runtime <see cref="Type"/>.
/// </summary>
/// <example>
/// To run Merger.MergeLists{T} for a List where you don't know the type at compile type,
/// you could do:
/// <code lang="C#">
/// Utility.RunGenericMethod&lt;object&gt;(
/// typeof(Utility),
/// nameof(MergeLists),
/// enumerableType,
/// oldValue, newValue, equalityComparer)
/// </code>
/// </example>
/// <param name="owner">The type that owns the method. For non static methods, the type of <c>this</c>.</param>
/// <param name="methodName">The name of the method. You should use the <c>nameof</c> keyword.</param>
/// <param name="type">The generic type to run the method with.</param>
/// <param name="args">The list of arguments of the method</param>
/// <typeparam name="T">
/// The return type of the method. You can put <see cref="object"/> for an unknown one.
/// </typeparam>
/// <exception cref="ArgumentException">No method match the given constraints.</exception>
/// <returns>The return of the method you wanted to run.</returns>
/// <seealso cref="RunGenericMethod{T}(System.Type,string,System.Type[],object[])"/>
public static T? RunGenericMethod<T>(
Type owner,
string methodName,
Type type,
params object[] args
)
{
return RunGenericMethod<T>(owner, methodName, new[] { type }, args);
}
/// <summary>
/// Run a generic static method for a multiple runtime <see cref="Type"/>.
/// If your generic method only needs one type, see
/// <see cref="RunGenericMethod{T}(System.Type,string,System.Type,object[])"/>
/// </summary>
/// <example>
/// To run Merger.MergeLists{T} for a List where you don't know the type at compile type,
/// you could do:
/// <code>
/// Utility.RunGenericMethod&lt;object&gt;(
/// typeof(Utility),
/// nameof(MergeLists),
/// enumerableType,
/// oldValue, newValue, equalityComparer)
/// </code>
/// </example>
/// <param name="owner">The type that owns the method. For non static methods, the type of <c>this</c>.</param>
/// <param name="methodName">The name of the method. You should use the <c>nameof</c> keyword.</param>
/// <param name="types">The list of generic types to run the method with.</param>
/// <param name="args">The list of arguments of the method</param>
/// <typeparam name="T">
/// The return type of the method. You can put <see cref="object"/> for an unknown one.
/// </typeparam>
/// <exception cref="ArgumentException">No method match the given constraints.</exception>
/// <returns>The return of the method you wanted to run.</returns>
/// <seealso cref="RunGenericMethod{T}(System.Type,string,System.Type,object[])"/>
public static T? RunGenericMethod<T>(
Type owner,
string methodName,
Type[] types,
params object?[] args
)
{
if (types.Length < 1)
throw new ArgumentException(
$"The {nameof(types)} array is empty. At least one type is needed."
);
MethodInfo method = GetMethod(owner, BindingFlags.Static, methodName, types, args);
return (T?)method.MakeGenericMethod(types).Invoke(null, args);
}
/// <summary>
/// Convert a dictionary to a query string.
/// </summary>
/// <param name="query">The list of query parameters.</param>
/// <returns>A valid query string with all items in the dictionary.</returns>
public static string ToQueryString(this Dictionary<string, string> query)
{
if (!query.Any())
return string.Empty;
return "?" + string.Join('&', query.Select(x => $"{x.Key}={x.Value}"));
} }
} }

273
back/src/Kyoo.Authentication/AuthenticationModule.cs
View File

@ -32,158 +32,151 @@ using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Primitives; using Microsoft.Extensions.Primitives;
using Microsoft.IdentityModel.Tokens; using Microsoft.IdentityModel.Tokens;
namespace Kyoo.Authentication namespace Kyoo.Authentication;
/// <summary>
/// A module that enable OpenID authentication for Kyoo.
/// </summary>
/// <remarks>
/// Create a new authentication module instance and use the given configuration.
/// </remarks>
public class AuthenticationModule(
IConfiguration configuration,
ILogger<AuthenticationModule> logger
) : IPlugin
{ {
/// <inheritdoc />
public string Name => "Authentication";
/// <summary> /// <summary>
/// A module that enable OpenID authentication for Kyoo. /// The configuration to use.
/// </summary> /// </summary>
/// <remarks> private readonly IConfiguration _configuration = configuration;
/// Create a new authentication module instance and use the given configuration.
/// </remarks> /// <inheritdoc />
public class AuthenticationModule( public void Configure(ContainerBuilder builder)
IConfiguration configuration,
ILogger<AuthenticationModule> logger
) : IPlugin
{ {
/// <inheritdoc /> builder.RegisterType<PermissionValidator>().As<IPermissionValidator>().SingleInstance();
public string Name => "Authentication"; builder.RegisterType<TokenController>().As<ITokenController>().SingleInstance();
}
/// <summary> /// <inheritdoc />
/// The configuration to use. public void Configure(IServiceCollection services)
/// </summary> {
private readonly IConfiguration _configuration = configuration; string secret = _configuration.GetValue(
"AUTHENTICATION_SECRET",
/// <inheritdoc /> AuthenticationOption.DefaultSecret
public void Configure(ContainerBuilder builder) )!;
{ PermissionOption options =
builder.RegisterType<PermissionValidator>().As<IPermissionValidator>().SingleInstance(); new()
builder.RegisterType<TokenController>().As<ITokenController>().SingleInstance(); {
} Default = _configuration
.GetValue("UNLOGGED_PERMISSIONS", "")!
/// <inheritdoc /> .Split(',')
public void Configure(IServiceCollection services) .Where(x => x.Length > 0)
{ .ToArray(),
string secret = _configuration.GetValue( NewUser = _configuration
"AUTHENTICATION_SECRET", .GetValue("DEFAULT_PERMISSIONS", "overall.read,overall.play")!
AuthenticationOption.DefaultSecret .Split(','),
)!; RequireVerification = _configuration.GetValue("REQUIRE_ACCOUNT_VERIFICATION", true),
PermissionOption options = PublicUrl =
new() _configuration.GetValue<string?>("PUBLIC_URL") ?? "http://localhost:8901",
{ ApiKeys = _configuration.GetValue("KYOO_APIKEYS", string.Empty)!.Split(','),
Default = _configuration OIDC = _configuration
.GetValue("UNLOGGED_PERMISSIONS", "")! .AsEnumerable()
.Split(',') .Where((pair) => pair.Key.StartsWith("OIDC_"))
.Where(x => x.Length > 0) .Aggregate(
.ToArray(), new Dictionary<string, OidcProvider>(),
NewUser = _configuration (acc, val) =>
.GetValue("DEFAULT_PERMISSIONS", "overall.read,overall.play")! {
.Split(','), if (val.Value is null)
RequireVerification = _configuration.GetValue( return acc;
"REQUIRE_ACCOUNT_VERIFICATION", if (val.Key.Split("_") is not ["OIDC", string provider, string key])
true
),
PublicUrl =
_configuration.GetValue<string?>("PUBLIC_URL") ?? "http://localhost:8901",
ApiKeys = _configuration.GetValue("KYOO_APIKEYS", string.Empty)!.Split(','),
OIDC = _configuration
.AsEnumerable()
.Where((pair) => pair.Key.StartsWith("OIDC_"))
.Aggregate(
new Dictionary<string, OidcProvider>(),
(acc, val) =>
{ {
if (val.Value is null) logger.LogError("Invalid oidc config value: {Key}", val.Key);
return acc;
if (val.Key.Split("_") is not ["OIDC", string provider, string key])
{
logger.LogError("Invalid oidc config value: {Key}", val.Key);
return acc;
}
provider = provider.ToLowerInvariant();
key = key.ToLowerInvariant();
if (!acc.ContainsKey(provider))
acc.Add(provider, new(provider));
switch (key)
{
case "clientid":
acc[provider].ClientId = val.Value;
break;
case "secret":
acc[provider].Secret = val.Value;
break;
case "scope":
acc[provider].Scope = val.Value;
break;
case "authorization":
acc[provider].AuthorizationUrl = val.Value;
break;
case "token":
acc[provider].TokenUrl = val.Value;
break;
case "userinfo":
case "profile":
acc[provider].ProfileUrl = val.Value;
break;
case "name":
acc[provider].DisplayName = val.Value;
break;
case "logo":
acc[provider].LogoUrl = val.Value;
break;
default:
logger.LogError("Invalid oidc config value: {Key}", key);
return acc;
}
return acc; return acc;
} }
), provider = provider.ToLowerInvariant();
}; key = key.ToLowerInvariant();
services.AddSingleton(options);
services.AddSingleton(
new AuthenticationOption() { Secret = secret, Permissions = options, }
);
services if (!acc.ContainsKey(provider))
.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) acc.Add(provider, new(provider));
.AddJwtBearer(options => switch (key)
{
options.Events = new()
{
OnMessageReceived = (ctx) =>
{
string prefix = "Bearer ";
if (
ctx.Request.Headers.TryGetValue(
"Authorization",
out StringValues val
)
&& val.ToString() is string auth
&& auth.StartsWith(prefix)
)
{ {
ctx.Token ??= auth[prefix.Length..]; case "clientid":
acc[provider].ClientId = val.Value;
break;
case "secret":
acc[provider].Secret = val.Value;
break;
case "scope":
acc[provider].Scope = val.Value;
break;
case "authorization":
acc[provider].AuthorizationUrl = val.Value;
break;
case "token":
acc[provider].TokenUrl = val.Value;
break;
case "userinfo":
case "profile":
acc[provider].ProfileUrl = val.Value;
break;
case "name":
acc[provider].DisplayName = val.Value;
break;
case "logo":
acc[provider].LogoUrl = val.Value;
break;
default:
logger.LogError("Invalid oidc config value: {Key}", key);
return acc;
} }
ctx.Token ??= ctx.Request.Cookies["X-Bearer"]; return acc;
return Task.CompletedTask;
} }
}; ),
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = false,
ValidateAudience = false,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secret))
};
});
}
/// <inheritdoc />
public IEnumerable<IStartupAction> ConfigureSteps =>
new IStartupAction[]
{
SA.New<IApplicationBuilder>(app => app.UseAuthentication(), SA.Authentication),
}; };
services.AddSingleton(options);
services.AddSingleton(
new AuthenticationOption() { Secret = secret, Permissions = options, }
);
services
.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.Events = new()
{
OnMessageReceived = (ctx) =>
{
string prefix = "Bearer ";
if (
ctx.Request.Headers.TryGetValue("Authorization", out StringValues val)
&& val.ToString() is string auth
&& auth.StartsWith(prefix)
)
{
ctx.Token ??= auth[prefix.Length..];
}
ctx.Token ??= ctx.Request.Cookies["X-Bearer"];
return Task.CompletedTask;
}
};
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = false,
ValidateAudience = false,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secret))
};
});
} }
/// <inheritdoc />
public IEnumerable<IStartupAction> ConfigureSteps =>
new IStartupAction[]
{
SA.New<IApplicationBuilder>(app => app.UseAuthentication(), SA.Authentication),
};
} }

49
back/src/Kyoo.Authentication/Controllers/ITokenController.cs
View File

@ -21,34 +21,33 @@ using System.Threading.Tasks;
using Kyoo.Abstractions.Models; using Kyoo.Abstractions.Models;
using Microsoft.IdentityModel.Tokens; using Microsoft.IdentityModel.Tokens;
namespace Kyoo.Authentication namespace Kyoo.Authentication;
/// <summary>
/// The service that controls jwt creation and validation.
/// </summary>
public interface ITokenController
{ {
/// <summary> /// <summary>
/// The service that controls jwt creation and validation. /// Create a new access token for the given user.
/// </summary> /// </summary>
public interface ITokenController /// <param name="user">The user to create a token for.</param>
{ /// <param name="expireIn">When this token will expire.</param>
/// <summary> /// <returns>A new, valid access token.</returns>
/// Create a new access token for the given user. string CreateAccessToken(User user, out TimeSpan expireIn);
/// </summary>
/// <param name="user">The user to create a token for.</param>
/// <param name="expireIn">When this token will expire.</param>
/// <returns>A new, valid access token.</returns>
string CreateAccessToken(User user, out TimeSpan expireIn);
/// <summary> /// <summary>
/// Create a new refresh token for the given user. /// Create a new refresh token for the given user.
/// </summary> /// </summary>
/// <param name="user">The user to create a token for.</param> /// <param name="user">The user to create a token for.</param>
/// <returns>A new, valid refresh token.</returns> /// <returns>A new, valid refresh token.</returns>
Task<string> CreateRefreshToken(User user); Task<string> CreateRefreshToken(User user);
/// <summary> /// <summary>
/// Check if the given refresh token is valid and if it is, retrieve the id of the user this token belongs to. /// Check if the given refresh token is valid and if it is, retrieve the id of the user this token belongs to.
/// </summary> /// </summary>
/// <param name="refreshToken">The refresh token to validate.</param> /// <param name="refreshToken">The refresh token to validate.</param>
/// <exception cref="SecurityTokenException">The given refresh token is not valid.</exception> /// <exception cref="SecurityTokenException">The given refresh token is not valid.</exception>
/// <returns>The id of the token's user.</returns> /// <returns>The id of the token's user.</returns>
Guid GetRefreshTokenUserID(string refreshToken); Guid GetRefreshTokenUserID(string refreshToken);
}
} }

422
back/src/Kyoo.Authentication/Controllers/PermissionValidator.cs
View File

@ -32,267 +32,253 @@ using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters; using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.Extensions.Primitives; using Microsoft.Extensions.Primitives;
namespace Kyoo.Authentication namespace Kyoo.Authentication;
/// <summary>
/// A permission validator to validate permission with user Permission array
/// or the default array from the configurations if the user is not logged.
/// </summary>
public class PermissionValidator : IPermissionValidator
{ {
/// <summary> /// <summary>
/// A permission validator to validate permission with user Permission array /// The permissions options to retrieve default permissions.
/// or the default array from the configurations if the user is not logged.
/// </summary> /// </summary>
public class PermissionValidator : IPermissionValidator private readonly PermissionOption _options;
/// <summary>
/// Create a new factory with the given options.
/// </summary>
/// <param name="options">The option containing default values.</param>
public PermissionValidator(PermissionOption options)
{ {
_options = options;
}
/// <inheritdoc />
public IFilterMetadata Create(PermissionAttribute attribute)
{
return new PermissionValidatorFilter(
attribute.Type,
attribute.Kind,
attribute.Group,
_options
);
}
/// <inheritdoc />
public IFilterMetadata Create(PartialPermissionAttribute attribute)
{
return new PermissionValidatorFilter(
((object?)attribute.Type ?? attribute.Kind)!,
attribute.Group,
_options
);
}
/// <summary>
/// The authorization filter used by <see cref="PermissionValidator"/>.
/// </summary>
private class PermissionValidatorFilter : IAsyncAuthorizationFilter
{
/// <summary>
/// The permission to validate.
/// </summary>
private readonly string? _permission;
/// <summary>
/// The kind of permission needed.
/// </summary>
private readonly Kind? _kind;
/// <summary>
/// The group of he permission.
/// </summary>
private Group _group;
/// <summary> /// <summary>
/// The permissions options to retrieve default permissions. /// The permissions options to retrieve default permissions.
/// </summary> /// </summary>
private readonly PermissionOption _options; private readonly PermissionOption _options;
/// <summary> /// <summary>
/// Create a new factory with the given options. /// Create a new permission validator with the given options.
/// </summary> /// </summary>
/// <param name="permission">The permission to validate.</param>
/// <param name="kind">The kind of permission needed.</param>
/// <param name="group">The group of the permission.</param>
/// <param name="options">The option containing default values.</param> /// <param name="options">The option containing default values.</param>
public PermissionValidator(PermissionOption options) public PermissionValidatorFilter(
string permission,
Kind kind,
Group group,
PermissionOption options
)
{ {
_permission = permission;
_kind = kind;
_group = group;
_options = options;
}
/// <summary>
/// Create a new permission validator with the given options.
/// </summary>
/// <param name="partialInfo">The partial permission to validate.</param>
/// <param name="group">The group of the permission.</param>
/// <param name="options">The option containing default values.</param>
public PermissionValidatorFilter(object partialInfo, Group? group, PermissionOption options)
{
switch (partialInfo)
{
case Kind kind:
_kind = kind;
break;
case string perm:
_permission = perm;
break;
default:
throw new ArgumentException(
$"{nameof(partialInfo)} can only be a permission string or a kind."
);
}
if (group is not null and not Group.None)
_group = group.Value;
_options = options; _options = options;
} }
/// <inheritdoc /> /// <inheritdoc />
public IFilterMetadata Create(PermissionAttribute attribute) public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
{ {
return new PermissionValidatorFilter( string? permission = _permission;
attribute.Type, Kind? kind = _kind;
attribute.Kind,
attribute.Group,
_options
);
}
/// <inheritdoc /> if (permission == null || kind == null)
public IFilterMetadata Create(PartialPermissionAttribute attribute)
{
return new PermissionValidatorFilter(
((object?)attribute.Type ?? attribute.Kind)!,
attribute.Group,
_options
);
}
/// <summary>
/// The authorization filter used by <see cref="PermissionValidator"/>.
/// </summary>
private class PermissionValidatorFilter : IAsyncAuthorizationFilter
{
/// <summary>
/// The permission to validate.
/// </summary>
private readonly string? _permission;
/// <summary>
/// The kind of permission needed.
/// </summary>
private readonly Kind? _kind;
/// <summary>
/// The group of he permission.
/// </summary>
private Group _group;
/// <summary>
/// The permissions options to retrieve default permissions.
/// </summary>
private readonly PermissionOption _options;
/// <summary>
/// Create a new permission validator with the given options.
/// </summary>
/// <param name="permission">The permission to validate.</param>
/// <param name="kind">The kind of permission needed.</param>
/// <param name="group">The group of the permission.</param>
/// <param name="options">The option containing default values.</param>
public PermissionValidatorFilter(
string permission,
Kind kind,
Group group,
PermissionOption options
)
{ {
_permission = permission; if (context.HttpContext.Items["PermissionGroup"] is Group group and not Group.None)
_kind = kind; _group = group;
_group = group; else if (_group == Group.None)
_options = options; _group = Group.Overall;
} else
context.HttpContext.Items["PermissionGroup"] = _group;
/// <summary> switch (context.HttpContext.Items["PermissionType"])
/// Create a new permission validator with the given options.
/// </summary>
/// <param name="partialInfo">The partial permission to validate.</param>
/// <param name="group">The group of the permission.</param>
/// <param name="options">The option containing default values.</param>
public PermissionValidatorFilter(
object partialInfo,
Group? group,
PermissionOption options
)
{
switch (partialInfo)
{ {
case Kind kind:
_kind = kind;
break;
case string perm: case string perm:
_permission = perm; permission = perm;
break; break;
case Kind kin:
kind = kin;
break;
case null when kind != null:
context.HttpContext.Items["PermissionType"] = kind;
return;
case null when permission != null:
context.HttpContext.Items["PermissionType"] = permission;
return;
default: default:
throw new ArgumentException( throw new ArgumentException(
$"{nameof(partialInfo)} can only be a permission string or a kind." "Multiple non-matching partial permission attribute "
+ "are not supported."
); );
} }
if (group is not null and not Group.None)
_group = group.Value;
_options = options;
}
/// <inheritdoc />
public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
{
string? permission = _permission;
Kind? kind = _kind;
if (permission == null || kind == null) if (permission == null || kind == null)
{ {
if ( throw new ArgumentException(
context.HttpContext.Items["PermissionGroup"] "The permission type or kind is still missing after two partial "
is Group group + "permission attributes, this is unsupported."
and not Group.None );
)
_group = group;
else if (_group == Group.None)
_group = Group.Overall;
else
context.HttpContext.Items["PermissionGroup"] = _group;
switch (context.HttpContext.Items["PermissionType"])
{
case string perm:
permission = perm;
break;
case Kind kin:
kind = kin;
break;
case null when kind != null:
context.HttpContext.Items["PermissionType"] = kind;
return;
case null when permission != null:
context.HttpContext.Items["PermissionType"] = permission;
return;
default:
throw new ArgumentException(
"Multiple non-matching partial permission attribute "
+ "are not supported."
);
}
if (permission == null || kind == null)
{
throw new ArgumentException(
"The permission type or kind is still missing after two partial "
+ "permission attributes, this is unsupported."
);
}
} }
}
string permStr = $"{permission.ToLower()}.{kind.ToString()!.ToLower()}"; string permStr = $"{permission.ToLower()}.{kind.ToString()!.ToLower()}";
string overallStr = $"{_group.ToString().ToLower()}.{kind.ToString()!.ToLower()}"; string overallStr = $"{_group.ToString().ToLower()}.{kind.ToString()!.ToLower()}";
AuthenticateResult res = _ApiKeyCheck(context); AuthenticateResult res = _ApiKeyCheck(context);
if (res.None) if (res.None)
res = await _JwtCheck(context); res = await _JwtCheck(context);
if (res.Succeeded) if (res.Succeeded)
{ {
ICollection<string> permissions = res.Principal.GetPermissions(); ICollection<string> permissions = res.Principal.GetPermissions();
if (permissions.All(x => x != permStr && x != overallStr)) if (permissions.All(x => x != permStr && x != overallStr))
context.Result = _ErrorResult(
$"Missing permission {permStr} or {overallStr}",
StatusCodes.Status403Forbidden
);
}
else if (res.None)
{
ICollection<string> permissions = _options.Default ?? Array.Empty<string>();
if (permissions.All(x => x != permStr && x != overallStr))
{
context.Result = _ErrorResult(
$"Unlogged user does not have permission {permStr} or {overallStr}",
StatusCodes.Status401Unauthorized
);
}
}
else if (res.Failure != null)
context.Result = _ErrorResult( context.Result = _ErrorResult(
res.Failure.Message, $"Missing permission {permStr} or {overallStr}",
StatusCodes.Status403Forbidden StatusCodes.Status403Forbidden
); );
else }
else if (res.None)
{
ICollection<string> permissions = _options.Default ?? Array.Empty<string>();
if (permissions.All(x => x != permStr && x != overallStr))
{
context.Result = _ErrorResult( context.Result = _ErrorResult(
"Authentication panic", $"Unlogged user does not have permission {permStr} or {overallStr}",
StatusCodes.Status500InternalServerError StatusCodes.Status401Unauthorized
); );
}
} }
else if (res.Failure != null)
private AuthenticateResult _ApiKeyCheck(ActionContext context) context.Result = _ErrorResult(res.Failure.Message, StatusCodes.Status403Forbidden);
{ else
if ( context.Result = _ErrorResult(
!context.HttpContext.Request.Headers.TryGetValue( "Authentication panic",
"X-API-Key", StatusCodes.Status500InternalServerError
out StringValues apiKey
)
)
return AuthenticateResult.NoResult();
if (!_options.ApiKeys.Contains<string>(apiKey!))
return AuthenticateResult.Fail("Invalid API-Key.");
return AuthenticateResult.Success(
new AuthenticationTicket(
new ClaimsPrincipal(
new[]
{
new ClaimsIdentity(
new[]
{
// TODO: Make permission configurable, for now every APIKEY as all permissions.
new Claim(
Claims.Permissions,
string.Join(',', PermissionOption.Admin)
)
}
)
}
),
"apikey"
)
); );
}
private async Task<AuthenticateResult> _JwtCheck(ActionContext context)
{
AuthenticateResult ret = await context.HttpContext.AuthenticateAsync(
JwtBearerDefaults.AuthenticationScheme
);
// Change the failure message to make the API nice to use.
if (ret.Failure != null)
return AuthenticateResult.Fail(
"Invalid JWT token. The token may have expired."
);
return ret;
}
} }
/// <summary> private AuthenticateResult _ApiKeyCheck(ActionContext context)
/// Create a new action result with the given error message and error code.
/// </summary>
/// <param name="error">The error message.</param>
/// <param name="code">The status code of the error.</param>
/// <returns>The resulting error action.</returns>
private static IActionResult _ErrorResult(string error, int code)
{ {
return new ObjectResult(new RequestError(error)) { StatusCode = code }; if (
!context.HttpContext.Request.Headers.TryGetValue(
"X-API-Key",
out StringValues apiKey
)
)
return AuthenticateResult.NoResult();
if (!_options.ApiKeys.Contains<string>(apiKey!))
return AuthenticateResult.Fail("Invalid API-Key.");
return AuthenticateResult.Success(
new AuthenticationTicket(
new ClaimsPrincipal(
new[]
{
new ClaimsIdentity(
new[]
{
// TODO: Make permission configurable, for now every APIKEY as all permissions.
new Claim(
Claims.Permissions,
string.Join(',', PermissionOption.Admin)
)
}
)
}
),
"apikey"
)
);
}
private async Task<AuthenticateResult> _JwtCheck(ActionContext context)
{
AuthenticateResult ret = await context.HttpContext.AuthenticateAsync(
JwtBearerDefaults.AuthenticationScheme
);
// Change the failure message to make the API nice to use.
if (ret.Failure != null)
return AuthenticateResult.Fail("Invalid JWT token. The token may have expired.");
return ret;
} }
} }
/// <summary>
/// Create a new action result with the given error message and error code.
/// </summary>
/// <param name="error">The error message.</param>
/// <param name="code">The status code of the error.</param>
/// <returns>The resulting error action.</returns>
private static IActionResult _ErrorResult(string error, int code)
{
return new ObjectResult(new RequestError(error)) { StatusCode = code };
}
} }

179
back/src/Kyoo.Authentication/Controllers/TokenController.cs
View File

@ -27,109 +27,108 @@ using Kyoo.Abstractions.Models;
using Kyoo.Authentication.Models; using Kyoo.Authentication.Models;
using Microsoft.IdentityModel.Tokens; using Microsoft.IdentityModel.Tokens;
namespace Kyoo.Authentication namespace Kyoo.Authentication;
/// <summary>
/// The service that controls jwt creation and validation.
/// </summary>
public class TokenController : ITokenController
{ {
/// <summary> /// <summary>
/// The service that controls jwt creation and validation. /// The options that this controller will use.
/// </summary> /// </summary>
public class TokenController : ITokenController private readonly AuthenticationOption _options;
/// <summary>
/// Create a new <see cref="TokenController"/>.
/// </summary>
/// <param name="options">The options that this controller will use.</param>
public TokenController(AuthenticationOption options)
{ {
/// <summary> _options = options;
/// The options that this controller will use. }
/// </summary>
private readonly AuthenticationOption _options;
/// <summary> /// <inheritdoc />
/// Create a new <see cref="TokenController"/>. public string CreateAccessToken(User user, out TimeSpan expireIn)
/// </summary> {
/// <param name="options">The options that this controller will use.</param> expireIn = new TimeSpan(1, 0, 0);
public TokenController(AuthenticationOption options)
{
_options = options;
}
/// <inheritdoc /> SymmetricSecurityKey key = new(Encoding.UTF8.GetBytes(_options.Secret));
public string CreateAccessToken(User user, out TimeSpan expireIn) SigningCredentials credential = new(key, SecurityAlgorithms.HmacSha256Signature);
{ string permissions =
expireIn = new TimeSpan(1, 0, 0); user.Permissions != null ? string.Join(',', user.Permissions) : string.Empty;
List<Claim> claims =
new()
{
new Claim(Claims.Id, user.Id.ToString()),
new Claim(Claims.Name, user.Username),
new Claim(Claims.Permissions, permissions),
new Claim(Claims.Type, "access")
};
if (user.Email != null)
claims.Add(new Claim(Claims.Email, user.Email));
JwtSecurityToken token =
new(
signingCredentials: credential,
claims: claims,
expires: DateTime.UtcNow.Add(expireIn)
);
return new JwtSecurityTokenHandler().WriteToken(token);
}
SymmetricSecurityKey key = new(Encoding.UTF8.GetBytes(_options.Secret)); /// <inheritdoc />
SigningCredentials credential = new(key, SecurityAlgorithms.HmacSha256Signature); public Task<string> CreateRefreshToken(User user)
string permissions = {
user.Permissions != null ? string.Join(',', user.Permissions) : string.Empty; SymmetricSecurityKey key = new(Encoding.UTF8.GetBytes(_options.Secret));
List<Claim> claims = SigningCredentials credential = new(key, SecurityAlgorithms.HmacSha256Signature);
new() JwtSecurityToken token =
new(
signingCredentials: credential,
claims: new[]
{ {
new Claim(Claims.Id, user.Id.ToString()), new Claim(Claims.Id, user.Id.ToString()),
new Claim(Claims.Name, user.Username), new Claim(Claims.Guid, Guid.NewGuid().ToString()),
new Claim(Claims.Permissions, permissions), new Claim(Claims.Type, "refresh")
new Claim(Claims.Type, "access") },
}; expires: DateTime.UtcNow.AddYears(1)
if (user.Email != null) );
claims.Add(new Claim(Claims.Email, user.Email)); // TODO: refresh keys are unique (thanks to the guid) but we could store them in DB to invalidate them if requested by the user.
JwtSecurityToken token = return Task.FromResult(new JwtSecurityTokenHandler().WriteToken(token));
new( }
signingCredentials: credential,
claims: claims,
expires: DateTime.UtcNow.Add(expireIn)
);
return new JwtSecurityTokenHandler().WriteToken(token);
}
/// <inheritdoc /> /// <inheritdoc />
public Task<string> CreateRefreshToken(User user) public Guid GetRefreshTokenUserID(string refreshToken)
{
SymmetricSecurityKey key = new(Encoding.UTF8.GetBytes(_options.Secret));
JwtSecurityTokenHandler tokenHandler = new();
ClaimsPrincipal principal;
try
{ {
SymmetricSecurityKey key = new(Encoding.UTF8.GetBytes(_options.Secret)); principal = tokenHandler.ValidateToken(
SigningCredentials credential = new(key, SecurityAlgorithms.HmacSha256Signature); refreshToken,
JwtSecurityToken token = new TokenValidationParameters
new( {
signingCredentials: credential, ValidateIssuer = false,
claims: new[] ValidateAudience = false,
{ ValidateIssuerSigningKey = true,
new Claim(Claims.Id, user.Id.ToString()), ValidateLifetime = true,
new Claim(Claims.Guid, Guid.NewGuid().ToString()), IssuerSigningKey = key
new Claim(Claims.Type, "refresh") },
}, out SecurityToken _
expires: DateTime.UtcNow.AddYears(1) );
);
// TODO: refresh keys are unique (thanks to the guid) but we could store them in DB to invalidate them if requested by the user.
return Task.FromResult(new JwtSecurityTokenHandler().WriteToken(token));
} }
catch (Exception)
/// <inheritdoc />
public Guid GetRefreshTokenUserID(string refreshToken)
{ {
SymmetricSecurityKey key = new(Encoding.UTF8.GetBytes(_options.Secret)); throw new SecurityTokenException("Invalid refresh token");
JwtSecurityTokenHandler tokenHandler = new();
ClaimsPrincipal principal;
try
{
principal = tokenHandler.ValidateToken(
refreshToken,
new TokenValidationParameters
{
ValidateIssuer = false,
ValidateAudience = false,
ValidateIssuerSigningKey = true,
ValidateLifetime = true,
IssuerSigningKey = key
},
out SecurityToken _
);
}
catch (Exception)
{
throw new SecurityTokenException("Invalid refresh token");
}
if (principal.Claims.First(x => x.Type == Claims.Type).Value != "refresh")
throw new SecurityTokenException(
"Invalid token type. The token should be a refresh token."
);
Claim identifier = principal.Claims.First(x => x.Type == Claims.Id);
if (Guid.TryParse(identifier.Value, out Guid id))
return id;
throw new SecurityTokenException("Token not associated to any user.");
} }
if (principal.Claims.First(x => x.Type == Claims.Type).Value != "refresh")
throw new SecurityTokenException(
"Invalid token type. The token should be a refresh token."
);
Claim identifier = principal.Claims.First(x => x.Type == Claims.Id);
if (Guid.TryParse(identifier.Value, out Guid id))
return id;
throw new SecurityTokenException("Token not associated to any user.");
} }
} }

45
back/src/Kyoo.Authentication/Models/DTO/LoginRequest.cs
View File

@ -16,32 +16,31 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with Kyoo. If not, see <https://www.gnu.org/licenses/>. // along with Kyoo. If not, see <https://www.gnu.org/licenses/>.
namespace Kyoo.Authentication.Models.DTO namespace Kyoo.Authentication.Models.DTO;
/// <summary>
/// A model only used on login requests.
/// </summary>
public class LoginRequest
{ {
/// <summary> /// <summary>
/// A model only used on login requests. /// The user's username.
/// </summary> /// </summary>
public class LoginRequest public string Username { get; set; }
/// <summary>
/// The user's password.
/// </summary>
public string Password { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="LoginRequest"/> class.
/// </summary>
/// <param name="username">The user's username.</param>
/// <param name="password">The user's password.</param>
public LoginRequest(string username, string password)
{ {
/// <summary> Username = username;
/// The user's username. Password = password;
/// </summary>
public string Username { get; set; }
/// <summary>
/// The user's password.
/// </summary>
public string Password { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="LoginRequest"/> class.
/// </summary>
/// <param name="username">The user's username.</param>
/// <param name="password">The user's password.</param>
public LoginRequest(string username, string password)
{
Username = username;
Password = password;
}
} }
} }

91
back/src/Kyoo.Authentication/Models/DTO/RegisterRequest.cs
View File

@ -21,57 +21,56 @@ using Kyoo.Abstractions.Models;
using Kyoo.Utils; using Kyoo.Utils;
using BCryptNet = BCrypt.Net.BCrypt; using BCryptNet = BCrypt.Net.BCrypt;
namespace Kyoo.Authentication.Models.DTO namespace Kyoo.Authentication.Models.DTO;
/// <summary>
/// A model only used on register requests.
/// </summary>
public class RegisterRequest
{ {
/// <summary> /// <summary>
/// A model only used on register requests. /// The user email address
/// </summary> /// </summary>
public class RegisterRequest [EmailAddress(ErrorMessage = "The email must be a valid email address")]
public string Email { get; set; }
/// <summary>
/// The user's username.
/// </summary>
[MinLength(4, ErrorMessage = "The username must have at least {1} characters")]
public string Username { get; set; }
/// <summary>
/// The user's password.
/// </summary>
[MinLength(4, ErrorMessage = "The password must have at least {1} characters")]
public string Password { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="RegisterRequest"/> class.
/// </summary>
/// <param name="email">The user email address.</param>
/// <param name="username">The user's username.</param>
/// <param name="password">The user's password.</param>
public RegisterRequest(string email, string username, string password)
{ {
/// <summary> Email = email;
/// The user email address Username = username;
/// </summary> Password = password;
[EmailAddress(ErrorMessage = "The email must be a valid email address")] }
public string Email { get; set; }
/// <summary> /// <summary>
/// The user's username. /// Convert this register request to a new <see cref="User"/> class.
/// </summary> /// </summary>
[MinLength(4, ErrorMessage = "The username must have at least {1} characters")] /// <returns>A user representing this request.</returns>
public string Username { get; set; } public User ToUser()
{
/// <summary> return new User
/// The user's password.
/// </summary>
[MinLength(4, ErrorMessage = "The password must have at least {1} characters")]
public string Password { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="RegisterRequest"/> class.
/// </summary>
/// <param name="email">The user email address.</param>
/// <param name="username">The user's username.</param>
/// <param name="password">The user's password.</param>
public RegisterRequest(string email, string username, string password)
{ {
Email = email; Slug = Utility.ToSlug(Username),
Username = username; Username = Username,
Password = password; Password = BCryptNet.HashPassword(Password),
} Email = Email,
};
/// <summary>
/// Convert this register request to a new <see cref="User"/> class.
/// </summary>
/// <returns>A user representing this request.</returns>
public User ToUser()
{
return new User
{
Slug = Utility.ToSlug(Username),
Username = Username,
Password = BCryptNet.HashPassword(Password),
Email = Email,
};
}
} }
} }

41
back/src/Kyoo.Authentication/Models/Options/AuthenticationOption.cs
View File

@ -16,31 +16,30 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with Kyoo. If not, see <https://www.gnu.org/licenses/>. // along with Kyoo. If not, see <https://www.gnu.org/licenses/>.
namespace Kyoo.Authentication.Models namespace Kyoo.Authentication.Models;
/// <summary>
/// The main authentication options.
/// </summary>
public class AuthenticationOption
{ {
/// <summary> /// <summary>
/// The main authentication options. /// The path to get this option from the root configuration.
/// </summary> /// </summary>
public class AuthenticationOption public const string Path = "authentication";
{
/// <summary>
/// The path to get this option from the root configuration.
/// </summary>
public const string Path = "authentication";
/// <summary> /// <summary>
/// The default jwt secret. /// The default jwt secret.
/// </summary> /// </summary>
public const string DefaultSecret = "4c@mraGB!KRfF@kpS8739y9FcHemKxBsqqxLbdR?"; public const string DefaultSecret = "4c@mraGB!KRfF@kpS8739y9FcHemKxBsqqxLbdR?";
/// <summary> /// <summary>
/// The secret used to encrypt the jwt. /// The secret used to encrypt the jwt.
/// </summary> /// </summary>
public string Secret { get; set; } = DefaultSecret; public string Secret { get; set; } = DefaultSecret;
/// <summary> /// <summary>
/// Options for permissions /// Options for permissions
/// </summary> /// </summary>
public PermissionOption Permissions { get; set; } = new(); public PermissionOption Permissions { get; set; } = new();
}
} }

870
back/src/Kyoo.Authentication/Views/AuthApi.cs
View File

@ -35,464 +35,458 @@ using Microsoft.IdentityModel.Tokens;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
using BCryptNet = BCrypt.Net.BCrypt; using BCryptNet = BCrypt.Net.BCrypt;
namespace Kyoo.Authentication.Views namespace Kyoo.Authentication.Views;
/// <summary>
/// Sign in, Sign up or refresh tokens.
/// </summary>
[ApiController]
[Route("auth")]
[ApiDefinition("Authentication", Group = UsersGroup)]
public class AuthApi(
IUserRepository users,
OidcController oidc,
ITokenController tokenController,
IThumbnailsManager thumbs,
PermissionOption options
) : ControllerBase
{ {
/// <summary> /// <summary>
/// Sign in, Sign up or refresh tokens. /// Create a new Forbidden result from an object.
/// </summary> /// </summary>
[ApiController] /// <param name="value">The json value to output on the response.</param>
[Route("auth")] /// <returns>A new forbidden result with the given json object.</returns>
[ApiDefinition("Authentication", Group = UsersGroup)] public static ObjectResult Forbid(object value)
public class AuthApi(
IUserRepository users,
OidcController oidc,
ITokenController tokenController,
IThumbnailsManager thumbs,
PermissionOption options
) : ControllerBase
{ {
/// <summary> return new ObjectResult(value) { StatusCode = StatusCodes.Status403Forbidden };
/// Create a new Forbidden result from an object. }
/// </summary>
/// <param name="value">The json value to output on the response.</param>
/// <returns>A new forbidden result with the given json object.</returns>
public static ObjectResult Forbid(object value)
{
return new ObjectResult(value) { StatusCode = StatusCodes.Status403Forbidden };
}
private static string _BuildUrl(string baseUrl, Dictionary<string, string?> queryParams) private static string _BuildUrl(string baseUrl, Dictionary<string, string?> queryParams)
{
char querySep = baseUrl.Contains('?') ? '&' : '?';
foreach ((string key, string? val) in queryParams)
{ {
char querySep = baseUrl.Contains('?') ? '&' : '?'; if (val is null)
foreach ((string key, string? val) in queryParams) continue;
{ baseUrl += $"{querySep}{key}={val}";
if (val is null) querySep = '&';
continue;
baseUrl += $"{querySep}{key}={val}";
querySep = '&';
}
return baseUrl;
} }
return baseUrl;
}
/// <summary> /// <summary>
/// Oauth Login. /// Oauth Login.
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Login via a registered oauth provider. /// Login via a registered oauth provider.
/// </remarks> /// </remarks>
/// <param name="provider">The provider code.</param> /// <param name="provider">The provider code.</param>
/// <param name="redirectUrl"> /// <param name="redirectUrl">
/// A url where you will be redirected with the query params provider, code and error. It can be a deep link. /// A url where you will be redirected with the query params provider, code and error. It can be a deep link.
/// </param> /// </param>
/// <returns>A redirect to the provider's login page.</returns> /// <returns>A redirect to the provider's login page.</returns>
/// <response code="404">The provider is not register with this instance of kyoo.</response> /// <response code="404">The provider is not register with this instance of kyoo.</response>
[HttpGet("login/{provider}")] [HttpGet("login/{provider}")]
[ProducesResponseType(StatusCodes.Status302Found)] [ProducesResponseType(StatusCodes.Status302Found)]
[ProducesResponseType(StatusCodes.Status404NotFound, Type = typeof(RequestError))] [ProducesResponseType(StatusCodes.Status404NotFound, Type = typeof(RequestError))]
public ActionResult<JwtToken> LoginVia(string provider, [FromQuery] string redirectUrl) public ActionResult<JwtToken> LoginVia(string provider, [FromQuery] string redirectUrl)
{
if (!options.OIDC.ContainsKey(provider) || !options.OIDC[provider].Enabled)
{ {
if (!options.OIDC.ContainsKey(provider) || !options.OIDC[provider].Enabled) return NotFound(
{ new RequestError(
return NotFound( $"Invalid provider. {provider} is not registered no this instance of kyoo."
new RequestError(
$"Invalid provider. {provider} is not registered no this instance of kyoo."
)
);
}
OidcProvider prov = options.OIDC[provider];
return Redirect(
_BuildUrl(
prov.AuthorizationUrl,
new()
{
["response_type"] = "code",
["client_id"] = prov.ClientId,
["redirect_uri"] =
$"{options.PublicUrl.TrimEnd('/')}/api/auth/logged/{provider}",
["scope"] = prov.Scope,
["state"] = redirectUrl,
}
) )
); );
} }
OidcProvider prov = options.OIDC[provider];
/// <summary> return Redirect(
/// Oauth Code Redirect. _BuildUrl(
/// </summary> prov.AuthorizationUrl,
/// <remarks> new()
/// This route is not meant to be called manually, the user should be redirected automatically here
/// after a successful login on the /login/{provider} page.
/// </remarks>
/// <returns>A redirect to the provider's login page.</returns>
/// <response code="403">The provider gave an error.</response>
[HttpGet("logged/{provider}")]
[ProducesResponseType(StatusCodes.Status302Found)]
public ActionResult OauthCodeRedirect(
string provider,
string code,
string state,
string? error
)
{
return Redirect(
_BuildUrl(
state,
new()
{
["provider"] = provider,
["code"] = code,
["error"] = error,
}
)
);
}
/// <summary>
/// Oauth callback
/// </summary>
/// <remarks>
/// This route should be manually called by the page that got redirected to after a call to /login/{provider}.
/// </remarks>
/// <returns>A jwt token</returns>
/// <response code="400">Bad provider or code</response>
[HttpPost("callback/{provider}")]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
public async Task<ActionResult<JwtToken>> OauthCallback(string provider, string code)
{
if (!options.OIDC.ContainsKey(provider) || !options.OIDC[provider].Enabled)
{
return NotFound(
new RequestError(
$"Invalid provider. {provider} is not registered no this instance of kyoo."
)
);
}
if (code == null)
return BadRequest(new RequestError("Invalid code."));
Guid? userId = User.GetId();
User user = userId.HasValue
? await oidc.LinkAccountOrLogin(userId.Value, provider, code)
: await oidc.LoginViaCode(provider, code);
return new JwtToken(
tokenController.CreateAccessToken(user, out TimeSpan expireIn),
await tokenController.CreateRefreshToken(user),
expireIn
);
}
/// <summary>
/// Unlink account
/// </summary>
/// <remarks>
/// Unlink your account from an external account.
/// </remarks>
/// <param name="provider">The provider code.</param>
/// <returns>Your updated user account</returns>
[HttpDelete("login/{provider}")]
[ProducesResponseType(StatusCodes.Status200OK)]
[UserOnly]
public Task<User> UnlinkAccount(string provider)
{
Guid id = User.GetIdOrThrow();
return users.DeleteExternalToken(id, provider);
}
/// <summary>
/// Login.
/// </summary>
/// <remarks>
/// Login as a user and retrieve an access and a refresh token.
/// </remarks>
/// <param name="request">The body of the request.</param>
/// <returns>A new access and a refresh token.</returns>
/// <response code="403">The user and password does not match.</response>
[HttpPost("login")]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<JwtToken>> Login([FromBody] LoginRequest request)
{
User? user = await users.GetOrDefault(
new Filter<User>.Eq(nameof(Abstractions.Models.User.Username), request.Username)
);
if (user == null || !BCryptNet.Verify(request.Password, user.Password))
return Forbid(new RequestError("The user and password does not match."));
return new JwtToken(
tokenController.CreateAccessToken(user, out TimeSpan expireIn),
await tokenController.CreateRefreshToken(user),
expireIn
);
}
/// <summary>
/// Register.
/// </summary>
/// <remarks>
/// Register a new user and get a new access/refresh token for this new user.
/// </remarks>
/// <param name="request">The body of the request.</param>
/// <returns>A new access and a refresh token.</returns>
/// <response code="400">The request is invalid.</response>
/// <response code="409">A user already exists with this username or email address.</response>
[HttpPost("register")]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status409Conflict, Type = typeof(RequestError))]
public async Task<ActionResult<JwtToken>> Register([FromBody] RegisterRequest request)
{
try
{
User user = await users.Create(request.ToUser());
return new JwtToken(
tokenController.CreateAccessToken(user, out TimeSpan expireIn),
await tokenController.CreateRefreshToken(user),
expireIn
);
}
catch (DuplicatedItemException)
{
return Conflict(new RequestError("A user already exists with this username."));
}
}
/// <summary>
/// Refresh a token.
/// </summary>
/// <remarks>
/// Refresh an access token using the given refresh token. A new access and refresh token are generated.
/// </remarks>
/// <param name="token">A valid refresh token.</param>
/// <returns>A new access and refresh token.</returns>
/// <response code="403">The given refresh token is invalid.</response>
[HttpGet("refresh")]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<JwtToken>> Refresh([FromQuery] string token)
{
try
{
Guid userId = tokenController.GetRefreshTokenUserID(token);
User user = await users.Get(userId);
return new JwtToken(
tokenController.CreateAccessToken(user, out TimeSpan expireIn),
await tokenController.CreateRefreshToken(user),
expireIn
);
}
catch (ItemNotFoundException)
{
return Forbid(new RequestError("Invalid refresh token."));
}
catch (SecurityTokenException ex)
{
return Forbid(new RequestError(ex.Message));
}
}
/// <summary>
/// Reset your password
/// </summary>
/// <remarks>
/// Change your password.
/// </remarks>
/// <param name="request">The old and new password</param>
/// <returns>Your account info.</returns>
/// <response code="403">The old password is invalid.</response>
[HttpPost("password-reset")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<User>> ResetPassword([FromBody] PasswordResetRequest request)
{
User user = await users.Get(User.GetIdOrThrow());
if (user.HasPassword && !BCryptNet.Verify(request.OldPassword, user.Password))
return Forbid(new RequestError("The old password is invalid."));
return await users.Patch(
user.Id,
(user) =>
{ {
user.Password = BCryptNet.HashPassword(request.NewPassword); ["response_type"] = "code",
return user; ["client_id"] = prov.ClientId,
["redirect_uri"] =
$"{options.PublicUrl.TrimEnd('/')}/api/auth/logged/{provider}",
["scope"] = prov.Scope,
["state"] = redirectUrl,
} }
)
);
}
/// <summary>
/// Oauth Code Redirect.
/// </summary>
/// <remarks>
/// This route is not meant to be called manually, the user should be redirected automatically here
/// after a successful login on the /login/{provider} page.
/// </remarks>
/// <returns>A redirect to the provider's login page.</returns>
/// <response code="403">The provider gave an error.</response>
[HttpGet("logged/{provider}")]
[ProducesResponseType(StatusCodes.Status302Found)]
public ActionResult OauthCodeRedirect(string provider, string code, string state, string? error)
{
return Redirect(
_BuildUrl(
state,
new()
{
["provider"] = provider,
["code"] = code,
["error"] = error,
}
)
);
}
/// <summary>
/// Oauth callback
/// </summary>
/// <remarks>
/// This route should be manually called by the page that got redirected to after a call to /login/{provider}.
/// </remarks>
/// <returns>A jwt token</returns>
/// <response code="400">Bad provider or code</response>
[HttpPost("callback/{provider}")]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
public async Task<ActionResult<JwtToken>> OauthCallback(string provider, string code)
{
if (!options.OIDC.ContainsKey(provider) || !options.OIDC[provider].Enabled)
{
return NotFound(
new RequestError(
$"Invalid provider. {provider} is not registered no this instance of kyoo."
)
); );
} }
if (code == null)
return BadRequest(new RequestError("Invalid code."));
/// <summary> Guid? userId = User.GetId();
/// Get authenticated user. User user = userId.HasValue
/// </summary> ? await oidc.LinkAccountOrLogin(userId.Value, provider, code)
/// <remarks> : await oidc.LoginViaCode(provider, code);
/// Get information about the currently authenticated user. This can also be used to ensure that you are return new JwtToken(
/// logged in. tokenController.CreateAccessToken(user, out TimeSpan expireIn),
/// </remarks> await tokenController.CreateRefreshToken(user),
/// <returns>The currently authenticated user.</returns> expireIn
/// <response code="401">The user is not authenticated.</response> );
/// <response code="403">The given access token is invalid.</response> }
[HttpGet("me")]
[UserOnly] /// <summary>
[ProducesResponseType(StatusCodes.Status200OK)] /// Unlink account
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))] /// </summary>
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))] /// <remarks>
public async Task<ActionResult<User>> GetMe() /// Unlink your account from an external account.
/// </remarks>
/// <param name="provider">The provider code.</param>
/// <returns>Your updated user account</returns>
[HttpDelete("login/{provider}")]
[ProducesResponseType(StatusCodes.Status200OK)]
[UserOnly]
public Task<User> UnlinkAccount(string provider)
{
Guid id = User.GetIdOrThrow();
return users.DeleteExternalToken(id, provider);
}
/// <summary>
/// Login.
/// </summary>
/// <remarks>
/// Login as a user and retrieve an access and a refresh token.
/// </remarks>
/// <param name="request">The body of the request.</param>
/// <returns>A new access and a refresh token.</returns>
/// <response code="403">The user and password does not match.</response>
[HttpPost("login")]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<JwtToken>> Login([FromBody] LoginRequest request)
{
User? user = await users.GetOrDefault(
new Filter<User>.Eq(nameof(Abstractions.Models.User.Username), request.Username)
);
if (user == null || !BCryptNet.Verify(request.Password, user.Password))
return Forbid(new RequestError("The user and password does not match."));
return new JwtToken(
tokenController.CreateAccessToken(user, out TimeSpan expireIn),
await tokenController.CreateRefreshToken(user),
expireIn
);
}
/// <summary>
/// Register.
/// </summary>
/// <remarks>
/// Register a new user and get a new access/refresh token for this new user.
/// </remarks>
/// <param name="request">The body of the request.</param>
/// <returns>A new access and a refresh token.</returns>
/// <response code="400">The request is invalid.</response>
/// <response code="409">A user already exists with this username or email address.</response>
[HttpPost("register")]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status409Conflict, Type = typeof(RequestError))]
public async Task<ActionResult<JwtToken>> Register([FromBody] RegisterRequest request)
{
try
{ {
try User user = await users.Create(request.ToUser());
{ return new JwtToken(
return await users.Get(User.GetIdOrThrow()); tokenController.CreateAccessToken(user, out TimeSpan expireIn),
} await tokenController.CreateRefreshToken(user),
catch (ItemNotFoundException) expireIn
{ );
return Forbid(new RequestError("Invalid token"));
}
} }
catch (DuplicatedItemException)
/// <summary>
/// Edit self
/// </summary>
/// <remarks>
/// Edit information about the currently authenticated user.
/// </remarks>
/// <param name="user">The new data for the current user.</param>
/// <returns>The currently authenticated user after modifications.</returns>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpPut("me")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<User>> EditMe(User user)
{ {
try return Conflict(new RequestError("A user already exists with this username."));
{
user.Id = User.GetIdOrThrow();
return await users.Edit(user);
}
catch (ItemNotFoundException)
{
return Forbid(new RequestError("Invalid token"));
}
}
/// <summary>
/// Patch self
/// </summary>
/// <remarks>
/// Edit only provided informations about the currently authenticated user.
/// </remarks>
/// <param name="patch">The new data for the current user.</param>
/// <returns>The currently authenticated user after modifications.</returns>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpPatch("me")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<User>> PatchMe([FromBody] Patch<User> patch)
{
Guid userId = User.GetIdOrThrow();
try
{
if (patch.Id.HasValue && patch.Id != userId)
throw new ArgumentException("Can't edit your user id.");
if (patch.ContainsKey(nameof(Abstractions.Models.User.Password)))
throw new ArgumentException(
"Can't edit your password via a PATCH. Use /auth/password-reset"
);
return await users.Patch(userId, patch.Apply);
}
catch (ItemNotFoundException)
{
return Forbid(new RequestError("Invalid token"));
}
}
/// <summary>
/// Delete account
/// </summary>
/// <remarks>
/// Delete the current account.
/// </remarks>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpDelete("me")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<User>> DeleteMe()
{
try
{
await users.Delete(User.GetIdOrThrow());
return NoContent();
}
catch (ItemNotFoundException)
{
return Forbid(new RequestError("Invalid token"));
}
}
/// <summary>
/// Get profile picture
/// </summary>
/// <remarks>
/// Get your profile picture
/// </remarks>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpGet("me/logo")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult> GetProfilePicture()
{
Stream img = await thumbs.GetUserImage(User.GetIdOrThrow());
// Allow clients to cache the image for 6 month.
Response.Headers.Add("Cache-Control", $"public, max-age={60 * 60 * 24 * 31 * 6}");
return File(img, "image/webp", true);
}
/// <summary>
/// Set profile picture
/// </summary>
/// <remarks>
/// Set your profile picture
/// </remarks>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpPost("me/logo")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult> SetProfilePicture(IFormFile picture)
{
if (picture == null || picture.Length == 0)
return BadRequest();
await thumbs.SetUserImage(User.GetIdOrThrow(), picture.OpenReadStream());
return NoContent();
}
/// <summary>
/// Delete profile picture
/// </summary>
/// <remarks>
/// Delete your profile picture
/// </remarks>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpDelete("me/logo")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult> DeleteProfilePicture()
{
await thumbs.SetUserImage(User.GetIdOrThrow(), null);
return NoContent();
} }
} }
/// <summary>
/// Refresh a token.
/// </summary>
/// <remarks>
/// Refresh an access token using the given refresh token. A new access and refresh token are generated.
/// </remarks>
/// <param name="token">A valid refresh token.</param>
/// <returns>A new access and refresh token.</returns>
/// <response code="403">The given refresh token is invalid.</response>
[HttpGet("refresh")]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<JwtToken>> Refresh([FromQuery] string token)
{
try
{
Guid userId = tokenController.GetRefreshTokenUserID(token);
User user = await users.Get(userId);
return new JwtToken(
tokenController.CreateAccessToken(user, out TimeSpan expireIn),
await tokenController.CreateRefreshToken(user),
expireIn
);
}
catch (ItemNotFoundException)
{
return Forbid(new RequestError("Invalid refresh token."));
}
catch (SecurityTokenException ex)
{
return Forbid(new RequestError(ex.Message));
}
}
/// <summary>
/// Reset your password
/// </summary>
/// <remarks>
/// Change your password.
/// </remarks>
/// <param name="request">The old and new password</param>
/// <returns>Your account info.</returns>
/// <response code="403">The old password is invalid.</response>
[HttpPost("password-reset")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<User>> ResetPassword([FromBody] PasswordResetRequest request)
{
User user = await users.Get(User.GetIdOrThrow());
if (user.HasPassword && !BCryptNet.Verify(request.OldPassword, user.Password))
return Forbid(new RequestError("The old password is invalid."));
return await users.Patch(
user.Id,
(user) =>
{
user.Password = BCryptNet.HashPassword(request.NewPassword);
return user;
}
);
}
/// <summary>
/// Get authenticated user.
/// </summary>
/// <remarks>
/// Get information about the currently authenticated user. This can also be used to ensure that you are
/// logged in.
/// </remarks>
/// <returns>The currently authenticated user.</returns>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpGet("me")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<User>> GetMe()
{
try
{
return await users.Get(User.GetIdOrThrow());
}
catch (ItemNotFoundException)
{
return Forbid(new RequestError("Invalid token"));
}
}
/// <summary>
/// Edit self
/// </summary>
/// <remarks>
/// Edit information about the currently authenticated user.
/// </remarks>
/// <param name="user">The new data for the current user.</param>
/// <returns>The currently authenticated user after modifications.</returns>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpPut("me")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<User>> EditMe(User user)
{
try
{
user.Id = User.GetIdOrThrow();
return await users.Edit(user);
}
catch (ItemNotFoundException)
{
return Forbid(new RequestError("Invalid token"));
}
}
/// <summary>
/// Patch self
/// </summary>
/// <remarks>
/// Edit only provided informations about the currently authenticated user.
/// </remarks>
/// <param name="patch">The new data for the current user.</param>
/// <returns>The currently authenticated user after modifications.</returns>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpPatch("me")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<User>> PatchMe([FromBody] Patch<User> patch)
{
Guid userId = User.GetIdOrThrow();
try
{
if (patch.Id.HasValue && patch.Id != userId)
throw new ArgumentException("Can't edit your user id.");
if (patch.ContainsKey(nameof(Abstractions.Models.User.Password)))
throw new ArgumentException(
"Can't edit your password via a PATCH. Use /auth/password-reset"
);
return await users.Patch(userId, patch.Apply);
}
catch (ItemNotFoundException)
{
return Forbid(new RequestError("Invalid token"));
}
}
/// <summary>
/// Delete account
/// </summary>
/// <remarks>
/// Delete the current account.
/// </remarks>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpDelete("me")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult<User>> DeleteMe()
{
try
{
await users.Delete(User.GetIdOrThrow());
return NoContent();
}
catch (ItemNotFoundException)
{
return Forbid(new RequestError("Invalid token"));
}
}
/// <summary>
/// Get profile picture
/// </summary>
/// <remarks>
/// Get your profile picture
/// </remarks>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpGet("me/logo")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult> GetProfilePicture()
{
Stream img = await thumbs.GetUserImage(User.GetIdOrThrow());
// Allow clients to cache the image for 6 month.
Response.Headers.Add("Cache-Control", $"public, max-age={60 * 60 * 24 * 31 * 6}");
return File(img, "image/webp", true);
}
/// <summary>
/// Set profile picture
/// </summary>
/// <remarks>
/// Set your profile picture
/// </remarks>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpPost("me/logo")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult> SetProfilePicture(IFormFile picture)
{
if (picture == null || picture.Length == 0)
return BadRequest();
await thumbs.SetUserImage(User.GetIdOrThrow(), picture.OpenReadStream());
return NoContent();
}
/// <summary>
/// Delete profile picture
/// </summary>
/// <remarks>
/// Delete your profile picture
/// </remarks>
/// <response code="401">The user is not authenticated.</response>
/// <response code="403">The given access token is invalid.</response>
[HttpDelete("me/logo")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status401Unauthorized, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status403Forbidden, Type = typeof(RequestError))]
public async Task<ActionResult> DeleteProfilePicture()
{
await thumbs.SetUserImage(User.GetIdOrThrow(), null);
return NoContent();
}
} }

31
back/src/Kyoo.Core/Controllers/IdentifierRouteConstraint.cs
View File

@ -20,23 +20,22 @@ using Kyoo.Abstractions.Models.Utils;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing; using Microsoft.AspNetCore.Routing;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// The route constraint that goes with the <see cref="Identifier"/>.
/// </summary>
public class IdentifierRouteConstraint : IRouteConstraint
{ {
/// <summary> /// <inheritdoc />
/// The route constraint that goes with the <see cref="Identifier"/>. public bool Match(
/// </summary> HttpContext? httpContext,
public class IdentifierRouteConstraint : IRouteConstraint IRouter? route,
string routeKey,
RouteValueDictionary values,
RouteDirection routeDirection
)
{ {
/// <inheritdoc /> return values.ContainsKey(routeKey);
public bool Match(
HttpContext? httpContext,
IRouter? route,
string routeKey,
RouteValueDictionary values,
RouteDirection routeDirection
)
{
return values.ContainsKey(routeKey);
}
} }
} }

133
back/src/Kyoo.Core/Controllers/LibraryManager.cs
View File

@ -20,87 +20,86 @@ using System.Linq;
using Kyoo.Abstractions.Controllers; using Kyoo.Abstractions.Controllers;
using Kyoo.Abstractions.Models; using Kyoo.Abstractions.Models;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// An class to interact with the database. Every repository is mapped through here.
/// </summary>
public class LibraryManager : ILibraryManager
{ {
/// <summary> private readonly IBaseRepository[] _repositories;
/// An class to interact with the database. Every repository is mapped through here.
/// </summary> public LibraryManager(
public class LibraryManager : ILibraryManager IRepository<ILibraryItem> libraryItemRepository,
IRepository<INews> newsRepository,
IWatchStatusRepository watchStatusRepository,
IRepository<Collection> collectionRepository,
IRepository<Movie> movieRepository,
IRepository<Show> showRepository,
IRepository<Season> seasonRepository,
IRepository<Episode> episodeRepository,
IRepository<Studio> studioRepository,
IRepository<User> userRepository
)
{ {
private readonly IBaseRepository[] _repositories; LibraryItems = libraryItemRepository;
News = newsRepository;
WatchStatus = watchStatusRepository;
Collections = collectionRepository;
Movies = movieRepository;
Shows = showRepository;
Seasons = seasonRepository;
Episodes = episodeRepository;
Studios = studioRepository;
Users = userRepository;
public LibraryManager( _repositories = new IBaseRepository[]
IRepository<ILibraryItem> libraryItemRepository,
IRepository<INews> newsRepository,
IWatchStatusRepository watchStatusRepository,
IRepository<Collection> collectionRepository,
IRepository<Movie> movieRepository,
IRepository<Show> showRepository,
IRepository<Season> seasonRepository,
IRepository<Episode> episodeRepository,
IRepository<Studio> studioRepository,
IRepository<User> userRepository
)
{ {
LibraryItems = libraryItemRepository; LibraryItems,
News = newsRepository; News,
WatchStatus = watchStatusRepository; Collections,
Collections = collectionRepository; Movies,
Movies = movieRepository; Shows,
Shows = showRepository; Seasons,
Seasons = seasonRepository; Episodes,
Episodes = episodeRepository; Studios,
Studios = studioRepository; Users
Users = userRepository; };
}
_repositories = new IBaseRepository[] /// <inheritdoc />
{ public IRepository<ILibraryItem> LibraryItems { get; }
LibraryItems,
News,
Collections,
Movies,
Shows,
Seasons,
Episodes,
Studios,
Users
};
}
/// <inheritdoc /> /// <inheritdoc />
public IRepository<ILibraryItem> LibraryItems { get; } public IRepository<INews> News { get; }
/// <inheritdoc /> /// <inheritdoc />
public IRepository<INews> News { get; } public IWatchStatusRepository WatchStatus { get; }
/// <inheritdoc /> /// <inheritdoc />
public IWatchStatusRepository WatchStatus { get; } public IRepository<Collection> Collections { get; }
/// <inheritdoc /> /// <inheritdoc />
public IRepository<Collection> Collections { get; } public IRepository<Movie> Movies { get; }
/// <inheritdoc /> /// <inheritdoc />
public IRepository<Movie> Movies { get; } public IRepository<Show> Shows { get; }
/// <inheritdoc /> /// <inheritdoc />
public IRepository<Show> Shows { get; } public IRepository<Season> Seasons { get; }
/// <inheritdoc /> /// <inheritdoc />
public IRepository<Season> Seasons { get; } public IRepository<Episode> Episodes { get; }
/// <inheritdoc /> /// <inheritdoc />
public IRepository<Episode> Episodes { get; } public IRepository<Studio> Studios { get; }
/// <inheritdoc /> /// <inheritdoc />
public IRepository<Studio> Studios { get; } public IRepository<User> Users { get; }
/// <inheritdoc /> public IRepository<T> Repository<T>()
public IRepository<User> Users { get; } where T : IResource, IQuery
{
public IRepository<T> Repository<T>() return (IRepository<T>)_repositories.First(x => x.RepositoryType == typeof(T));
where T : IResource, IQuery
{
return (IRepository<T>)_repositories.First(x => x.RepositoryType == typeof(T));
}
} }
} }

123
back/src/Kyoo.Core/Controllers/Repositories/CollectionRepository.cs
View File

@ -26,78 +26,77 @@ using Kyoo.Abstractions.Models.Utils;
using Kyoo.Postgresql; using Kyoo.Postgresql;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// A local repository to handle collections
/// </summary>
public class CollectionRepository : LocalRepository<Collection>
{ {
/// <summary> /// <summary>
/// A local repository to handle collections /// The database handle
/// </summary> /// </summary>
public class CollectionRepository : LocalRepository<Collection> private readonly DatabaseContext _database;
/// <summary>
/// Create a new <see cref="CollectionRepository"/>.
/// </summary>
/// <param name="database">The database handle to use</param>
/// <param name="thumbs">The thumbnail manager used to store images.</param>
public CollectionRepository(DatabaseContext database, IThumbnailsManager thumbs)
: base(database, thumbs)
{ {
/// <summary> _database = database;
/// The database handle }
/// </summary>
private readonly DatabaseContext _database;
/// <summary> /// <inheritdoc />
/// Create a new <see cref="CollectionRepository"/>. public override async Task<ICollection<Collection>> Search(
/// </summary> string query,
/// <param name="database">The database handle to use</param> Include<Collection>? include = default
/// <param name="thumbs">The thumbnail manager used to store images.</param> )
public CollectionRepository(DatabaseContext database, IThumbnailsManager thumbs) {
: base(database, thumbs) return await AddIncludes(_database.Collections, include)
{ .Where(x => EF.Functions.ILike(x.Name + " " + x.Slug, $"%{query}%"))
_database = database; .Take(20)
} .ToListAsync();
}
/// <inheritdoc /> /// <inheritdoc />
public override async Task<ICollection<Collection>> Search( public override async Task<Collection> Create(Collection obj)
string query, {
Include<Collection>? include = default await base.Create(obj);
) _database.Entry(obj).State = EntityState.Added;
{ await _database.SaveChangesAsync(() => Get(obj.Slug));
return await AddIncludes(_database.Collections, include) await IRepository<Collection>.OnResourceCreated(obj);
.Where(x => EF.Functions.ILike(x.Name + " " + x.Slug, $"%{query}%")) return obj;
.Take(20) }
.ToListAsync();
}
/// <inheritdoc /> /// <inheritdoc />
public override async Task<Collection> Create(Collection obj) protected override async Task Validate(Collection resource)
{ {
await base.Create(obj); await base.Validate(resource);
_database.Entry(obj).State = EntityState.Added;
await _database.SaveChangesAsync(() => Get(obj.Slug));
await IRepository<Collection>.OnResourceCreated(obj);
return obj;
}
/// <inheritdoc /> if (string.IsNullOrEmpty(resource.Name))
protected override async Task Validate(Collection resource) throw new ArgumentException("The collection's name must be set and not empty");
{ }
await base.Validate(resource);
if (string.IsNullOrEmpty(resource.Name)) public async Task AddMovie(Guid id, Guid movieId)
throw new ArgumentException("The collection's name must be set and not empty"); {
} _database.AddLinks<Collection, Movie>(id, movieId);
await _database.SaveChangesAsync();
}
public async Task AddMovie(Guid id, Guid movieId) public async Task AddShow(Guid id, Guid showId)
{ {
_database.AddLinks<Collection, Movie>(id, movieId); _database.AddLinks<Collection, Show>(id, showId);
await _database.SaveChangesAsync(); await _database.SaveChangesAsync();
} }
public async Task AddShow(Guid id, Guid showId) /// <inheritdoc />
{ public override async Task Delete(Collection obj)
_database.AddLinks<Collection, Show>(id, showId); {
await _database.SaveChangesAsync(); _database.Entry(obj).State = EntityState.Deleted;
} await _database.SaveChangesAsync();
await base.Delete(obj);
/// <inheritdoc />
public override async Task Delete(Collection obj)
{
_database.Entry(obj).State = EntityState.Deleted;
await _database.SaveChangesAsync();
await base.Delete(obj);
}
} }
} }

226
back/src/Kyoo.Core/Controllers/Repositories/EpisodeRepository.cs
View File

@ -27,130 +27,128 @@ using Kyoo.Postgresql;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// A local repository to handle episodes.
/// </summary>
public class EpisodeRepository : LocalRepository<Episode>
{ {
/// <summary> /// <summary>
/// A local repository to handle episodes. /// The database handle
/// </summary> /// </summary>
public class EpisodeRepository : LocalRepository<Episode> private readonly DatabaseContext _database;
private readonly IRepository<Show> _shows;
static EpisodeRepository()
{ {
/// <summary> // Edit episode slugs when the show's slug changes.
/// The database handle IRepository<Show>.OnEdited += async (show) =>
/// </summary>
private readonly DatabaseContext _database;
private readonly IRepository<Show> _shows;
static EpisodeRepository()
{ {
// Edit episode slugs when the show's slug changes. await using AsyncServiceScope scope = CoreModule.Services.CreateAsyncScope();
IRepository<Show>.OnEdited += async (show) => DatabaseContext database = scope.ServiceProvider.GetRequiredService<DatabaseContext>();
{ List<Episode> episodes = await database
await using AsyncServiceScope scope = CoreModule.Services.CreateAsyncScope(); .Episodes.AsTracking()
DatabaseContext database = .Where(x => x.ShowId == show.Id)
scope.ServiceProvider.GetRequiredService<DatabaseContext>();
List<Episode> episodes = await database
.Episodes.AsTracking()
.Where(x => x.ShowId == show.Id)
.ToListAsync();
foreach (Episode ep in episodes)
{
ep.ShowSlug = show.Slug;
await database.SaveChangesAsync();
await IRepository<Episode>.OnResourceEdited(ep);
}
};
}
/// <summary>
/// Create a new <see cref="EpisodeRepository"/>.
/// </summary>
/// <param name="database">The database handle to use.</param>
/// <param name="shows">A show repository</param>
/// <param name="thumbs">The thumbnail manager used to store images.</param>
public EpisodeRepository(
DatabaseContext database,
IRepository<Show> shows,
IThumbnailsManager thumbs
)
: base(database, thumbs)
{
_database = database;
_shows = shows;
}
/// <inheritdoc />
public override async Task<ICollection<Episode>> Search(
string query,
Include<Episode>? include = default
)
{
return await AddIncludes(_database.Episodes, include)
.Where(x => EF.Functions.ILike(x.Name!, $"%{query}%"))
.Take(20)
.ToListAsync(); .ToListAsync();
} foreach (Episode ep in episodes)
{
ep.ShowSlug = show.Slug;
await database.SaveChangesAsync();
await IRepository<Episode>.OnResourceEdited(ep);
}
};
}
protected override Task<Episode?> GetDuplicated(Episode item) /// <summary>
{ /// Create a new <see cref="EpisodeRepository"/>.
if (item is { SeasonNumber: not null, EpisodeNumber: not null }) /// </summary>
return _database.Episodes.FirstOrDefaultAsync(x => /// <param name="database">The database handle to use.</param>
x.ShowId == item.ShowId /// <param name="shows">A show repository</param>
&& x.SeasonNumber == item.SeasonNumber /// <param name="thumbs">The thumbnail manager used to store images.</param>
&& x.EpisodeNumber == item.EpisodeNumber public EpisodeRepository(
); DatabaseContext database,
IRepository<Show> shows,
IThumbnailsManager thumbs
)
: base(database, thumbs)
{
_database = database;
_shows = shows;
}
/// <inheritdoc />
public override async Task<ICollection<Episode>> Search(
string query,
Include<Episode>? include = default
)
{
return await AddIncludes(_database.Episodes, include)
.Where(x => EF.Functions.ILike(x.Name!, $"%{query}%"))
.Take(20)
.ToListAsync();
}
protected override Task<Episode?> GetDuplicated(Episode item)
{
if (item is { SeasonNumber: not null, EpisodeNumber: not null })
return _database.Episodes.FirstOrDefaultAsync(x => return _database.Episodes.FirstOrDefaultAsync(x =>
x.ShowId == item.ShowId && x.AbsoluteNumber == item.AbsoluteNumber x.ShowId == item.ShowId
&& x.SeasonNumber == item.SeasonNumber
&& x.EpisodeNumber == item.EpisodeNumber
);
return _database.Episodes.FirstOrDefaultAsync(x =>
x.ShowId == item.ShowId && x.AbsoluteNumber == item.AbsoluteNumber
);
}
/// <inheritdoc />
public override async Task<Episode> Create(Episode obj)
{
obj.ShowSlug =
obj.Show?.Slug ?? (await _database.Shows.FirstAsync(x => x.Id == obj.ShowId)).Slug;
await base.Create(obj);
_database.Entry(obj).State = EntityState.Added;
await _database.SaveChangesAsync(() => GetDuplicated(obj));
await IRepository<Episode>.OnResourceCreated(obj);
return obj;
}
/// <inheritdoc />
protected override async Task Validate(Episode resource)
{
await base.Validate(resource);
if (resource.ShowId == Guid.Empty)
{
if (resource.Show == null)
{
throw new ArgumentException(
$"Can't store an episode not related "
+ $"to any show (showID: {resource.ShowId})."
);
}
resource.ShowId = resource.Show.Id;
}
if (resource.SeasonId == null && resource.SeasonNumber != null)
{
resource.Season = await _database.Seasons.FirstOrDefaultAsync(x =>
x.ShowId == resource.ShowId && x.SeasonNumber == resource.SeasonNumber
); );
} }
}
/// <inheritdoc /> /// <inheritdoc />
public override async Task<Episode> Create(Episode obj) public override async Task Delete(Episode obj)
{ {
obj.ShowSlug = int epCount = await _database
obj.Show?.Slug ?? (await _database.Shows.FirstAsync(x => x.Id == obj.ShowId)).Slug; .Episodes.Where(x => x.ShowId == obj.ShowId)
await base.Create(obj); .Take(2)
_database.Entry(obj).State = EntityState.Added; .CountAsync();
await _database.SaveChangesAsync(() => GetDuplicated(obj)); _database.Entry(obj).State = EntityState.Deleted;
await IRepository<Episode>.OnResourceCreated(obj); await _database.SaveChangesAsync();
return obj; await base.Delete(obj);
} if (epCount == 1)
await _shows.Delete(obj.ShowId);
/// <inheritdoc />
protected override async Task Validate(Episode resource)
{
await base.Validate(resource);
if (resource.ShowId == Guid.Empty)
{
if (resource.Show == null)
{
throw new ArgumentException(
$"Can't store an episode not related "
+ $"to any show (showID: {resource.ShowId})."
);
}
resource.ShowId = resource.Show.Id;
}
if (resource.SeasonId == null && resource.SeasonNumber != null)
{
resource.Season = await _database.Seasons.FirstOrDefaultAsync(x =>
x.ShowId == resource.ShowId && x.SeasonNumber == resource.SeasonNumber
);
}
}
/// <inheritdoc />
public override async Task Delete(Episode obj)
{
int epCount = await _database
.Episodes.Where(x => x.ShowId == obj.ShowId)
.Take(2)
.CountAsync();
_database.Entry(obj).State = EntityState.Deleted;
await _database.SaveChangesAsync();
await base.Delete(obj);
if (epCount == 1)
await _shows.Delete(obj.ShowId);
}
} }
} }

181
back/src/Kyoo.Core/Controllers/Repositories/LibraryItemRepository.cs
View File

@ -25,103 +25,102 @@ using Kyoo.Abstractions.Controllers;
using Kyoo.Abstractions.Models; using Kyoo.Abstractions.Models;
using Kyoo.Abstractions.Models.Utils; using Kyoo.Abstractions.Models.Utils;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// A local repository to handle library items.
/// </summary>
public class LibraryItemRepository : DapperRepository<ILibraryItem>
{ {
/// <summary> // language=PostgreSQL
/// A local repository to handle library items. protected override FormattableString Sql =>
/// </summary> $"""
public class LibraryItemRepository : DapperRepository<ILibraryItem> select
s.*, -- Show as s
m.*,
c.*
/* includes */
from
shows as s
full outer join (
select
* -- Movie
from
movies) as m on false
full outer join(
select
c.* -- Collection as c
from
collections as c
left join link_collection_show as ls on ls.collection_id = c.id
left join link_collection_movie as lm on lm.collection_id = c.id
group by c.id
having count(*) > 1
) as c on false
""";
protected override Dictionary<string, Type> Config =>
new()
{
{ "s", typeof(Show) },
{ "m", typeof(Movie) },
{ "c", typeof(Collection) }
};
protected override ILibraryItem Mapper(List<object?> items)
{
if (items[0] is Show show && show.Id != Guid.Empty)
return show;
if (items[1] is Movie movie && movie.Id != Guid.Empty)
return movie;
if (items[2] is Collection collection && collection.Id != Guid.Empty)
return collection;
throw new InvalidDataException();
}
public LibraryItemRepository(DbConnection database, SqlVariableContext context)
: base(database, context) { }
public async Task<ICollection<ILibraryItem>> GetAllOfCollection(
Guid collectionId,
Filter<ILibraryItem>? filter = default,
Sort<ILibraryItem>? sort = default,
Include<ILibraryItem>? include = default,
Pagination? limit = default
)
{ {
// language=PostgreSQL // language=PostgreSQL
protected override FormattableString Sql => FormattableString sql = $"""
$""" select
s.*,
m.*
/* includes */
from (
select select
s.*, -- Show as s * -- Show
m.*,
c.*
/* includes */
from from
shows as s shows
full outer join ( inner join link_collection_show as ls on ls.show_id = id and ls.collection_id = {collectionId}
select ) as s
* -- Movie full outer join (
from
movies) as m on false
full outer join(
select
c.* -- Collection as c
from
collections as c
left join link_collection_show as ls on ls.collection_id = c.id
left join link_collection_movie as lm on lm.collection_id = c.id
group by c.id
having count(*) > 1
) as c on false
""";
protected override Dictionary<string, Type> Config =>
new()
{
{ "s", typeof(Show) },
{ "m", typeof(Movie) },
{ "c", typeof(Collection) }
};
protected override ILibraryItem Mapper(List<object?> items)
{
if (items[0] is Show show && show.Id != Guid.Empty)
return show;
if (items[1] is Movie movie && movie.Id != Guid.Empty)
return movie;
if (items[2] is Collection collection && collection.Id != Guid.Empty)
return collection;
throw new InvalidDataException();
}
public LibraryItemRepository(DbConnection database, SqlVariableContext context)
: base(database, context) { }
public async Task<ICollection<ILibraryItem>> GetAllOfCollection(
Guid collectionId,
Filter<ILibraryItem>? filter = default,
Sort<ILibraryItem>? sort = default,
Include<ILibraryItem>? include = default,
Pagination? limit = default
)
{
// language=PostgreSQL
FormattableString sql = $"""
select select
s.*, * -- Movie
m.* from
/* includes */ movies
from ( inner join link_collection_movie as lm on lm.movie_id = id and lm.collection_id = {collectionId}
select ) as m on false
* -- Show """;
from
shows
inner join link_collection_show as ls on ls.show_id = id and ls.collection_id = {collectionId}
) as s
full outer join (
select
* -- Movie
from
movies
inner join link_collection_movie as lm on lm.movie_id = id and lm.collection_id = {collectionId}
) as m on false
""";
return await Database.Query<ILibraryItem>( return await Database.Query<ILibraryItem>(
sql, sql,
new() { { "s", typeof(Show) }, { "m", typeof(Movie) }, }, new() { { "s", typeof(Show) }, { "m", typeof(Movie) }, },
Mapper, Mapper,
(id) => Get(id), (id) => Get(id),
Context, Context,
include, include,
filter, filter,
sort ?? new Sort<ILibraryItem>.Default(), sort ?? new Sort<ILibraryItem>.Default(),
limit ?? new() limit ?? new()
); );
}
} }
} }

806
back/src/Kyoo.Core/Controllers/Repositories/LocalRepository.cs
View File

@ -32,468 +32,456 @@ using Kyoo.Postgresql;
using Kyoo.Utils; using Kyoo.Utils;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// A base class to create repositories using Entity Framework.
/// </summary>
/// <typeparam name="T">The type of this repository</typeparam>
public abstract class LocalRepository<T> : IRepository<T>
where T : class, IResource, IQuery
{ {
/// <summary> /// <summary>
/// A base class to create repositories using Entity Framework. /// The Entity Framework's Database handle.
/// </summary> /// </summary>
/// <typeparam name="T">The type of this repository</typeparam> protected DbContext Database { get; }
public abstract class LocalRepository<T> : IRepository<T>
where T : class, IResource, IQuery /// <summary>
/// The thumbnail manager used to store images.
/// </summary>
private readonly IThumbnailsManager _thumbs;
/// <summary>
/// Create a new base <see cref="LocalRepository{T}"/> with the given database handle.
/// </summary>
/// <param name="database">A database connection to load resources of type <typeparamref name="T"/></param>
/// <param name="thumbs">The thumbnail manager used to store images.</param>
protected LocalRepository(DbContext database, IThumbnailsManager thumbs)
{ {
/// <summary> Database = database;
/// The Entity Framework's Database handle. _thumbs = thumbs;
/// </summary> }
protected DbContext Database { get; }
/// <summary> /// <inheritdoc/>
/// The thumbnail manager used to store images. public Type RepositoryType => typeof(T);
/// </summary>
private readonly IThumbnailsManager _thumbs;
/// <summary> /// <summary>
/// Create a new base <see cref="LocalRepository{T}"/> with the given database handle. /// Sort the given query.
/// </summary> /// </summary>
/// <param name="database">A database connection to load resources of type <typeparamref name="T"/></param> /// <param name="query">The query to sort.</param>
/// <param name="thumbs">The thumbnail manager used to store images.</param> /// <param name="sortBy">How to sort the query.</param>
protected LocalRepository(DbContext database, IThumbnailsManager thumbs) /// <returns>The newly sorted query.</returns>
protected IOrderedQueryable<T> Sort(IQueryable<T> query, Sort<T>? sortBy)
{
sortBy ??= new Sort<T>.Default();
IOrderedQueryable<T> _SortBy(
IQueryable<T> qr,
Expression<Func<T, object>> sort,
bool desc,
bool then
)
{ {
Database = database; if (then && qr is IOrderedQueryable<T> qro)
_thumbs = thumbs; {
return desc ? qro.ThenByDescending(sort) : qro.ThenBy(sort);
}
return desc ? qr.OrderByDescending(sort) : qr.OrderBy(sort);
} }
/// <inheritdoc/> IOrderedQueryable<T> _Sort(IQueryable<T> query, Sort<T> sortBy, bool then)
public Type RepositoryType => typeof(T);
/// <summary>
/// Sort the given query.
/// </summary>
/// <param name="query">The query to sort.</param>
/// <param name="sortBy">How to sort the query.</param>
/// <returns>The newly sorted query.</returns>
protected IOrderedQueryable<T> Sort(IQueryable<T> query, Sort<T>? sortBy)
{ {
sortBy ??= new Sort<T>.Default(); switch (sortBy)
IOrderedQueryable<T> _SortBy(
IQueryable<T> qr,
Expression<Func<T, object>> sort,
bool desc,
bool then
)
{ {
if (then && qr is IOrderedQueryable<T> qro) case Sort<T>.Default(var value):
{ return _Sort(query, value, then);
return desc ? qro.ThenByDescending(sort) : qro.ThenBy(sort); case Sort<T>.By(var key, var desc):
} return _SortBy(query, x => EF.Property<T>(x, key), desc, then);
return desc ? qr.OrderByDescending(sort) : qr.OrderBy(sort); case Sort<T>.Random(var seed):
// NOTE: To edit this, don't forget to edit the random handiling inside the KeysetPaginate function
return _SortBy(
query,
x => DatabaseContext.MD5(seed + x.Id.ToString()),
false,
then
);
case Sort<T>.Conglomerate(var sorts):
IOrderedQueryable<T> nQuery = _Sort(query, sorts.First(), false);
foreach (Sort<T> sort in sorts.Skip(1))
nQuery = _Sort(nQuery, sort, true);
return nQuery;
default:
// The language should not require me to do this...
throw new SwitchExpressionException();
} }
IOrderedQueryable<T> _Sort(IQueryable<T> query, Sort<T> sortBy, bool then)
{
switch (sortBy)
{
case Sort<T>.Default(var value):
return _Sort(query, value, then);
case Sort<T>.By(var key, var desc):
return _SortBy(query, x => EF.Property<T>(x, key), desc, then);
case Sort<T>.Random(var seed):
// NOTE: To edit this, don't forget to edit the random handiling inside the KeysetPaginate function
return _SortBy(
query,
x => DatabaseContext.MD5(seed + x.Id.ToString()),
false,
then
);
case Sort<T>.Conglomerate(var sorts):
IOrderedQueryable<T> nQuery = _Sort(query, sorts.First(), false);
foreach (Sort<T> sort in sorts.Skip(1))
nQuery = _Sort(nQuery, sort, true);
return nQuery;
default:
// The language should not require me to do this...
throw new SwitchExpressionException();
}
}
return _Sort(query, sortBy, false).ThenBy(x => x.Id);
} }
return _Sort(query, sortBy, false).ThenBy(x => x.Id);
}
protected IQueryable<T> AddIncludes(IQueryable<T> query, Include<T>? include) protected IQueryable<T> AddIncludes(IQueryable<T> query, Include<T>? include)
{ {
if (include == null) if (include == null)
return query;
foreach (string field in include.Fields)
query = query.Include(field);
return query; return query;
} foreach (string field in include.Fields)
query = query.Include(field);
return query;
}
/// <summary> /// <summary>
/// Get a resource from it's ID and make the <see cref="Database"/> instance track it. /// Get a resource from it's ID and make the <see cref="Database"/> instance track it.
/// </summary> /// </summary>
/// <param name="id">The ID of the resource</param> /// <param name="id">The ID of the resource</param>
/// <exception cref="ItemNotFoundException">If the item is not found</exception> /// <exception cref="ItemNotFoundException">If the item is not found</exception>
/// <returns>The tracked resource with the given ID</returns> /// <returns>The tracked resource with the given ID</returns>
protected virtual async Task<T> GetWithTracking(Guid id) protected virtual async Task<T> GetWithTracking(Guid id)
{
T? ret = await Database.Set<T>().AsTracking().FirstOrDefaultAsync(x => x.Id == id);
if (ret == null)
throw new ItemNotFoundException($"No {typeof(T).Name} found with the id {id}");
return ret;
}
/// <inheritdoc/>
public virtual async Task<T> Get(Guid id, Include<T>? include = default)
{
T? ret = await GetOrDefault(id, include);
if (ret == null)
throw new ItemNotFoundException($"No {typeof(T).Name} found with the id {id}");
return ret;
}
/// <inheritdoc/>
public virtual async Task<T> Get(string slug, Include<T>? include = default)
{
T? ret = await GetOrDefault(slug, include);
if (ret == null)
throw new ItemNotFoundException($"No {typeof(T).Name} found with the slug {slug}");
return ret;
}
/// <inheritdoc/>
public virtual async Task<T> Get(
Filter<T> filter,
Include<T>? include = default,
Sort<T>? sortBy = default,
bool reverse = false,
Guid? afterId = default
)
{
T? ret = await GetOrDefault(filter, include, sortBy, reverse, afterId);
if (ret == null)
throw new ItemNotFoundException($"No {typeof(T).Name} found with the given predicate.");
return ret;
}
protected virtual Task<T?> GetDuplicated(T item)
{
return GetOrDefault(item.Slug);
}
/// <inheritdoc />
public virtual Task<T?> GetOrDefault(Guid id, Include<T>? include = default)
{
return AddIncludes(Database.Set<T>(), include).FirstOrDefaultAsync(x => x.Id == id);
}
/// <inheritdoc />
public virtual Task<T?> GetOrDefault(string slug, Include<T>? include = default)
{
if (slug == "random")
{ {
T? ret = await Database.Set<T>().AsTracking().FirstOrDefaultAsync(x => x.Id == id); return AddIncludes(Database.Set<T>(), include)
if (ret == null) .OrderBy(x => EF.Functions.Random())
throw new ItemNotFoundException($"No {typeof(T).Name} found with the id {id}"); .FirstOrDefaultAsync();
return ret;
} }
return AddIncludes(Database.Set<T>(), include).FirstOrDefaultAsync(x => x.Slug == slug);
}
/// <inheritdoc/> /// <inheritdoc />
public virtual async Task<T> Get(Guid id, Include<T>? include = default) public virtual async Task<T?> GetOrDefault(
{ Filter<T>? filter,
T? ret = await GetOrDefault(id, include); Include<T>? include = default,
if (ret == null) Sort<T>? sortBy = default,
throw new ItemNotFoundException($"No {typeof(T).Name} found with the id {id}"); bool reverse = false,
return ret; Guid? afterId = default
} )
{
IQueryable<T> query = await ApplyFilters(
Database.Set<T>(),
filter,
sortBy,
new Pagination(1, afterId, reverse),
include
);
return await query.FirstOrDefaultAsync();
}
/// <inheritdoc/> /// <inheritdoc/>
public virtual async Task<T> Get(string slug, Include<T>? include = default) public virtual async Task<ICollection<T>> FromIds(
{ IList<Guid> ids,
T? ret = await GetOrDefault(slug, include); Include<T>? include = default
if (ret == null) )
throw new ItemNotFoundException($"No {typeof(T).Name} found with the slug {slug}"); {
return ret; return (
} await AddIncludes(Database.Set<T>(), include)
.Where(x => ids.Contains(x.Id))
/// <inheritdoc/> .ToListAsync()
public virtual async Task<T> Get(
Filter<T> filter,
Include<T>? include = default,
Sort<T>? sortBy = default,
bool reverse = false,
Guid? afterId = default
) )
{ .OrderBy(x => ids.IndexOf(x.Id))
T? ret = await GetOrDefault(filter, include, sortBy, reverse, afterId); .ToList();
if (ret == null) }
throw new ItemNotFoundException(
$"No {typeof(T).Name} found with the given predicate."
);
return ret;
}
protected virtual Task<T?> GetDuplicated(T item) /// <inheritdoc/>
{ public abstract Task<ICollection<T>> Search(string query, Include<T>? include = default);
return GetOrDefault(item.Slug);
}
/// <inheritdoc /> /// <inheritdoc/>
public virtual Task<T?> GetOrDefault(Guid id, Include<T>? include = default) public virtual async Task<ICollection<T>> GetAll(
{ Filter<T>? filter = null,
return AddIncludes(Database.Set<T>(), include).FirstOrDefaultAsync(x => x.Id == id); Sort<T>? sort = default,
} Include<T>? include = default,
Pagination? limit = default
)
{
IQueryable<T> query = await ApplyFilters(Database.Set<T>(), filter, sort, limit, include);
return await query.ToListAsync();
}
/// <inheritdoc /> /// <summary>
public virtual Task<T?> GetOrDefault(string slug, Include<T>? include = default) /// Apply filters to a query to ease sort, pagination and where queries for resources of this repository
{ /// </summary>
if (slug == "random") /// <param name="query">The base query to filter.</param>
{ /// <param name="filter">An expression to filter based on arbitrary conditions</param>
return AddIncludes(Database.Set<T>(), include) /// <param name="sort">The sort settings (sort order and sort by)</param>
.OrderBy(x => EF.Functions.Random()) /// <param name="limit">Pagination information (where to start and how many to get)</param>
.FirstOrDefaultAsync(); /// <param name="include">Related fields to also load with this query.</param>
} /// <returns>The filtered query</returns>
return AddIncludes(Database.Set<T>(), include).FirstOrDefaultAsync(x => x.Slug == slug); protected async Task<IQueryable<T>> ApplyFilters(
} IQueryable<T> query,
Filter<T>? filter = null,
Sort<T>? sort = default,
Pagination? limit = default,
Include<T>? include = default
)
{
query = AddIncludes(query, include);
query = Sort(query, sort);
limit ??= new();
/// <inheritdoc /> if (limit.AfterID != null)
public virtual async Task<T?> GetOrDefault(
Filter<T>? filter,
Include<T>? include = default,
Sort<T>? sortBy = default,
bool reverse = false,
Guid? afterId = default
)
{ {
IQueryable<T> query = await ApplyFilters( T reference = await Get(limit.AfterID.Value);
Database.Set<T>(), Filter<T>? keysetFilter = RepositoryHelper.KeysetPaginate(
filter,
sortBy,
new Pagination(1, afterId, reverse),
include
);
return await query.FirstOrDefaultAsync();
}
/// <inheritdoc/>
public virtual async Task<ICollection<T>> FromIds(
IList<Guid> ids,
Include<T>? include = default
)
{
return (
await AddIncludes(Database.Set<T>(), include)
.Where(x => ids.Contains(x.Id))
.ToListAsync()
)
.OrderBy(x => ids.IndexOf(x.Id))
.ToList();
}
/// <inheritdoc/>
public abstract Task<ICollection<T>> Search(string query, Include<T>? include = default);
/// <inheritdoc/>
public virtual async Task<ICollection<T>> GetAll(
Filter<T>? filter = null,
Sort<T>? sort = default,
Include<T>? include = default,
Pagination? limit = default
)
{
IQueryable<T> query = await ApplyFilters(
Database.Set<T>(),
filter,
sort, sort,
limit, reference,
include !limit.Reverse
); );
return await query.ToListAsync(); filter = Filter.And(filter, keysetFilter);
} }
if (filter != null)
query = query.Where(filter.ToEfLambda());
/// <summary> if (limit.Reverse)
/// Apply filters to a query to ease sort, pagination and where queries for resources of this repository query = query.Reverse();
/// </summary> if (limit.Limit > 0)
/// <param name="query">The base query to filter.</param> query = query.Take(limit.Limit);
/// <param name="filter">An expression to filter based on arbitrary conditions</param> if (limit.Reverse)
/// <param name="sort">The sort settings (sort order and sort by)</param> query = query.Reverse();
/// <param name="limit">Pagination information (where to start and how many to get)</param>
/// <param name="include">Related fields to also load with this query.</param>
/// <returns>The filtered query</returns>
protected async Task<IQueryable<T>> ApplyFilters(
IQueryable<T> query,
Filter<T>? filter = null,
Sort<T>? sort = default,
Pagination? limit = default,
Include<T>? include = default
)
{
query = AddIncludes(query, include);
query = Sort(query, sort);
limit ??= new();
if (limit.AfterID != null) return query;
{ }
T reference = await Get(limit.AfterID.Value);
Filter<T>? keysetFilter = RepositoryHelper.KeysetPaginate(
sort,
reference,
!limit.Reverse
);
filter = Filter.And(filter, keysetFilter);
}
if (filter != null)
query = query.Where(filter.ToEfLambda());
if (limit.Reverse) /// <inheritdoc/>
query = query.Reverse(); public virtual Task<int> GetCount(Filter<T>? filter = null)
if (limit.Limit > 0) {
query = query.Take(limit.Limit); IQueryable<T> query = Database.Set<T>();
if (limit.Reverse) if (filter != null)
query = query.Reverse(); query = query.Where(filter.ToEfLambda());
return query.CountAsync();
}
return query; /// <inheritdoc/>
} public virtual async Task<T> Create(T obj)
{
/// <inheritdoc/> await Validate(obj);
public virtual Task<int> GetCount(Filter<T>? filter = null) if (obj is IThumbnails thumbs)
{
IQueryable<T> query = Database.Set<T>();
if (filter != null)
query = query.Where(filter.ToEfLambda());
return query.CountAsync();
}
/// <inheritdoc/>
public virtual async Task<T> Create(T obj)
{
await Validate(obj);
if (obj is IThumbnails thumbs)
{
try
{
await _thumbs.DownloadImages(thumbs);
}
catch (DuplicatedItemException e) when (e.Existing is null)
{
throw new DuplicatedItemException(await GetDuplicated(obj));
}
if (thumbs.Poster != null)
Database.Entry(thumbs).Reference(x => x.Poster).TargetEntry!.State =
EntityState.Added;
if (thumbs.Thumbnail != null)
Database.Entry(thumbs).Reference(x => x.Thumbnail).TargetEntry!.State =
EntityState.Added;
if (thumbs.Logo != null)
Database.Entry(thumbs).Reference(x => x.Logo).TargetEntry!.State =
EntityState.Added;
}
return obj;
}
/// <inheritdoc/>
public virtual async Task<T> CreateIfNotExists(T obj)
{ {
try try
{ {
T? old = await GetOrDefault(obj.Slug); await _thumbs.DownloadImages(thumbs);
if (old != null)
return old;
return await Create(obj);
} }
catch (DuplicatedItemException) catch (DuplicatedItemException e) when (e.Existing is null)
{ {
return await Get(obj.Slug); throw new DuplicatedItemException(await GetDuplicated(obj));
} }
if (thumbs.Poster != null)
Database.Entry(thumbs).Reference(x => x.Poster).TargetEntry!.State =
EntityState.Added;
if (thumbs.Thumbnail != null)
Database.Entry(thumbs).Reference(x => x.Thumbnail).TargetEntry!.State =
EntityState.Added;
if (thumbs.Logo != null)
Database.Entry(thumbs).Reference(x => x.Logo).TargetEntry!.State =
EntityState.Added;
} }
return obj;
}
/// <inheritdoc/> /// <inheritdoc/>
public virtual async Task<T> Edit(T edited) public virtual async Task<T> CreateIfNotExists(T obj)
{
try
{ {
bool lazyLoading = Database.ChangeTracker.LazyLoadingEnabled; T? old = await GetOrDefault(obj.Slug);
Database.ChangeTracker.LazyLoadingEnabled = false; if (old != null)
try
{
T old = await GetWithTracking(edited.Id);
Merger.Complete(
old,
edited,
x => x.GetCustomAttribute<LoadableRelationAttribute>() == null
);
await EditRelations(old, edited);
await Database.SaveChangesAsync();
await IRepository<T>.OnResourceEdited(old);
return old; return old;
}
finally
{
Database.ChangeTracker.LazyLoadingEnabled = lazyLoading;
Database.ChangeTracker.Clear();
}
}
/// <inheritdoc/> return await Create(obj);
public virtual async Task<T> Patch(Guid id, Func<T, T> patch) }
catch (DuplicatedItemException)
{
return await Get(obj.Slug);
}
}
/// <inheritdoc/>
public virtual async Task<T> Edit(T edited)
{
bool lazyLoading = Database.ChangeTracker.LazyLoadingEnabled;
Database.ChangeTracker.LazyLoadingEnabled = false;
try
{
T old = await GetWithTracking(edited.Id);
Merger.Complete(
old,
edited,
x => x.GetCustomAttribute<LoadableRelationAttribute>() == null
);
await EditRelations(old, edited);
await Database.SaveChangesAsync();
await IRepository<T>.OnResourceEdited(old);
return old;
}
finally
{
Database.ChangeTracker.LazyLoadingEnabled = lazyLoading;
Database.ChangeTracker.Clear();
}
}
/// <inheritdoc/>
public virtual async Task<T> Patch(Guid id, Func<T, T> patch)
{
bool lazyLoading = Database.ChangeTracker.LazyLoadingEnabled;
Database.ChangeTracker.LazyLoadingEnabled = false;
try
{
T resource = await GetWithTracking(id);
resource = patch(resource);
await Database.SaveChangesAsync();
await IRepository<T>.OnResourceEdited(resource);
return resource;
}
finally
{
Database.ChangeTracker.LazyLoadingEnabled = lazyLoading;
Database.ChangeTracker.Clear();
}
}
/// <summary>
/// An overridable method to edit relation of a resource.
/// </summary>
/// <param name="resource">
/// The non edited resource
/// </param>
/// <param name="changed">
/// The new version of <paramref name="resource"/>.
/// This item will be saved on the database and replace <paramref name="resource"/>
/// </param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected virtual Task EditRelations(T resource, T changed)
{
if (resource is IThumbnails thumbs && changed is IThumbnails chng)
{
Database.Entry(thumbs).Reference(x => x.Poster).IsModified =
thumbs.Poster != chng.Poster;
Database.Entry(thumbs).Reference(x => x.Thumbnail).IsModified =
thumbs.Thumbnail != chng.Thumbnail;
Database.Entry(thumbs).Reference(x => x.Logo).IsModified = thumbs.Logo != chng.Logo;
}
return Validate(resource);
}
/// <summary>
/// A method called just before saving a new resource to the database.
/// It is also called on the default implementation of <see cref="EditRelations"/>
/// </summary>
/// <param name="resource">The resource that will be saved</param>
/// <exception cref="ArgumentException">
/// You can throw this if the resource is illegal and should not be saved.
/// </exception>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected virtual Task Validate(T resource)
{
if (
typeof(T).GetProperty(nameof(resource.Slug))!.GetCustomAttribute<ComputedAttribute>()
!= null
)
return Task.CompletedTask;
if (string.IsNullOrEmpty(resource.Slug))
throw new ArgumentException("Resource can't have null as a slug.");
if (int.TryParse(resource.Slug, out int _) || resource.Slug == "random")
{ {
bool lazyLoading = Database.ChangeTracker.LazyLoadingEnabled;
Database.ChangeTracker.LazyLoadingEnabled = false;
try try
{ {
T resource = await GetWithTracking(id); MethodInfo? setter = typeof(T).GetProperty(nameof(resource.Slug))!.GetSetMethod();
if (setter != null)
resource = patch(resource); setter.Invoke(resource, new object[] { resource.Slug + '!' });
else
await Database.SaveChangesAsync();
await IRepository<T>.OnResourceEdited(resource);
return resource;
}
finally
{
Database.ChangeTracker.LazyLoadingEnabled = lazyLoading;
Database.ChangeTracker.Clear();
}
}
/// <summary>
/// An overridable method to edit relation of a resource.
/// </summary>
/// <param name="resource">
/// The non edited resource
/// </param>
/// <param name="changed">
/// The new version of <paramref name="resource"/>.
/// This item will be saved on the database and replace <paramref name="resource"/>
/// </param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected virtual Task EditRelations(T resource, T changed)
{
if (resource is IThumbnails thumbs && changed is IThumbnails chng)
{
Database.Entry(thumbs).Reference(x => x.Poster).IsModified =
thumbs.Poster != chng.Poster;
Database.Entry(thumbs).Reference(x => x.Thumbnail).IsModified =
thumbs.Thumbnail != chng.Thumbnail;
Database.Entry(thumbs).Reference(x => x.Logo).IsModified = thumbs.Logo != chng.Logo;
}
return Validate(resource);
}
/// <summary>
/// A method called just before saving a new resource to the database.
/// It is also called on the default implementation of <see cref="EditRelations"/>
/// </summary>
/// <param name="resource">The resource that will be saved</param>
/// <exception cref="ArgumentException">
/// You can throw this if the resource is illegal and should not be saved.
/// </exception>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected virtual Task Validate(T resource)
{
if (
typeof(T)
.GetProperty(nameof(resource.Slug))!
.GetCustomAttribute<ComputedAttribute>() != null
)
return Task.CompletedTask;
if (string.IsNullOrEmpty(resource.Slug))
throw new ArgumentException("Resource can't have null as a slug.");
if (int.TryParse(resource.Slug, out int _) || resource.Slug == "random")
{
try
{
MethodInfo? setter = typeof(T)
.GetProperty(nameof(resource.Slug))!
.GetSetMethod();
if (setter != null)
setter.Invoke(resource, new object[] { resource.Slug + '!' });
else
throw new ArgumentException(
"Resources slug can't be number only or the literal \"random\"."
);
}
catch
{
throw new ArgumentException( throw new ArgumentException(
"Resources slug can't be number only or the literal \"random\"." "Resources slug can't be number only or the literal \"random\"."
); );
}
} }
return Task.CompletedTask; catch
{
throw new ArgumentException(
"Resources slug can't be number only or the literal \"random\"."
);
}
} }
return Task.CompletedTask;
}
/// <inheritdoc/> /// <inheritdoc/>
public virtual async Task Delete(Guid id) public virtual async Task Delete(Guid id)
{ {
T resource = await Get(id); T resource = await Get(id);
await Delete(resource);
}
/// <inheritdoc/>
public virtual async Task Delete(string slug)
{
T resource = await Get(slug);
await Delete(resource);
}
/// <inheritdoc/>
public virtual Task Delete(T obj)
{
IRepository<T>.OnResourceDeleted(obj);
if (obj is IThumbnails thumbs)
return _thumbs.DeleteImages(thumbs);
return Task.CompletedTask;
}
/// <inheritdoc/>
public async Task DeleteAll(Filter<T> filter)
{
foreach (T resource in await GetAll(filter))
await Delete(resource); await Delete(resource);
}
/// <inheritdoc/>
public virtual async Task Delete(string slug)
{
T resource = await Get(slug);
await Delete(resource);
}
/// <inheritdoc/>
public virtual Task Delete(T obj)
{
IRepository<T>.OnResourceDeleted(obj);
if (obj is IThumbnails thumbs)
return _thumbs.DeleteImages(thumbs);
return Task.CompletedTask;
}
/// <inheritdoc/>
public async Task DeleteAll(Filter<T> filter)
{
foreach (T resource in await GetAll(filter))
await Delete(resource);
}
} }
} }

143
back/src/Kyoo.Core/Controllers/Repositories/MovieRepository.cs
View File

@ -25,85 +25,84 @@ using Kyoo.Abstractions.Models.Utils;
using Kyoo.Postgresql; using Kyoo.Postgresql;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// A local repository to handle shows
/// </summary>
public class MovieRepository : LocalRepository<Movie>
{ {
/// <summary> /// <summary>
/// A local repository to handle shows /// The database handle
/// </summary> /// </summary>
public class MovieRepository : LocalRepository<Movie> private readonly DatabaseContext _database;
/// <summary>
/// A studio repository to handle creation/validation of related studios.
/// </summary>
private readonly IRepository<Studio> _studios;
public MovieRepository(
DatabaseContext database,
IRepository<Studio> studios,
IThumbnailsManager thumbs
)
: base(database, thumbs)
{ {
/// <summary> _database = database;
/// The database handle _studios = studios;
/// </summary> }
private readonly DatabaseContext _database;
/// <summary> /// <inheritdoc />
/// A studio repository to handle creation/validation of related studios. public override async Task<ICollection<Movie>> Search(
/// </summary> string query,
private readonly IRepository<Studio> _studios; Include<Movie>? include = default
)
{
return await AddIncludes(_database.Movies, include)
.Where(x => EF.Functions.ILike(x.Name + " " + x.Slug, $"%{query}%"))
.Take(20)
.ToListAsync();
}
public MovieRepository( /// <inheritdoc />
DatabaseContext database, public override async Task<Movie> Create(Movie obj)
IRepository<Studio> studios, {
IThumbnailsManager thumbs await base.Create(obj);
) _database.Entry(obj).State = EntityState.Added;
: base(database, thumbs) await _database.SaveChangesAsync(() => Get(obj.Slug));
await IRepository<Movie>.OnResourceCreated(obj);
return obj;
}
/// <inheritdoc />
protected override async Task Validate(Movie resource)
{
await base.Validate(resource);
if (resource.Studio != null)
{ {
_database = database; resource.Studio = await _studios.CreateIfNotExists(resource.Studio);
_studios = studios; resource.StudioId = resource.Studio.Id;
}
/// <inheritdoc />
public override async Task<ICollection<Movie>> Search(
string query,
Include<Movie>? include = default
)
{
return await AddIncludes(_database.Movies, include)
.Where(x => EF.Functions.ILike(x.Name + " " + x.Slug, $"%{query}%"))
.Take(20)
.ToListAsync();
}
/// <inheritdoc />
public override async Task<Movie> Create(Movie obj)
{
await base.Create(obj);
_database.Entry(obj).State = EntityState.Added;
await _database.SaveChangesAsync(() => Get(obj.Slug));
await IRepository<Movie>.OnResourceCreated(obj);
return obj;
}
/// <inheritdoc />
protected override async Task Validate(Movie resource)
{
await base.Validate(resource);
if (resource.Studio != null)
{
resource.Studio = await _studios.CreateIfNotExists(resource.Studio);
resource.StudioId = resource.Studio.Id;
}
}
/// <inheritdoc />
protected override async Task EditRelations(Movie resource, Movie changed)
{
await Validate(changed);
if (changed.Studio != null || changed.StudioId == null)
{
await Database.Entry(resource).Reference(x => x.Studio).LoadAsync();
resource.Studio = changed.Studio;
}
}
/// <inheritdoc />
public override async Task Delete(Movie obj)
{
_database.Remove(obj);
await _database.SaveChangesAsync();
await base.Delete(obj);
} }
} }
/// <inheritdoc />
protected override async Task EditRelations(Movie resource, Movie changed)
{
await Validate(changed);
if (changed.Studio != null || changed.StudioId == null)
{
await Database.Entry(resource).Reference(x => x.Studio).LoadAsync();
resource.Studio = changed.Studio;
}
}
/// <inheritdoc />
public override async Task Delete(Movie obj)
{
_database.Remove(obj);
await _database.SaveChangesAsync();
await base.Delete(obj);
}
} }

65
back/src/Kyoo.Core/Controllers/Repositories/NewsRepository.cs
View File

@ -22,43 +22,42 @@ using System.Data.Common;
using System.IO; using System.IO;
using Kyoo.Abstractions.Models; using Kyoo.Abstractions.Models;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// A local repository to handle shows
/// </summary>
public class NewsRepository : DapperRepository<INews>
{ {
/// <summary> // language=PostgreSQL
/// A local repository to handle shows protected override FormattableString Sql =>
/// </summary> $"""
public class NewsRepository : DapperRepository<INews> select
{ e.*, -- Episode as e
// language=PostgreSQL m.*
protected override FormattableString Sql => /* includes */
$""" from
episodes as e
full outer join (
select select
e.*, -- Episode as e * -- Movie
m.*
/* includes */
from from
episodes as e movies
full outer join ( ) as m on false
select """;
* -- Movie
from
movies
) as m on false
""";
protected override Dictionary<string, Type> Config => protected override Dictionary<string, Type> Config =>
new() { { "e", typeof(Episode) }, { "m", typeof(Movie) }, }; new() { { "e", typeof(Episode) }, { "m", typeof(Movie) }, };
protected override INews Mapper(List<object?> items) protected override INews Mapper(List<object?> items)
{ {
if (items[0] is Episode episode && episode.Id != Guid.Empty) if (items[0] is Episode episode && episode.Id != Guid.Empty)
return episode; return episode;
if (items[1] is Movie movie && movie.Id != Guid.Empty) if (items[1] is Movie movie && movie.Id != Guid.Empty)
return movie; return movie;
throw new InvalidDataException(); throw new InvalidDataException();
}
public NewsRepository(DbConnection database, SqlVariableContext context)
: base(database, context) { }
} }
public NewsRepository(DbConnection database, SqlVariableContext context)
: base(database, context) { }
} }

176
back/src/Kyoo.Core/Controllers/Repositories/SeasonRepository.cs
View File

@ -29,105 +29,103 @@ using Kyoo.Postgresql;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// A local repository to handle seasons.
/// </summary>
public class SeasonRepository : LocalRepository<Season>
{ {
/// <summary> /// <summary>
/// A local repository to handle seasons. /// The database handle
/// </summary> /// </summary>
public class SeasonRepository : LocalRepository<Season> private readonly DatabaseContext _database;
static SeasonRepository()
{ {
/// <summary> // Edit seasons slugs when the show's slug changes.
/// The database handle IRepository<Show>.OnEdited += async (show) =>
/// </summary>
private readonly DatabaseContext _database;
static SeasonRepository()
{ {
// Edit seasons slugs when the show's slug changes. await using AsyncServiceScope scope = CoreModule.Services.CreateAsyncScope();
IRepository<Show>.OnEdited += async (show) => DatabaseContext database = scope.ServiceProvider.GetRequiredService<DatabaseContext>();
{ List<Season> seasons = await database
await using AsyncServiceScope scope = CoreModule.Services.CreateAsyncScope(); .Seasons.AsTracking()
DatabaseContext database = .Where(x => x.ShowId == show.Id)
scope.ServiceProvider.GetRequiredService<DatabaseContext>();
List<Season> seasons = await database
.Seasons.AsTracking()
.Where(x => x.ShowId == show.Id)
.ToListAsync();
foreach (Season season in seasons)
{
season.ShowSlug = show.Slug;
await database.SaveChangesAsync();
await IRepository<Season>.OnResourceEdited(season);
}
};
}
/// <summary>
/// Create a new <see cref="SeasonRepository"/>.
/// </summary>
/// <param name="database">The database handle that will be used</param>
/// <param name="thumbs">The thumbnail manager used to store images.</param>
public SeasonRepository(DatabaseContext database, IThumbnailsManager thumbs)
: base(database, thumbs)
{
_database = database;
}
protected override Task<Season?> GetDuplicated(Season item)
{
return _database.Seasons.FirstOrDefaultAsync(x =>
x.ShowId == item.ShowId && x.SeasonNumber == item.SeasonNumber
);
}
/// <inheritdoc/>
public override async Task<ICollection<Season>> Search(
string query,
Include<Season>? include = default
)
{
return await AddIncludes(_database.Seasons, include)
.Where(x => EF.Functions.ILike(x.Name!, $"%{query}%"))
.Take(20)
.ToListAsync(); .ToListAsync();
} foreach (Season season in seasons)
/// <inheritdoc/>
public override async Task<Season> Create(Season obj)
{
await base.Create(obj);
obj.ShowSlug =
(await _database.Shows.FirstOrDefaultAsync(x => x.Id == obj.ShowId))?.Slug
?? throw new ItemNotFoundException($"No show found with ID {obj.ShowId}");
_database.Entry(obj).State = EntityState.Added;
await _database.SaveChangesAsync(() => GetDuplicated(obj));
await IRepository<Season>.OnResourceCreated(obj);
return obj;
}
/// <inheritdoc/>
protected override async Task Validate(Season resource)
{
await base.Validate(resource);
if (resource.ShowId == Guid.Empty)
{ {
if (resource.Show == null) season.ShowSlug = show.Slug;
{ await database.SaveChangesAsync();
throw new ValidationException( await IRepository<Season>.OnResourceEdited(season);
$"Can't store a season not related to any show "
+ $"(showID: {resource.ShowId})."
);
}
resource.ShowId = resource.Show.Id;
} }
} };
}
/// <inheritdoc/> /// <summary>
public override async Task Delete(Season obj) /// Create a new <see cref="SeasonRepository"/>.
/// </summary>
/// <param name="database">The database handle that will be used</param>
/// <param name="thumbs">The thumbnail manager used to store images.</param>
public SeasonRepository(DatabaseContext database, IThumbnailsManager thumbs)
: base(database, thumbs)
{
_database = database;
}
protected override Task<Season?> GetDuplicated(Season item)
{
return _database.Seasons.FirstOrDefaultAsync(x =>
x.ShowId == item.ShowId && x.SeasonNumber == item.SeasonNumber
);
}
/// <inheritdoc/>
public override async Task<ICollection<Season>> Search(
string query,
Include<Season>? include = default
)
{
return await AddIncludes(_database.Seasons, include)
.Where(x => EF.Functions.ILike(x.Name!, $"%{query}%"))
.Take(20)
.ToListAsync();
}
/// <inheritdoc/>
public override async Task<Season> Create(Season obj)
{
await base.Create(obj);
obj.ShowSlug =
(await _database.Shows.FirstOrDefaultAsync(x => x.Id == obj.ShowId))?.Slug
?? throw new ItemNotFoundException($"No show found with ID {obj.ShowId}");
_database.Entry(obj).State = EntityState.Added;
await _database.SaveChangesAsync(() => GetDuplicated(obj));
await IRepository<Season>.OnResourceCreated(obj);
return obj;
}
/// <inheritdoc/>
protected override async Task Validate(Season resource)
{
await base.Validate(resource);
if (resource.ShowId == Guid.Empty)
{ {
_database.Remove(obj); if (resource.Show == null)
await _database.SaveChangesAsync(); {
await base.Delete(obj); throw new ValidationException(
$"Can't store a season not related to any show "
+ $"(showID: {resource.ShowId})."
);
}
resource.ShowId = resource.Show.Id;
} }
} }
/// <inheritdoc/>
public override async Task Delete(Season obj)
{
_database.Remove(obj);
await _database.SaveChangesAsync();
await base.Delete(obj);
}
} }

143
back/src/Kyoo.Core/Controllers/Repositories/ShowRepository.cs
View File

@ -26,85 +26,84 @@ using Kyoo.Postgresql;
using Kyoo.Utils; using Kyoo.Utils;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// A local repository to handle shows
/// </summary>
public class ShowRepository : LocalRepository<Show>
{ {
/// <summary> /// <summary>
/// A local repository to handle shows /// The database handle
/// </summary> /// </summary>
public class ShowRepository : LocalRepository<Show> private readonly DatabaseContext _database;
/// <summary>
/// A studio repository to handle creation/validation of related studios.
/// </summary>
private readonly IRepository<Studio> _studios;
public ShowRepository(
DatabaseContext database,
IRepository<Studio> studios,
IThumbnailsManager thumbs
)
: base(database, thumbs)
{ {
/// <summary> _database = database;
/// The database handle _studios = studios;
/// </summary> }
private readonly DatabaseContext _database;
/// <summary> /// <inheritdoc />
/// A studio repository to handle creation/validation of related studios. public override async Task<ICollection<Show>> Search(
/// </summary> string query,
private readonly IRepository<Studio> _studios; Include<Show>? include = default
)
{
return await AddIncludes(_database.Shows, include)
.Where(x => EF.Functions.ILike(x.Name + " " + x.Slug, $"%{query}%"))
.Take(20)
.ToListAsync();
}
public ShowRepository( /// <inheritdoc />
DatabaseContext database, public override async Task<Show> Create(Show obj)
IRepository<Studio> studios, {
IThumbnailsManager thumbs await base.Create(obj);
) _database.Entry(obj).State = EntityState.Added;
: base(database, thumbs) await _database.SaveChangesAsync(() => Get(obj.Slug));
await IRepository<Show>.OnResourceCreated(obj);
return obj;
}
/// <inheritdoc />
protected override async Task Validate(Show resource)
{
await base.Validate(resource);
if (resource.Studio != null)
{ {
_database = database; resource.Studio = await _studios.CreateIfNotExists(resource.Studio);
_studios = studios; resource.StudioId = resource.Studio.Id;
}
/// <inheritdoc />
public override async Task<ICollection<Show>> Search(
string query,
Include<Show>? include = default
)
{
return await AddIncludes(_database.Shows, include)
.Where(x => EF.Functions.ILike(x.Name + " " + x.Slug, $"%{query}%"))
.Take(20)
.ToListAsync();
}
/// <inheritdoc />
public override async Task<Show> Create(Show obj)
{
await base.Create(obj);
_database.Entry(obj).State = EntityState.Added;
await _database.SaveChangesAsync(() => Get(obj.Slug));
await IRepository<Show>.OnResourceCreated(obj);
return obj;
}
/// <inheritdoc />
protected override async Task Validate(Show resource)
{
await base.Validate(resource);
if (resource.Studio != null)
{
resource.Studio = await _studios.CreateIfNotExists(resource.Studio);
resource.StudioId = resource.Studio.Id;
}
}
/// <inheritdoc />
protected override async Task EditRelations(Show resource, Show changed)
{
await Validate(changed);
if (changed.Studio != null || changed.StudioId == null)
{
await Database.Entry(resource).Reference(x => x.Studio).LoadAsync();
resource.Studio = changed.Studio;
}
}
/// <inheritdoc />
public override async Task Delete(Show obj)
{
_database.Remove(obj);
await _database.SaveChangesAsync();
await base.Delete(obj);
} }
} }
/// <inheritdoc />
protected override async Task EditRelations(Show resource, Show changed)
{
await Validate(changed);
if (changed.Studio != null || changed.StudioId == null)
{
await Database.Entry(resource).Reference(x => x.Studio).LoadAsync();
resource.Studio = changed.Studio;
}
}
/// <inheritdoc />
public override async Task Delete(Show obj)
{
_database.Remove(obj);
await _database.SaveChangesAsync();
await base.Delete(obj);
}
} }

89
back/src/Kyoo.Core/Controllers/Repositories/StudioRepository.cs
View File

@ -26,57 +26,56 @@ using Kyoo.Postgresql;
using Kyoo.Utils; using Kyoo.Utils;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// A local repository to handle studios
/// </summary>
public class StudioRepository : LocalRepository<Studio>
{ {
/// <summary> /// <summary>
/// A local repository to handle studios /// The database handle
/// </summary> /// </summary>
public class StudioRepository : LocalRepository<Studio> private readonly DatabaseContext _database;
/// <summary>
/// Create a new <see cref="StudioRepository"/>.
/// </summary>
/// <param name="database">The database handle</param>
/// <param name="thumbs">The thumbnail manager used to store images.</param>
public StudioRepository(DatabaseContext database, IThumbnailsManager thumbs)
: base(database, thumbs)
{ {
/// <summary> _database = database;
/// The database handle }
/// </summary>
private readonly DatabaseContext _database;
/// <summary> /// <inheritdoc />
/// Create a new <see cref="StudioRepository"/>. public override async Task<ICollection<Studio>> Search(
/// </summary> string query,
/// <param name="database">The database handle</param> Include<Studio>? include = default
/// <param name="thumbs">The thumbnail manager used to store images.</param> )
public StudioRepository(DatabaseContext database, IThumbnailsManager thumbs) {
: base(database, thumbs) return await AddIncludes(_database.Studios, include)
{ .Where(x => EF.Functions.ILike(x.Name, $"%{query}%"))
_database = database; .Take(20)
} .ToListAsync();
}
/// <inheritdoc /> /// <inheritdoc />
public override async Task<ICollection<Studio>> Search( public override async Task<Studio> Create(Studio obj)
string query, {
Include<Studio>? include = default await base.Create(obj);
) _database.Entry(obj).State = EntityState.Added;
{ await _database.SaveChangesAsync(() => Get(obj.Slug));
return await AddIncludes(_database.Studios, include) await IRepository<Studio>.OnResourceCreated(obj);
.Where(x => EF.Functions.ILike(x.Name, $"%{query}%")) return obj;
.Take(20) }
.ToListAsync();
}
/// <inheritdoc /> /// <inheritdoc />
public override async Task<Studio> Create(Studio obj) public override async Task Delete(Studio obj)
{ {
await base.Create(obj); _database.Entry(obj).State = EntityState.Deleted;
_database.Entry(obj).State = EntityState.Added; await _database.SaveChangesAsync();
await _database.SaveChangesAsync(() => Get(obj.Slug)); await base.Delete(obj);
await IRepository<Studio>.OnResourceCreated(obj);
return obj;
}
/// <inheritdoc />
public override async Task Delete(Studio obj)
{
_database.Entry(obj).State = EntityState.Deleted;
await _database.SaveChangesAsync();
await base.Delete(obj);
}
} }
} }

440
back/src/Kyoo.Core/Controllers/ThumbnailsManager.cs
View File

@ -31,238 +31,236 @@ using Kyoo.Abstractions.Models.Exceptions;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using SkiaSharp; using SkiaSharp;
namespace Kyoo.Core.Controllers namespace Kyoo.Core.Controllers;
/// <summary>
/// Download images and retrieve the path of those images for a resource.
/// </summary>
public class ThumbnailsManager(
IHttpClientFactory clientFactory,
ILogger<ThumbnailsManager> logger,
Lazy<IRepository<User>> users
) : IThumbnailsManager
{ {
/// <summary> private static readonly Dictionary<string, TaskCompletionSource<object>> _downloading = new();
/// Download images and retrieve the path of those images for a resource.
/// </summary> private static async Task _WriteTo(SKBitmap bitmap, string path, int quality)
public class ThumbnailsManager(
IHttpClientFactory clientFactory,
ILogger<ThumbnailsManager> logger,
Lazy<IRepository<User>> users
) : IThumbnailsManager
{ {
private static readonly Dictionary<string, TaskCompletionSource<object>> _downloading = SKData data = bitmap.Encode(SKEncodedImageFormat.Webp, quality);
new(); await using Stream reader = data.AsStream();
await using Stream file = File.Create(path);
await reader.CopyToAsync(file);
}
private static async Task _WriteTo(SKBitmap bitmap, string path, int quality) private async Task _DownloadImage(Image? image, string localPath, string what)
{
if (image == null)
return;
try
{ {
SKData data = bitmap.Encode(SKEncodedImageFormat.Webp, quality); logger.LogInformation("Downloading image {What}", what);
await using Stream reader = data.AsStream();
await using Stream file = File.Create(path);
await reader.CopyToAsync(file);
}
private async Task _DownloadImage(Image? image, string localPath, string what) HttpClient client = clientFactory.CreateClient();
{ HttpResponseMessage response = await client.GetAsync(image.Source);
if (image == null) response.EnsureSuccessStatusCode();
return; await using Stream reader = await response.Content.ReadAsStreamAsync();
try using SKCodec codec = SKCodec.Create(reader);
if (codec == null)
{ {
logger.LogInformation("Downloading image {What}", what); logger.LogError("Unsupported codec for {What}", what);
HttpClient client = clientFactory.CreateClient();
HttpResponseMessage response = await client.GetAsync(image.Source);
response.EnsureSuccessStatusCode();
await using Stream reader = await response.Content.ReadAsStreamAsync();
using SKCodec codec = SKCodec.Create(reader);
if (codec == null)
{
logger.LogError("Unsupported codec for {What}", what);
return;
}
SKImageInfo info = codec.Info;
info.ColorType = SKColorType.Rgba8888;
using SKBitmap original = SKBitmap.Decode(codec, info);
using SKBitmap high = original.Resize(
new SKSizeI(original.Width, original.Height),
SKFilterQuality.High
);
await _WriteTo(
original,
$"{localPath}.{ImageQuality.High.ToString().ToLowerInvariant()}.webp",
90
);
using SKBitmap medium = high.Resize(
new SKSizeI((int)(high.Width / 1.5), (int)(high.Height / 1.5)),
SKFilterQuality.Medium
);
await _WriteTo(
medium,
$"{localPath}.{ImageQuality.Medium.ToString().ToLowerInvariant()}.webp",
75
);
using SKBitmap low = medium.Resize(
new SKSizeI(original.Width / 2, original.Height / 2),
SKFilterQuality.Low
);
await _WriteTo(
low,
$"{localPath}.{ImageQuality.Low.ToString().ToLowerInvariant()}.webp",
50
);
image.Blurhash = Blurhasher.Encode(low, 4, 3);
}
catch (Exception ex)
{
logger.LogError(ex, "{What} could not be downloaded", what);
}
}
/// <inheritdoc />
public async Task DownloadImages<T>(T item)
where T : IThumbnails
{
string name = item is IResource res ? res.Slug : "???";
string posterPath =
$"{_GetBaseImagePath(item, "poster")}.{ImageQuality.High.ToString().ToLowerInvariant()}.webp";
bool duplicated = false;
TaskCompletionSource<object>? sync = null;
try
{
lock (_downloading)
{
if (_downloading.ContainsKey(posterPath))
{
duplicated = true;
sync = _downloading.GetValueOrDefault(posterPath);
}
else
{
sync = new();
_downloading.Add(posterPath, sync);
}
}
if (duplicated)
{
object? dup = sync != null ? await sync.Task : null;
if (dup != null)
throw new DuplicatedItemException(dup);
}
await _DownloadImage(
item.Poster,
_GetBaseImagePath(item, "poster"),
$"The poster of {name}"
);
await _DownloadImage(
item.Thumbnail,
_GetBaseImagePath(item, "thumbnail"),
$"The poster of {name}"
);
await _DownloadImage(
item.Logo,
_GetBaseImagePath(item, "logo"),
$"The poster of {name}"
);
}
finally
{
if (!duplicated)
{
lock (_downloading)
{
_downloading.Remove(posterPath);
sync!.SetResult(item);
}
}
}
}
private static string _GetBaseImagePath<T>(T item, string image)
{
string directory = item switch
{
IResource res
=> Path.Combine("./metadata", item.GetType().Name.ToLowerInvariant(), res.Slug),
_ => Path.Combine("./metadata", typeof(T).Name.ToLowerInvariant())
};
Directory.CreateDirectory(directory);
return Path.Combine(directory, image);
}
/// <inheritdoc />
public string GetImagePath<T>(T item, string image, ImageQuality quality)
where T : IThumbnails
{
return $"{_GetBaseImagePath(item, image)}.{quality.ToString().ToLowerInvariant()}.webp";
}
/// <inheritdoc />
public Task DeleteImages<T>(T item)
where T : IThumbnails
{
IEnumerable<string> images = new[] { "poster", "thumbnail", "logo" }
.SelectMany(x => _GetBaseImagePath(item, x))
.SelectMany(x =>
new[]
{
ImageQuality.High.ToString().ToLowerInvariant(),
ImageQuality.Medium.ToString().ToLowerInvariant(),
ImageQuality.Low.ToString().ToLowerInvariant(),
}.Select(quality => $"{x}.{quality}.webp")
);
foreach (string image in images)
File.Delete(image);
return Task.CompletedTask;
}
public async Task<Stream> GetUserImage(Guid userId)
{
try
{
return File.Open($"/metadata/user/{userId}.webp", FileMode.Open);
}
catch (FileNotFoundException) { }
catch (DirectoryNotFoundException) { }
User user = await users.Value.Get(userId);
if (user.Email == null)
throw new ItemNotFoundException();
using MD5 md5 = MD5.Create();
string hash = Convert
.ToHexString(md5.ComputeHash(Encoding.ASCII.GetBytes(user.Email)))
.ToLower();
try
{
HttpClient client = clientFactory.CreateClient();
HttpResponseMessage response = await client.GetAsync(
$"https://www.gravatar.com/avatar/{hash}.jpg?d=404&s=250"
);
response.EnsureSuccessStatusCode();
return await response.Content.ReadAsStreamAsync();
}
catch
{
throw new ItemNotFoundException();
}
}
public async Task SetUserImage(Guid userId, Stream? image)
{
if (image == null)
{
try
{
File.Delete($"/metadata/user/{userId}.webp");
}
catch { }
return; return;
} }
using SKCodec codec = SKCodec.Create(image);
SKImageInfo info = codec.Info; SKImageInfo info = codec.Info;
info.ColorType = SKColorType.Rgba8888; info.ColorType = SKColorType.Rgba8888;
using SKBitmap original = SKBitmap.Decode(codec, info); using SKBitmap original = SKBitmap.Decode(codec, info);
using SKBitmap ret = original.Resize(new SKSizeI(250, 250), SKFilterQuality.High);
Directory.CreateDirectory("/metadata/user"); using SKBitmap high = original.Resize(
await _WriteTo(ret, $"/metadata/user/{userId}.webp", 75); new SKSizeI(original.Width, original.Height),
SKFilterQuality.High
);
await _WriteTo(
original,
$"{localPath}.{ImageQuality.High.ToString().ToLowerInvariant()}.webp",
90
);
using SKBitmap medium = high.Resize(
new SKSizeI((int)(high.Width / 1.5), (int)(high.Height / 1.5)),
SKFilterQuality.Medium
);
await _WriteTo(
medium,
$"{localPath}.{ImageQuality.Medium.ToString().ToLowerInvariant()}.webp",
75
);
using SKBitmap low = medium.Resize(
new SKSizeI(original.Width / 2, original.Height / 2),
SKFilterQuality.Low
);
await _WriteTo(
low,
$"{localPath}.{ImageQuality.Low.ToString().ToLowerInvariant()}.webp",
50
);
image.Blurhash = Blurhasher.Encode(low, 4, 3);
}
catch (Exception ex)
{
logger.LogError(ex, "{What} could not be downloaded", what);
} }
} }
/// <inheritdoc />
public async Task DownloadImages<T>(T item)
where T : IThumbnails
{
string name = item is IResource res ? res.Slug : "???";
string posterPath =
$"{_GetBaseImagePath(item, "poster")}.{ImageQuality.High.ToString().ToLowerInvariant()}.webp";
bool duplicated = false;
TaskCompletionSource<object>? sync = null;
try
{
lock (_downloading)
{
if (_downloading.ContainsKey(posterPath))
{
duplicated = true;
sync = _downloading.GetValueOrDefault(posterPath);
}
else
{
sync = new();
_downloading.Add(posterPath, sync);
}
}
if (duplicated)
{
object? dup = sync != null ? await sync.Task : null;
if (dup != null)
throw new DuplicatedItemException(dup);
}
await _DownloadImage(
item.Poster,
_GetBaseImagePath(item, "poster"),
$"The poster of {name}"
);
await _DownloadImage(
item.Thumbnail,
_GetBaseImagePath(item, "thumbnail"),
$"The poster of {name}"
);
await _DownloadImage(
item.Logo,
_GetBaseImagePath(item, "logo"),
$"The poster of {name}"
);
}
finally
{
if (!duplicated)
{
lock (_downloading)
{
_downloading.Remove(posterPath);
sync!.SetResult(item);
}
}
}
}
private static string _GetBaseImagePath<T>(T item, string image)
{
string directory = item switch
{
IResource res
=> Path.Combine("./metadata", item.GetType().Name.ToLowerInvariant(), res.Slug),
_ => Path.Combine("./metadata", typeof(T).Name.ToLowerInvariant())
};
Directory.CreateDirectory(directory);
return Path.Combine(directory, image);
}
/// <inheritdoc />
public string GetImagePath<T>(T item, string image, ImageQuality quality)
where T : IThumbnails
{
return $"{_GetBaseImagePath(item, image)}.{quality.ToString().ToLowerInvariant()}.webp";
}
/// <inheritdoc />
public Task DeleteImages<T>(T item)
where T : IThumbnails
{
IEnumerable<string> images = new[] { "poster", "thumbnail", "logo" }
.SelectMany(x => _GetBaseImagePath(item, x))
.SelectMany(x =>
new[]
{
ImageQuality.High.ToString().ToLowerInvariant(),
ImageQuality.Medium.ToString().ToLowerInvariant(),
ImageQuality.Low.ToString().ToLowerInvariant(),
}.Select(quality => $"{x}.{quality}.webp")
);
foreach (string image in images)
File.Delete(image);
return Task.CompletedTask;
}
public async Task<Stream> GetUserImage(Guid userId)
{
try
{
return File.Open($"/metadata/user/{userId}.webp", FileMode.Open);
}
catch (FileNotFoundException) { }
catch (DirectoryNotFoundException) { }
User user = await users.Value.Get(userId);
if (user.Email == null)
throw new ItemNotFoundException();
using MD5 md5 = MD5.Create();
string hash = Convert
.ToHexString(md5.ComputeHash(Encoding.ASCII.GetBytes(user.Email)))
.ToLower();
try
{
HttpClient client = clientFactory.CreateClient();
HttpResponseMessage response = await client.GetAsync(
$"https://www.gravatar.com/avatar/{hash}.jpg?d=404&s=250"
);
response.EnsureSuccessStatusCode();
return await response.Content.ReadAsStreamAsync();
}
catch
{
throw new ItemNotFoundException();
}
}
public async Task SetUserImage(Guid userId, Stream? image)
{
if (image == null)
{
try
{
File.Delete($"/metadata/user/{userId}.webp");
}
catch { }
return;
}
using SKCodec codec = SKCodec.Create(image);
SKImageInfo info = codec.Info;
info.ColorType = SKColorType.Rgba8888;
using SKBitmap original = SKBitmap.Decode(codec, info);
using SKBitmap ret = original.Resize(new SKSizeI(250, 250), SKFilterQuality.High);
Directory.CreateDirectory("/metadata/user");
await _WriteTo(ret, $"/metadata/user/{userId}.webp", 75);
}
} }

211
back/src/Kyoo.Core/CoreModule.cs
View File

@ -33,116 +33,115 @@ using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Routing; using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
namespace Kyoo.Core namespace Kyoo.Core;
/// <summary>
/// The core module containing default implementations
/// </summary>
public class CoreModule : IPlugin
{ {
/// <summary> /// <summary>
/// The core module containing default implementations /// A service provider to access services in static context (in events for example).
/// </summary> /// </summary>
public class CoreModule : IPlugin /// <remarks>Don't forget to create a scope.</remarks>
public static IServiceProvider Services { get; set; }
/// <inheritdoc />
public string Name => "Core";
/// <inheritdoc />
public void Configure(ContainerBuilder builder)
{ {
/// <summary> builder
/// A service provider to access services in static context (in events for example). .RegisterType<ThumbnailsManager>()
/// </summary> .As<IThumbnailsManager>()
/// <remarks>Don't forget to create a scope.</remarks> .InstancePerLifetimeScope();
public static IServiceProvider Services { get; set; } builder.RegisterType<LibraryManager>().As<ILibraryManager>().InstancePerLifetimeScope();
/// <inheritdoc /> builder.RegisterRepository<LibraryItemRepository>();
public string Name => "Core"; builder.RegisterRepository<CollectionRepository>();
builder.RegisterRepository<MovieRepository>();
/// <inheritdoc /> builder.RegisterRepository<ShowRepository>();
public void Configure(ContainerBuilder builder) builder.RegisterRepository<SeasonRepository>();
{ builder.RegisterRepository<EpisodeRepository>();
builder builder.RegisterRepository<StudioRepository>();
.RegisterType<ThumbnailsManager>() builder.RegisterRepository<UserRepository>().As<IUserRepository>();
.As<IThumbnailsManager>() builder.RegisterRepository<NewsRepository>();
.InstancePerLifetimeScope(); builder
builder.RegisterType<LibraryManager>().As<ILibraryManager>().InstancePerLifetimeScope(); .RegisterType<WatchStatusRepository>()
.As<IWatchStatusRepository>()
builder.RegisterRepository<LibraryItemRepository>(); .AsSelf()
builder.RegisterRepository<CollectionRepository>(); .InstancePerLifetimeScope();
builder.RegisterRepository<MovieRepository>(); builder
builder.RegisterRepository<ShowRepository>(); .RegisterType<IssueRepository>()
builder.RegisterRepository<SeasonRepository>(); .As<IIssueRepository>()
builder.RegisterRepository<EpisodeRepository>(); .AsSelf()
builder.RegisterRepository<StudioRepository>(); .InstancePerLifetimeScope();
builder.RegisterRepository<UserRepository>().As<IUserRepository>(); builder.RegisterType<SqlVariableContext>().InstancePerLifetimeScope();
builder.RegisterRepository<NewsRepository>();
builder
.RegisterType<WatchStatusRepository>()
.As<IWatchStatusRepository>()
.AsSelf()
.InstancePerLifetimeScope();
builder
.RegisterType<IssueRepository>()
.As<IIssueRepository>()
.AsSelf()
.InstancePerLifetimeScope();
builder.RegisterType<SqlVariableContext>().InstancePerLifetimeScope();
}
/// <inheritdoc />
public void Configure(IServiceCollection services)
{
services.AddHttpContextAccessor();
services
.AddMvcCore(options =>
{
options.Filters.Add<ExceptionFilter>();
options.ModelBinderProviders.Insert(0, new SortBinder.Provider());
options.ModelBinderProviders.Insert(0, new IncludeBinder.Provider());
options.ModelBinderProviders.Insert(0, new FilterBinder.Provider());
})
.AddJsonOptions(x =>
{
x.JsonSerializerOptions.TypeInfoResolver = new WithKindResolver()
{
Modifiers = { WithKindResolver.HandleLoadableFields }
};
x.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
x.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
})
.AddDataAnnotations()
.AddControllersAsServices()
.AddApiExplorer()
.ConfigureApiBehaviorOptions(options =>
{
options.SuppressMapClientErrors = true;
options.InvalidModelStateResponseFactory = ctx =>
{
string[] errors = ctx
.ModelState.SelectMany(x => x.Value!.Errors)
.Select(x => x.ErrorMessage)
.ToArray();
return new BadRequestObjectResult(new RequestError(errors));
};
});
services.Configure<RouteOptions>(x =>
{
x.ConstraintMap.Add("id", typeof(IdentifierRouteConstraint));
});
services.AddResponseCompression(x =>
{
x.EnableForHttps = true;
});
services.AddProxies();
services.AddHttpClient();
}
/// <inheritdoc />
public IEnumerable<IStartupAction> ConfigureSteps =>
new IStartupAction[]
{
SA.New<IApplicationBuilder>(app => app.UseHsts(), SA.Before),
SA.New<IApplicationBuilder>(app => app.UseResponseCompression(), SA.Routing + 1),
SA.New<IApplicationBuilder>(app => app.UseRouting(), SA.Routing),
SA.New<IApplicationBuilder>(
app => app.UseEndpoints(x => x.MapControllers()),
SA.Endpoint
)
};
} }
/// <inheritdoc />
public void Configure(IServiceCollection services)
{
services.AddHttpContextAccessor();
services
.AddMvcCore(options =>
{
options.Filters.Add<ExceptionFilter>();
options.ModelBinderProviders.Insert(0, new SortBinder.Provider());
options.ModelBinderProviders.Insert(0, new IncludeBinder.Provider());
options.ModelBinderProviders.Insert(0, new FilterBinder.Provider());
})
.AddJsonOptions(x =>
{
x.JsonSerializerOptions.TypeInfoResolver = new WithKindResolver()
{
Modifiers = { WithKindResolver.HandleLoadableFields }
};
x.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
x.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
})
.AddDataAnnotations()
.AddControllersAsServices()
.AddApiExplorer()
.ConfigureApiBehaviorOptions(options =>
{
options.SuppressMapClientErrors = true;
options.InvalidModelStateResponseFactory = ctx =>
{
string[] errors = ctx
.ModelState.SelectMany(x => x.Value!.Errors)
.Select(x => x.ErrorMessage)
.ToArray();
return new BadRequestObjectResult(new RequestError(errors));
};
});
services.Configure<RouteOptions>(x =>
{
x.ConstraintMap.Add("id", typeof(IdentifierRouteConstraint));
});
services.AddResponseCompression(x =>
{
x.EnableForHttps = true;
});
services.AddProxies();
services.AddHttpClient();
}
/// <inheritdoc />
public IEnumerable<IStartupAction> ConfigureSteps =>
new IStartupAction[]
{
SA.New<IApplicationBuilder>(app => app.UseHsts(), SA.Before),
SA.New<IApplicationBuilder>(app => app.UseResponseCompression(), SA.Routing + 1),
SA.New<IApplicationBuilder>(app => app.UseRouting(), SA.Routing),
SA.New<IApplicationBuilder>(
app => app.UseEndpoints(x => x.MapControllers()),
SA.Endpoint
)
};
} }

101
back/src/Kyoo.Core/ExceptionFilter.cs
View File

@ -25,59 +25,58 @@ using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters; using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace Kyoo.Core namespace Kyoo.Core;
{
/// <summary>
/// A middleware to handle errors globally.
/// </summary>
/// <remarks>
/// Initializes a new instance of the <see cref="ExceptionFilter"/> class.
/// </remarks>
/// <param name="logger">The logger used to log errors.</param>
public class ExceptionFilter(ILogger<ExceptionFilter> logger) : IExceptionFilter
{
/// <inheritdoc/>
public void OnException(ExceptionContext context)
{
switch (context.Exception)
{
case ValidationException ex:
context.Result = new BadRequestObjectResult(new RequestError(ex.Message));
break;
case ItemNotFoundException ex:
context.Result = new NotFoundObjectResult(new RequestError(ex.Message));
break;
case DuplicatedItemException ex when ex.Existing is not null:
context.Result = new ConflictObjectResult(ex.Existing);
break;
case DuplicatedItemException:
// Should not happen but if it does, it is better than returning a 409 with no body since clients expect json content
context.Result = new ConflictObjectResult(new RequestError("Duplicated item"));
break;
case UnauthorizedException ex:
context.Result = new UnauthorizedObjectResult(new RequestError(ex.Message));
break;
case Exception ex:
logger.LogError(ex, "Unhandled error");
context.Result = new ServerErrorObjectResult(
new RequestError("Internal Server Error")
);
break;
}
}
/// <inheritdoc /> /// <summary>
public class ServerErrorObjectResult : ObjectResult /// A middleware to handle errors globally.
/// </summary>
/// <remarks>
/// Initializes a new instance of the <see cref="ExceptionFilter"/> class.
/// </remarks>
/// <param name="logger">The logger used to log errors.</param>
public class ExceptionFilter(ILogger<ExceptionFilter> logger) : IExceptionFilter
{
/// <inheritdoc/>
public void OnException(ExceptionContext context)
{
switch (context.Exception)
{ {
/// <summary> case ValidationException ex:
/// Initializes a new instance of the <see cref="ServerErrorObjectResult"/> class. context.Result = new BadRequestObjectResult(new RequestError(ex.Message));
/// </summary> break;
/// <param name="value">The object to return.</param> case ItemNotFoundException ex:
public ServerErrorObjectResult(object value) context.Result = new NotFoundObjectResult(new RequestError(ex.Message));
: base(value) break;
{ case DuplicatedItemException ex when ex.Existing is not null:
StatusCode = StatusCodes.Status500InternalServerError; context.Result = new ConflictObjectResult(ex.Existing);
} break;
case DuplicatedItemException:
// Should not happen but if it does, it is better than returning a 409 with no body since clients expect json content
context.Result = new ConflictObjectResult(new RequestError("Duplicated item"));
break;
case UnauthorizedException ex:
context.Result = new UnauthorizedObjectResult(new RequestError(ex.Message));
break;
case Exception ex:
logger.LogError(ex, "Unhandled error");
context.Result = new ServerErrorObjectResult(
new RequestError("Internal Server Error")
);
break;
}
}
/// <inheritdoc />
public class ServerErrorObjectResult : ObjectResult
{
/// <summary>
/// Initializes a new instance of the <see cref="ServerErrorObjectResult"/> class.
/// </summary>
/// <param name="value">The object to return.</param>
public ServerErrorObjectResult(object value)
: base(value)
{
StatusCode = StatusCodes.Status500InternalServerError;
} }
} }
} }

89
back/src/Kyoo.Core/Views/Health.cs
View File

@ -22,54 +22,53 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Diagnostics.HealthChecks; using Microsoft.Extensions.Diagnostics.HealthChecks;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// An API endpoint to check the health.
/// </summary>
[Route("health")]
[ApiController]
[ApiDefinition("Health")]
public class Health : BaseApi
{ {
private readonly HealthCheckService _healthCheckService;
/// <summary> /// <summary>
/// An API endpoint to check the health. /// Create a new <see cref="Health"/>.
/// </summary> /// </summary>
[Route("health")] /// <param name="healthCheckService">The service to check health.</param>
[ApiController] public Health(HealthCheckService healthCheckService)
[ApiDefinition("Health")]
public class Health : BaseApi
{ {
private readonly HealthCheckService _healthCheckService; _healthCheckService = healthCheckService;
/// <summary>
/// Create a new <see cref="Health"/>.
/// </summary>
/// <param name="healthCheckService">The service to check health.</param>
public Health(HealthCheckService healthCheckService)
{
_healthCheckService = healthCheckService;
}
/// <summary>
/// Check if the api is ready to accept requests.
/// </summary>
/// <returns>A status indicating the health of the api.</returns>
[HttpGet]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
public async Task<IActionResult> CheckHealth()
{
IHeaderDictionary headers = HttpContext.Response.Headers;
headers.CacheControl = "no-store, no-cache";
headers.Pragma = "no-cache";
headers.Expires = "Thu, 01 Jan 1970 00:00:00 GMT";
HealthReport result = await _healthCheckService.CheckHealthAsync();
return result.Status switch
{
HealthStatus.Healthy => Ok(new HealthResult("Healthy")),
HealthStatus.Unhealthy => Ok(new HealthResult("Unstable")),
HealthStatus.Degraded => StatusCode(StatusCodes.Status503ServiceUnavailable),
_ => StatusCode(StatusCodes.Status500InternalServerError),
};
}
/// <summary>
/// The result of a health operation.
/// </summary>
public record HealthResult(string Status);
} }
/// <summary>
/// Check if the api is ready to accept requests.
/// </summary>
/// <returns>A status indicating the health of the api.</returns>
[HttpGet]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
public async Task<IActionResult> CheckHealth()
{
IHeaderDictionary headers = HttpContext.Response.Headers;
headers.CacheControl = "no-store, no-cache";
headers.Pragma = "no-cache";
headers.Expires = "Thu, 01 Jan 1970 00:00:00 GMT";
HealthReport result = await _healthCheckService.CheckHealthAsync();
return result.Status switch
{
HealthStatus.Healthy => Ok(new HealthResult("Healthy")),
HealthStatus.Unhealthy => Ok(new HealthResult("Unstable")),
HealthStatus.Degraded => StatusCode(StatusCodes.Status503ServiceUnavailable),
_ => StatusCode(StatusCodes.Status500InternalServerError),
};
}
/// <summary>
/// The result of a health operation.
/// </summary>
public record HealthResult(string Status);
} }

121
back/src/Kyoo.Core/Views/Helper/BaseApi.cs
View File

@ -25,76 +25,75 @@ using Kyoo.Abstractions.Models;
using Kyoo.Utils; using Kyoo.Utils;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// A common API containing custom methods to help inheritors.
/// </summary>
public abstract class BaseApi : ControllerBase
{ {
/// <summary> /// <summary>
/// A common API containing custom methods to help inheritors. /// Construct and return a page from an api.
/// </summary> /// </summary>
public abstract class BaseApi : ControllerBase /// <param name="resources">The list of resources that should be included in the current page.</param>
/// <param name="limit">
/// The max number of items that should be present per page. This should be the same as in the request,
/// it is used to calculate if this is the last page and so on.
/// </param>
/// <typeparam name="TResult">The type of items on the page.</typeparam>
/// <returns>A Page representing the response.</returns>
protected Page<TResult> Page<TResult>(ICollection<TResult> resources, int limit)
where TResult : IResource
{ {
/// <summary> Dictionary<string, string> query = Request.Query.ToDictionary(
/// Construct and return a page from an api. x => x.Key,
/// </summary> x => x.Value.ToString(),
/// <param name="resources">The list of resources that should be included in the current page.</param> StringComparer.InvariantCultureIgnoreCase
/// <param name="limit"> );
/// The max number of items that should be present per page. This should be the same as in the request,
/// it is used to calculate if this is the last page and so on. // If the query was sorted randomly, add the seed to the url to get reproducible links (next,prev,first...)
/// </param> if (query.ContainsKey("sortBy"))
/// <typeparam name="TResult">The type of items on the page.</typeparam>
/// <returns>A Page representing the response.</returns>
protected Page<TResult> Page<TResult>(ICollection<TResult> resources, int limit)
where TResult : IResource
{ {
Dictionary<string, string> query = Request.Query.ToDictionary( object seed = HttpContext.Items["seed"]!;
x => x.Key,
x => x.Value.ToString(),
StringComparer.InvariantCultureIgnoreCase
);
// If the query was sorted randomly, add the seed to the url to get reproducible links (next,prev,first...) query["sortBy"] = Regex.Replace(query["sortBy"], "random(?!:)", $"random:{seed}");
if (query.ContainsKey("sortBy")) }
{ return new Page<TResult>(resources, Request.Path, query, limit);
object seed = HttpContext.Items["seed"]!; }
query["sortBy"] = Regex.Replace(query["sortBy"], "random(?!:)", $"random:{seed}"); protected SearchPage<TResult> SearchPage<TResult>(SearchPage<TResult>.SearchResult result)
} where TResult : IResource
return new Page<TResult>(resources, Request.Path, query, limit); {
Dictionary<string, string> query = Request.Query.ToDictionary(
x => x.Key,
x => x.Value.ToString(),
StringComparer.InvariantCultureIgnoreCase
);
string self = Request.Path + query.ToQueryString();
string? previous = null;
string? next = null;
string first;
int limit = query.TryGetValue("limit", out string? limitStr)
? int.Parse(limitStr)
: new SearchPagination().Limit;
int? skip = query.TryGetValue("skip", out string? skipStr) ? int.Parse(skipStr) : null;
if (skip != null)
{
query["skip"] = Math.Max(0, skip.Value - limit).ToString();
previous = Request.Path + query.ToQueryString();
}
if (result.Items.Count == limit && limit > 0)
{
int newSkip = skip.HasValue ? skip.Value + limit : limit;
query["skip"] = newSkip.ToString();
next = Request.Path + query.ToQueryString();
} }
protected SearchPage<TResult> SearchPage<TResult>(SearchPage<TResult>.SearchResult result) query.Remove("skip");
where TResult : IResource first = Request.Path + query.ToQueryString();
{
Dictionary<string, string> query = Request.Query.ToDictionary(
x => x.Key,
x => x.Value.ToString(),
StringComparer.InvariantCultureIgnoreCase
);
string self = Request.Path + query.ToQueryString(); return new SearchPage<TResult>(result, self, previous, next, first);
string? previous = null;
string? next = null;
string first;
int limit = query.TryGetValue("limit", out string? limitStr)
? int.Parse(limitStr)
: new SearchPagination().Limit;
int? skip = query.TryGetValue("skip", out string? skipStr) ? int.Parse(skipStr) : null;
if (skip != null)
{
query["skip"] = Math.Max(0, skip.Value - limit).ToString();
previous = Request.Path + query.ToQueryString();
}
if (result.Items.Count == limit && limit > 0)
{
int newSkip = skip.HasValue ? skip.Value + limit : limit;
query["skip"] = newSkip.ToString();
next = Request.Path + query.ToQueryString();
}
query.Remove("skip");
first = Request.Path + query.ToQueryString();
return new SearchPage<TResult>(result, self, previous, next, first);
}
} }
} }

452
back/src/Kyoo.Core/Views/Helper/CrudApi.cs
View File

@ -27,250 +27,246 @@ using Kyoo.Models;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// A base class to handle CRUD operations on a specific resource type <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type of resource to make CRUD apis for.</typeparam>
[ApiController]
public class CrudApi<T> : BaseApi
where T : class, IResource, IQuery
{ {
/// <summary> /// <summary>
/// A base class to handle CRUD operations on a specific resource type <typeparamref name="T"/>. /// The repository of the resource, used to retrieve, save and do operations on the baking store.
/// </summary> /// </summary>
/// <typeparam name="T">The type of resource to make CRUD apis for.</typeparam> protected IRepository<T> Repository { get; }
[ApiController]
public class CrudApi<T> : BaseApi /// <summary>
where T : class, IResource, IQuery /// Create a new <see cref="CrudApi{T}"/> using the given repository and base url.
/// </summary>
/// <param name="repository">
/// The repository to use as a baking store for the type <typeparamref name="T"/>.
/// </param>
public CrudApi(IRepository<T> repository)
{ {
/// <summary> Repository = repository;
/// The repository of the resource, used to retrieve, save and do operations on the baking store. }
/// </summary>
protected IRepository<T> Repository { get; }
/// <summary> /// <summary>
/// Create a new <see cref="CrudApi{T}"/> using the given repository and base url. /// Get item
/// </summary> /// </summary>
/// <param name="repository"> /// <remarks>
/// The repository to use as a baking store for the type <typeparamref name="T"/>. /// Get a specific resource via it's ID or it's slug.
/// </param> /// </remarks>
public CrudApi(IRepository<T> repository) /// <param name="identifier">The ID or slug of the resource to retrieve.</param>
{ /// <param name="fields">The aditional fields to include in the result.</param>
Repository = repository; /// <returns>The retrieved resource.</returns>
} /// <response code="404">A resource with the given ID or slug does not exist.</response>
[HttpGet("{identifier:id}")]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<T>> Get(Identifier identifier, [FromQuery] Include<T>? fields)
{
T? ret = await identifier.Match(
id => Repository.GetOrDefault(id, fields),
slug => Repository.GetOrDefault(slug, fields)
);
if (ret == null)
return NotFound();
return ret;
}
/// <summary> /// <summary>
/// Get item /// Get count
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Get a specific resource via it's ID or it's slug. /// Get the number of resources that match the filters.
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the resource to retrieve.</param> /// <param name="filter">A list of filters to respect.</param>
/// <param name="fields">The aditional fields to include in the result.</param> /// <returns>How many resources matched that filter.</returns>
/// <returns>The retrieved resource.</returns> /// <response code="400">Invalid filters.</response>
/// <response code="404">A resource with the given ID or slug does not exist.</response> [HttpGet("count")]
[HttpGet("{identifier:id}")] [PartialPermission(Kind.Read)]
[PartialPermission(Kind.Read)] [ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status200OK)] [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)] public async Task<ActionResult<int>> GetCount([FromQuery] Filter<T> filter)
public async Task<ActionResult<T>> Get( {
Identifier identifier, return await Repository.GetCount(filter);
[FromQuery] Include<T>? fields }
)
{
T? ret = await identifier.Match(
id => Repository.GetOrDefault(id, fields),
slug => Repository.GetOrDefault(slug, fields)
);
if (ret == null)
return NotFound();
return ret;
}
/// <summary> /// <summary>
/// Get count /// Get all
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Get the number of resources that match the filters. /// Get all resources that match the given filter.
/// </remarks> /// </remarks>
/// <param name="filter">A list of filters to respect.</param> /// <param name="sortBy">Sort information about the query (sort by, sort order).</param>
/// <returns>How many resources matched that filter.</returns> /// <param name="filter">Filter the returned items.</param>
/// <response code="400">Invalid filters.</response> /// <param name="pagination">How many items per page should be returned, where should the page start...</param>
[HttpGet("count")] /// <param name="fields">The aditional fields to include in the result.</param>
[PartialPermission(Kind.Read)] /// <returns>A list of resources that match every filters.</returns>
[ProducesResponseType(StatusCodes.Status200OK)] /// <response code="400">Invalid filters or sort information.</response>
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))] [HttpGet]
public async Task<ActionResult<int>> GetCount([FromQuery] Filter<T> filter) [PartialPermission(Kind.Read)]
{ [ProducesResponseType(StatusCodes.Status200OK)]
return await Repository.GetCount(filter); [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
} public async Task<ActionResult<Page<T>>> GetAll(
[FromQuery] Sort<T> sortBy,
[FromQuery] Filter<T>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<T>? fields
)
{
ICollection<T> resources = await Repository.GetAll(filter, sortBy, fields, pagination);
/// <summary> return Page(resources, pagination.Limit);
/// Get all }
/// </summary>
/// <remarks>
/// Get all resources that match the given filter.
/// </remarks>
/// <param name="sortBy">Sort information about the query (sort by, sort order).</param>
/// <param name="filter">Filter the returned items.</param>
/// <param name="pagination">How many items per page should be returned, where should the page start...</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A list of resources that match every filters.</returns>
/// <response code="400">Invalid filters or sort information.</response>
[HttpGet]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
public async Task<ActionResult<Page<T>>> GetAll(
[FromQuery] Sort<T> sortBy,
[FromQuery] Filter<T>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<T>? fields
)
{
ICollection<T> resources = await Repository.GetAll(filter, sortBy, fields, pagination);
return Page(resources, pagination.Limit); /// <summary>
} /// Create new
/// </summary>
/// <remarks>
/// Create a new item and store it. You may leave the ID unspecified, it will be filed by Kyoo.
/// </remarks>
/// <param name="resource">The resource to create.</param>
/// <returns>The created resource.</returns>
/// <response code="400">The resource in the request body is invalid.</response>
/// <response code="409">This item already exists (maybe a duplicated slug).</response>
[HttpPost]
[PartialPermission(Kind.Create)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status409Conflict, Type = typeof(ActionResult<>))]
public virtual async Task<ActionResult<T>> Create([FromBody] T resource)
{
return await Repository.Create(resource);
}
/// <summary> /// <summary>
/// Create new /// Edit
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Create a new item and store it. You may leave the ID unspecified, it will be filed by Kyoo. /// Edit an item. If the ID is specified it will be used to identify the resource.
/// </remarks> /// If not, the slug will be used to identify it.
/// <param name="resource">The resource to create.</param> /// </remarks>
/// <returns>The created resource.</returns> /// <param name="resource">The resource to edit.</param>
/// <response code="400">The resource in the request body is invalid.</response> /// <returns>The edited resource.</returns>
/// <response code="409">This item already exists (maybe a duplicated slug).</response> /// <response code="400">The resource in the request body is invalid.</response>
[HttpPost] /// <response code="404">No item found with the specified ID (or slug).</response>
[PartialPermission(Kind.Create)] [HttpPut]
[ProducesResponseType(StatusCodes.Status200OK)] [PartialPermission(Kind.Write)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))] [ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status409Conflict, Type = typeof(ActionResult<>))] [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
public virtual async Task<ActionResult<T>> Create([FromBody] T resource) [ProducesResponseType(StatusCodes.Status404NotFound)]
{ public async Task<ActionResult<T>> Edit([FromBody] T resource)
return await Repository.Create(resource); {
} if (resource.Id != Guid.Empty)
/// <summary>
/// Edit
/// </summary>
/// <remarks>
/// Edit an item. If the ID is specified it will be used to identify the resource.
/// If not, the slug will be used to identify it.
/// </remarks>
/// <param name="resource">The resource to edit.</param>
/// <returns>The edited resource.</returns>
/// <response code="400">The resource in the request body is invalid.</response>
/// <response code="404">No item found with the specified ID (or slug).</response>
[HttpPut]
[PartialPermission(Kind.Write)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<T>> Edit([FromBody] T resource)
{
if (resource.Id != Guid.Empty)
return await Repository.Edit(resource);
T old = await Repository.Get(resource.Slug);
resource.Id = old.Id;
return await Repository.Edit(resource); return await Repository.Edit(resource);
}
/// <summary> T old = await Repository.Get(resource.Slug);
/// Patch resource.Id = old.Id;
/// </summary> return await Repository.Edit(resource);
/// <remarks> }
/// Edit only specified properties of an item. If the ID is specified it will be used to identify the resource.
/// If not, the slug will be used to identify it.
/// </remarks>
/// <param name="patch">The resource to patch.</param>
/// <returns>The edited resource.</returns>
/// <response code="400">The resource in the request body is invalid.</response>
/// <response code="404">No item found with the specified ID (or slug).</response>
[HttpPatch]
[PartialPermission(Kind.Write)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<T>> Patch([FromBody] Patch<T> patch)
{
if (patch.Id.HasValue)
return await Repository.Patch(patch.Id.Value, patch.Apply);
if (patch.Slug == null)
throw new ArgumentException(
"Either the Id or the slug of the resource has to be defined to edit it."
);
T old = await Repository.Get(patch.Slug); /// <summary>
return await Repository.Patch(old.Id, patch.Apply); /// Patch
} /// </summary>
/// <remarks>
/// <summary> /// Edit only specified properties of an item. If the ID is specified it will be used to identify the resource.
/// Patch /// If not, the slug will be used to identify it.
/// </summary> /// </remarks>
/// <remarks> /// <param name="patch">The resource to patch.</param>
/// Edit only specified properties of an item. If the ID is specified it will be used to identify the resource. /// <returns>The edited resource.</returns>
/// If not, the slug will be used to identify it. /// <response code="400">The resource in the request body is invalid.</response>
/// </remarks> /// <response code="404">No item found with the specified ID (or slug).</response>
/// <param name="identifier">The id or slug of the resource.</param> [HttpPatch]
/// <param name="patch">The resource to patch.</param> [PartialPermission(Kind.Write)]
/// <returns>The edited resource.</returns> [ProducesResponseType(StatusCodes.Status200OK)]
/// <response code="400">The resource in the request body is invalid.</response> [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
/// <response code="404">No item found with the specified ID (or slug).</response> [ProducesResponseType(StatusCodes.Status404NotFound)]
[HttpPatch("{identifier:id}")] public async Task<ActionResult<T>> Patch([FromBody] Patch<T> patch)
[PartialPermission(Kind.Write)] {
[ProducesResponseType(StatusCodes.Status200OK)] if (patch.Id.HasValue)
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))] return await Repository.Patch(patch.Id.Value, patch.Apply);
[ProducesResponseType(StatusCodes.Status404NotFound)] if (patch.Slug == null)
public async Task<ActionResult<T>> Patch(Identifier identifier, [FromBody] Patch<T> patch) throw new ArgumentException(
{ "Either the Id or the slug of the resource has to be defined to edit it."
Guid id = await identifier.Match(
id => Task.FromResult(id),
async slug => (await Repository.Get(slug)).Id
); );
if (patch.Id.HasValue && patch.Id.Value != id)
throw new ArgumentException("Can not edit id of a resource.");
return await Repository.Patch(id, patch.Apply);
}
/// <summary> T old = await Repository.Get(patch.Slug);
/// Delete an item return await Repository.Patch(old.Id, patch.Apply);
/// </summary> }
/// <remarks>
/// Delete one item via it's ID or it's slug.
/// </remarks>
/// <param name="identifier">The ID or slug of the resource to delete.</param>
/// <returns>The item has successfully been deleted.</returns>
/// <response code="404">No item could be found with the given id or slug.</response>
[HttpDelete("{identifier:id}")]
[PartialPermission(Kind.Delete)]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> Delete(Identifier identifier)
{
await identifier.Match(id => Repository.Delete(id), slug => Repository.Delete(slug));
return NoContent();
}
/// <summary> /// <summary>
/// Delete all where /// Patch
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Delete all items matching the given filters. If no filter is specified, delete all items. /// Edit only specified properties of an item. If the ID is specified it will be used to identify the resource.
/// </remarks> /// If not, the slug will be used to identify it.
/// <param name="filter">The list of filters.</param> /// </remarks>
/// <returns>The item(s) has successfully been deleted.</returns> /// <param name="identifier">The id or slug of the resource.</param>
/// <response code="400">One or multiple filters are invalid.</response> /// <param name="patch">The resource to patch.</param>
[HttpDelete] /// <returns>The edited resource.</returns>
[PartialPermission(Kind.Delete)] /// <response code="400">The resource in the request body is invalid.</response>
[ProducesResponseType(StatusCodes.Status204NoContent)] /// <response code="404">No item found with the specified ID (or slug).</response>
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))] [HttpPatch("{identifier:id}")]
public async Task<IActionResult> Delete([FromQuery] Filter<T> filter) [PartialPermission(Kind.Write)]
{ [ProducesResponseType(StatusCodes.Status200OK)]
if (filter == null) [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
return BadRequest( [ProducesResponseType(StatusCodes.Status404NotFound)]
new RequestError("Incule a filter to delete items, all items won't be deleted.") public async Task<ActionResult<T>> Patch(Identifier identifier, [FromBody] Patch<T> patch)
); {
Guid id = await identifier.Match(
id => Task.FromResult(id),
async slug => (await Repository.Get(slug)).Id
);
if (patch.Id.HasValue && patch.Id.Value != id)
throw new ArgumentException("Can not edit id of a resource.");
return await Repository.Patch(id, patch.Apply);
}
await Repository.DeleteAll(filter); /// <summary>
return NoContent(); /// Delete an item
} /// </summary>
/// <remarks>
/// Delete one item via it's ID or it's slug.
/// </remarks>
/// <param name="identifier">The ID or slug of the resource to delete.</param>
/// <returns>The item has successfully been deleted.</returns>
/// <response code="404">No item could be found with the given id or slug.</response>
[HttpDelete("{identifier:id}")]
[PartialPermission(Kind.Delete)]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> Delete(Identifier identifier)
{
await identifier.Match(id => Repository.Delete(id), slug => Repository.Delete(slug));
return NoContent();
}
/// <summary>
/// Delete all where
/// </summary>
/// <remarks>
/// Delete all items matching the given filters. If no filter is specified, delete all items.
/// </remarks>
/// <param name="filter">The list of filters.</param>
/// <returns>The item(s) has successfully been deleted.</returns>
/// <response code="400">One or multiple filters are invalid.</response>
[HttpDelete]
[PartialPermission(Kind.Delete)]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
public async Task<IActionResult> Delete([FromQuery] Filter<T> filter)
{
if (filter == null)
return BadRequest(
new RequestError("Incule a filter to delete items, all items won't be deleted.")
);
await Repository.DeleteAll(filter);
return NoContent();
} }
} }

215
back/src/Kyoo.Core/Views/Helper/CrudThumbsApi.cs
View File

@ -26,126 +26,119 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// A base class to handle CRUD operations and services thumbnails for
/// a specific resource type <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type of resource to make CRUD and thumbnails apis for.</typeparam>
[ApiController]
public class CrudThumbsApi<T> : CrudApi<T>
where T : class, IResource, IThumbnails, IQuery
{ {
/// <summary> /// <summary>
/// A base class to handle CRUD operations and services thumbnails for /// The thumbnail manager used to retrieve images paths.
/// a specific resource type <typeparamref name="T"/>.
/// </summary> /// </summary>
/// <typeparam name="T">The type of resource to make CRUD and thumbnails apis for.</typeparam> private readonly IThumbnailsManager _thumbs;
[ApiController]
public class CrudThumbsApi<T> : CrudApi<T> /// <summary>
where T : class, IResource, IThumbnails, IQuery /// Create a new <see cref="CrudThumbsApi{T}"/> that handles crud requests and thumbnails.
/// </summary>
/// <param name="repository">
/// The repository to use as a baking store for the type <typeparamref name="T"/>.
/// </param>
/// <param name="thumbs">The thumbnail manager used to retrieve images paths.</param>
public CrudThumbsApi(IRepository<T> repository, IThumbnailsManager thumbs)
: base(repository)
{ {
/// <summary> _thumbs = thumbs;
/// The thumbnail manager used to retrieve images paths. }
/// </summary>
private readonly IThumbnailsManager _thumbs;
/// <summary> private async Task<IActionResult> _GetImage(
/// Create a new <see cref="CrudThumbsApi{T}"/> that handles crud requests and thumbnails. Identifier identifier,
/// </summary> string image,
/// <param name="repository"> ImageQuality? quality
/// The repository to use as a baking store for the type <typeparamref name="T"/>. )
/// </param> {
/// <param name="thumbs">The thumbnail manager used to retrieve images paths.</param> T? resource = await identifier.Match(
public CrudThumbsApi(IRepository<T> repository, IThumbnailsManager thumbs) id => Repository.GetOrDefault(id),
: base(repository) slug => Repository.GetOrDefault(slug)
);
if (resource == null)
return NotFound();
string path = _thumbs.GetImagePath(resource, image, quality ?? ImageQuality.High);
if (!System.IO.File.Exists(path))
return NotFound();
if (!identifier.Match(id => false, slug => slug == "random"))
{ {
_thumbs = thumbs; // Allow clients to cache the image for 6 month.
Response.Headers.Add("Cache-Control", $"public, max-age={60 * 60 * 24 * 31 * 6}");
} }
else
Response.Headers.Add("Cache-Control", $"public, no-store");
return PhysicalFile(Path.GetFullPath(path), "image/webp", true);
}
private async Task<IActionResult> _GetImage( /// <summary>
Identifier identifier, /// Get Poster
string image, /// </summary>
ImageQuality? quality /// <remarks>
) /// Get the poster for the specified item.
{ /// </remarks>
T? resource = await identifier.Match( /// <param name="identifier">The ID or slug of the resource to get the image for.</param>
id => Repository.GetOrDefault(id), /// <param name="quality">The quality of the image to retrieve.</param>
slug => Repository.GetOrDefault(slug) /// <returns>The image asked.</returns>
); /// <response code="404">
if (resource == null) /// No item exist with the specific identifier or the image does not exists on kyoo.
return NotFound(); /// </response>
string path = _thumbs.GetImagePath(resource, image, quality ?? ImageQuality.High); [HttpGet("{identifier:id}/poster")]
if (!System.IO.File.Exists(path)) [PartialPermission(Kind.Read)]
return NotFound(); [ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public Task<IActionResult> GetPoster(Identifier identifier, [FromQuery] ImageQuality? quality)
{
return _GetImage(identifier, "poster", quality);
}
if (!identifier.Match(id => false, slug => slug == "random")) /// <summary>
{ /// Get Logo
// Allow clients to cache the image for 6 month. /// </summary>
Response.Headers.Add("Cache-Control", $"public, max-age={60 * 60 * 24 * 31 * 6}"); /// <remarks>
} /// Get the logo for the specified item.
else /// </remarks>
Response.Headers.Add("Cache-Control", $"public, no-store"); /// <param name="identifier">The ID or slug of the resource to get the image for.</param>
return PhysicalFile(Path.GetFullPath(path), "image/webp", true); /// <param name="quality">The quality of the image to retrieve.</param>
} /// <returns>The image asked.</returns>
/// <response code="404">
/// No item exist with the specific identifier or the image does not exists on kyoo.
/// </response>
[HttpGet("{identifier:id}/logo")]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public Task<IActionResult> GetLogo(Identifier identifier, [FromQuery] ImageQuality? quality)
{
return _GetImage(identifier, "logo", quality);
}
/// <summary> /// <summary>
/// Get Poster /// Get Thumbnail
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Get the poster for the specified item. /// Get the thumbnail for the specified item.
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the resource to get the image for.</param> /// <param name="identifier">The ID or slug of the resource to get the image for.</param>
/// <param name="quality">The quality of the image to retrieve.</param> /// <param name="quality">The quality of the image to retrieve.</param>
/// <returns>The image asked.</returns> /// <returns>The image asked.</returns>
/// <response code="404"> /// <response code="404">
/// No item exist with the specific identifier or the image does not exists on kyoo. /// No item exist with the specific identifier or the image does not exists on kyoo.
/// </response> /// </response>
[HttpGet("{identifier:id}/poster")] [HttpGet("{identifier:id}/thumbnail")]
[PartialPermission(Kind.Read)] [HttpGet("{identifier:id}/backdrop", Order = AlternativeRoute)]
[ProducesResponseType(StatusCodes.Status200OK)] public Task<IActionResult> GetBackdrop(Identifier identifier, [FromQuery] ImageQuality? quality)
[ProducesResponseType(StatusCodes.Status404NotFound)] {
public Task<IActionResult> GetPoster( return _GetImage(identifier, "thumbnail", quality);
Identifier identifier,
[FromQuery] ImageQuality? quality
)
{
return _GetImage(identifier, "poster", quality);
}
/// <summary>
/// Get Logo
/// </summary>
/// <remarks>
/// Get the logo for the specified item.
/// </remarks>
/// <param name="identifier">The ID or slug of the resource to get the image for.</param>
/// <param name="quality">The quality of the image to retrieve.</param>
/// <returns>The image asked.</returns>
/// <response code="404">
/// No item exist with the specific identifier or the image does not exists on kyoo.
/// </response>
[HttpGet("{identifier:id}/logo")]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public Task<IActionResult> GetLogo(Identifier identifier, [FromQuery] ImageQuality? quality)
{
return _GetImage(identifier, "logo", quality);
}
/// <summary>
/// Get Thumbnail
/// </summary>
/// <remarks>
/// Get the thumbnail for the specified item.
/// </remarks>
/// <param name="identifier">The ID or slug of the resource to get the image for.</param>
/// <param name="quality">The quality of the image to retrieve.</param>
/// <returns>The image asked.</returns>
/// <response code="404">
/// No item exist with the specific identifier or the image does not exists on kyoo.
/// </response>
[HttpGet("{identifier:id}/thumbnail")]
[HttpGet("{identifier:id}/backdrop", Order = AlternativeRoute)]
public Task<IActionResult> GetBackdrop(
Identifier identifier,
[FromQuery] ImageQuality? quality
)
{
return _GetImage(identifier, "thumbnail", quality);
}
} }
} }

127
back/src/Kyoo.Core/Views/Metadata/StudioApi.cs
View File

@ -28,76 +28,75 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// Information about one or multiple <see cref="Studio"/>.
/// </summary>
[Route("studios")]
[Route("studio", Order = AlternativeRoute)]
[ApiController]
[PartialPermission(nameof(Show))]
[ApiDefinition("Studios", Group = MetadataGroup)]
public class StudioApi : CrudApi<Studio>
{ {
/// <summary> /// <summary>
/// Information about one or multiple <see cref="Studio"/>. /// The library manager used to modify or retrieve information in the data store.
/// </summary> /// </summary>
[Route("studios")] private readonly ILibraryManager _libraryManager;
[Route("studio", Order = AlternativeRoute)]
[ApiController] /// <summary>
[PartialPermission(nameof(Show))] /// Create a new <see cref="StudioApi"/>.
[ApiDefinition("Studios", Group = MetadataGroup)] /// </summary>
public class StudioApi : CrudApi<Studio> /// <param name="libraryManager">
/// The library manager used to modify or retrieve information in the data store.
/// </param>
public StudioApi(ILibraryManager libraryManager)
: base(libraryManager.Studios)
{ {
/// <summary> _libraryManager = libraryManager;
/// The library manager used to modify or retrieve information in the data store. }
/// </summary>
private readonly ILibraryManager _libraryManager;
/// <summary> /// <summary>
/// Create a new <see cref="StudioApi"/>. /// Get shows
/// </summary> /// </summary>
/// <param name="libraryManager"> /// <remarks>
/// The library manager used to modify or retrieve information in the data store. /// List shows that were made by this specific studio.
/// </param> /// </remarks>
public StudioApi(ILibraryManager libraryManager) /// <param name="identifier">The ID or slug of the <see cref="Studio"/>.</param>
: base(libraryManager.Studios) /// <param name="sortBy">A key to sort shows by.</param>
{ /// <param name="filter">An optional list of filters.</param>
_libraryManager = libraryManager; /// <param name="pagination">The number of shows to return.</param>
} /// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A page of shows.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No studio with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/shows")]
[HttpGet("{identifier:id}/show", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Show>>> GetShows(
Identifier identifier,
[FromQuery] Sort<Show> sortBy,
[FromQuery] Filter<Show>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Show> fields
)
{
ICollection<Show> resources = await _libraryManager.Shows.GetAll(
Filter.And(filter, identifier.Matcher<Show>(x => x.StudioId, x => x.Studio!.Slug)),
sortBy,
fields,
pagination
);
/// <summary> if (
/// Get shows !resources.Any()
/// </summary> && await _libraryManager.Studios.GetOrDefault(identifier.IsSame<Studio>()) == null
/// <remarks>
/// List shows that were made by this specific studio.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Studio"/>.</param>
/// <param name="sortBy">A key to sort shows by.</param>
/// <param name="filter">An optional list of filters.</param>
/// <param name="pagination">The number of shows to return.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A page of shows.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No studio with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/shows")]
[HttpGet("{identifier:id}/show", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Show>>> GetShows(
Identifier identifier,
[FromQuery] Sort<Show> sortBy,
[FromQuery] Filter<Show>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Show> fields
) )
{ return NotFound();
ICollection<Show> resources = await _libraryManager.Shows.GetAll( return Page(resources, pagination.Limit);
Filter.And(filter, identifier.Matcher<Show>(x => x.StudioId, x => x.Studio!.Slug)),
sortBy,
fields,
pagination
);
if (
!resources.Any()
&& await _libraryManager.Studios.GetOrDefault(identifier.IsSame<Studio>()) == null
)
return NotFound();
return Page(resources, pagination.Limit);
}
} }
} }

437
back/src/Kyoo.Core/Views/Resources/CollectionApi.cs
View File

@ -30,234 +30,233 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// Information about one or multiple <see cref="Collection"/>.
/// </summary>
[Route("collections")]
[Route("collection", Order = AlternativeRoute)]
[ApiController]
[PartialPermission(nameof(Collection))]
[ApiDefinition("Collections", Group = ResourcesGroup)]
public class CollectionApi : CrudThumbsApi<Collection>
{ {
/// <summary> private readonly ILibraryManager _libraryManager;
/// Information about one or multiple <see cref="Collection"/>. private readonly CollectionRepository _collections;
/// </summary> private readonly LibraryItemRepository _items;
[Route("collections")]
[Route("collection", Order = AlternativeRoute)] public CollectionApi(
[ApiController] ILibraryManager libraryManager,
[PartialPermission(nameof(Collection))] CollectionRepository collections,
[ApiDefinition("Collections", Group = ResourcesGroup)] LibraryItemRepository items,
public class CollectionApi : CrudThumbsApi<Collection> IThumbnailsManager thumbs
)
: base(libraryManager.Collections, thumbs)
{ {
private readonly ILibraryManager _libraryManager; _libraryManager = libraryManager;
private readonly CollectionRepository _collections; _collections = collections;
private readonly LibraryItemRepository _items; _items = items;
}
public CollectionApi( /// <summary>
ILibraryManager libraryManager, /// Add a movie
CollectionRepository collections, /// </summary>
LibraryItemRepository items, /// <remarks>
IThumbnailsManager thumbs /// Add a movie in the collection.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Collection"/>.</param>
/// <param name="movie">The ID or slug of the <see cref="Movie"/> to add.</param>
/// <returns>Nothing if successful.</returns>
/// <response code="404">No collection or movie with the given ID could be found.</response>
/// <response code="409">The specified movie is already in this collection.</response>
[HttpPut("{identifier:id}/movies/{movie:id}")]
[HttpPut("{identifier:id}/movie/{movie:id}", Order = AlternativeRoute)]
[PartialPermission(Kind.Write)]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
[ProducesResponseType(StatusCodes.Status409Conflict)]
public async Task<ActionResult> AddMovie(Identifier identifier, Identifier movie)
{
Guid collectionId = await identifier.Match(
async id => (await _libraryManager.Collections.Get(id)).Id,
async slug => (await _libraryManager.Collections.Get(slug)).Id
);
Guid movieId = await movie.Match(
async id => (await _libraryManager.Movies.Get(id)).Id,
async slug => (await _libraryManager.Movies.Get(slug)).Id
);
await _collections.AddMovie(collectionId, movieId);
return NoContent();
}
/// <summary>
/// Add a show
/// </summary>
/// <remarks>
/// Add a show in the collection.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Collection"/>.</param>
/// <param name="show">The ID or slug of the <see cref="Show"/> to add.</param>
/// <returns>Nothing if successful.</returns>
/// <response code="404">No collection or show with the given ID could be found.</response>
/// <response code="409">The specified show is already in this collection.</response>
[HttpPut("{identifier:id}/shows/{show:id}")]
[HttpPut("{identifier:id}/show/{show:id}", Order = AlternativeRoute)]
[PartialPermission(Kind.Write)]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
[ProducesResponseType(StatusCodes.Status409Conflict)]
public async Task<ActionResult> AddShow(Identifier identifier, Identifier show)
{
Guid collectionId = await identifier.Match(
async id => (await _libraryManager.Collections.Get(id)).Id,
async slug => (await _libraryManager.Collections.Get(slug)).Id
);
Guid showId = await show.Match(
async id => (await _libraryManager.Shows.Get(id)).Id,
async slug => (await _libraryManager.Shows.Get(slug)).Id
);
await _collections.AddShow(collectionId, showId);
return NoContent();
}
/// <summary>
/// Get items in collection
/// </summary>
/// <remarks>
/// Lists the items that are contained in the collection with the given id or slug.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Collection"/>.</param>
/// <param name="sortBy">A key to sort items by.</param>
/// <param name="filter">An optional list of filters.</param>
/// <param name="pagination">The number of items to return.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A page of items.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No collection with the given ID could be found.</response>
[HttpGet("{identifier:id}/items")]
[HttpGet("{identifier:id}/item", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<ILibraryItem>>> GetItems(
Identifier identifier,
[FromQuery] Sort<ILibraryItem> sortBy,
[FromQuery] Filter<ILibraryItem>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<ILibraryItem>? fields
)
{
Guid collectionId = await identifier.Match(
id => Task.FromResult(id),
async slug => (await _libraryManager.Collections.Get(slug)).Id
);
ICollection<ILibraryItem> resources = await _items.GetAllOfCollection(
collectionId,
filter,
sortBy == new Sort<ILibraryItem>.Default()
? new Sort<ILibraryItem>.By(nameof(Movie.AirDate))
: sortBy,
fields,
pagination
);
if (
!resources.Any()
&& await _libraryManager.Collections.GetOrDefault(identifier.IsSame<Collection>())
== null
) )
: base(libraryManager.Collections, thumbs) return NotFound();
{ return Page(resources, pagination.Limit);
_libraryManager = libraryManager; }
_collections = collections;
_items = items;
}
/// <summary> /// <summary>
/// Add a movie /// Get shows in collection
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Add a movie in the collection. /// Lists the shows that are contained in the collection with the given id or slug.
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Collection"/>.</param> /// <param name="identifier">The ID or slug of the <see cref="Collection"/>.</param>
/// <param name="movie">The ID or slug of the <see cref="Movie"/> to add.</param> /// <param name="sortBy">A key to sort shows by.</param>
/// <returns>Nothing if successful.</returns> /// <param name="filter">An optional list of filters.</param>
/// <response code="404">No collection or movie with the given ID could be found.</response> /// <param name="pagination">The number of shows to return.</param>
/// <response code="409">The specified movie is already in this collection.</response> /// <param name="fields">The additional fields to include in the result.</param>
[HttpPut("{identifier:id}/movies/{movie:id}")] /// <returns>A page of shows.</returns>
[HttpPut("{identifier:id}/movie/{movie:id}", Order = AlternativeRoute)] /// <response code="400">The filters or the sort parameters are invalid.</response>
[PartialPermission(Kind.Write)] /// <response code="404">No collection with the given ID could be found.</response>
[ProducesResponseType(StatusCodes.Status204NoContent)] [HttpGet("{identifier:id}/shows")]
[ProducesResponseType(StatusCodes.Status404NotFound)] [HttpGet("{identifier:id}/show", Order = AlternativeRoute)]
[ProducesResponseType(StatusCodes.Status409Conflict)] [PartialPermission(Kind.Read)]
public async Task<ActionResult> AddMovie(Identifier identifier, Identifier movie) [ProducesResponseType(StatusCodes.Status200OK)]
{ [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
Guid collectionId = await identifier.Match( [ProducesResponseType(StatusCodes.Status404NotFound)]
async id => (await _libraryManager.Collections.Get(id)).Id, public async Task<ActionResult<Page<Show>>> GetShows(
async slug => (await _libraryManager.Collections.Get(slug)).Id Identifier identifier,
); [FromQuery] Sort<Show> sortBy,
Guid movieId = await movie.Match( [FromQuery] Filter<Show>? filter,
async id => (await _libraryManager.Movies.Get(id)).Id, [FromQuery] Pagination pagination,
async slug => (await _libraryManager.Movies.Get(slug)).Id [FromQuery] Include<Show>? fields
); )
await _collections.AddMovie(collectionId, movieId); {
return NoContent(); ICollection<Show> resources = await _libraryManager.Shows.GetAll(
} Filter.And(filter, identifier.IsContainedIn<Show, Collection>(x => x.Collections)),
sortBy == new Sort<Show>.Default() ? new Sort<Show>.By(x => x.AirDate) : sortBy,
fields,
pagination
);
/// <summary> if (
/// Add a show !resources.Any()
/// </summary> && await _libraryManager.Collections.GetOrDefault(identifier.IsSame<Collection>())
/// <remarks> == null
/// Add a show in the collection.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Collection"/>.</param>
/// <param name="show">The ID or slug of the <see cref="Show"/> to add.</param>
/// <returns>Nothing if successful.</returns>
/// <response code="404">No collection or show with the given ID could be found.</response>
/// <response code="409">The specified show is already in this collection.</response>
[HttpPut("{identifier:id}/shows/{show:id}")]
[HttpPut("{identifier:id}/show/{show:id}", Order = AlternativeRoute)]
[PartialPermission(Kind.Write)]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
[ProducesResponseType(StatusCodes.Status409Conflict)]
public async Task<ActionResult> AddShow(Identifier identifier, Identifier show)
{
Guid collectionId = await identifier.Match(
async id => (await _libraryManager.Collections.Get(id)).Id,
async slug => (await _libraryManager.Collections.Get(slug)).Id
);
Guid showId = await show.Match(
async id => (await _libraryManager.Shows.Get(id)).Id,
async slug => (await _libraryManager.Shows.Get(slug)).Id
);
await _collections.AddShow(collectionId, showId);
return NoContent();
}
/// <summary>
/// Get items in collection
/// </summary>
/// <remarks>
/// Lists the items that are contained in the collection with the given id or slug.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Collection"/>.</param>
/// <param name="sortBy">A key to sort items by.</param>
/// <param name="filter">An optional list of filters.</param>
/// <param name="pagination">The number of items to return.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A page of items.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No collection with the given ID could be found.</response>
[HttpGet("{identifier:id}/items")]
[HttpGet("{identifier:id}/item", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<ILibraryItem>>> GetItems(
Identifier identifier,
[FromQuery] Sort<ILibraryItem> sortBy,
[FromQuery] Filter<ILibraryItem>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<ILibraryItem>? fields
) )
{ return NotFound();
Guid collectionId = await identifier.Match( return Page(resources, pagination.Limit);
id => Task.FromResult(id), }
async slug => (await _libraryManager.Collections.Get(slug)).Id
);
ICollection<ILibraryItem> resources = await _items.GetAllOfCollection(
collectionId,
filter,
sortBy == new Sort<ILibraryItem>.Default()
? new Sort<ILibraryItem>.By(nameof(Movie.AirDate))
: sortBy,
fields,
pagination
);
if ( /// <summary>
!resources.Any() /// Get movies in collection
&& await _libraryManager.Collections.GetOrDefault(identifier.IsSame<Collection>()) /// </summary>
== null /// <remarks>
) /// Lists the movies that are contained in the collection with the given id or slug.
return NotFound(); /// </remarks>
return Page(resources, pagination.Limit); /// <param name="identifier">The ID or slug of the <see cref="Collection"/>.</param>
} /// <param name="sortBy">A key to sort movies by.</param>
/// <param name="filter">An optional list of filters.</param>
/// <param name="pagination">The number of movies to return.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A page of movies.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No collection with the given ID could be found.</response>
[HttpGet("{identifier:id}/movies")]
[HttpGet("{identifier:id}/movie", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Movie>>> GetMovies(
Identifier identifier,
[FromQuery] Sort<Movie> sortBy,
[FromQuery] Filter<Movie>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Movie>? fields
)
{
ICollection<Movie> resources = await _libraryManager.Movies.GetAll(
Filter.And(filter, identifier.IsContainedIn<Movie, Collection>(x => x.Collections)),
sortBy == new Sort<Movie>.Default() ? new Sort<Movie>.By(x => x.AirDate) : sortBy,
fields,
pagination
);
/// <summary> if (
/// Get shows in collection !resources.Any()
/// </summary> && await _libraryManager.Collections.GetOrDefault(identifier.IsSame<Collection>())
/// <remarks> == null
/// Lists the shows that are contained in the collection with the given id or slug.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Collection"/>.</param>
/// <param name="sortBy">A key to sort shows by.</param>
/// <param name="filter">An optional list of filters.</param>
/// <param name="pagination">The number of shows to return.</param>
/// <param name="fields">The additional fields to include in the result.</param>
/// <returns>A page of shows.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No collection with the given ID could be found.</response>
[HttpGet("{identifier:id}/shows")]
[HttpGet("{identifier:id}/show", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Show>>> GetShows(
Identifier identifier,
[FromQuery] Sort<Show> sortBy,
[FromQuery] Filter<Show>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Show>? fields
) )
{ return NotFound();
ICollection<Show> resources = await _libraryManager.Shows.GetAll( return Page(resources, pagination.Limit);
Filter.And(filter, identifier.IsContainedIn<Show, Collection>(x => x.Collections)),
sortBy == new Sort<Show>.Default() ? new Sort<Show>.By(x => x.AirDate) : sortBy,
fields,
pagination
);
if (
!resources.Any()
&& await _libraryManager.Collections.GetOrDefault(identifier.IsSame<Collection>())
== null
)
return NotFound();
return Page(resources, pagination.Limit);
}
/// <summary>
/// Get movies in collection
/// </summary>
/// <remarks>
/// Lists the movies that are contained in the collection with the given id or slug.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Collection"/>.</param>
/// <param name="sortBy">A key to sort movies by.</param>
/// <param name="filter">An optional list of filters.</param>
/// <param name="pagination">The number of movies to return.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A page of movies.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No collection with the given ID could be found.</response>
[HttpGet("{identifier:id}/movies")]
[HttpGet("{identifier:id}/movie", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Movie>>> GetMovies(
Identifier identifier,
[FromQuery] Sort<Movie> sortBy,
[FromQuery] Filter<Movie>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Movie>? fields
)
{
ICollection<Movie> resources = await _libraryManager.Movies.GetAll(
Filter.And(filter, identifier.IsContainedIn<Movie, Collection>(x => x.Collections)),
sortBy == new Sort<Movie>.Default() ? new Sort<Movie>.By(x => x.AirDate) : sortBy,
fields,
pagination
);
if (
!resources.Any()
&& await _libraryManager.Collections.GetOrDefault(identifier.IsSame<Collection>())
== null
)
return NotFound();
return Page(resources, pagination.Limit);
}
} }
} }

315
back/src/Kyoo.Core/Views/Resources/EpisodeApi.cs
View File

@ -28,172 +28,171 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// Information about one or multiple <see cref="Episode"/>.
/// </summary>
[Route("episodes")]
[Route("episode", Order = AlternativeRoute)]
[ApiController]
[PartialPermission(nameof(Episode))]
[ApiDefinition("Episodes", Group = ResourcesGroup)]
public class EpisodeApi(ILibraryManager libraryManager, IThumbnailsManager thumbnails)
: TranscoderApi<Episode>(libraryManager.Episodes, thumbnails)
{ {
/// <summary> /// <summary>
/// Information about one or multiple <see cref="Episode"/>. /// Get episode's show
/// </summary> /// </summary>
[Route("episodes")] /// <remarks>
[Route("episode", Order = AlternativeRoute)] /// Get the show that this episode is part of.
[ApiController] /// </remarks>
[PartialPermission(nameof(Episode))] /// <param name="identifier">The ID or slug of the <see cref="Episode"/>.</param>
[ApiDefinition("Episodes", Group = ResourcesGroup)] /// <param name="fields">The aditional fields to include in the result.</param>
public class EpisodeApi(ILibraryManager libraryManager, IThumbnailsManager thumbnails) /// <returns>The show that contains this episode.</returns>
: TranscoderApi<Episode>(libraryManager.Episodes, thumbnails) /// <response code="404">No episode with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/show")]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Show>> GetShow(
Identifier identifier,
[FromQuery] Include<Show> fields
)
{ {
/// <summary> return await libraryManager.Shows.Get(
/// Get episode's show identifier.IsContainedIn<Show, Episode>(x => x.Episodes!),
/// </summary> fields
/// <remarks> );
/// Get the show that this episode is part of. }
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Episode"/>.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>The show that contains this episode.</returns>
/// <response code="404">No episode with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/show")]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Show>> GetShow(
Identifier identifier,
[FromQuery] Include<Show> fields
)
{
return await libraryManager.Shows.Get(
identifier.IsContainedIn<Show, Episode>(x => x.Episodes!),
fields
);
}
/// <summary> /// <summary>
/// Get episode's season /// Get episode's season
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Get the season that this episode is part of. /// Get the season that this episode is part of.
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Episode"/>.</param> /// <param name="identifier">The ID or slug of the <see cref="Episode"/>.</param>
/// <param name="fields">The aditional fields to include in the result.</param> /// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>The season that contains this episode.</returns> /// <returns>The season that contains this episode.</returns>
/// <response code="204">The episode is not part of a season.</response> /// <response code="204">The episode is not part of a season.</response>
/// <response code="404">No episode with the given ID or slug could be found.</response> /// <response code="404">No episode with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/season")] [HttpGet("{identifier:id}/season")]
[PartialPermission(Kind.Read)] [PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)] [ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status204NoContent)] [ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status404NotFound)] [ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Season>> GetSeason( public async Task<ActionResult<Season>> GetSeason(
Identifier identifier, Identifier identifier,
[FromQuery] Include<Season> fields [FromQuery] Include<Season> fields
) )
{ {
Season? ret = await libraryManager.Seasons.GetOrDefault( Season? ret = await libraryManager.Seasons.GetOrDefault(
identifier.IsContainedIn<Season, Episode>(x => x.Episodes!), identifier.IsContainedIn<Season, Episode>(x => x.Episodes!),
fields fields
); );
if (ret != null) if (ret != null)
return ret; return ret;
Episode? episode = await identifier.Match( Episode? episode = await identifier.Match(
id => libraryManager.Episodes.GetOrDefault(id), id => libraryManager.Episodes.GetOrDefault(id),
slug => libraryManager.Episodes.GetOrDefault(slug) slug => libraryManager.Episodes.GetOrDefault(slug)
); );
return episode == null ? NotFound() : NoContent(); return episode == null ? NotFound() : NoContent();
} }
/// <summary> /// <summary>
/// Get watch status /// Get watch status
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Get when an item has been wathed and if it was watched. /// Get when an item has been wathed and if it was watched.
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Episode"/>.</param> /// <param name="identifier">The ID or slug of the <see cref="Episode"/>.</param>
/// <returns>The status.</returns> /// <returns>The status.</returns>
/// <response code="204">This episode does not have a specific status.</response> /// <response code="204">This episode does not have a specific status.</response>
/// <response code="404">No episode with the given ID or slug could be found.</response> /// <response code="404">No episode with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/watchStatus")] [HttpGet("{identifier:id}/watchStatus")]
[UserOnly] [UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)] [ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status204NoContent)] [ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status404NotFound)] [ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<EpisodeWatchStatus?> GetWatchStatus(Identifier identifier) public async Task<EpisodeWatchStatus?> GetWatchStatus(Identifier identifier)
{ {
Guid id = await identifier.Match( Guid id = await identifier.Match(
id => Task.FromResult(id), id => Task.FromResult(id),
async slug => (await libraryManager.Episodes.Get(slug)).Id async slug => (await libraryManager.Episodes.Get(slug)).Id
); );
return await libraryManager.WatchStatus.GetEpisodeStatus(id, User.GetIdOrThrow()); return await libraryManager.WatchStatus.GetEpisodeStatus(id, User.GetIdOrThrow());
} }
/// <summary> /// <summary>
/// Set watch status /// Set watch status
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Set when an item has been wathed and if it was watched. /// Set when an item has been wathed and if it was watched.
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Episode"/>.</param> /// <param name="identifier">The ID or slug of the <see cref="Episode"/>.</param>
/// <param name="status">The new watch status.</param> /// <param name="status">The new watch status.</param>
/// <param name="watchedTime">Where the user stopped watching (in seconds).</param> /// <param name="watchedTime">Where the user stopped watching (in seconds).</param>
/// <param name="percent">Where the user stopped watching (in percent).</param> /// <param name="percent">Where the user stopped watching (in percent).</param>
/// <returns>The newly set status.</returns> /// <returns>The newly set status.</returns>
/// <response code="200">The status has been set</response> /// <response code="200">The status has been set</response>
/// <response code="204">The status was not considered impactfull enough to be saved (less then 5% of watched for example).</response> /// <response code="204">The status was not considered impactfull enough to be saved (less then 5% of watched for example).</response>
/// <response code="404">No episode with the given ID or slug could be found.</response> /// <response code="404">No episode with the given ID or slug could be found.</response>
[HttpPost("{identifier:id}/watchStatus")] [HttpPost("{identifier:id}/watchStatus")]
[UserOnly] [UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)] [ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status204NoContent)] [ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)] [ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status404NotFound)] [ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<EpisodeWatchStatus?> SetWatchStatus( public async Task<EpisodeWatchStatus?> SetWatchStatus(
Identifier identifier, Identifier identifier,
WatchStatus status, WatchStatus status,
int? watchedTime, int? watchedTime,
int? percent int? percent
) )
{ {
Guid id = await identifier.Match( Guid id = await identifier.Match(
id => Task.FromResult(id), id => Task.FromResult(id),
async slug => (await libraryManager.Episodes.Get(slug)).Id async slug => (await libraryManager.Episodes.Get(slug)).Id
); );
return await libraryManager.WatchStatus.SetEpisodeStatus( return await libraryManager.WatchStatus.SetEpisodeStatus(
id, id,
User.GetIdOrThrow(), User.GetIdOrThrow(),
status, status,
watchedTime, watchedTime,
percent percent
); );
} }
/// <summary> /// <summary>
/// Delete watch status /// Delete watch status
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Delete watch status (to rewatch for example). /// Delete watch status (to rewatch for example).
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Episode"/>.</param> /// <param name="identifier">The ID or slug of the <see cref="Episode"/>.</param>
/// <returns>The newly set status.</returns> /// <returns>The newly set status.</returns>
/// <response code="204">The status has been deleted.</response> /// <response code="204">The status has been deleted.</response>
/// <response code="404">No episode with the given ID or slug could be found.</response> /// <response code="404">No episode with the given ID or slug could be found.</response>
[HttpDelete("{identifier:id}/watchStatus")] [HttpDelete("{identifier:id}/watchStatus")]
[UserOnly] [UserOnly]
[ProducesResponseType(StatusCodes.Status204NoContent)] [ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status404NotFound)] [ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task DeleteWatchStatus(Identifier identifier) public async Task DeleteWatchStatus(Identifier identifier)
{ {
Guid id = await identifier.Match( Guid id = await identifier.Match(
id => Task.FromResult(id), id => Task.FromResult(id),
async slug => (await libraryManager.Episodes.Get(slug)).Id async slug => (await libraryManager.Episodes.Get(slug)).Id
); );
await libraryManager.WatchStatus.DeleteEpisodeStatus(id, User.GetIdOrThrow()); await libraryManager.WatchStatus.DeleteEpisodeStatus(id, User.GetIdOrThrow());
} }
protected override async Task<(string path, string route)> GetPath(Identifier identifier) protected override async Task<(string path, string route)> GetPath(Identifier identifier)
{ {
string path = await identifier.Match( string path = await identifier.Match(
async id => (await Repository.Get(id)).Path, async id => (await Repository.Get(id)).Path,
async slug => (await Repository.Get(slug)).Path async slug => (await Repository.Get(slug)).Path
); );
return (path, $"/episodes/{identifier}"); return (path, $"/episodes/{identifier}");
}
} }
} }

51
back/src/Kyoo.Core/Views/Resources/LibraryItemApi.cs
View File

@ -23,35 +23,34 @@ using Kyoo.Abstractions.Models.Permissions;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// Endpoint for items that are not part of a specific library.
/// An item can ether represent a collection or a show.
/// </summary>
[Route("items")]
[Route("item", Order = AlternativeRoute)]
[ApiController]
[PartialPermission("LibraryItem")]
[ApiDefinition("Items", Group = ResourcesGroup)]
public class LibraryItemApi : CrudThumbsApi<ILibraryItem>
{ {
/// <summary> /// <summary>
/// Endpoint for items that are not part of a specific library. /// The library item repository used to modify or retrieve information in the data store.
/// An item can ether represent a collection or a show.
/// </summary> /// </summary>
[Route("items")] private readonly IRepository<ILibraryItem> _libraryItems;
[Route("item", Order = AlternativeRoute)]
[ApiController]
[PartialPermission("LibraryItem")]
[ApiDefinition("Items", Group = ResourcesGroup)]
public class LibraryItemApi : CrudThumbsApi<ILibraryItem>
{
/// <summary>
/// The library item repository used to modify or retrieve information in the data store.
/// </summary>
private readonly IRepository<ILibraryItem> _libraryItems;
/// <summary> /// <summary>
/// Create a new <see cref="LibraryItemApi"/>. /// Create a new <see cref="LibraryItemApi"/>.
/// </summary> /// </summary>
/// <param name="libraryItems"> /// <param name="libraryItems">
/// The library item repository used to modify or retrieve information in the data store. /// The library item repository used to modify or retrieve information in the data store.
/// </param> /// </param>
/// <param name="thumbs">Thumbnail manager to retrieve images.</param> /// <param name="thumbs">Thumbnail manager to retrieve images.</param>
public LibraryItemApi(IRepository<ILibraryItem> libraryItems, IThumbnailsManager thumbs) public LibraryItemApi(IRepository<ILibraryItem> libraryItems, IThumbnailsManager thumbs)
: base(libraryItems, thumbs) : base(libraryItems, thumbs)
{ {
_libraryItems = libraryItems; _libraryItems = libraryItems;
}
} }
} }

335
back/src/Kyoo.Core/Views/Resources/MovieApi.cs
View File

@ -30,182 +30,181 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// Information about one or multiple <see cref="Movie"/>.
/// </summary>
[Route("movies")]
[Route("movie", Order = AlternativeRoute)]
[ApiController]
[PartialPermission(nameof(Show))]
[ApiDefinition("Shows", Group = ResourcesGroup)]
public class MovieApi(ILibraryManager libraryManager, IThumbnailsManager thumbs)
: TranscoderApi<Movie>(libraryManager.Movies, thumbs)
{ {
/// <summary> /// <summary>
/// Information about one or multiple <see cref="Movie"/>. /// Get studio that made the show
/// </summary> /// </summary>
[Route("movies")] /// <remarks>
[Route("movie", Order = AlternativeRoute)] /// Get the studio that made the show.
[ApiController] /// </remarks>
[PartialPermission(nameof(Show))] /// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
[ApiDefinition("Shows", Group = ResourcesGroup)] /// <param name="fields">The aditional fields to include in the result.</param>
public class MovieApi(ILibraryManager libraryManager, IThumbnailsManager thumbs) /// <returns>The studio that made the show.</returns>
: TranscoderApi<Movie>(libraryManager.Movies, thumbs) /// <response code="404">No show with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/studio")]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Studio>> GetStudio(
Identifier identifier,
[FromQuery] Include<Studio> fields
)
{ {
/// <summary> return await libraryManager.Studios.Get(
/// Get studio that made the show identifier.IsContainedIn<Studio, Movie>(x => x.Movies!),
/// </summary> fields
/// <remarks> );
/// Get the studio that made the show. }
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param> /// <summary>
/// <param name="fields">The aditional fields to include in the result.</param> /// Get collections containing this show
/// <returns>The studio that made the show.</returns> /// </summary>
/// <response code="404">No show with the given ID or slug could be found.</response> /// <remarks>
[HttpGet("{identifier:id}/studio")] /// List the collections that contain this show.
[PartialPermission(Kind.Read)] /// </remarks>
[ProducesResponseType(StatusCodes.Status200OK)] /// <param name="identifier">The ID or slug of the <see cref="Movie"/>.</param>
[ProducesResponseType(StatusCodes.Status404NotFound)] /// <param name="sortBy">A key to sort collections by.</param>
public async Task<ActionResult<Studio>> GetStudio( /// <param name="filter">An optional list of filters.</param>
Identifier identifier, /// <param name="pagination">The number of collections to return.</param>
[FromQuery] Include<Studio> fields /// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A page of collections.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No show with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/collections")]
[HttpGet("{identifier:id}/collection", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Collection>>> GetCollections(
Identifier identifier,
[FromQuery] Sort<Collection> sortBy,
[FromQuery] Filter<Collection>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Collection> fields
)
{
ICollection<Collection> resources = await libraryManager.Collections.GetAll(
Filter.And(filter, identifier.IsContainedIn<Collection, Movie>(x => x.Movies)),
sortBy,
fields,
pagination
);
if (
!resources.Any()
&& await libraryManager.Movies.GetOrDefault(identifier.IsSame<Movie>()) == null
) )
{ return NotFound();
return await libraryManager.Studios.Get( return Page(resources, pagination.Limit);
identifier.IsContainedIn<Studio, Movie>(x => x.Movies!), }
fields
);
}
/// <summary> /// <summary>
/// Get collections containing this show /// Get watch status
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// List the collections that contain this show. /// Get when an item has been wathed and if it was watched.
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Movie"/>.</param> /// <param name="identifier">The ID or slug of the <see cref="Movie"/>.</param>
/// <param name="sortBy">A key to sort collections by.</param> /// <returns>The status.</returns>
/// <param name="filter">An optional list of filters.</param> /// <response code="204">This movie does not have a specific status.</response>
/// <param name="pagination">The number of collections to return.</param> /// <response code="404">No movie with the given ID or slug could be found.</response>
/// <param name="fields">The aditional fields to include in the result.</param> [HttpGet("{identifier:id}/watchStatus")]
/// <returns>A page of collections.</returns> [UserOnly]
/// <response code="400">The filters or the sort parameters are invalid.</response> [ProducesResponseType(StatusCodes.Status200OK)]
/// <response code="404">No show with the given ID or slug could be found.</response> [ProducesResponseType(StatusCodes.Status204NoContent)]
[HttpGet("{identifier:id}/collections")] [ProducesResponseType(StatusCodes.Status404NotFound)]
[HttpGet("{identifier:id}/collection", Order = AlternativeRoute)] public async Task<MovieWatchStatus?> GetWatchStatus(Identifier identifier)
[PartialPermission(Kind.Read)] {
[ProducesResponseType(StatusCodes.Status200OK)] Guid id = await identifier.Match(
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))] id => Task.FromResult(id),
[ProducesResponseType(StatusCodes.Status404NotFound)] async slug => (await libraryManager.Movies.Get(slug)).Id
public async Task<ActionResult<Page<Collection>>> GetCollections( );
Identifier identifier, return await libraryManager.WatchStatus.GetMovieStatus(id, User.GetIdOrThrow());
[FromQuery] Sort<Collection> sortBy, }
[FromQuery] Filter<Collection>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Collection> fields
)
{
ICollection<Collection> resources = await libraryManager.Collections.GetAll(
Filter.And(filter, identifier.IsContainedIn<Collection, Movie>(x => x.Movies)),
sortBy,
fields,
pagination
);
if ( /// <summary>
!resources.Any() /// Set watch status
&& await libraryManager.Movies.GetOrDefault(identifier.IsSame<Movie>()) == null /// </summary>
) /// <remarks>
return NotFound(); /// Set when an item has been wathed and if it was watched.
return Page(resources, pagination.Limit); /// </remarks>
} /// <param name="identifier">The ID or slug of the <see cref="Movie"/>.</param>
/// <param name="status">The new watch status.</param>
/// <param name="watchedTime">Where the user stopped watching.</param>
/// <param name="percent">Where the user stopped watching (in percent).</param>
/// <returns>The newly set status.</returns>
/// <response code="200">The status has been set</response>
/// <response code="204">The status was not considered impactfull enough to be saved (less then 5% of watched for example).</response>
/// <response code="400">WatchedTime can't be specified if status is not watching.</response>
/// <response code="404">No movie with the given ID or slug could be found.</response>
[HttpPost("{identifier:id}/watchStatus")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<MovieWatchStatus?> SetWatchStatus(
Identifier identifier,
WatchStatus status,
int? watchedTime,
int? percent
)
{
Guid id = await identifier.Match(
id => Task.FromResult(id),
async slug => (await libraryManager.Movies.Get(slug)).Id
);
return await libraryManager.WatchStatus.SetMovieStatus(
id,
User.GetIdOrThrow(),
status,
watchedTime,
percent
);
}
/// <summary> /// <summary>
/// Get watch status /// Delete watch status
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Get when an item has been wathed and if it was watched. /// Delete watch status (to rewatch for example).
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Movie"/>.</param> /// <param name="identifier">The ID or slug of the <see cref="Movie"/>.</param>
/// <returns>The status.</returns> /// <returns>The newly set status.</returns>
/// <response code="204">This movie does not have a specific status.</response> /// <response code="204">The status has been deleted.</response>
/// <response code="404">No movie with the given ID or slug could be found.</response> /// <response code="404">No movie with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/watchStatus")] [HttpDelete("{identifier:id}/watchStatus")]
[UserOnly] [UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)] [ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status204NoContent)] [ProducesResponseType(StatusCodes.Status404NotFound)]
[ProducesResponseType(StatusCodes.Status404NotFound)] public async Task DeleteWatchStatus(Identifier identifier)
public async Task<MovieWatchStatus?> GetWatchStatus(Identifier identifier) {
{ Guid id = await identifier.Match(
Guid id = await identifier.Match( id => Task.FromResult(id),
id => Task.FromResult(id), async slug => (await libraryManager.Movies.Get(slug)).Id
async slug => (await libraryManager.Movies.Get(slug)).Id );
); await libraryManager.WatchStatus.DeleteMovieStatus(id, User.GetIdOrThrow());
return await libraryManager.WatchStatus.GetMovieStatus(id, User.GetIdOrThrow()); }
}
/// <summary> protected override async Task<(string path, string route)> GetPath(Identifier identifier)
/// Set watch status {
/// </summary> string path = await identifier.Match(
/// <remarks> async id => (await Repository.Get(id)).Path,
/// Set when an item has been wathed and if it was watched. async slug => (await Repository.Get(slug)).Path
/// </remarks> );
/// <param name="identifier">The ID or slug of the <see cref="Movie"/>.</param> return (path, $"/movies/{identifier}");
/// <param name="status">The new watch status.</param>
/// <param name="watchedTime">Where the user stopped watching.</param>
/// <param name="percent">Where the user stopped watching (in percent).</param>
/// <returns>The newly set status.</returns>
/// <response code="200">The status has been set</response>
/// <response code="204">The status was not considered impactfull enough to be saved (less then 5% of watched for example).</response>
/// <response code="400">WatchedTime can't be specified if status is not watching.</response>
/// <response code="404">No movie with the given ID or slug could be found.</response>
[HttpPost("{identifier:id}/watchStatus")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<MovieWatchStatus?> SetWatchStatus(
Identifier identifier,
WatchStatus status,
int? watchedTime,
int? percent
)
{
Guid id = await identifier.Match(
id => Task.FromResult(id),
async slug => (await libraryManager.Movies.Get(slug)).Id
);
return await libraryManager.WatchStatus.SetMovieStatus(
id,
User.GetIdOrThrow(),
status,
watchedTime,
percent
);
}
/// <summary>
/// Delete watch status
/// </summary>
/// <remarks>
/// Delete watch status (to rewatch for example).
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Movie"/>.</param>
/// <returns>The newly set status.</returns>
/// <response code="204">The status has been deleted.</response>
/// <response code="404">No movie with the given ID or slug could be found.</response>
[HttpDelete("{identifier:id}/watchStatus")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task DeleteWatchStatus(Identifier identifier)
{
Guid id = await identifier.Match(
id => Task.FromResult(id),
async slug => (await libraryManager.Movies.Get(slug)).Id
);
await libraryManager.WatchStatus.DeleteMovieStatus(id, User.GetIdOrThrow());
}
protected override async Task<(string path, string route)> GetPath(Identifier identifier)
{
string path = await identifier.Match(
async id => (await Repository.Get(id)).Path,
async slug => (await Repository.Get(slug)).Path
);
return (path, $"/movies/{identifier}");
}
} }
} }

27
back/src/Kyoo.Core/Views/Resources/NewsApi.cs
View File

@ -23,19 +23,18 @@ using Kyoo.Abstractions.Models.Permissions;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// List new items added to kyoo.
/// </summary>
[Route("news")]
[Route("new", Order = AlternativeRoute)]
[ApiController]
[PartialPermission("LibraryItem")]
[ApiDefinition("News", Group = ResourcesGroup)]
public class NewsApi : CrudThumbsApi<INews>
{ {
/// <summary> public NewsApi(IRepository<INews> news, IThumbnailsManager thumbs)
/// List new items added to kyoo. : base(news, thumbs) { }
/// </summary>
[Route("news")]
[Route("new", Order = AlternativeRoute)]
[ApiController]
[PartialPermission("LibraryItem")]
[ApiDefinition("News", Group = ResourcesGroup)]
public class NewsApi : CrudThumbsApi<INews>
{
public NewsApi(IRepository<INews> news, IThumbnailsManager thumbs)
: base(news, thumbs) { }
}
} }

333
back/src/Kyoo.Core/Views/Resources/SearchApi.cs
View File

@ -26,182 +26,179 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// An endpoint to search for every resources of kyoo. Searching for only a specific type of resource
/// is available on the said endpoint.
/// </summary>
[Route("search")]
[ApiController]
[ApiDefinition("Search", Group = ResourcesGroup)]
public class SearchApi : BaseApi
{ {
/// <summary> private readonly ISearchManager _searchManager;
/// An endpoint to search for every resources of kyoo. Searching for only a specific type of resource
/// is available on the said endpoint. public SearchApi(ISearchManager searchManager)
/// </summary>
[Route("search")]
[ApiController]
[ApiDefinition("Search", Group = ResourcesGroup)]
public class SearchApi : BaseApi
{ {
private readonly ISearchManager _searchManager; _searchManager = searchManager;
}
public SearchApi(ISearchManager searchManager) // TODO: add filters and facets
{
_searchManager = searchManager;
}
// TODO: add filters and facets /// <summary>
/// Search collections
/// </summary>
/// <remarks>
/// Search for collections
/// </remarks>
/// <param name="q">The query to search for.</param>
/// <param name="sortBy">Sort information about the query (sort by, sort order).</param>
/// <param name="pagination">How many items per page should be returned, where should the page start...</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A list of collections found for the specified query.</returns>
[HttpGet("collections")]
[HttpGet("collection", Order = AlternativeRoute)]
[Permission(nameof(Collection), Kind.Read)]
[ApiDefinition("Collections")]
[ProducesResponseType(StatusCodes.Status200OK)]
public async Task<SearchPage<Collection>> SearchCollections(
[FromQuery] string? q,
[FromQuery] Sort<Collection> sortBy,
[FromQuery] SearchPagination pagination,
[FromQuery] Include<Collection> fields
)
{
return SearchPage(await _searchManager.SearchCollections(q, sortBy, pagination, fields));
}
/// <summary> /// <summary>
/// Search collections /// Search shows
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Search for collections /// Search for shows
/// </remarks> /// </remarks>
/// <param name="q">The query to search for.</param> /// <param name="q">The query to search for.</param>
/// <param name="sortBy">Sort information about the query (sort by, sort order).</param> /// <param name="sortBy">Sort information about the query (sort by, sort order).</param>
/// <param name="pagination">How many items per page should be returned, where should the page start...</param> /// <param name="pagination">How many items per page should be returned, where should the page start...</param>
/// <param name="fields">The aditional fields to include in the result.</param> /// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A list of collections found for the specified query.</returns> /// <returns>A list of shows found for the specified query.</returns>
[HttpGet("collections")] [HttpGet("shows")]
[HttpGet("collection", Order = AlternativeRoute)] [HttpGet("show", Order = AlternativeRoute)]
[Permission(nameof(Collection), Kind.Read)] [Permission(nameof(Show), Kind.Read)]
[ApiDefinition("Collections")] [ApiDefinition("Show")]
[ProducesResponseType(StatusCodes.Status200OK)] [ProducesResponseType(StatusCodes.Status200OK)]
public async Task<SearchPage<Collection>> SearchCollections( public async Task<SearchPage<Show>> SearchShows(
[FromQuery] string? q, [FromQuery] string? q,
[FromQuery] Sort<Collection> sortBy, [FromQuery] Sort<Show> sortBy,
[FromQuery] SearchPagination pagination, [FromQuery] SearchPagination pagination,
[FromQuery] Include<Collection> fields [FromQuery] Include<Show> fields
) )
{ {
return SearchPage( return SearchPage(await _searchManager.SearchShows(q, sortBy, pagination, fields));
await _searchManager.SearchCollections(q, sortBy, pagination, fields) }
);
}
/// <summary> /// <summary>
/// Search shows /// Search movie
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Search for shows /// Search for movie
/// </remarks> /// </remarks>
/// <param name="q">The query to search for.</param> /// <param name="q">The query to search for.</param>
/// <param name="sortBy">Sort information about the query (sort by, sort order).</param> /// <param name="sortBy">Sort information about the query (sort by, sort order).</param>
/// <param name="pagination">How many items per page should be returned, where should the page start...</param> /// <param name="pagination">How many items per page should be returned, where should the page start...</param>
/// <param name="fields">The aditional fields to include in the result.</param> /// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A list of shows found for the specified query.</returns> /// <returns>A list of movies found for the specified query.</returns>
[HttpGet("shows")] [HttpGet("movies")]
[HttpGet("show", Order = AlternativeRoute)] [HttpGet("movie", Order = AlternativeRoute)]
[Permission(nameof(Show), Kind.Read)] [Permission(nameof(Movie), Kind.Read)]
[ApiDefinition("Show")] [ApiDefinition("Movie")]
[ProducesResponseType(StatusCodes.Status200OK)] [ProducesResponseType(StatusCodes.Status200OK)]
public async Task<SearchPage<Show>> SearchShows( public async Task<SearchPage<Movie>> SearchMovies(
[FromQuery] string? q, [FromQuery] string? q,
[FromQuery] Sort<Show> sortBy, [FromQuery] Sort<Movie> sortBy,
[FromQuery] SearchPagination pagination, [FromQuery] SearchPagination pagination,
[FromQuery] Include<Show> fields [FromQuery] Include<Movie> fields
) )
{ {
return SearchPage(await _searchManager.SearchShows(q, sortBy, pagination, fields)); return SearchPage(await _searchManager.SearchMovies(q, sortBy, pagination, fields));
} }
/// <summary> /// <summary>
/// Search movie /// Search items
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Search for movie /// Search for items
/// </remarks> /// </remarks>
/// <param name="q">The query to search for.</param> /// <param name="q">The query to search for.</param>
/// <param name="sortBy">Sort information about the query (sort by, sort order).</param> /// <param name="sortBy">Sort information about the query (sort by, sort order).</param>
/// <param name="pagination">How many items per page should be returned, where should the page start...</param> /// <param name="pagination">How many items per page should be returned, where should the page start...</param>
/// <param name="fields">The aditional fields to include in the result.</param> /// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A list of movies found for the specified query.</returns> /// <returns>A list of items found for the specified query.</returns>
[HttpGet("movies")] [HttpGet("items")]
[HttpGet("movie", Order = AlternativeRoute)] [HttpGet("item", Order = AlternativeRoute)]
[Permission(nameof(Movie), Kind.Read)] [Permission(nameof(ILibraryItem), Kind.Read)]
[ApiDefinition("Movie")] [ApiDefinition("Item")]
[ProducesResponseType(StatusCodes.Status200OK)] [ProducesResponseType(StatusCodes.Status200OK)]
public async Task<SearchPage<Movie>> SearchMovies( public async Task<SearchPage<ILibraryItem>> SearchItems(
[FromQuery] string? q, [FromQuery] string? q,
[FromQuery] Sort<Movie> sortBy, [FromQuery] Sort<ILibraryItem> sortBy,
[FromQuery] SearchPagination pagination, [FromQuery] SearchPagination pagination,
[FromQuery] Include<Movie> fields [FromQuery] Include<ILibraryItem> fields
) )
{ {
return SearchPage(await _searchManager.SearchMovies(q, sortBy, pagination, fields)); return SearchPage(await _searchManager.SearchItems(q, sortBy, pagination, fields));
} }
/// <summary> /// <summary>
/// Search items /// Search episodes
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Search for items /// Search for episodes
/// </remarks> /// </remarks>
/// <param name="q">The query to search for.</param> /// <param name="q">The query to search for.</param>
/// <param name="sortBy">Sort information about the query (sort by, sort order).</param> /// <param name="sortBy">Sort information about the query (sort by, sort order).</param>
/// <param name="pagination">How many items per page should be returned, where should the page start...</param> /// <param name="pagination">How many items per page should be returned, where should the page start...</param>
/// <param name="fields">The aditional fields to include in the result.</param> /// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A list of items found for the specified query.</returns> /// <returns>A list of episodes found for the specified query.</returns>
[HttpGet("items")] [HttpGet("episodes")]
[HttpGet("item", Order = AlternativeRoute)] [HttpGet("episode", Order = AlternativeRoute)]
[Permission(nameof(ILibraryItem), Kind.Read)] [Permission(nameof(Episode), Kind.Read)]
[ApiDefinition("Item")] [ApiDefinition("Episodes")]
[ProducesResponseType(StatusCodes.Status200OK)] [ProducesResponseType(StatusCodes.Status200OK)]
public async Task<SearchPage<ILibraryItem>> SearchItems( public async Task<SearchPage<Episode>> SearchEpisodes(
[FromQuery] string? q, [FromQuery] string? q,
[FromQuery] Sort<ILibraryItem> sortBy, [FromQuery] Sort<Episode> sortBy,
[FromQuery] SearchPagination pagination, [FromQuery] SearchPagination pagination,
[FromQuery] Include<ILibraryItem> fields [FromQuery] Include<Episode> fields
) )
{ {
return SearchPage(await _searchManager.SearchItems(q, sortBy, pagination, fields)); return SearchPage(await _searchManager.SearchEpisodes(q, sortBy, pagination, fields));
} }
/// <summary> /// <summary>
/// Search episodes /// Search studios
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Search for episodes /// Search for studios
/// </remarks> /// </remarks>
/// <param name="q">The query to search for.</param> /// <param name="q">The query to search for.</param>
/// <param name="sortBy">Sort information about the query (sort by, sort order).</param> /// <param name="sortBy">Sort information about the query (sort by, sort order).</param>
/// <param name="pagination">How many items per page should be returned, where should the page start...</param> /// <param name="pagination">How many items per page should be returned, where should the page start...</param>
/// <param name="fields">The aditional fields to include in the result.</param> /// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A list of episodes found for the specified query.</returns> /// <returns>A list of studios found for the specified query.</returns>
[HttpGet("episodes")] [HttpGet("studios")]
[HttpGet("episode", Order = AlternativeRoute)] [HttpGet("studio", Order = AlternativeRoute)]
[Permission(nameof(Episode), Kind.Read)] [Permission(nameof(Studio), Kind.Read)]
[ApiDefinition("Episodes")] [ApiDefinition("Studios")]
[ProducesResponseType(StatusCodes.Status200OK)] [ProducesResponseType(StatusCodes.Status200OK)]
public async Task<SearchPage<Episode>> SearchEpisodes( public async Task<SearchPage<Studio>> SearchStudios(
[FromQuery] string? q, [FromQuery] string? q,
[FromQuery] Sort<Episode> sortBy, [FromQuery] Sort<Studio> sortBy,
[FromQuery] SearchPagination pagination, [FromQuery] SearchPagination pagination,
[FromQuery] Include<Episode> fields [FromQuery] Include<Studio> fields
) )
{ {
return SearchPage(await _searchManager.SearchEpisodes(q, sortBy, pagination, fields)); return SearchPage(await _searchManager.SearchStudios(q, sortBy, pagination, fields));
}
/// <summary>
/// Search studios
/// </summary>
/// <remarks>
/// Search for studios
/// </remarks>
/// <param name="q">The query to search for.</param>
/// <param name="sortBy">Sort information about the query (sort by, sort order).</param>
/// <param name="pagination">How many items per page should be returned, where should the page start...</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A list of studios found for the specified query.</returns>
[HttpGet("studios")]
[HttpGet("studio", Order = AlternativeRoute)]
[Permission(nameof(Studio), Kind.Read)]
[ApiDefinition("Studios")]
[ProducesResponseType(StatusCodes.Status200OK)]
public async Task<SearchPage<Studio>> SearchStudios(
[FromQuery] string? q,
[FromQuery] Sort<Studio> sortBy,
[FromQuery] SearchPagination pagination,
[FromQuery] Include<Studio> fields
)
{
return SearchPage(await _searchManager.SearchStudios(q, sortBy, pagination, fields));
}
} }
} }

186
back/src/Kyoo.Core/Views/Resources/SeasonApi.cs
View File

@ -28,108 +28,104 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// Information about one or multiple <see cref="Season"/>.
/// </summary>
[Route("seasons")]
[Route("season", Order = AlternativeRoute)]
[ApiController]
[PartialPermission(nameof(Season))]
[ApiDefinition("Seasons", Group = ResourcesGroup)]
public class SeasonApi : CrudThumbsApi<Season>
{ {
/// <summary> /// <summary>
/// Information about one or multiple <see cref="Season"/>. /// The library manager used to modify or retrieve information in the data store.
/// </summary> /// </summary>
[Route("seasons")] private readonly ILibraryManager _libraryManager;
[Route("season", Order = AlternativeRoute)]
[ApiController] /// <summary>
[PartialPermission(nameof(Season))] /// Create a new <see cref="SeasonApi"/>.
[ApiDefinition("Seasons", Group = ResourcesGroup)] /// </summary>
public class SeasonApi : CrudThumbsApi<Season> /// <param name="libraryManager">
/// The library manager used to modify or retrieve information in the data store.
/// </param>
/// <param name="thumbs">The thumbnail manager used to retrieve images paths.</param>
public SeasonApi(ILibraryManager libraryManager, IThumbnailsManager thumbs)
: base(libraryManager.Seasons, thumbs)
{ {
/// <summary> _libraryManager = libraryManager;
/// The library manager used to modify or retrieve information in the data store. }
/// </summary>
private readonly ILibraryManager _libraryManager;
/// <summary> /// <summary>
/// Create a new <see cref="SeasonApi"/>. /// Get episodes in the season
/// </summary> /// </summary>
/// <param name="libraryManager"> /// <remarks>
/// The library manager used to modify or retrieve information in the data store. /// List the episodes that are part of the specified season.
/// </param> /// </remarks>
/// <param name="thumbs">The thumbnail manager used to retrieve images paths.</param> /// <param name="identifier">The ID or slug of the <see cref="Season"/>.</param>
public SeasonApi(ILibraryManager libraryManager, IThumbnailsManager thumbs) /// <param name="sortBy">A key to sort episodes by.</param>
: base(libraryManager.Seasons, thumbs) /// <param name="filter">An optional list of filters.</param>
{ /// <param name="pagination">The number of episodes to return.</param>
_libraryManager = libraryManager; /// <param name="fields">The aditional fields to include in the result.</param>
} /// <returns>A page of episodes.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No season with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/episodes")]
[HttpGet("{identifier:id}/episode", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Episode>>> GetEpisode(
Identifier identifier,
[FromQuery] Sort<Episode> sortBy,
[FromQuery] Filter<Episode>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Episode> fields
)
{
ICollection<Episode> resources = await _libraryManager.Episodes.GetAll(
Filter.And(filter, identifier.Matcher<Episode>(x => x.SeasonId, x => x.Season!.Slug)),
sortBy,
fields,
pagination
);
/// <summary> if (
/// Get episodes in the season !resources.Any()
/// </summary> && await _libraryManager.Seasons.GetOrDefault(identifier.IsSame<Season>()) == null
/// <remarks>
/// List the episodes that are part of the specified season.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Season"/>.</param>
/// <param name="sortBy">A key to sort episodes by.</param>
/// <param name="filter">An optional list of filters.</param>
/// <param name="pagination">The number of episodes to return.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A page of episodes.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No season with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/episodes")]
[HttpGet("{identifier:id}/episode", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Episode>>> GetEpisode(
Identifier identifier,
[FromQuery] Sort<Episode> sortBy,
[FromQuery] Filter<Episode>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Episode> fields
) )
{ return NotFound();
ICollection<Episode> resources = await _libraryManager.Episodes.GetAll( return Page(resources, pagination.Limit);
Filter.And( }
filter,
identifier.Matcher<Episode>(x => x.SeasonId, x => x.Season!.Slug)
),
sortBy,
fields,
pagination
);
if ( /// <summary>
!resources.Any() /// Get season's show
&& await _libraryManager.Seasons.GetOrDefault(identifier.IsSame<Season>()) == null /// </summary>
) /// <remarks>
return NotFound(); /// Get the show that this season is part of.
return Page(resources, pagination.Limit); /// </remarks>
} /// <param name="identifier">The ID or slug of the <see cref="Season"/>.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <summary> /// <returns>The show that contains this season.</returns>
/// Get season's show /// <response code="404">No season with the given ID or slug could be found.</response>
/// </summary> [HttpGet("{identifier:id}/show")]
/// <remarks> [PartialPermission(Kind.Read)]
/// Get the show that this season is part of. [ProducesResponseType(StatusCodes.Status200OK)]
/// </remarks> [ProducesResponseType(StatusCodes.Status404NotFound)]
/// <param name="identifier">The ID or slug of the <see cref="Season"/>.</param> public async Task<ActionResult<Show>> GetShow(
/// <param name="fields">The aditional fields to include in the result.</param> Identifier identifier,
/// <returns>The show that contains this season.</returns> [FromQuery] Include<Show> fields
/// <response code="404">No season with the given ID or slug could be found.</response> )
[HttpGet("{identifier:id}/show")] {
[PartialPermission(Kind.Read)] Show? ret = await _libraryManager.Shows.GetOrDefault(
[ProducesResponseType(StatusCodes.Status200OK)] identifier.IsContainedIn<Show, Season>(x => x.Seasons!),
[ProducesResponseType(StatusCodes.Status404NotFound)] fields
public async Task<ActionResult<Show>> GetShow( );
Identifier identifier, if (ret == null)
[FromQuery] Include<Show> fields return NotFound();
) return ret;
{
Show? ret = await _libraryManager.Shows.GetOrDefault(
identifier.IsContainedIn<Show, Season>(x => x.Seasons!),
fields
);
if (ret == null)
return NotFound();
return ret;
}
} }
} }

484
back/src/Kyoo.Core/Views/Resources/ShowApi.cs
View File

@ -30,265 +30,261 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// Information about one or multiple <see cref="Show"/>.
/// </summary>
[Route("shows")]
[Route("show", Order = AlternativeRoute)]
[ApiController]
[PartialPermission(nameof(Show))]
[ApiDefinition("Shows", Group = ResourcesGroup)]
public class ShowApi : CrudThumbsApi<Show>
{ {
/// <summary> /// <summary>
/// Information about one or multiple <see cref="Show"/>. /// The library manager used to modify or retrieve information in the data store.
/// </summary> /// </summary>
[Route("shows")] private readonly ILibraryManager _libraryManager;
[Route("show", Order = AlternativeRoute)]
[ApiController] /// <summary>
[PartialPermission(nameof(Show))] /// Create a new <see cref="ShowApi"/>.
[ApiDefinition("Shows", Group = ResourcesGroup)] /// </summary>
public class ShowApi : CrudThumbsApi<Show> /// <param name="libraryManager">
/// The library manager used to modify or retrieve information about the data store.
/// </param>
/// <param name="thumbs">The thumbnail manager used to retrieve images paths.</param>
public ShowApi(ILibraryManager libraryManager, IThumbnailsManager thumbs)
: base(libraryManager.Shows, thumbs)
{ {
/// <summary> _libraryManager = libraryManager;
/// The library manager used to modify or retrieve information in the data store. }
/// </summary>
private readonly ILibraryManager _libraryManager;
/// <summary> /// <summary>
/// Create a new <see cref="ShowApi"/>. /// Get seasons of this show
/// </summary> /// </summary>
/// <param name="libraryManager"> /// <remarks>
/// The library manager used to modify or retrieve information about the data store. /// List the seasons that are part of the specified show.
/// </param> /// </remarks>
/// <param name="thumbs">The thumbnail manager used to retrieve images paths.</param> /// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
public ShowApi(ILibraryManager libraryManager, IThumbnailsManager thumbs) /// <param name="sortBy">A key to sort seasons by.</param>
: base(libraryManager.Shows, thumbs) /// <param name="filter">An optional list of filters.</param>
{ /// <param name="pagination">The number of seasons to return.</param>
_libraryManager = libraryManager; /// <param name="fields">The aditional fields to include in the result.</param>
} /// <returns>A page of seasons.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No show with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/seasons")]
[HttpGet("{identifier:id}/season", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Season>>> GetSeasons(
Identifier identifier,
[FromQuery] Sort<Season> sortBy,
[FromQuery] Filter<Season>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Season> fields
)
{
ICollection<Season> resources = await _libraryManager.Seasons.GetAll(
Filter.And(filter, identifier.Matcher<Season>(x => x.ShowId, x => x.Show!.Slug)),
sortBy,
fields,
pagination
);
/// <summary> if (
/// Get seasons of this show !resources.Any()
/// </summary> && await _libraryManager.Shows.GetOrDefault(identifier.IsSame<Show>()) == null
/// <remarks>
/// List the seasons that are part of the specified show.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
/// <param name="sortBy">A key to sort seasons by.</param>
/// <param name="filter">An optional list of filters.</param>
/// <param name="pagination">The number of seasons to return.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A page of seasons.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No show with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/seasons")]
[HttpGet("{identifier:id}/season", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Season>>> GetSeasons(
Identifier identifier,
[FromQuery] Sort<Season> sortBy,
[FromQuery] Filter<Season>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Season> fields
) )
{ return NotFound();
ICollection<Season> resources = await _libraryManager.Seasons.GetAll( return Page(resources, pagination.Limit);
Filter.And(filter, identifier.Matcher<Season>(x => x.ShowId, x => x.Show!.Slug)), }
sortBy,
fields,
pagination
);
if ( /// <summary>
!resources.Any() /// Get episodes of this show
&& await _libraryManager.Shows.GetOrDefault(identifier.IsSame<Show>()) == null /// </summary>
) /// <remarks>
return NotFound(); /// List the episodes that are part of the specified show.
return Page(resources, pagination.Limit); /// </remarks>
} /// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
/// <param name="sortBy">A key to sort episodes by.</param>
/// <param name="filter">An optional list of filters.</param>
/// <param name="pagination">The number of episodes to return.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A page of episodes.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No show with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/episodes")]
[HttpGet("{identifier:id}/episode", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Episode>>> GetEpisodes(
Identifier identifier,
[FromQuery] Sort<Episode> sortBy,
[FromQuery] Filter<Episode>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Episode> fields
)
{
ICollection<Episode> resources = await _libraryManager.Episodes.GetAll(
Filter.And(filter, identifier.Matcher<Episode>(x => x.ShowId, x => x.Show!.Slug)),
sortBy,
fields,
pagination
);
/// <summary> if (
/// Get episodes of this show !resources.Any()
/// </summary> && await _libraryManager.Shows.GetOrDefault(identifier.IsSame<Show>()) == null
/// <remarks>
/// List the episodes that are part of the specified show.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
/// <param name="sortBy">A key to sort episodes by.</param>
/// <param name="filter">An optional list of filters.</param>
/// <param name="pagination">The number of episodes to return.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A page of episodes.</returns>
/// <response code="400">The filters or the sort parameters are invalid.</response>
/// <response code="404">No show with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/episodes")]
[HttpGet("{identifier:id}/episode", Order = AlternativeRoute)]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Episode>>> GetEpisodes(
Identifier identifier,
[FromQuery] Sort<Episode> sortBy,
[FromQuery] Filter<Episode>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Episode> fields
) )
{ return NotFound();
ICollection<Episode> resources = await _libraryManager.Episodes.GetAll( return Page(resources, pagination.Limit);
Filter.And(filter, identifier.Matcher<Episode>(x => x.ShowId, x => x.Show!.Slug)), }
sortBy,
fields,
pagination
);
if ( /// <summary>
!resources.Any() /// Get studio that made the show
&& await _libraryManager.Shows.GetOrDefault(identifier.IsSame<Show>()) == null /// </summary>
) /// <remarks>
return NotFound(); /// Get the studio that made the show.
return Page(resources, pagination.Limit); /// </remarks>
} /// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>The studio that made the show.</returns>
/// <response code="404">No show with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/studio")]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Studio>> GetStudio(
Identifier identifier,
[FromQuery] Include<Studio> fields
)
{
return await _libraryManager.Studios.Get(
identifier.IsContainedIn<Studio, Show>(x => x.Shows!),
fields
);
}
/// <summary> /// <summary>
/// Get studio that made the show /// Get collections containing this show
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Get the studio that made the show. /// List the collections that contain this show.
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param> /// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
/// <param name="fields">The aditional fields to include in the result.</param> /// <param name="sortBy">A key to sort collections by.</param>
/// <returns>The studio that made the show.</returns> /// <param name="filter">An optional list of filters.</param>
/// <response code="404">No show with the given ID or slug could be found.</response> /// <param name="pagination">The number of collections to return.</param>
[HttpGet("{identifier:id}/studio")] /// <param name="fields">The aditional fields to include in the result.</param>
[PartialPermission(Kind.Read)] /// <returns>A page of collections.</returns>
[ProducesResponseType(StatusCodes.Status200OK)] /// <response code="400">The filters or the sort parameters are invalid.</response>
[ProducesResponseType(StatusCodes.Status404NotFound)] /// <response code="404">No show with the given ID or slug could be found.</response>
public async Task<ActionResult<Studio>> GetStudio( [HttpGet("{identifier:id}/collections")]
Identifier identifier, [HttpGet("{identifier:id}/collection", Order = AlternativeRoute)]
[FromQuery] Include<Studio> fields [PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<Page<Collection>>> GetCollections(
Identifier identifier,
[FromQuery] Sort<Collection> sortBy,
[FromQuery] Filter<Collection>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Collection> fields
)
{
ICollection<Collection> resources = await _libraryManager.Collections.GetAll(
Filter.And(filter, identifier.IsContainedIn<Collection, Show>(x => x.Shows!)),
sortBy,
fields,
pagination
);
if (
!resources.Any()
&& await _libraryManager.Shows.GetOrDefault(identifier.IsSame<Show>()) == null
) )
{ return NotFound();
return await _libraryManager.Studios.Get( return Page(resources, pagination.Limit);
identifier.IsContainedIn<Studio, Show>(x => x.Shows!), }
fields
);
}
/// <summary> /// <summary>
/// Get collections containing this show /// Get watch status
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// List the collections that contain this show. /// Get when an item has been wathed and if it was watched.
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param> /// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
/// <param name="sortBy">A key to sort collections by.</param> /// <returns>The status.</returns>
/// <param name="filter">An optional list of filters.</param> /// <response code="204">This show does not have a specific status.</response>
/// <param name="pagination">The number of collections to return.</param> /// <response code="404">No show with the given ID or slug could be found.</response>
/// <param name="fields">The aditional fields to include in the result.</param> [HttpGet("{identifier:id}/watchStatus")]
/// <returns>A page of collections.</returns> [UserOnly]
/// <response code="400">The filters or the sort parameters are invalid.</response> [ProducesResponseType(StatusCodes.Status200OK)]
/// <response code="404">No show with the given ID or slug could be found.</response> [ProducesResponseType(StatusCodes.Status204NoContent)]
[HttpGet("{identifier:id}/collections")] [ProducesResponseType(StatusCodes.Status404NotFound)]
[HttpGet("{identifier:id}/collection", Order = AlternativeRoute)] public async Task<ShowWatchStatus?> GetWatchStatus(Identifier identifier)
[PartialPermission(Kind.Read)] {
[ProducesResponseType(StatusCodes.Status200OK)] Guid id = await identifier.Match(
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))] id => Task.FromResult(id),
[ProducesResponseType(StatusCodes.Status404NotFound)] async slug => (await _libraryManager.Shows.Get(slug)).Id
public async Task<ActionResult<Page<Collection>>> GetCollections( );
Identifier identifier, return await _libraryManager.WatchStatus.GetShowStatus(id, User.GetIdOrThrow());
[FromQuery] Sort<Collection> sortBy, }
[FromQuery] Filter<Collection>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<Collection> fields
)
{
ICollection<Collection> resources = await _libraryManager.Collections.GetAll(
Filter.And(filter, identifier.IsContainedIn<Collection, Show>(x => x.Shows!)),
sortBy,
fields,
pagination
);
if ( /// <summary>
!resources.Any() /// Set watch status
&& await _libraryManager.Shows.GetOrDefault(identifier.IsSame<Show>()) == null /// </summary>
) /// <remarks>
return NotFound(); /// Set when an item has been wathed and if it was watched.
return Page(resources, pagination.Limit); /// </remarks>
} /// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
/// <param name="status">The new watch status.</param>
/// <returns>The newly set status.</returns>
/// <response code="200">The status has been set</response>
/// <response code="204">The status was not considered impactfull enough to be saved (less then 5% of watched for example).</response>
/// <response code="404">No movie with the given ID or slug could be found.</response>
[HttpPost("{identifier:id}/watchStatus")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ShowWatchStatus?> SetWatchStatus(Identifier identifier, WatchStatus status)
{
Guid id = await identifier.Match(
id => Task.FromResult(id),
async slug => (await _libraryManager.Shows.Get(slug)).Id
);
return await _libraryManager.WatchStatus.SetShowStatus(id, User.GetIdOrThrow(), status);
}
/// <summary> /// <summary>
/// Get watch status /// Delete watch status
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// Get when an item has been wathed and if it was watched. /// Delete watch status (to rewatch for example).
/// </remarks> /// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param> /// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
/// <returns>The status.</returns> /// <returns>The newly set status.</returns>
/// <response code="204">This show does not have a specific status.</response> /// <response code="204">The status has been deleted.</response>
/// <response code="404">No show with the given ID or slug could be found.</response> /// <response code="404">No show with the given ID or slug could be found.</response>
[HttpGet("{identifier:id}/watchStatus")] [HttpDelete("{identifier:id}/watchStatus")]
[UserOnly] [UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)] [ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status204NoContent)] [ProducesResponseType(StatusCodes.Status404NotFound)]
[ProducesResponseType(StatusCodes.Status404NotFound)] public async Task DeleteWatchStatus(Identifier identifier)
public async Task<ShowWatchStatus?> GetWatchStatus(Identifier identifier) {
{ Guid id = await identifier.Match(
Guid id = await identifier.Match( id => Task.FromResult(id),
id => Task.FromResult(id), async slug => (await _libraryManager.Shows.Get(slug)).Id
async slug => (await _libraryManager.Shows.Get(slug)).Id );
); await _libraryManager.WatchStatus.DeleteShowStatus(id, User.GetIdOrThrow());
return await _libraryManager.WatchStatus.GetShowStatus(id, User.GetIdOrThrow());
}
/// <summary>
/// Set watch status
/// </summary>
/// <remarks>
/// Set when an item has been wathed and if it was watched.
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
/// <param name="status">The new watch status.</param>
/// <returns>The newly set status.</returns>
/// <response code="200">The status has been set</response>
/// <response code="204">The status was not considered impactfull enough to be saved (less then 5% of watched for example).</response>
/// <response code="404">No movie with the given ID or slug could be found.</response>
[HttpPost("{identifier:id}/watchStatus")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ShowWatchStatus?> SetWatchStatus(
Identifier identifier,
WatchStatus status
)
{
Guid id = await identifier.Match(
id => Task.FromResult(id),
async slug => (await _libraryManager.Shows.Get(slug)).Id
);
return await _libraryManager.WatchStatus.SetShowStatus(id, User.GetIdOrThrow(), status);
}
/// <summary>
/// Delete watch status
/// </summary>
/// <remarks>
/// Delete watch status (to rewatch for example).
/// </remarks>
/// <param name="identifier">The ID or slug of the <see cref="Show"/>.</param>
/// <returns>The newly set status.</returns>
/// <response code="204">The status has been deleted.</response>
/// <response code="404">No show with the given ID or slug could be found.</response>
[HttpDelete("{identifier:id}/watchStatus")]
[UserOnly]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task DeleteWatchStatus(Identifier identifier)
{
Guid id = await identifier.Match(
id => Task.FromResult(id),
async slug => (await _libraryManager.Shows.Get(slug)).Id
);
await _libraryManager.WatchStatus.DeleteShowStatus(id, User.GetIdOrThrow());
}
} }
} }

67
back/src/Kyoo.Core/Views/Resources/WatchlistApi.cs
View File

@ -29,44 +29,43 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
/// <summary>
/// List new items added to kyoo.
/// </summary>
[Route("watchlist")]
[ApiController]
[PartialPermission("LibraryItem")]
[ApiDefinition("News", Group = ResourcesGroup)]
[UserOnly]
public class WatchlistApi(IWatchStatusRepository repository) : BaseApi
{ {
/// <summary> /// <summary>
/// List new items added to kyoo. /// Get all
/// </summary> /// </summary>
[Route("watchlist")] /// <remarks>
[ApiController] /// Get all resources that match the given filter.
[PartialPermission("LibraryItem")] /// </remarks>
[ApiDefinition("News", Group = ResourcesGroup)] /// <param name="filter">Filter the returned items.</param>
[UserOnly] /// <param name="pagination">How many items per page should be returned, where should the page start...</param>
public class WatchlistApi(IWatchStatusRepository repository) : BaseApi /// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A list of resources that match every filters.</returns>
/// <response code="400">Invalid filters or sort information.</response>
[HttpGet]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
public async Task<ActionResult<Page<IWatchlist>>> GetAll(
[FromQuery] Filter<IWatchlist>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<IWatchlist>? fields
)
{ {
/// <summary> if (User.GetId() == null)
/// Get all throw new UnauthorizedException();
/// </summary> ICollection<IWatchlist> resources = await repository.GetAll(filter, fields, pagination);
/// <remarks>
/// Get all resources that match the given filter.
/// </remarks>
/// <param name="filter">Filter the returned items.</param>
/// <param name="pagination">How many items per page should be returned, where should the page start...</param>
/// <param name="fields">The aditional fields to include in the result.</param>
/// <returns>A list of resources that match every filters.</returns>
/// <response code="400">Invalid filters or sort information.</response>
[HttpGet]
[PartialPermission(Kind.Read)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(RequestError))]
public async Task<ActionResult<Page<IWatchlist>>> GetAll(
[FromQuery] Filter<IWatchlist>? filter,
[FromQuery] Pagination pagination,
[FromQuery] Include<IWatchlist>? fields
)
{
if (User.GetId() == null)
throw new UnauthorizedException();
ICollection<IWatchlist> resources = await repository.GetAll(filter, fields, pagination);
return Page(resources, pagination.Limit); return Page(resources, pagination.Limit);
}
} }
} }

125
back/src/Kyoo.Core/Views/Watch/ProxyApi.cs
View File

@ -28,69 +28,68 @@ using Kyoo.Utils;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
namespace Kyoo.Core.Api namespace Kyoo.Core.Api;
{
/// <summary>
/// Proxy to other services
/// </summary>
[ApiController]
[Obsolete("Use /episode/id/master.m3u8 or routes like that")]
public class ProxyApi(ILibraryManager library) : Controller
{
private Task _Proxy(string route, (string path, string route) info)
{
HttpProxyOptions proxyOptions = HttpProxyOptionsBuilder
.Instance.WithBeforeSend(
(ctx, req) =>
{
req.Headers.Add("X-Path", info.path);
req.Headers.Add("X-Route", info.route);
return Task.CompletedTask;
}
)
.WithHandleFailure(
async (context, exception) =>
{
context.Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
await context.Response.WriteAsJsonAsync(
new RequestError("Service unavailable")
);
}
)
.Build();
return this.HttpProxyAsync($"http://transcoder:7666/{route}", proxyOptions);
}
/// <summary> /// <summary>
/// Transcoder proxy /// Proxy to other services
/// </summary> /// </summary>
/// <remarks> [ApiController]
/// Simply proxy requests to the transcoder [Obsolete("Use /episode/id/master.m3u8 or routes like that")]
/// </remarks> public class ProxyApi(ILibraryManager library) : Controller
/// <param name="rest">The path of the transcoder.</param> {
/// <returns>The return value of the transcoder.</returns> private Task _Proxy(string route, (string path, string route) info)
[Route("video/{type}/{id:id}/{**rest}")] {
[Permission("video", Kind.Read)] HttpProxyOptions proxyOptions = HttpProxyOptionsBuilder
[Obsolete("Use /episode/id/master.m3u8 or routes like that")] .Instance.WithBeforeSend(
public async Task Proxy( (ctx, req) =>
string type, {
Identifier id, req.Headers.Add("X-Path", info.path);
string rest, req.Headers.Add("X-Route", info.route);
[FromQuery] Dictionary<string, string> query return Task.CompletedTask;
) }
{ )
string path = await ( .WithHandleFailure(
type is "movie" or "movies" async (context, exception) =>
? id.Match( {
async id => (await library.Movies.Get(id)).Path, context.Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
async slug => (await library.Movies.Get(slug)).Path await context.Response.WriteAsJsonAsync(
) new RequestError("Service unavailable")
: id.Match( );
async id => (await library.Episodes.Get(id)).Path, }
async slug => (await library.Episodes.Get(slug)).Path )
) .Build();
); return this.HttpProxyAsync($"http://transcoder:7666/{route}", proxyOptions);
await _Proxy(rest + query.ToQueryString(), (path, $"{type}/{id}")); }
}
/// <summary>
/// Transcoder proxy
/// </summary>
/// <remarks>
/// Simply proxy requests to the transcoder
/// </remarks>
/// <param name="rest">The path of the transcoder.</param>
/// <returns>The return value of the transcoder.</returns>
[Route("video/{type}/{id:id}/{**rest}")]
[Permission("video", Kind.Read)]
[Obsolete("Use /episode/id/master.m3u8 or routes like that")]
public async Task Proxy(
string type,
Identifier id,
string rest,
[FromQuery] Dictionary<string, string> query
)
{
string path = await (
type is "movie" or "movies"
? id.Match(
async id => (await library.Movies.Get(id)).Path,
async slug => (await library.Movies.Get(slug)).Path
)
: id.Match(
async id => (await library.Episodes.Get(id)).Path,
async slug => (await library.Episodes.Get(slug)).Path
)
);
await _Proxy(rest + query.ToQueryString(), (path, $"{type}/{id}"));
} }
} }

290
back/src/Kyoo.Host/Application.cs
View File

@ -37,166 +37,160 @@ using Serilog.Templates;
using Serilog.Templates.Themes; using Serilog.Templates.Themes;
using ILogger = Serilog.ILogger; using ILogger = Serilog.ILogger;
namespace Kyoo.Host namespace Kyoo.Host;
/// <summary>
/// Hosts of kyoo (main functions) generally only create a new <see cref="Application"/>
/// and return <see cref="Start(string[])"/>.
/// </summary>
public class Application
{ {
/// <summary> /// <summary>
/// Hosts of kyoo (main functions) generally only create a new <see cref="Application"/> /// The environment in witch Kyoo will run (ether "Production" or "Development").
/// and return <see cref="Start(string[])"/>.
/// </summary> /// </summary>
public class Application private readonly string _environment;
/// <summary>
/// The logger used for startup and error messages.
/// </summary>
private ILogger _logger;
/// <summary>
/// Create a new <see cref="Application"/> that will use the specified environment.
/// </summary>
/// <param name="environment">The environment to run in.</param>
public Application(string environment)
{ {
/// <summary> _environment = environment;
/// The environment in witch Kyoo will run (ether "Production" or "Development"). }
/// </summary>
private readonly string _environment;
/// <summary> /// <summary>
/// The logger used for startup and error messages. /// Start the application with the given console args.
/// </summary> /// This is generally called from the Main entrypoint of Kyoo.
private ILogger _logger; /// </summary>
/// <param name="args">The console arguments to use for kyoo.</param>
/// <returns>A task representing the whole process</returns>
public Task Start(string[] args)
{
return Start(args, _ => { });
}
/// <summary> /// <summary>
/// Create a new <see cref="Application"/> that will use the specified environment. /// Start the application with the given console args.
/// </summary> /// This is generally called from the Main entrypoint of Kyoo.
/// <param name="environment">The environment to run in.</param> /// </summary>
public Application(string environment) /// <param name="args">The console arguments to use for kyoo.</param>
/// <param name="configure">A custom action to configure the container before the start</param>
/// <returns>A task representing the whole process</returns>
public async Task Start(string[] args, Action<ContainerBuilder> configure)
{
IConfiguration parsed = _SetupConfig(new ConfigurationBuilder(), args).Build();
string path = Path.GetFullPath(parsed.GetValue("DATADIR", "/kyoo"));
if (!Directory.Exists(path))
Directory.CreateDirectory(path);
Environment.CurrentDirectory = path;
LoggerConfiguration config = new();
_ConfigureLogging(config);
Log.Logger = config.CreateBootstrapLogger();
_logger = Log.Logger.ForContext<Application>();
AppDomain.CurrentDomain.ProcessExit += (_, _) => Log.CloseAndFlush();
AppDomain.CurrentDomain.UnhandledException += (_, ex) =>
Log.Fatal(ex.ExceptionObject as Exception, "Unhandled exception");
IHost host = _CreateWebHostBuilder(args).ConfigureContainer(configure).Build();
await using (AsyncServiceScope scope = host.Services.CreateAsyncScope())
{ {
_environment = environment; PostgresModule.Initialize(scope.ServiceProvider);
await MeilisearchModule.Initialize(scope.ServiceProvider);
} }
/// <summary> await _StartWithHost(host);
/// Start the application with the given console args. }
/// This is generally called from the Main entrypoint of Kyoo.
/// </summary> /// <summary>
/// <param name="args">The console arguments to use for kyoo.</param> /// Start the given host and log failing exceptions.
/// <returns>A task representing the whole process</returns> /// </summary>
public Task Start(string[] args) /// <param name="host">The host to start.</param>
/// <param name="cancellationToken">A token to allow one to stop the host.</param>
private async Task _StartWithHost(IHost host, CancellationToken cancellationToken = default)
{
try
{ {
return Start(args, _ => { }); CoreModule.Services = host.Services;
_logger.Information(
"Version: {Version}",
Assembly.GetExecutingAssembly().GetName().Version.ToString(3)
);
_logger.Information("Data directory: {DataDirectory}", Environment.CurrentDirectory);
await host.RunAsync(cancellationToken);
} }
catch (Exception ex)
/// <summary>
/// Start the application with the given console args.
/// This is generally called from the Main entrypoint of Kyoo.
/// </summary>
/// <param name="args">The console arguments to use for kyoo.</param>
/// <param name="configure">A custom action to configure the container before the start</param>
/// <returns>A task representing the whole process</returns>
public async Task Start(string[] args, Action<ContainerBuilder> configure)
{ {
IConfiguration parsed = _SetupConfig(new ConfigurationBuilder(), args).Build(); _logger.Fatal(ex, "Unhandled exception");
string path = Path.GetFullPath(parsed.GetValue("DATADIR", "/kyoo"));
if (!Directory.Exists(path))
Directory.CreateDirectory(path);
Environment.CurrentDirectory = path;
LoggerConfiguration config = new();
_ConfigureLogging(config);
Log.Logger = config.CreateBootstrapLogger();
_logger = Log.Logger.ForContext<Application>();
AppDomain.CurrentDomain.ProcessExit += (_, _) => Log.CloseAndFlush();
AppDomain.CurrentDomain.UnhandledException += (_, ex) =>
Log.Fatal(ex.ExceptionObject as Exception, "Unhandled exception");
IHost host = _CreateWebHostBuilder(args).ConfigureContainer(configure).Build();
await using (AsyncServiceScope scope = host.Services.CreateAsyncScope())
{
PostgresModule.Initialize(scope.ServiceProvider);
await MeilisearchModule.Initialize(scope.ServiceProvider);
}
await _StartWithHost(host);
}
/// <summary>
/// Start the given host and log failing exceptions.
/// </summary>
/// <param name="host">The host to start.</param>
/// <param name="cancellationToken">A token to allow one to stop the host.</param>
private async Task _StartWithHost(IHost host, CancellationToken cancellationToken = default)
{
try
{
CoreModule.Services = host.Services;
_logger.Information(
"Version: {Version}",
Assembly.GetExecutingAssembly().GetName().Version.ToString(3)
);
_logger.Information(
"Data directory: {DataDirectory}",
Environment.CurrentDirectory
);
await host.RunAsync(cancellationToken);
}
catch (Exception ex)
{
_logger.Fatal(ex, "Unhandled exception");
}
}
/// <summary>
/// Create a a web host
/// </summary>
/// <param name="args">Command line parameters that can be handled by kestrel</param>
/// <returns>A new web host instance</returns>
private IHostBuilder _CreateWebHostBuilder(string[] args)
{
return new HostBuilder()
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
.UseContentRoot(AppDomain.CurrentDomain.BaseDirectory)
.UseEnvironment(_environment)
.ConfigureAppConfiguration(x => _SetupConfig(x, args))
.UseSerilog((host, services, builder) => _ConfigureLogging(builder))
.ConfigureServices(x => x.AddRouting())
.ConfigureWebHost(x =>
x.UseKestrel(options =>
{
options.AddServerHeader = false;
})
.UseIIS()
.UseIISIntegration()
.UseUrls(
Environment.GetEnvironmentVariable("KYOO_BIND_URL") ?? "http://*:5000"
)
.UseStartup(host =>
PluginsStartup.FromWebHost(host, new LoggerFactory().AddSerilog())
)
);
}
/// <summary>
/// Register settings.json, environment variables and command lines arguments as configuration.
/// </summary>
/// <param name="builder">The configuration builder to use</param>
/// <param name="args">The command line arguments</param>
/// <returns>The modified configuration builder</returns>
private IConfigurationBuilder _SetupConfig(IConfigurationBuilder builder, string[] args)
{
return builder
.AddEnvironmentVariables()
.AddEnvironmentVariables("KYOO_")
.AddCommandLine(args);
}
/// <summary>
/// Configure the logging.
/// </summary>
/// <param name="builder">The logger builder to configure.</param>
private void _ConfigureLogging(LoggerConfiguration builder)
{
const string template =
"[{@t:HH:mm:ss} {@l:u3} {Substring(SourceContext, LastIndexOf(SourceContext, '.') + 1), 25} "
+ "({@i:D10})] {@m}{#if not EndsWith(@m, '\n')}\n{#end}{@x}";
builder
.MinimumLevel.Warning()
.MinimumLevel.Override("Kyoo", LogEventLevel.Verbose)
.MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Verbose)
.MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Fatal)
.WriteTo.Console(new ExpressionTemplate(template, theme: TemplateTheme.Code))
.Enrich.WithThreadId()
.Enrich.FromLogContext();
} }
} }
/// <summary>
/// Create a a web host
/// </summary>
/// <param name="args">Command line parameters that can be handled by kestrel</param>
/// <returns>A new web host instance</returns>
private IHostBuilder _CreateWebHostBuilder(string[] args)
{
return new HostBuilder()
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
.UseContentRoot(AppDomain.CurrentDomain.BaseDirectory)
.UseEnvironment(_environment)
.ConfigureAppConfiguration(x => _SetupConfig(x, args))
.UseSerilog((host, services, builder) => _ConfigureLogging(builder))
.ConfigureServices(x => x.AddRouting())
.ConfigureWebHost(x =>
x.UseKestrel(options =>
{
options.AddServerHeader = false;
})
.UseIIS()
.UseIISIntegration()
.UseUrls(Environment.GetEnvironmentVariable("KYOO_BIND_URL") ?? "http://*:5000")
.UseStartup(host =>
PluginsStartup.FromWebHost(host, new LoggerFactory().AddSerilog())
)
);
}
/// <summary>
/// Register settings.json, environment variables and command lines arguments as configuration.
/// </summary>
/// <param name="builder">The configuration builder to use</param>
/// <param name="args">The command line arguments</param>
/// <returns>The modified configuration builder</returns>
private IConfigurationBuilder _SetupConfig(IConfigurationBuilder builder, string[] args)
{
return builder
.AddEnvironmentVariables()
.AddEnvironmentVariables("KYOO_")
.AddCommandLine(args);
}
/// <summary>
/// Configure the logging.
/// </summary>
/// <param name="builder">The logger builder to configure.</param>
private void _ConfigureLogging(LoggerConfiguration builder)
{
const string template =
"[{@t:HH:mm:ss} {@l:u3} {Substring(SourceContext, LastIndexOf(SourceContext, '.') + 1), 25} "
+ "({@i:D10})] {@m}{#if not EndsWith(@m, '\n')}\n{#end}{@x}";
builder
.MinimumLevel.Warning()
.MinimumLevel.Override("Kyoo", LogEventLevel.Verbose)
.MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Verbose)
.MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Fatal)
.WriteTo.Console(new ExpressionTemplate(template, theme: TemplateTheme.Code))
.Enrich.WithThreadId()
.Enrich.FromLogContext();
}
} }

115
back/src/Kyoo.Host/Contollers/PluginManager.cs
View File

@ -23,73 +23,70 @@ using Kyoo.Abstractions.Controllers;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace Kyoo.Host.Controllers namespace Kyoo.Host.Controllers;
/// <summary>
/// An implementation of <see cref="IPluginManager"/>.
/// This is used to load plugins and retrieve information from them.
/// </summary>
public class PluginManager : IPluginManager
{ {
/// <summary> /// <summary>
/// An implementation of <see cref="IPluginManager"/>. /// The service provider. It allow plugin's activation.
/// This is used to load plugins and retrieve information from them.
/// </summary> /// </summary>
public class PluginManager : IPluginManager private readonly IServiceProvider _provider;
/// <summary>
/// The logger used by this class.
/// </summary>
private readonly ILogger<PluginManager> _logger;
/// <summary>
/// The list of plugins that are currently loaded.
/// </summary>
private readonly List<IPlugin> _plugins = new();
/// <summary>
/// Create a new <see cref="PluginManager"/> instance.
/// </summary>
/// <param name="provider">A service container to allow initialization of plugins</param>
/// <param name="logger">The logger used by this class.</param>
public PluginManager(IServiceProvider provider, ILogger<PluginManager> logger)
{ {
/// <summary> _provider = provider;
/// The service provider. It allow plugin's activation. _logger = logger;
/// </summary> }
private readonly IServiceProvider _provider;
/// <summary> /// <inheritdoc />
/// The logger used by this class. public T GetPlugin<T>(string name)
/// </summary> {
private readonly ILogger<PluginManager> _logger; return (T)_plugins?.FirstOrDefault(x => x.Name == name && x is T);
}
/// <summary> /// <inheritdoc />
/// The list of plugins that are currently loaded. public ICollection<T> GetPlugins<T>()
/// </summary> {
private readonly List<IPlugin> _plugins = new(); return _plugins?.OfType<T>().ToArray();
}
/// <summary> /// <inheritdoc />
/// Create a new <see cref="PluginManager"/> instance. public ICollection<IPlugin> GetAllPlugins()
/// </summary> {
/// <param name="provider">A service container to allow initialization of plugins</param> return _plugins;
/// <param name="logger">The logger used by this class.</param> }
public PluginManager(IServiceProvider provider, ILogger<PluginManager> logger)
{
_provider = provider;
_logger = logger;
}
/// <inheritdoc /> /// <inheritdoc />
public T GetPlugin<T>(string name) public void LoadPlugins(ICollection<IPlugin> plugins)
{ {
return (T)_plugins?.FirstOrDefault(x => x.Name == name && x is T); _plugins.AddRange(plugins);
} _logger.LogInformation("Modules enabled: {Plugins}", _plugins.Select(x => x.Name));
}
/// <inheritdoc /> /// <inheritdoc />
public ICollection<T> GetPlugins<T>() public void LoadPlugins(params Type[] plugins)
{ {
return _plugins?.OfType<T>().ToArray(); LoadPlugins(
} plugins.Select(x => (IPlugin)ActivatorUtilities.CreateInstance(_provider, x)).ToArray()
);
/// <inheritdoc />
public ICollection<IPlugin> GetAllPlugins()
{
return _plugins;
}
/// <inheritdoc />
public void LoadPlugins(ICollection<IPlugin> plugins)
{
_plugins.AddRange(plugins);
_logger.LogInformation("Modules enabled: {Plugins}", _plugins.Select(x => x.Name));
}
/// <inheritdoc />
public void LoadPlugins(params Type[] plugins)
{
LoadPlugins(
plugins
.Select(x => (IPlugin)ActivatorUtilities.CreateInstance(_provider, x))
.ToArray()
);
}
} }
} }

59
back/src/Kyoo.Host/HostModule.cs
View File

@ -23,39 +23,38 @@ using Kyoo.Abstractions.Controllers;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Serilog; using Serilog;
namespace Kyoo.Host namespace Kyoo.Host;
/// <summary>
/// A module that registers host controllers and other needed things.
/// </summary>
public class HostModule : IPlugin
{ {
/// <inheritdoc />
public string Name => "Host";
/// <summary> /// <summary>
/// A module that registers host controllers and other needed things. /// The plugin manager that loaded all plugins.
/// </summary> /// </summary>
public class HostModule : IPlugin private readonly IPluginManager _plugins;
/// <summary>
/// Create a new <see cref="HostModule"/>.
/// </summary>
/// <param name="plugins">The plugin manager that loaded all plugins.</param>
public HostModule(IPluginManager plugins)
{ {
/// <inheritdoc /> _plugins = plugins;
public string Name => "Host";
/// <summary>
/// The plugin manager that loaded all plugins.
/// </summary>
private readonly IPluginManager _plugins;
/// <summary>
/// Create a new <see cref="HostModule"/>.
/// </summary>
/// <param name="plugins">The plugin manager that loaded all plugins.</param>
public HostModule(IPluginManager plugins)
{
_plugins = plugins;
}
/// <inheritdoc />
public void Configure(ContainerBuilder builder)
{
builder.RegisterModule<AttributedMetadataModule>();
builder.RegisterInstance(_plugins).As<IPluginManager>().ExternallyOwned();
}
/// <inheritdoc />
public IEnumerable<IStartupAction> ConfigureSteps =>
new[] { SA.New<IApplicationBuilder>(app => app.UseSerilogRequestLogging(), SA.Before) };
} }
/// <inheritdoc />
public void Configure(ContainerBuilder builder)
{
builder.RegisterModule<AttributedMetadataModule>();
builder.RegisterInstance(_plugins).As<IPluginManager>().ExternallyOwned();
}
/// <inheritdoc />
public IEnumerable<IStartupAction> ConfigureSteps =>
new[] { SA.New<IApplicationBuilder>(app => app.UseSerilogRequestLogging(), SA.Before) };
} }

270
back/src/Kyoo.Host/PluginsStartup.cs
View File

@ -36,167 +36,163 @@ using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace Kyoo.Host namespace Kyoo.Host;
/// <summary>
/// The Startup class is used to configure the AspNet's webhost.
/// </summary>
public class PluginsStartup
{ {
/// <summary> /// <summary>
/// The Startup class is used to configure the AspNet's webhost. /// A plugin manager used to load plugins and allow them to configure services / asp net.
/// </summary> /// </summary>
public class PluginsStartup private readonly IPluginManager _plugins;
/// <summary>
/// The plugin that adds controllers and tasks specific to this host.
/// </summary>
private readonly IPlugin _hostModule;
/// <summary>
/// Created from the DI container, those services are needed to load information and instantiate plugins.s
/// </summary>
/// <param name="plugins">The plugin manager to use to load new plugins and configure the host.</param>
public PluginsStartup(IPluginManager plugins)
{
_plugins = plugins;
_hostModule = new HostModule(_plugins);
_plugins.LoadPlugins(
typeof(CoreModule),
typeof(AuthenticationModule),
typeof(PostgresModule),
typeof(MeilisearchModule),
typeof(SwaggerModule)
);
}
/// <summary>
/// Create a new <see cref="PluginsStartup"/> from a webhost.
/// This is meant to be used from <see cref="WebHostBuilderExtensions.UseStartup"/>.
/// </summary>
/// <param name="host">The context of the web host.</param>
/// <param name="logger">
/// The logger factory used to log while the application is setting itself up.
/// </param>
/// <returns>A new <see cref="PluginsStartup"/>.</returns>
public static PluginsStartup FromWebHost(WebHostBuilderContext host, ILoggerFactory logger)
{
HostServiceProvider hostProvider = new(host.HostingEnvironment, host.Configuration, logger);
PluginManager plugins = new(hostProvider, logger.CreateLogger<PluginManager>());
return new PluginsStartup(plugins);
}
/// <summary>
/// Configure the services context via the <see cref="PluginManager"/>.
/// </summary>
/// <param name="services">The service collection to fill.</param>
public void ConfigureServices(IServiceCollection services)
{
foreach (Assembly assembly in _plugins.GetAllPlugins().Select(x => x.GetType().Assembly))
services.AddMvcCore().AddApplicationPart(assembly);
_hostModule.Configure(services);
foreach (IPlugin plugin in _plugins.GetAllPlugins())
plugin.Configure(services);
}
/// <summary>
/// Configure the autofac container via the <see cref="PluginManager"/>.
/// </summary>
/// <param name="builder">The builder to configure.</param>
public void ConfigureContainer(ContainerBuilder builder)
{
_hostModule.Configure(builder);
foreach (IPlugin plugin in _plugins.GetAllPlugins())
plugin.Configure(builder);
}
/// <summary>
/// Configure the asp net host.
/// </summary>
/// <param name="app">The asp net host to configure</param>
/// <param name="container">An autofac container used to create a new scope to configure asp-net.</param>
public void Configure(IApplicationBuilder app, ILifetimeScope container)
{
IEnumerable<IStartupAction> steps = _plugins
.GetAllPlugins()
.Append(_hostModule)
.SelectMany(x => x.ConfigureSteps)
.OrderByDescending(x => x.Priority);
using ILifetimeScope scope = container.BeginLifetimeScope(x =>
x.RegisterInstance(app).SingleInstance().ExternallyOwned()
);
IServiceProvider provider = scope.Resolve<IServiceProvider>();
foreach (IStartupAction step in steps)
step.Run(provider);
}
/// <summary>
/// A simple host service provider used to activate plugins instance.
/// The same services as a generic host are available and an <see cref="ILoggerFactory"/> has been added.
/// </summary>
private class HostServiceProvider : IServiceProvider
{ {
/// <summary> /// <summary>
/// A plugin manager used to load plugins and allow them to configure services / asp net. /// The host environment that could be used by plugins to configure themself.
/// </summary> /// </summary>
private readonly IPluginManager _plugins; private readonly IWebHostEnvironment _hostEnvironment;
/// <summary> /// <summary>
/// The plugin that adds controllers and tasks specific to this host. /// The configuration context.
/// </summary> /// </summary>
private readonly IPlugin _hostModule; private readonly IConfiguration _configuration;
/// <summary> /// <summary>
/// Created from the DI container, those services are needed to load information and instantiate plugins.s /// A logger factory used to create a logger for the plugin manager.
/// </summary> /// </summary>
/// <param name="plugins">The plugin manager to use to load new plugins and configure the host.</param> private readonly ILoggerFactory _loggerFactory;
public PluginsStartup(IPluginManager plugins)
{
_plugins = plugins;
_hostModule = new HostModule(_plugins);
_plugins.LoadPlugins(
typeof(CoreModule),
typeof(AuthenticationModule),
typeof(PostgresModule),
typeof(MeilisearchModule),
typeof(SwaggerModule)
);
}
/// <summary> /// <summary>
/// Create a new <see cref="PluginsStartup"/> from a webhost. /// Create a new <see cref="HostServiceProvider"/> that will return given services when asked.
/// This is meant to be used from <see cref="WebHostBuilderExtensions.UseStartup"/>.
/// </summary> /// </summary>
/// <param name="host">The context of the web host.</param> /// <param name="hostEnvironment">
/// <param name="logger"> /// The host environment that could be used by plugins to configure themself.
/// The logger factory used to log while the application is setting itself up.
/// </param> /// </param>
/// <returns>A new <see cref="PluginsStartup"/>.</returns> /// <param name="configuration">The configuration context</param>
public static PluginsStartup FromWebHost(WebHostBuilderContext host, ILoggerFactory logger) /// <param name="loggerFactory">A logger factory used to create a logger for the plugin manager.</param>
public HostServiceProvider(
IWebHostEnvironment hostEnvironment,
IConfiguration configuration,
ILoggerFactory loggerFactory
)
{ {
HostServiceProvider hostProvider = _hostEnvironment = hostEnvironment;
new(host.HostingEnvironment, host.Configuration, logger); _configuration = configuration;
PluginManager plugins = new(hostProvider, logger.CreateLogger<PluginManager>()); _loggerFactory = loggerFactory;
return new PluginsStartup(plugins);
} }
/// <summary> /// <inheritdoc />
/// Configure the services context via the <see cref="PluginManager"/>. public object GetService(Type serviceType)
/// </summary>
/// <param name="services">The service collection to fill.</param>
public void ConfigureServices(IServiceCollection services)
{ {
foreach ( if (
Assembly assembly in _plugins.GetAllPlugins().Select(x => x.GetType().Assembly) serviceType == typeof(IWebHostEnvironment)
) || serviceType == typeof(IHostEnvironment)
services.AddMvcCore().AddApplicationPart(assembly);
_hostModule.Configure(services);
foreach (IPlugin plugin in _plugins.GetAllPlugins())
plugin.Configure(services);
}
/// <summary>
/// Configure the autofac container via the <see cref="PluginManager"/>.
/// </summary>
/// <param name="builder">The builder to configure.</param>
public void ConfigureContainer(ContainerBuilder builder)
{
_hostModule.Configure(builder);
foreach (IPlugin plugin in _plugins.GetAllPlugins())
plugin.Configure(builder);
}
/// <summary>
/// Configure the asp net host.
/// </summary>
/// <param name="app">The asp net host to configure</param>
/// <param name="container">An autofac container used to create a new scope to configure asp-net.</param>
public void Configure(IApplicationBuilder app, ILifetimeScope container)
{
IEnumerable<IStartupAction> steps = _plugins
.GetAllPlugins()
.Append(_hostModule)
.SelectMany(x => x.ConfigureSteps)
.OrderByDescending(x => x.Priority);
using ILifetimeScope scope = container.BeginLifetimeScope(x =>
x.RegisterInstance(app).SingleInstance().ExternallyOwned()
);
IServiceProvider provider = scope.Resolve<IServiceProvider>();
foreach (IStartupAction step in steps)
step.Run(provider);
}
/// <summary>
/// A simple host service provider used to activate plugins instance.
/// The same services as a generic host are available and an <see cref="ILoggerFactory"/> has been added.
/// </summary>
private class HostServiceProvider : IServiceProvider
{
/// <summary>
/// The host environment that could be used by plugins to configure themself.
/// </summary>
private readonly IWebHostEnvironment _hostEnvironment;
/// <summary>
/// The configuration context.
/// </summary>
private readonly IConfiguration _configuration;
/// <summary>
/// A logger factory used to create a logger for the plugin manager.
/// </summary>
private readonly ILoggerFactory _loggerFactory;
/// <summary>
/// Create a new <see cref="HostServiceProvider"/> that will return given services when asked.
/// </summary>
/// <param name="hostEnvironment">
/// The host environment that could be used by plugins to configure themself.
/// </param>
/// <param name="configuration">The configuration context</param>
/// <param name="loggerFactory">A logger factory used to create a logger for the plugin manager.</param>
public HostServiceProvider(
IWebHostEnvironment hostEnvironment,
IConfiguration configuration,
ILoggerFactory loggerFactory
) )
return _hostEnvironment;
if (serviceType == typeof(IConfiguration))
return _configuration;
if (serviceType.GetGenericTypeDefinition() == typeof(ILogger<>))
{ {
_hostEnvironment = hostEnvironment; return Utility.RunGenericMethod<object>(
_configuration = configuration; typeof(LoggerFactoryExtensions),
_loggerFactory = loggerFactory; nameof(LoggerFactoryExtensions.CreateLogger),
serviceType.GetGenericArguments().First(),
_loggerFactory
);
} }
/// <inheritdoc /> return null;
public object GetService(Type serviceType)
{
if (
serviceType == typeof(IWebHostEnvironment)
|| serviceType == typeof(IHostEnvironment)
)
return _hostEnvironment;
if (serviceType == typeof(IConfiguration))
return _configuration;
if (serviceType.GetGenericTypeDefinition() == typeof(ILogger<>))
{
return Utility.RunGenericMethod<object>(
typeof(LoggerFactoryExtensions),
nameof(LoggerFactoryExtensions.CreateLogger),
serviceType.GetGenericArguments().First(),
_loggerFactory
);
}
return null;
}
} }
} }
} }

37
back/src/Kyoo.Host/Program.cs
View File

@ -19,31 +19,30 @@
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
namespace Kyoo.Host namespace Kyoo.Host;
/// <summary>
/// Program entrypoint.
/// </summary>
public static class Program
{ {
/// <summary> /// <summary>
/// Program entrypoint. /// The string representation of the environment used in <see cref="IWebHostEnvironment"/>.
/// </summary> /// </summary>
public static class Program
{
/// <summary>
/// The string representation of the environment used in <see cref="IWebHostEnvironment"/>.
/// </summary>
#if DEBUG #if DEBUG
private const string Environment = "Development"; private const string Environment = "Development";
#else #else
private const string Environment = "Production"; private const string Environment = "Production";
#endif #endif
/// <summary> /// <summary>
/// Main function of the program /// Main function of the program
/// </summary> /// </summary>
/// <param name="args">Command line arguments</param> /// <param name="args">Command line arguments</param>
/// <returns>A <see cref="Task"/> representing the lifetime of the program.</returns> /// <returns>A <see cref="Task"/> representing the lifetime of the program.</returns>
public static Task Main(string[] args) public static Task Main(string[] args)
{ {
Application application = new(Environment); Application application = new(Environment);
return application.Start(args); return application.Start(args);
}
} }
} }

311
back/src/Kyoo.Meilisearch/MeilisearchModule.cs
View File

@ -24,171 +24,166 @@ using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using static System.Text.Json.JsonNamingPolicy; using static System.Text.Json.JsonNamingPolicy;
namespace Kyoo.Meiliseach namespace Kyoo.Meiliseach;
public class MeilisearchModule : IPlugin
{ {
public class MeilisearchModule : IPlugin /// <inheritdoc />
public string Name => "Meilisearch";
private readonly IConfiguration _configuration;
public static Dictionary<string, Settings> IndexSettings =>
new()
{
{
"items",
new Settings()
{
SearchableAttributes = new[]
{
CamelCase.ConvertName(nameof(Movie.Name)),
CamelCase.ConvertName(nameof(Movie.Slug)),
CamelCase.ConvertName(nameof(Movie.Aliases)),
CamelCase.ConvertName(nameof(Movie.Path)),
CamelCase.ConvertName(nameof(Movie.Tags)),
CamelCase.ConvertName(nameof(Movie.Overview)),
},
FilterableAttributes = new[]
{
CamelCase.ConvertName(nameof(Movie.Genres)),
CamelCase.ConvertName(nameof(Movie.Status)),
CamelCase.ConvertName(nameof(Movie.AirDate)),
CamelCase.ConvertName(nameof(Movie.StudioId)),
"kind"
},
SortableAttributes = new[]
{
CamelCase.ConvertName(nameof(Movie.AirDate)),
CamelCase.ConvertName(nameof(Movie.AddedDate)),
CamelCase.ConvertName(nameof(Movie.Rating)),
CamelCase.ConvertName(nameof(Movie.Runtime)),
},
DisplayedAttributes = new[] { CamelCase.ConvertName(nameof(Movie.Id)), "kind" },
RankingRules = new[]
{
"words",
"typo",
"proximity",
"attribute",
"sort",
"exactness",
$"{CamelCase.ConvertName(nameof(Movie.Rating))}:desc",
}
// TODO: Add stopwords
}
},
{
nameof(Episode),
new Settings()
{
SearchableAttributes = new[]
{
CamelCase.ConvertName(nameof(Episode.Name)),
CamelCase.ConvertName(nameof(Episode.Overview)),
CamelCase.ConvertName(nameof(Episode.Slug)),
CamelCase.ConvertName(nameof(Episode.Path)),
},
FilterableAttributes = new[]
{
CamelCase.ConvertName(nameof(Episode.SeasonNumber)),
},
SortableAttributes = new[]
{
CamelCase.ConvertName(nameof(Episode.ReleaseDate)),
CamelCase.ConvertName(nameof(Episode.AddedDate)),
CamelCase.ConvertName(nameof(Episode.SeasonNumber)),
CamelCase.ConvertName(nameof(Episode.EpisodeNumber)),
CamelCase.ConvertName(nameof(Episode.AbsoluteNumber)),
},
DisplayedAttributes = new[] { CamelCase.ConvertName(nameof(Episode.Id)), },
// TODO: Add stopwords
}
},
{
nameof(Studio),
new Settings()
{
SearchableAttributes = new[]
{
CamelCase.ConvertName(nameof(Studio.Name)),
CamelCase.ConvertName(nameof(Studio.Slug)),
},
FilterableAttributes = Array.Empty<string>(),
SortableAttributes = Array.Empty<string>(),
DisplayedAttributes = new[] { CamelCase.ConvertName(nameof(Studio.Id)), },
// TODO: Add stopwords
}
},
};
public MeilisearchModule(IConfiguration configuration)
{ {
/// <inheritdoc /> _configuration = configuration;
public string Name => "Meilisearch"; }
private readonly IConfiguration _configuration; /// <summary>
/// Init meilisearch indexes.
/// </summary>
/// <param name="provider">The service list to retrieve the meilisearch client</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public static async Task Initialize(IServiceProvider provider)
{
MeilisearchClient client = provider.GetRequiredService<MeilisearchClient>();
public static Dictionary<string, Settings> IndexSettings => await _CreateIndex(client, "items", true);
new() await _CreateIndex(client, nameof(Episode), false);
{ await _CreateIndex(client, nameof(Studio), false);
{
"items",
new Settings()
{
SearchableAttributes = new[]
{
CamelCase.ConvertName(nameof(Movie.Name)),
CamelCase.ConvertName(nameof(Movie.Slug)),
CamelCase.ConvertName(nameof(Movie.Aliases)),
CamelCase.ConvertName(nameof(Movie.Path)),
CamelCase.ConvertName(nameof(Movie.Tags)),
CamelCase.ConvertName(nameof(Movie.Overview)),
},
FilterableAttributes = new[]
{
CamelCase.ConvertName(nameof(Movie.Genres)),
CamelCase.ConvertName(nameof(Movie.Status)),
CamelCase.ConvertName(nameof(Movie.AirDate)),
CamelCase.ConvertName(nameof(Movie.StudioId)),
"kind"
},
SortableAttributes = new[]
{
CamelCase.ConvertName(nameof(Movie.AirDate)),
CamelCase.ConvertName(nameof(Movie.AddedDate)),
CamelCase.ConvertName(nameof(Movie.Rating)),
CamelCase.ConvertName(nameof(Movie.Runtime)),
},
DisplayedAttributes = new[]
{
CamelCase.ConvertName(nameof(Movie.Id)),
"kind"
},
RankingRules = new[]
{
"words",
"typo",
"proximity",
"attribute",
"sort",
"exactness",
$"{CamelCase.ConvertName(nameof(Movie.Rating))}:desc",
}
// TODO: Add stopwords
}
},
{
nameof(Episode),
new Settings()
{
SearchableAttributes = new[]
{
CamelCase.ConvertName(nameof(Episode.Name)),
CamelCase.ConvertName(nameof(Episode.Overview)),
CamelCase.ConvertName(nameof(Episode.Slug)),
CamelCase.ConvertName(nameof(Episode.Path)),
},
FilterableAttributes = new[]
{
CamelCase.ConvertName(nameof(Episode.SeasonNumber)),
},
SortableAttributes = new[]
{
CamelCase.ConvertName(nameof(Episode.ReleaseDate)),
CamelCase.ConvertName(nameof(Episode.AddedDate)),
CamelCase.ConvertName(nameof(Episode.SeasonNumber)),
CamelCase.ConvertName(nameof(Episode.EpisodeNumber)),
CamelCase.ConvertName(nameof(Episode.AbsoluteNumber)),
},
DisplayedAttributes = new[] { CamelCase.ConvertName(nameof(Episode.Id)), },
// TODO: Add stopwords
}
},
{
nameof(Studio),
new Settings()
{
SearchableAttributes = new[]
{
CamelCase.ConvertName(nameof(Studio.Name)),
CamelCase.ConvertName(nameof(Studio.Slug)),
},
FilterableAttributes = Array.Empty<string>(),
SortableAttributes = Array.Empty<string>(),
DisplayedAttributes = new[] { CamelCase.ConvertName(nameof(Studio.Id)), },
// TODO: Add stopwords
}
},
};
public MeilisearchModule(IConfiguration configuration) IndexStats info = await client.Index("items").GetStatsAsync();
// If there is no documents in meilisearch, if a db exist and is not empty, add items to meilisearch.
if (info.NumberOfDocuments == 0)
{ {
_configuration = configuration; ILibraryManager database = provider.GetRequiredService<ILibraryManager>();
} MeiliSync search = provider.GetRequiredService<MeiliSync>();
/// <summary> // This is a naive implementation that absolutly does not care about performances.
/// Init meilisearch indexes. // This will run only once on users that already had a database when they upgrade.
/// </summary> foreach (Movie movie in await database.Movies.GetAll(limit: 0))
/// <param name="provider">The service list to retrieve the meilisearch client</param> await search.CreateOrUpdate("items", movie, nameof(Movie));
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> foreach (Show show in await database.Shows.GetAll(limit: 0))
public static async Task Initialize(IServiceProvider provider) await search.CreateOrUpdate("items", show, nameof(Show));
{ foreach (Collection collection in await database.Collections.GetAll(limit: 0))
MeilisearchClient client = provider.GetRequiredService<MeilisearchClient>(); await search.CreateOrUpdate("items", collection, nameof(Collection));
foreach (Episode episode in await database.Episodes.GetAll(limit: 0))
await _CreateIndex(client, "items", true); await search.CreateOrUpdate(nameof(Episode), episode);
await _CreateIndex(client, nameof(Episode), false); foreach (Studio studio in await database.Studios.GetAll(limit: 0))
await _CreateIndex(client, nameof(Studio), false); await search.CreateOrUpdate(nameof(Studio), studio);
IndexStats info = await client.Index("items").GetStatsAsync();
// If there is no documents in meilisearch, if a db exist and is not empty, add items to meilisearch.
if (info.NumberOfDocuments == 0)
{
ILibraryManager database = provider.GetRequiredService<ILibraryManager>();
MeiliSync search = provider.GetRequiredService<MeiliSync>();
// This is a naive implementation that absolutly does not care about performances.
// This will run only once on users that already had a database when they upgrade.
foreach (Movie movie in await database.Movies.GetAll(limit: 0))
await search.CreateOrUpdate("items", movie, nameof(Movie));
foreach (Show show in await database.Shows.GetAll(limit: 0))
await search.CreateOrUpdate("items", show, nameof(Show));
foreach (Collection collection in await database.Collections.GetAll(limit: 0))
await search.CreateOrUpdate("items", collection, nameof(Collection));
foreach (Episode episode in await database.Episodes.GetAll(limit: 0))
await search.CreateOrUpdate(nameof(Episode), episode);
foreach (Studio studio in await database.Studios.GetAll(limit: 0))
await search.CreateOrUpdate(nameof(Studio), studio);
}
}
private static async Task _CreateIndex(MeilisearchClient client, string index, bool hasKind)
{
TaskInfo task = await client.CreateIndexAsync(
index,
hasKind ? "ref" : CamelCase.ConvertName(nameof(IResource.Id))
);
await client.WaitForTaskAsync(task.TaskUid);
await client.Index(index).UpdateSettingsAsync(IndexSettings[index]);
}
/// <inheritdoc />
public void Configure(ContainerBuilder builder)
{
builder
.RegisterInstance(
new MeilisearchClient(
_configuration.GetValue("MEILI_HOST", "http://meilisearch:7700"),
_configuration.GetValue<string?>("MEILI_MASTER_KEY")
)
)
.SingleInstance();
builder.RegisterType<MeiliSync>().AsSelf().SingleInstance().AutoActivate();
builder.RegisterType<SearchManager>().As<ISearchManager>().InstancePerLifetimeScope();
} }
} }
private static async Task _CreateIndex(MeilisearchClient client, string index, bool hasKind)
{
TaskInfo task = await client.CreateIndexAsync(
index,
hasKind ? "ref" : CamelCase.ConvertName(nameof(IResource.Id))
);
await client.WaitForTaskAsync(task.TaskUid);
await client.Index(index).UpdateSettingsAsync(IndexSettings[index]);
}
/// <inheritdoc />
public void Configure(ContainerBuilder builder)
{
builder
.RegisterInstance(
new MeilisearchClient(
_configuration.GetValue("MEILI_HOST", "http://meilisearch:7700"),
_configuration.GetValue<string?>("MEILI_MASTER_KEY")
)
)
.SingleInstance();
builder.RegisterType<MeiliSync>().AsSelf().SingleInstance().AutoActivate();
builder.RegisterType<SearchManager>().As<ISearchManager>().InstancePerLifetimeScope();
}
} }

1184
back/src/Kyoo.Postgresql/DatabaseContext.cs
View File

File diff suppressed because it is too large Load Diff

191
back/src/Kyoo.Postgresql/PostgresContext.cs
View File

@ -25,114 +25,113 @@ using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Query.SqlExpressions; using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
using Npgsql; using Npgsql;
namespace Kyoo.Postgresql namespace Kyoo.Postgresql;
/// <summary>
/// A postgresql implementation of <see cref="DatabaseContext"/>.
/// </summary>
public class PostgresContext : DatabaseContext
{ {
/// <summary> /// <summary>
/// A postgresql implementation of <see cref="DatabaseContext"/>. /// Is this instance in debug mode?
/// </summary> /// </summary>
public class PostgresContext : DatabaseContext private readonly bool _debugMode;
/// <summary>
/// Should the configure step be skipped? This is used when the database is created via DbContextOptions.
/// </summary>
private readonly bool _skipConfigure;
// TODO: This needs ot be updated but ef-core still does not offer a way to use this.
[Obsolete]
static PostgresContext()
{ {
/// <summary> NpgsqlConnection.GlobalTypeMapper.MapEnum<Status>();
/// Is this instance in debug mode? NpgsqlConnection.GlobalTypeMapper.MapEnum<Genre>();
/// </summary> NpgsqlConnection.GlobalTypeMapper.MapEnum<WatchStatus>();
private readonly bool _debugMode; }
/// <summary> /// <summary>
/// Should the configure step be skipped? This is used when the database is created via DbContextOptions. /// Design time constructor (dotnet ef migrations add). Do not use
/// </summary> /// </summary>
private readonly bool _skipConfigure; public PostgresContext()
: base(null!) { }
// TODO: This needs ot be updated but ef-core still does not offer a way to use this. public PostgresContext(DbContextOptions options, IHttpContextAccessor accessor)
[Obsolete] : base(options, accessor)
static PostgresContext() {
_skipConfigure = true;
}
public PostgresContext(string connection, bool debugMode, IHttpContextAccessor accessor)
: base(accessor)
{
_debugMode = debugMode;
}
/// <summary>
/// Set connection information for this database context
/// </summary>
/// <param name="optionsBuilder">An option builder to fill.</param>
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
if (!_skipConfigure)
{ {
NpgsqlConnection.GlobalTypeMapper.MapEnum<Status>(); optionsBuilder.UseNpgsql();
NpgsqlConnection.GlobalTypeMapper.MapEnum<Genre>(); if (_debugMode)
NpgsqlConnection.GlobalTypeMapper.MapEnum<WatchStatus>(); optionsBuilder.EnableDetailedErrors().EnableSensitiveDataLogging();
} }
/// <summary> optionsBuilder.UseSnakeCaseNamingConvention();
/// Design time constructor (dotnet ef migrations add). Do not use base.OnConfiguring(optionsBuilder);
/// </summary> }
public PostgresContext()
: base(null!) { }
public PostgresContext(DbContextOptions options, IHttpContextAccessor accessor) /// <summary>
: base(options, accessor) /// Set database parameters to support every types of Kyoo.
{ /// </summary>
_skipConfigure = true; /// <param name="modelBuilder">The database's model builder.</param>
} protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.HasPostgresEnum<Status>();
modelBuilder.HasPostgresEnum<Genre>();
modelBuilder.HasPostgresEnum<WatchStatus>();
public PostgresContext(string connection, bool debugMode, IHttpContextAccessor accessor) modelBuilder
: base(accessor) .HasDbFunction(typeof(DatabaseContext).GetMethod(nameof(MD5))!)
{ .HasTranslation(args => new SqlFunctionExpression(
_debugMode = debugMode; "md5",
} args,
nullable: true,
argumentsPropagateNullability: new[] { false },
type: args[0].Type,
typeMapping: args[0].TypeMapping
));
/// <summary> base.OnModelCreating(modelBuilder);
/// Set connection information for this database context }
/// </summary>
/// <param name="optionsBuilder">An option builder to fill.</param> /// <inheritdoc />
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) protected override string LinkName<T, T2>()
{ {
if (!_skipConfigure) SnakeCaseNameRewriter rewriter = new(CultureInfo.InvariantCulture);
return rewriter.RewriteName("Link" + typeof(T).Name + typeof(T2).Name);
}
/// <inheritdoc />
protected override string LinkNameFk<T>()
{
SnakeCaseNameRewriter rewriter = new(CultureInfo.InvariantCulture);
return rewriter.RewriteName(typeof(T).Name + "ID");
}
/// <inheritdoc />
protected override bool IsDuplicateException(Exception ex)
{
return ex.InnerException
is PostgresException
{ {
optionsBuilder.UseNpgsql(); SqlState: PostgresErrorCodes.UniqueViolation
if (_debugMode) or PostgresErrorCodes.ForeignKeyViolation
optionsBuilder.EnableDetailedErrors().EnableSensitiveDataLogging(); };
}
optionsBuilder.UseSnakeCaseNamingConvention();
base.OnConfiguring(optionsBuilder);
}
/// <summary>
/// Set database parameters to support every types of Kyoo.
/// </summary>
/// <param name="modelBuilder">The database's model builder.</param>
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.HasPostgresEnum<Status>();
modelBuilder.HasPostgresEnum<Genre>();
modelBuilder.HasPostgresEnum<WatchStatus>();
modelBuilder
.HasDbFunction(typeof(DatabaseContext).GetMethod(nameof(MD5))!)
.HasTranslation(args => new SqlFunctionExpression(
"md5",
args,
nullable: true,
argumentsPropagateNullability: new[] { false },
type: args[0].Type,
typeMapping: args[0].TypeMapping
));
base.OnModelCreating(modelBuilder);
}
/// <inheritdoc />
protected override string LinkName<T, T2>()
{
SnakeCaseNameRewriter rewriter = new(CultureInfo.InvariantCulture);
return rewriter.RewriteName("Link" + typeof(T).Name + typeof(T2).Name);
}
/// <inheritdoc />
protected override string LinkNameFk<T>()
{
SnakeCaseNameRewriter rewriter = new(CultureInfo.InvariantCulture);
return rewriter.RewriteName(typeof(T).Name + "ID");
}
/// <inheritdoc />
protected override bool IsDuplicateException(Exception ex)
{
return ex.InnerException
is PostgresException
{
SqlState: PostgresErrorCodes.UniqueViolation
or PostgresErrorCodes.ForeignKeyViolation
};
}
} }
} }

191
back/src/Kyoo.Postgresql/PostgresModule.cs
View File

@ -33,115 +33,112 @@ using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Hosting;
using Npgsql; using Npgsql;
namespace Kyoo.Postgresql namespace Kyoo.Postgresql;
/// <summary>
/// A module to add postgresql capacity to the app.
/// </summary>
public class PostgresModule : IPlugin
{ {
/// <inheritdoc />
public string Name => "Postgresql";
/// <summary> /// <summary>
/// A module to add postgresql capacity to the app. /// The configuration to use. The database connection string is pulled from it.
/// </summary> /// </summary>
public class PostgresModule : IPlugin private readonly IConfiguration _configuration;
/// <summary>
/// The host environment to check if the app is in debug mode.
/// </summary>
private readonly IWebHostEnvironment _environment;
/// <summary>
/// Create a new postgres module instance and use the given configuration and environment.
/// </summary>
/// <param name="configuration">The configuration to use</param>
/// <param name="env">The environment that will be used (if the env is in development mode, more information will be displayed on errors.</param>
public PostgresModule(IConfiguration configuration, IWebHostEnvironment env)
{ {
/// <inheritdoc /> _configuration = configuration;
public string Name => "Postgresql"; _environment = env;
}
/// <summary> /// <summary>
/// The configuration to use. The database connection string is pulled from it. /// Migrate the database.
/// </summary> /// </summary>
private readonly IConfiguration _configuration; /// <param name="provider">The service list to retrieve the database context</param>
public static void Initialize(IServiceProvider provider)
{
DatabaseContext context = provider.GetRequiredService<DatabaseContext>();
context.Database.Migrate();
/// <summary> using NpgsqlConnection conn = (NpgsqlConnection)context.Database.GetDbConnection();
/// The host environment to check if the app is in debug mode. conn.Open();
/// </summary> conn.ReloadTypes();
private readonly IWebHostEnvironment _environment;
/// <summary> SqlMapper.TypeMapProvider = (type) =>
/// Create a new postgres module instance and use the given configuration and environment.
/// </summary>
/// <param name="configuration">The configuration to use</param>
/// <param name="env">The environment that will be used (if the env is in development mode, more information will be displayed on errors.</param>
public PostgresModule(IConfiguration configuration, IWebHostEnvironment env)
{ {
_configuration = configuration; return new CustomPropertyTypeMap(
_environment = env; type,
} (type, name) =>
{
string newName = Regex.Replace(
name,
"(^|_)([a-z])",
(match) => match.Groups[2].Value.ToUpperInvariant()
);
// TODO: Add images handling here (name: poster_source, newName: PosterSource) should set Poster.Source
return type.GetProperty(newName)!;
}
);
};
SqlMapper.AddTypeHandler(
typeof(Dictionary<string, MetadataId>),
new JsonTypeHandler<Dictionary<string, MetadataId>>()
);
SqlMapper.AddTypeHandler(
typeof(Dictionary<string, string>),
new JsonTypeHandler<Dictionary<string, string>>()
);
SqlMapper.AddTypeHandler(
typeof(Dictionary<string, ExternalToken>),
new JsonTypeHandler<Dictionary<string, ExternalToken>>()
);
SqlMapper.AddTypeHandler(typeof(List<string>), new ListTypeHandler<string>());
SqlMapper.AddTypeHandler(typeof(List<Genre>), new ListTypeHandler<Genre>());
SqlMapper.AddTypeHandler(typeof(Wrapper), new Wrapper.Handler());
InterpolatedSqlBuilderOptions.DefaultOptions.ReuseIdenticalParameters = true;
InterpolatedSqlBuilderOptions.DefaultOptions.AutoFixSingleQuotes = false;
}
/// <summary> /// <inheritdoc />
/// Migrate the database. public void Configure(IServiceCollection services)
/// </summary> {
/// <param name="provider">The service list to retrieve the database context</param> DbConnectionStringBuilder builder =
public static void Initialize(IServiceProvider provider) new()
{
DatabaseContext context = provider.GetRequiredService<DatabaseContext>();
context.Database.Migrate();
using NpgsqlConnection conn = (NpgsqlConnection)context.Database.GetDbConnection();
conn.Open();
conn.ReloadTypes();
SqlMapper.TypeMapProvider = (type) =>
{ {
return new CustomPropertyTypeMap( ["USER ID"] = _configuration.GetValue("POSTGRES_USER", "KyooUser"),
type, ["PASSWORD"] = _configuration.GetValue("POSTGRES_PASSWORD", "KyooPassword"),
(type, name) => ["SERVER"] = _configuration.GetValue("POSTGRES_SERVER", "db"),
{ ["PORT"] = _configuration.GetValue("POSTGRES_PORT", "5432"),
string newName = Regex.Replace( ["DATABASE"] = _configuration.GetValue("POSTGRES_DB", "kyooDB"),
name, ["POOLING"] = "true",
"(^|_)([a-z])", ["MAXPOOLSIZE"] = "95",
(match) => match.Groups[2].Value.ToUpperInvariant() ["TIMEOUT"] = "30"
);
// TODO: Add images handling here (name: poster_source, newName: PosterSource) should set Poster.Source
return type.GetProperty(newName)!;
}
);
}; };
SqlMapper.AddTypeHandler(
typeof(Dictionary<string, MetadataId>),
new JsonTypeHandler<Dictionary<string, MetadataId>>()
);
SqlMapper.AddTypeHandler(
typeof(Dictionary<string, string>),
new JsonTypeHandler<Dictionary<string, string>>()
);
SqlMapper.AddTypeHandler(
typeof(Dictionary<string, ExternalToken>),
new JsonTypeHandler<Dictionary<string, ExternalToken>>()
);
SqlMapper.AddTypeHandler(typeof(List<string>), new ListTypeHandler<string>());
SqlMapper.AddTypeHandler(typeof(List<Genre>), new ListTypeHandler<Genre>());
SqlMapper.AddTypeHandler(typeof(Wrapper), new Wrapper.Handler());
InterpolatedSqlBuilderOptions.DefaultOptions.ReuseIdenticalParameters = true;
InterpolatedSqlBuilderOptions.DefaultOptions.AutoFixSingleQuotes = false;
}
/// <inheritdoc /> services.AddDbContext<DatabaseContext, PostgresContext>(
public void Configure(IServiceCollection services) x =>
{ {
DbConnectionStringBuilder builder = x.UseNpgsql(builder.ConnectionString).UseProjectables();
new() if (_environment.IsDevelopment())
{ x.EnableDetailedErrors().EnableSensitiveDataLogging();
["USER ID"] = _configuration.GetValue("POSTGRES_USER", "KyooUser"), },
["PASSWORD"] = _configuration.GetValue("POSTGRES_PASSWORD", "KyooPassword"), ServiceLifetime.Transient
["SERVER"] = _configuration.GetValue("POSTGRES_SERVER", "db"), );
["PORT"] = _configuration.GetValue("POSTGRES_PORT", "5432"), services.AddTransient<DbConnection>((_) => new NpgsqlConnection(builder.ConnectionString));
["DATABASE"] = _configuration.GetValue("POSTGRES_DB", "kyooDB"),
["POOLING"] = "true",
["MAXPOOLSIZE"] = "95",
["TIMEOUT"] = "30"
};
services.AddDbContext<DatabaseContext, PostgresContext>( services.AddHealthChecks().AddDbContextCheck<DatabaseContext>();
x =>
{
x.UseNpgsql(builder.ConnectionString).UseProjectables();
if (_environment.IsDevelopment())
x.EnableDetailedErrors().EnableSensitiveDataLogging();
},
ServiceLifetime.Transient
);
services.AddTransient<DbConnection>(
(_) => new NpgsqlConnection(builder.ConnectionString)
);
services.AddHealthChecks().AddDbContextCheck<DatabaseContext>();
}
} }
} }

67
back/src/Kyoo.Swagger/ApiSorter.cs
View File

@ -22,45 +22,44 @@ using Kyoo.Swagger.Models;
using NSwag; using NSwag;
using NSwag.Generation.AspNetCore; using NSwag.Generation.AspNetCore;
namespace Kyoo.Swagger namespace Kyoo.Swagger;
/// <summary>
/// A class to sort apis.
/// </summary>
public static class ApiSorter
{ {
/// <summary> /// <summary>
/// A class to sort apis. /// Sort apis by alphabetical orders.
/// </summary> /// </summary>
public static class ApiSorter /// <param name="options">The swagger settings to update.</param>
public static void SortApis(this AspNetCoreOpenApiDocumentGeneratorSettings options)
{ {
/// <summary> options.PostProcess += postProcess =>
/// Sort apis by alphabetical orders.
/// </summary>
/// <param name="options">The swagger settings to update.</param>
public static void SortApis(this AspNetCoreOpenApiDocumentGeneratorSettings options)
{ {
options.PostProcess += postProcess => // We can't reorder items by assigning the sorted value to the Paths variable since it has no setter.
{ List<KeyValuePair<string, OpenApiPathItem>> sorted = postProcess
// We can't reorder items by assigning the sorted value to the Paths variable since it has no setter. .Paths.OrderBy(x => x.Key)
List<KeyValuePair<string, OpenApiPathItem>> sorted = postProcess .ToList();
.Paths.OrderBy(x => x.Key) postProcess.Paths.Clear();
.ToList(); foreach ((string key, OpenApiPathItem value) in sorted)
postProcess.Paths.Clear(); postProcess.Paths.Add(key, value);
foreach ((string key, OpenApiPathItem value) in sorted) };
postProcess.Paths.Add(key, value);
};
options.PostProcess += postProcess => options.PostProcess += postProcess =>
{ {
if (!postProcess.ExtensionData.TryGetValue("x-tagGroups", out object list)) if (!postProcess.ExtensionData.TryGetValue("x-tagGroups", out object list))
return; return;
List<TagGroups> tagGroups = (List<TagGroups>)list; List<TagGroups> tagGroups = (List<TagGroups>)list;
postProcess.ExtensionData["x-tagGroups"] = tagGroups postProcess.ExtensionData["x-tagGroups"] = tagGroups
.OrderBy(x => x.Name) .OrderBy(x => x.Name)
.Select(x => .Select(x =>
{ {
x.Name = x.Name[(x.Name.IndexOf(':') + 1)..]; x.Name = x.Name[(x.Name.IndexOf(':') + 1)..];
x.Tags = x.Tags.OrderBy(y => y).ToList(); x.Tags = x.Tags.OrderBy(y => y).ToList();
return x; return x;
}) })
.ToList(); .ToList();
}; };
}
} }
} }

163
back/src/Kyoo.Swagger/ApiTagsFilter.cs
View File

@ -26,99 +26,98 @@ using NSwag;
using NSwag.Generation.AspNetCore; using NSwag.Generation.AspNetCore;
using NSwag.Generation.Processors.Contexts; using NSwag.Generation.Processors.Contexts;
namespace Kyoo.Swagger namespace Kyoo.Swagger;
/// <summary>
/// A class to handle Api Groups (OpenApi tags and x-tagGroups).
/// Tags should be specified via <see cref="ApiDefinitionAttribute"/> and this filter will map this to the
/// <see cref="OpenApiDocument"/>.
/// </summary>
public static class ApiTagsFilter
{ {
/// <summary> /// <summary>
/// A class to handle Api Groups (OpenApi tags and x-tagGroups). /// The main operation filter that will map every <see cref="ApiDefinitionAttribute"/>.
/// Tags should be specified via <see cref="ApiDefinitionAttribute"/> and this filter will map this to the
/// <see cref="OpenApiDocument"/>.
/// </summary> /// </summary>
public static class ApiTagsFilter /// <param name="context">The processor context, this is given by the AddOperationFilter method.</param>
/// <returns>This always return <c>true</c> since it should not remove operations.</returns>
public static bool OperationFilter(OperationProcessorContext context)
{ {
/// <summary> ApiDefinitionAttribute def =
/// The main operation filter that will map every <see cref="ApiDefinitionAttribute"/>. context.ControllerType.GetCustomAttribute<ApiDefinitionAttribute>();
/// </summary> string name = def?.Name ?? context.ControllerType.Name;
/// <param name="context">The processor context, this is given by the AddOperationFilter method.</param>
/// <returns>This always return <c>true</c> since it should not remove operations.</returns> ApiDefinitionAttribute methodOverride =
public static bool OperationFilter(OperationProcessorContext context) context.MethodInfo.GetCustomAttribute<ApiDefinitionAttribute>();
if (methodOverride != null)
name = methodOverride.Name;
context.OperationDescription.Operation.Tags.Add(name);
if (context.Document.Tags.All(x => x.Name != name))
{ {
ApiDefinitionAttribute def = context.Document.Tags.Add(
context.ControllerType.GetCustomAttribute<ApiDefinitionAttribute>(); new OpenApiTag
string name = def?.Name ?? context.ControllerType.Name; {
Name = name,
ApiDefinitionAttribute methodOverride = Description = context.ControllerType.GetXmlDocsSummary()
context.MethodInfo.GetCustomAttribute<ApiDefinitionAttribute>(); }
if (methodOverride != null) );
name = methodOverride.Name; }
context.OperationDescription.Operation.Tags.Add(name);
if (context.Document.Tags.All(x => x.Name != name))
{
context.Document.Tags.Add(
new OpenApiTag
{
Name = name,
Description = context.ControllerType.GetXmlDocsSummary()
}
);
}
if (def?.Group == null)
return true;
context.Document.ExtensionData ??= new Dictionary<string, object>();
context.Document.ExtensionData.TryAdd("x-tagGroups", new List<TagGroups>());
List<TagGroups> obj = (List<TagGroups>)context.Document.ExtensionData["x-tagGroups"];
TagGroups existing = obj.FirstOrDefault(x => x.Name == def.Group);
if (existing != null)
{
if (!existing.Tags.Contains(def.Name))
existing.Tags.Add(def.Name);
}
else
{
obj.Add(
new TagGroups
{
Name = def.Group,
Tags = new List<string> { def.Name }
}
);
}
if (def?.Group == null)
return true; return true;
context.Document.ExtensionData ??= new Dictionary<string, object>();
context.Document.ExtensionData.TryAdd("x-tagGroups", new List<TagGroups>());
List<TagGroups> obj = (List<TagGroups>)context.Document.ExtensionData["x-tagGroups"];
TagGroups existing = obj.FirstOrDefault(x => x.Name == def.Group);
if (existing != null)
{
if (!existing.Tags.Contains(def.Name))
existing.Tags.Add(def.Name);
}
else
{
obj.Add(
new TagGroups
{
Name = def.Group,
Tags = new List<string> { def.Name }
}
);
} }
/// <summary> return true;
/// This add every tags that are not in a x-tagGroups to a new tagGroups named "Other". }
/// Since tags that are not in a tagGroups are not shown, this is necessary if you want them displayed.
/// </summary>
/// <param name="postProcess">
/// The document to do this for. This should be done in the PostProcess part of the document or after
/// the main operation filter (see <see cref="OperationFilter"/>) has finished.
/// </param>
public static void AddLeftoversToOthersGroup(this OpenApiDocument postProcess)
{
List<TagGroups> tagGroups = (List<TagGroups>)postProcess.ExtensionData["x-tagGroups"];
List<string> tagsWithoutGroup = postProcess
.Tags.Select(x => x.Name)
.Where(x => tagGroups.SelectMany(y => y.Tags).All(y => y != x))
.ToList();
if (tagsWithoutGroup.Any())
{
tagGroups.Add(new TagGroups { Name = "Others", Tags = tagsWithoutGroup });
}
}
/// <summary> /// <summary>
/// Use <see cref="ApiDefinitionAttribute"/> to create tags and groups of tags on the resulting swagger /// This add every tags that are not in a x-tagGroups to a new tagGroups named "Other".
/// document. /// Since tags that are not in a tagGroups are not shown, this is necessary if you want them displayed.
/// </summary> /// </summary>
/// <param name="options">The settings of the swagger document.</param> /// <param name="postProcess">
public static void UseApiTags(this AspNetCoreOpenApiDocumentGeneratorSettings options) /// The document to do this for. This should be done in the PostProcess part of the document or after
/// the main operation filter (see <see cref="OperationFilter"/>) has finished.
/// </param>
public static void AddLeftoversToOthersGroup(this OpenApiDocument postProcess)
{
List<TagGroups> tagGroups = (List<TagGroups>)postProcess.ExtensionData["x-tagGroups"];
List<string> tagsWithoutGroup = postProcess
.Tags.Select(x => x.Name)
.Where(x => tagGroups.SelectMany(y => y.Tags).All(y => y != x))
.ToList();
if (tagsWithoutGroup.Any())
{ {
options.AddOperationFilter(OperationFilter); tagGroups.Add(new TagGroups { Name = "Others", Tags = tagsWithoutGroup });
options.PostProcess += x => x.AddLeftoversToOthersGroup();
} }
} }
/// <summary>
/// Use <see cref="ApiDefinitionAttribute"/> to create tags and groups of tags on the resulting swagger
/// document.
/// </summary>
/// <param name="options">The settings of the swagger document.</param>
public static void UseApiTags(this AspNetCoreOpenApiDocumentGeneratorSettings options)
{
options.AddOperationFilter(OperationFilter);
options.PostProcess += x => x.AddLeftoversToOthersGroup();
}
} }

69
back/src/Kyoo.Swagger/GenericResponseProvider.cs
View File

@ -24,45 +24,44 @@ using Kyoo.Utils;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ApplicationModels; using Microsoft.AspNetCore.Mvc.ApplicationModels;
namespace Kyoo.Swagger namespace Kyoo.Swagger;
/// <summary>
/// A filter that change <see cref="ProducesResponseTypeAttribute"/>'s
/// <see cref="ProducesResponseTypeAttribute.Type"/> that where set to <see cref="ActionResult{T}"/> to the
/// return type of the method.
/// </summary>
/// <remarks>
/// This is only useful when the return type of the method is a generics type and that can't be specified in the
/// attribute directly (since attributes don't support generics). This should not be used otherwise.
/// </remarks>
public class GenericResponseProvider : IApplicationModelProvider
{ {
/// <summary> /// <inheritdoc />
/// A filter that change <see cref="ProducesResponseTypeAttribute"/>'s public int Order => -1;
/// <see cref="ProducesResponseTypeAttribute.Type"/> that where set to <see cref="ActionResult{T}"/> to the
/// return type of the method. /// <inheritdoc />
/// </summary> public void OnProvidersExecuted(ApplicationModelProviderContext context) { }
/// <remarks>
/// This is only useful when the return type of the method is a generics type and that can't be specified in the /// <inheritdoc />
/// attribute directly (since attributes don't support generics). This should not be used otherwise. public void OnProvidersExecuting(ApplicationModelProviderContext context)
/// </remarks>
public class GenericResponseProvider : IApplicationModelProvider
{ {
/// <inheritdoc /> foreach (ActionModel action in context.Result.Controllers.SelectMany(x => x.Actions))
public int Order => -1;
/// <inheritdoc />
public void OnProvidersExecuted(ApplicationModelProviderContext context) { }
/// <inheritdoc />
public void OnProvidersExecuting(ApplicationModelProviderContext context)
{ {
foreach (ActionModel action in context.Result.Controllers.SelectMany(x => x.Actions)) IEnumerable<ProducesResponseTypeAttribute> responses = action
.Filters.OfType<ProducesResponseTypeAttribute>()
.Where(x => x.Type == typeof(ActionResult<>));
foreach (ProducesResponseTypeAttribute response in responses)
{ {
IEnumerable<ProducesResponseTypeAttribute> responses = action Type type = action.ActionMethod.ReturnType;
.Filters.OfType<ProducesResponseTypeAttribute>() type =
.Where(x => x.Type == typeof(ActionResult<>)); Utility.GetGenericDefinition(type, typeof(Task<>))?.GetGenericArguments()[0]
foreach (ProducesResponseTypeAttribute response in responses) ?? type;
{ type =
Type type = action.ActionMethod.ReturnType; Utility
type = .GetGenericDefinition(type, typeof(ActionResult<>))
Utility.GetGenericDefinition(type, typeof(Task<>))?.GetGenericArguments()[0] ?.GetGenericArguments()[0] ?? type;
?? type; response.Type = type;
type =
Utility
.GetGenericDefinition(type, typeof(ActionResult<>))
?.GetGenericArguments()[0] ?? type;
response.Type = type;
}
} }
} }
} }

29
back/src/Kyoo.Swagger/Models/TagGroups.cs
View File

@ -20,23 +20,22 @@ using System.Collections.Generic;
using Newtonsoft.Json; using Newtonsoft.Json;
using NSwag; using NSwag;
namespace Kyoo.Swagger.Models namespace Kyoo.Swagger.Models;
/// <summary>
/// A class representing a group of tags in the <see cref="OpenApiDocument"/>
/// </summary>
public class TagGroups
{ {
/// <summary> /// <summary>
/// A class representing a group of tags in the <see cref="OpenApiDocument"/> /// The name of the tag group.
/// </summary> /// </summary>
public class TagGroups [JsonProperty(PropertyName = "name")]
{ public string Name { get; set; }
/// <summary>
/// The name of the tag group.
/// </summary>
[JsonProperty(PropertyName = "name")]
public string Name { get; set; }
/// <summary> /// <summary>
/// The list of tags in this group. /// The list of tags in this group.
/// </summary> /// </summary>
[JsonProperty(PropertyName = "tags")] [JsonProperty(PropertyName = "tags")]
public List<string> Tags { get; set; } public List<string> Tags { get; set; }
}
} }

124
back/src/Kyoo.Swagger/OperationPermissionProcessor.cs
View File

@ -25,80 +25,78 @@ using NSwag;
using NSwag.Generation.Processors; using NSwag.Generation.Processors;
using NSwag.Generation.Processors.Contexts; using NSwag.Generation.Processors.Contexts;
namespace Kyoo.Swagger namespace Kyoo.Swagger;
{
/// <summary>
/// An operation processor that adds permissions information from the <see cref="PermissionAttribute"/> and the
/// <see cref="PartialPermissionAttribute"/>.
/// </summary>
public class OperationPermissionProcessor : IOperationProcessor
{
/// <inheritdoc />
public bool Process(OperationProcessorContext context)
{
context.OperationDescription.Operation.Security ??=
new List<OpenApiSecurityRequirement>();
OpenApiSecurityRequirement perms = context
.MethodInfo.GetCustomAttributes<UserOnlyAttribute>()
.Aggregate(
new OpenApiSecurityRequirement(),
(agg, _) =>
{
agg[nameof(Kyoo)] = Array.Empty<string>();
return agg;
}
);
/// <summary>
/// An operation processor that adds permissions information from the <see cref="PermissionAttribute"/> and the
/// <see cref="PartialPermissionAttribute"/>.
/// </summary>
public class OperationPermissionProcessor : IOperationProcessor
{
/// <inheritdoc />
public bool Process(OperationProcessorContext context)
{
context.OperationDescription.Operation.Security ??= new List<OpenApiSecurityRequirement>();
OpenApiSecurityRequirement perms = context
.MethodInfo.GetCustomAttributes<UserOnlyAttribute>()
.Aggregate(
new OpenApiSecurityRequirement(),
(agg, _) =>
{
agg[nameof(Kyoo)] = Array.Empty<string>();
return agg;
}
);
perms = context
.MethodInfo.GetCustomAttributes<PermissionAttribute>()
.Aggregate(
perms,
(agg, cur) =>
{
ICollection<string> permissions = _GetPermissionsList(agg, cur.Group);
permissions.Add($"{cur.Type}.{cur.Kind.ToString().ToLower()}");
agg[nameof(Kyoo)] = permissions;
return agg;
}
);
PartialPermissionAttribute controller =
context.ControllerType.GetCustomAttribute<PartialPermissionAttribute>();
if (controller != null)
{
perms = context perms = context
.MethodInfo.GetCustomAttributes<PermissionAttribute>() .MethodInfo.GetCustomAttributes<PartialPermissionAttribute>()
.Aggregate( .Aggregate(
perms, perms,
(agg, cur) => (agg, cur) =>
{ {
ICollection<string> permissions = _GetPermissionsList(agg, cur.Group); Group? group =
permissions.Add($"{cur.Type}.{cur.Kind.ToString().ToLower()}"); controller.Group != Group.Overall ? controller.Group : cur.Group;
string type = controller.Type ?? cur.Type;
Kind? kind = controller.Type == null ? controller.Kind : cur.Kind;
ICollection<string> permissions = _GetPermissionsList(
agg,
group ?? Group.Overall
);
permissions.Add($"{type}.{kind!.Value.ToString().ToLower()}");
agg[nameof(Kyoo)] = permissions; agg[nameof(Kyoo)] = permissions;
return agg; return agg;
} }
); );
PartialPermissionAttribute controller =
context.ControllerType.GetCustomAttribute<PartialPermissionAttribute>();
if (controller != null)
{
perms = context
.MethodInfo.GetCustomAttributes<PartialPermissionAttribute>()
.Aggregate(
perms,
(agg, cur) =>
{
Group? group =
controller.Group != Group.Overall ? controller.Group : cur.Group;
string type = controller.Type ?? cur.Type;
Kind? kind = controller.Type == null ? controller.Kind : cur.Kind;
ICollection<string> permissions = _GetPermissionsList(
agg,
group ?? Group.Overall
);
permissions.Add($"{type}.{kind!.Value.ToString().ToLower()}");
agg[nameof(Kyoo)] = permissions;
return agg;
}
);
}
context.OperationDescription.Operation.Security.Add(perms);
return true;
} }
private static ICollection<string> _GetPermissionsList( context.OperationDescription.Operation.Security.Add(perms);
OpenApiSecurityRequirement security, return true;
Group group }
)
{ private static ICollection<string> _GetPermissionsList(
return security.TryGetValue(group.ToString(), out IEnumerable<string> perms) OpenApiSecurityRequirement security,
? perms.ToList() Group group
: new List<string>(); )
} {
return security.TryGetValue(group.ToString(), out IEnumerable<string> perms)
? perms.ToList()
: new List<string>();
} }
} }

177
back/src/Kyoo.Swagger/SwaggerModule.cs
View File

@ -29,103 +29,102 @@ using NSwag;
using NSwag.Generation.AspNetCore; using NSwag.Generation.AspNetCore;
using static Kyoo.Abstractions.Models.Utils.Constants; using static Kyoo.Abstractions.Models.Utils.Constants;
namespace Kyoo.Swagger namespace Kyoo.Swagger;
/// <summary>
/// A module to enable a swagger interface and an OpenAPI endpoint to document Kyoo.
/// </summary>
public class SwaggerModule : IPlugin
{ {
/// <summary> /// <inheritdoc />
/// A module to enable a swagger interface and an OpenAPI endpoint to document Kyoo. public string Name => "Swagger";
/// </summary>
public class SwaggerModule : IPlugin /// <inheritdoc />
public void Configure(IServiceCollection services)
{ {
/// <inheritdoc /> services.AddTransient<IApplicationModelProvider, GenericResponseProvider>();
public string Name => "Swagger"; services.AddOpenApiDocument(document =>
/// <inheritdoc />
public void Configure(IServiceCollection services)
{ {
services.AddTransient<IApplicationModelProvider, GenericResponseProvider>(); document.Title = "Kyoo API";
services.AddOpenApiDocument(document => // TODO use a real multi-line description in markdown.
document.Description = "The Kyoo's public API";
document.Version = Assembly.GetExecutingAssembly().GetName().Version!.ToString(3);
document.DocumentName = "v1";
document.UseControllerSummaryAsTagDescription = true;
document.GenerateExamples = true;
document.PostProcess = options =>
{ {
document.Title = "Kyoo API"; options.Info.Contact = new OpenApiContact
// TODO use a real multi-line description in markdown.
document.Description = "The Kyoo's public API";
document.Version = Assembly.GetExecutingAssembly().GetName().Version!.ToString(3);
document.DocumentName = "v1";
document.UseControllerSummaryAsTagDescription = true;
document.GenerateExamples = true;
document.PostProcess = options =>
{ {
options.Info.Contact = new OpenApiContact Name = "Kyoo's github",
{ Url = "https://github.com/zoriya/Kyoo"
Name = "Kyoo's github",
Url = "https://github.com/zoriya/Kyoo"
};
options.Info.License = new OpenApiLicense
{
Name = "GPL-3.0-or-later",
Url = "https://github.com/zoriya/Kyoo/blob/master/LICENSE"
};
options.Info.ExtensionData ??= new Dictionary<string, object>();
options.Info.ExtensionData["x-logo"] = new
{
url = "/banner.png",
backgroundColor = "#FFFFFF",
altText = "Kyoo's logo"
};
}; };
document.UseApiTags(); options.Info.License = new OpenApiLicense
document.SortApis();
document.AddOperationFilter(x =>
{ {
if (x is AspNetCoreOperationProcessorContext ctx) Name = "GPL-3.0-or-later",
return ctx.ApiDescription.ActionDescriptor.AttributeRouteInfo?.Order Url = "https://github.com/zoriya/Kyoo/blob/master/LICENSE"
!= AlternativeRoute; };
return true;
});
document.SchemaGenerator.Settings.TypeMappers.Add(
new PrimitiveTypeMapper(
typeof(Identifier),
x =>
{
x.IsNullableRaw = false;
x.Type = JsonObjectType.String | JsonObjectType.Integer;
}
)
);
document.AddSecurity( options.Info.ExtensionData ??= new Dictionary<string, object>();
nameof(Kyoo), options.Info.ExtensionData["x-logo"] = new
new OpenApiSecurityScheme {
{ url = "/banner.png",
Type = OpenApiSecuritySchemeType.Http, backgroundColor = "#FFFFFF",
Scheme = "Bearer", altText = "Kyoo's logo"
BearerFormat = "JWT", };
Description = "The user's bearer"
}
);
document.OperationProcessors.Add(new OperationPermissionProcessor());
});
}
/// <inheritdoc />
public IEnumerable<IStartupAction> ConfigureSteps =>
new IStartupAction[]
{
SA.New<IApplicationBuilder>(app => app.UseOpenApi(), SA.Before + 1),
SA.New<IApplicationBuilder>(
app =>
app.UseReDoc(x =>
{
x.Path = "/doc";
x.TransformToExternalPath = (internalUiRoute, _) =>
"/api" + internalUiRoute;
x.AdditionalSettings["theme"] = new
{
colors = new { primary = new { main = "#e13e13" } }
};
}),
SA.Before
)
}; };
document.UseApiTags();
document.SortApis();
document.AddOperationFilter(x =>
{
if (x is AspNetCoreOperationProcessorContext ctx)
return ctx.ApiDescription.ActionDescriptor.AttributeRouteInfo?.Order
!= AlternativeRoute;
return true;
});
document.SchemaGenerator.Settings.TypeMappers.Add(
new PrimitiveTypeMapper(
typeof(Identifier),
x =>
{
x.IsNullableRaw = false;
x.Type = JsonObjectType.String | JsonObjectType.Integer;
}
)
);
document.AddSecurity(
nameof(Kyoo),
new OpenApiSecurityScheme
{
Type = OpenApiSecuritySchemeType.Http,
Scheme = "Bearer",
BearerFormat = "JWT",
Description = "The user's bearer"
}
);
document.OperationProcessors.Add(new OperationPermissionProcessor());
});
} }
/// <inheritdoc />
public IEnumerable<IStartupAction> ConfigureSteps =>
new IStartupAction[]
{
SA.New<IApplicationBuilder>(app => app.UseOpenApi(), SA.Before + 1),
SA.New<IApplicationBuilder>(
app =>
app.UseReDoc(x =>
{
x.Path = "/doc";
x.TransformToExternalPath = (internalUiRoute, _) =>
"/api" + internalUiRoute;
x.AdditionalSettings["theme"] = new
{
colors = new { primary = new { main = "#e13e13" } }
};
}),
SA.Before
)
};
} }