mirror of
https://github.com/MrSleeps/jellyfin-scene-search.git
synced 2026-11-20 00:33:36 +00:00
275 lines
10 KiB
C#
275 lines
10 KiB
C#
using Jellyfin.Data.Enums;
|
|
using Jellyfin.Plugin.SceneSearch.Configuration;
|
|
using MediaBrowser.Common.Api;
|
|
using MediaBrowser.Controller.Library;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
|
|
namespace Jellyfin.Plugin.SceneSearch.Api;
|
|
|
|
[ApiController]
|
|
[Authorize(Policy = Policies.RequiresElevation)]
|
|
[Route("Plugins/SceneSearch")]
|
|
[Produces("application/json")]
|
|
public sealed class SceneSearchController : ControllerBase
|
|
{
|
|
private readonly SceneSearchClient _client;
|
|
private readonly ISearchManager _searchManager;
|
|
private readonly ILibraryManager _libraryManager;
|
|
|
|
public SceneSearchController(
|
|
SceneSearchClient client,
|
|
ISearchManager searchManager,
|
|
ILibraryManager libraryManager)
|
|
{
|
|
_client = client;
|
|
_searchManager = searchManager;
|
|
_libraryManager = libraryManager;
|
|
}
|
|
|
|
|
|
[HttpGet("SearchDiagnostics")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
public async Task<ActionResult<SceneSearchDiagnosticsResponse>> SearchDiagnostics(
|
|
[FromQuery] string query)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(query))
|
|
{
|
|
return BadRequest("Enter a search query.");
|
|
}
|
|
|
|
var config = Plugin.Instance?.Configuration ?? new PluginConfiguration();
|
|
var trimmedQuery = query.Trim();
|
|
var backendQuery = StripPrefix(trimmedQuery, config);
|
|
if (string.IsNullOrWhiteSpace(backendQuery))
|
|
{
|
|
return BadRequest("The search prefix must be followed by a query.");
|
|
}
|
|
|
|
var providerQuery = new SearchProviderQuery
|
|
{
|
|
SearchTerm = trimmedQuery,
|
|
IncludeItemTypes =
|
|
[
|
|
BaseItemKind.Movie,
|
|
BaseItemKind.Series,
|
|
BaseItemKind.Episode,
|
|
BaseItemKind.Video
|
|
],
|
|
Limit = Math.Clamp(config.MaxResults, 1, 50)
|
|
};
|
|
|
|
var providers = _searchManager.GetProviders();
|
|
var registeredProviders = providers.Select(provider => new SceneSearchDiagnosticProvider
|
|
{
|
|
Name = provider.Name,
|
|
Kind = provider is IExternalSearchProvider
|
|
? "external"
|
|
: provider is IInternalSearchProvider
|
|
? "internal"
|
|
: "unknown",
|
|
Priority = provider.Priority
|
|
}).ToList();
|
|
|
|
var apiResults = await _client.SearchAsync(
|
|
backendQuery,
|
|
Math.Clamp(config.MaxResults, 1, 50),
|
|
HttpContext.RequestAborted).ConfigureAwait(false);
|
|
|
|
var apiIds = new HashSet<Guid>();
|
|
var diagnosticApiResults = new List<SceneSearchDiagnosticApiResult>();
|
|
foreach (var result in apiResults)
|
|
{
|
|
if (Guid.TryParse(result.JellyfinItemId, out var apiId) && apiId != Guid.Empty)
|
|
{
|
|
apiIds.Add(apiId);
|
|
}
|
|
|
|
diagnosticApiResults.Add(new SceneSearchDiagnosticApiResult
|
|
{
|
|
ItemId = result.JellyfinItemId ?? string.Empty,
|
|
Title = result.Title,
|
|
ItemType = result.JellyfinItemType,
|
|
Score = result.RankingScore ?? result.SiglipScore
|
|
});
|
|
}
|
|
|
|
var coreResults = await _searchManager.GetSearchResultsAsync(
|
|
providerQuery,
|
|
HttpContext.RequestAborted).ConfigureAwait(false);
|
|
|
|
var diagnosticCoreResults = new List<SceneSearchDiagnosticCoreResult>();
|
|
var resolvedCoreResults = 0;
|
|
var apiCoreOverlap = 0;
|
|
foreach (var result in coreResults)
|
|
{
|
|
var item = _libraryManager.GetItemById(result.ItemId);
|
|
var resolved = item is not null;
|
|
if (resolved)
|
|
{
|
|
resolvedCoreResults++;
|
|
}
|
|
|
|
var returnedByApi = apiIds.Contains(result.ItemId);
|
|
if (returnedByApi)
|
|
{
|
|
apiCoreOverlap++;
|
|
}
|
|
|
|
diagnosticCoreResults.Add(new SceneSearchDiagnosticCoreResult
|
|
{
|
|
ItemId = result.ItemId.ToString("N"),
|
|
Score = result.Score,
|
|
Resolved = resolved,
|
|
Title = item?.Name,
|
|
ItemType = item?.GetType().Name,
|
|
ReturnedByApi = returnedByApi
|
|
});
|
|
}
|
|
|
|
return Ok(new SceneSearchDiagnosticsResponse
|
|
{
|
|
Query = trimmedQuery,
|
|
BackendQuery = backendQuery,
|
|
ApiConfigured = _client.IsConfigured,
|
|
ProviderRegistered = providers.Any(provider => provider is SceneSearchProvider),
|
|
RegisteredProviders = registeredProviders,
|
|
ApiResultCount = apiResults.Count,
|
|
ApiResults = diagnosticApiResults,
|
|
CoreResultCount = coreResults.Count,
|
|
CoreResults = diagnosticCoreResults,
|
|
ResolvedCoreResults = resolvedCoreResults,
|
|
ApiCoreOverlap = apiCoreOverlap
|
|
});
|
|
}
|
|
|
|
private static string StripPrefix(string term, PluginConfiguration config)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(config.SearchPrefix))
|
|
{
|
|
return term;
|
|
}
|
|
|
|
return term.StartsWith(config.SearchPrefix, StringComparison.OrdinalIgnoreCase)
|
|
? term[config.SearchPrefix.Length..].Trim()
|
|
: term;
|
|
}
|
|
|
|
[HttpGet("Libraries")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
public async Task<ActionResult<SceneSearchLibraryListResponse>> Libraries()
|
|
{
|
|
var result = await _client.GetLibrariesAsync(HttpContext.RequestAborted).ConfigureAwait(false);
|
|
return result is null
|
|
? StatusCode(StatusCodes.Status503ServiceUnavailable, "Scene Search API unavailable.")
|
|
: Ok(result);
|
|
}
|
|
|
|
[HttpPost("LibrarySelection")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
public async Task<ActionResult<Dictionary<string, object>>> LibrarySelection([FromBody] SceneSearchIndexRequest request)
|
|
{
|
|
var result = await _client.ApplyLibrarySelectionAsync(request, HttpContext.RequestAborted).ConfigureAwait(false);
|
|
return result is null
|
|
? StatusCode(StatusCodes.Status503ServiceUnavailable, "Scene Search API unavailable.")
|
|
: Ok(result);
|
|
}
|
|
|
|
[HttpPost("Index")]
|
|
[ProducesResponseType(StatusCodes.Status202Accepted)]
|
|
public async Task<ActionResult<SceneSearchIndexStatus>> Index([FromBody] SceneSearchIndexRequest request)
|
|
{
|
|
var result = await _client.StartIndexAsync(request, HttpContext.RequestAborted).ConfigureAwait(false);
|
|
return result is null
|
|
? StatusCode(StatusCodes.Status503ServiceUnavailable, "Scene Search API unavailable.")
|
|
: Accepted(result);
|
|
}
|
|
|
|
[HttpGet("IndexStatus")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
public async Task<ActionResult<SceneSearchIndexStatus>> IndexStatus()
|
|
{
|
|
var result = await _client.GetIndexStatusAsync(HttpContext.RequestAborted).ConfigureAwait(false);
|
|
return result is null
|
|
? StatusCode(StatusCodes.Status503ServiceUnavailable, "Scene Search API unavailable.")
|
|
: Ok(result);
|
|
}
|
|
|
|
[HttpGet("IndexReport")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
public async Task<ActionResult<SceneSearchIndexReportResponse>> IndexReport(
|
|
[FromQuery] string? category = null,
|
|
[FromQuery] int offset = 0,
|
|
[FromQuery] int limit = 200)
|
|
{
|
|
var result = await _client.GetIndexReportAsync(
|
|
category,
|
|
offset,
|
|
limit,
|
|
HttpContext.RequestAborted).ConfigureAwait(false);
|
|
|
|
return result is null
|
|
? StatusCode(StatusCodes.Status503ServiceUnavailable, "Scene Search API unavailable.")
|
|
: Ok(result);
|
|
}
|
|
|
|
|
|
[HttpPost("Caption")]
|
|
[ProducesResponseType(StatusCodes.Status202Accepted)]
|
|
public async Task<ActionResult<SceneSearchCaptionStatus>> Caption([FromBody] SceneSearchCaptionRequest request)
|
|
{
|
|
if (request.LibraryIds.Count == 0)
|
|
{
|
|
return BadRequest("Select at least one library.");
|
|
}
|
|
|
|
var result = await _client.StartCaptionAsync(request, HttpContext.RequestAborted).ConfigureAwait(false);
|
|
return result is null
|
|
? StatusCode(StatusCodes.Status503ServiceUnavailable, "Scene Search API unavailable.")
|
|
: Accepted(result);
|
|
}
|
|
|
|
[HttpGet("CaptionStatus")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
public async Task<ActionResult<SceneSearchCaptionStatus>> CaptionStatus()
|
|
{
|
|
var result = await _client.GetCaptionStatusAsync(HttpContext.RequestAborted).ConfigureAwait(false);
|
|
return result is null
|
|
? StatusCode(StatusCodes.Status503ServiceUnavailable, "Scene Search API unavailable.")
|
|
: Ok(result);
|
|
}
|
|
|
|
|
|
[HttpPost("CaptionPause")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
public async Task<ActionResult<SceneSearchCaptionStatus>> CaptionPause()
|
|
{
|
|
var result = await _client.PauseCaptionAsync(HttpContext.RequestAborted).ConfigureAwait(false);
|
|
return result is null
|
|
? StatusCode(StatusCodes.Status503ServiceUnavailable, "Scene Search API unavailable.")
|
|
: Ok(result);
|
|
}
|
|
|
|
[HttpPost("CaptionResume")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
public async Task<ActionResult<SceneSearchCaptionStatus>> CaptionResume()
|
|
{
|
|
var result = await _client.ResumeCaptionAsync(HttpContext.RequestAborted).ConfigureAwait(false);
|
|
return result is null
|
|
? StatusCode(StatusCodes.Status503ServiceUnavailable, "Scene Search API unavailable.")
|
|
: Ok(result);
|
|
}
|
|
|
|
|
|
[HttpPost("CaptionStop")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
public async Task<ActionResult<SceneSearchCaptionStatus>> CaptionStop()
|
|
{
|
|
var result = await _client.StopCaptionAsync(HttpContext.RequestAborted).ConfigureAwait(false);
|
|
return result is null
|
|
? StatusCode(StatusCodes.Status503ServiceUnavailable, "Scene Search API unavailable.")
|
|
: Ok(result);
|
|
}
|
|
}
|