mirror of
https://github.com/SoPat712/allstarr.git
synced 2026-02-09 23:55:10 -05:00
Josh Patra
5acdacf132
When LRClib returns plain/unsynced lyrics, they contain newlines but were being sent as a single text block. Jellyfin clients would display them all on one line. Now splits plain lyrics by newlines and sends each line separately, so they display properly line-by-line in the client. LRClib search URL format: https://lrclib.net/api/get\?track_name\=\{track\}\&artist_name\=\{artist\}\&album_name\=\{album\}\&duration\=\{seconds\}
2672 lines
106 KiB
C#
2672 lines
106 KiB
C#
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.Extensions.Options;
|
|
using System.Text.Json;
|
|
using allstarr.Models.Domain;
|
|
using allstarr.Models.Settings;
|
|
using allstarr.Models.Subsonic;
|
|
using allstarr.Services;
|
|
using allstarr.Services.Common;
|
|
using allstarr.Services.Local;
|
|
using allstarr.Services.Jellyfin;
|
|
using allstarr.Services.Subsonic;
|
|
using allstarr.Services.Lyrics;
|
|
using allstarr.Filters;
|
|
|
|
namespace allstarr.Controllers;
|
|
|
|
/// <summary>
|
|
/// Jellyfin-compatible API controller. Merges local library with external providers
|
|
/// (Deezer, Qobuz, SquidWTF). Auth goes through Jellyfin.
|
|
/// </summary>
|
|
[ApiController]
|
|
[Route("")]
|
|
public class JellyfinController : ControllerBase
|
|
{
|
|
private readonly JellyfinSettings _settings;
|
|
private readonly SpotifyImportSettings _spotifySettings;
|
|
private readonly IMusicMetadataService _metadataService;
|
|
private readonly ILocalLibraryService _localLibraryService;
|
|
private readonly IDownloadService _downloadService;
|
|
private readonly JellyfinResponseBuilder _responseBuilder;
|
|
private readonly JellyfinModelMapper _modelMapper;
|
|
private readonly JellyfinProxyService _proxyService;
|
|
private readonly PlaylistSyncService? _playlistSyncService;
|
|
private readonly RedisCacheService _cache;
|
|
private readonly ILogger<JellyfinController> _logger;
|
|
|
|
public JellyfinController(
|
|
IOptions<JellyfinSettings> settings,
|
|
IOptions<SpotifyImportSettings> spotifySettings,
|
|
IMusicMetadataService metadataService,
|
|
ILocalLibraryService localLibraryService,
|
|
IDownloadService downloadService,
|
|
JellyfinResponseBuilder responseBuilder,
|
|
JellyfinModelMapper modelMapper,
|
|
JellyfinProxyService proxyService,
|
|
RedisCacheService cache,
|
|
ILogger<JellyfinController> logger,
|
|
PlaylistSyncService? playlistSyncService = null)
|
|
{
|
|
_settings = settings.Value;
|
|
_spotifySettings = spotifySettings.Value;
|
|
_metadataService = metadataService;
|
|
_localLibraryService = localLibraryService;
|
|
_downloadService = downloadService;
|
|
_responseBuilder = responseBuilder;
|
|
_modelMapper = modelMapper;
|
|
_proxyService = proxyService;
|
|
_playlistSyncService = playlistSyncService;
|
|
_cache = cache;
|
|
_logger = logger;
|
|
|
|
if (string.IsNullOrWhiteSpace(_settings.Url))
|
|
{
|
|
throw new InvalidOperationException("JELLYFIN_URL environment variable is not set");
|
|
}
|
|
}
|
|
|
|
#region Search
|
|
|
|
/// <summary>
|
|
/// Searches local Jellyfin library and external providers.
|
|
/// Dedupes artists, combines songs/albums. Works with /Items and /Users/{userId}/Items.
|
|
/// </summary>
|
|
[HttpGet("Items", Order = 1)]
|
|
[HttpGet("Users/{userId}/Items", Order = 1)]
|
|
public async Task<IActionResult> SearchItems(
|
|
[FromQuery] string? searchTerm,
|
|
[FromQuery] string? includeItemTypes,
|
|
[FromQuery] int limit = 20,
|
|
[FromQuery] int startIndex = 0,
|
|
[FromQuery] string? parentId = null,
|
|
[FromQuery] string? artistIds = null,
|
|
[FromQuery] string? sortBy = null,
|
|
[FromQuery] bool recursive = true,
|
|
string? userId = null)
|
|
{
|
|
_logger.LogInformation("=== SEARCHITEMS V2 CALLED === searchTerm={SearchTerm}, includeItemTypes={ItemTypes}, parentId={ParentId}, artistIds={ArtistIds}, userId={UserId}",
|
|
searchTerm, includeItemTypes, parentId, artistIds, userId);
|
|
|
|
// If filtering by artist, handle external artists
|
|
if (!string.IsNullOrWhiteSpace(artistIds))
|
|
{
|
|
var artistId = artistIds.Split(',')[0]; // Take first artist if multiple
|
|
var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(artistId);
|
|
|
|
if (isExternal)
|
|
{
|
|
_logger.LogInformation("Fetching albums for external artist: {Provider}/{ExternalId}", provider, externalId);
|
|
return await GetExternalChildItems(provider!, externalId!, includeItemTypes);
|
|
}
|
|
}
|
|
|
|
// If no search term, proxy to Jellyfin for browsing
|
|
// If Jellyfin returns empty results, we'll just return empty (not mixing browse with external)
|
|
if (string.IsNullOrWhiteSpace(searchTerm) && string.IsNullOrWhiteSpace(parentId))
|
|
{
|
|
_logger.LogDebug("No search term or parentId, proxying to Jellyfin with full query string");
|
|
|
|
// Build the full endpoint path with query string
|
|
var endpoint = userId != null ? $"Users/{userId}/Items" : "Items";
|
|
if (Request.QueryString.HasValue)
|
|
{
|
|
endpoint = $"{endpoint}{Request.QueryString.Value}";
|
|
}
|
|
|
|
var browseResult = await _proxyService.GetJsonAsync(endpoint, null, Request.Headers);
|
|
|
|
if (browseResult == null)
|
|
{
|
|
_logger.LogInformation("Jellyfin returned null - likely 401 Unauthorized, returning 401 to client");
|
|
return Unauthorized(new { error = "Authentication required" });
|
|
}
|
|
|
|
// Update Spotify playlist counts if enabled and response contains playlists
|
|
if (_spotifySettings.Enabled && browseResult.RootElement.TryGetProperty("Items", out var _))
|
|
{
|
|
_logger.LogInformation("Browse result has Items, checking for Spotify playlists to update counts");
|
|
browseResult = await UpdateSpotifyPlaylistCounts(browseResult);
|
|
}
|
|
|
|
var result = JsonSerializer.Deserialize<object>(browseResult.RootElement.GetRawText());
|
|
if (_logger.IsEnabled(LogLevel.Debug))
|
|
{
|
|
var rawText = browseResult.RootElement.GetRawText();
|
|
var preview = rawText.Length > 200 ? rawText[..200] : rawText;
|
|
_logger.LogDebug("Jellyfin browse result preview: {Result}", preview);
|
|
}
|
|
return new JsonResult(result);
|
|
}
|
|
|
|
// If browsing a specific parent (album, artist, playlist)
|
|
if (!string.IsNullOrWhiteSpace(parentId))
|
|
{
|
|
// Check if this is the music library root - if so, treat as a search
|
|
var isMusicLibrary = parentId == _settings.LibraryId;
|
|
|
|
if (!isMusicLibrary || string.IsNullOrWhiteSpace(searchTerm))
|
|
{
|
|
_logger.LogDebug("Browsing parent: {ParentId}", parentId);
|
|
return await GetChildItems(parentId, includeItemTypes, limit, startIndex, sortBy);
|
|
}
|
|
|
|
// If searching within music library root, continue to integrated search below
|
|
_logger.LogInformation("Searching within music library {ParentId}, including external sources", parentId);
|
|
}
|
|
|
|
var cleanQuery = searchTerm?.Trim().Trim('"') ?? "";
|
|
_logger.LogInformation("Performing integrated search for: {Query}", cleanQuery);
|
|
|
|
// Run local and external searches in parallel
|
|
var itemTypes = ParseItemTypes(includeItemTypes);
|
|
var jellyfinTask = _proxyService.SearchAsync(cleanQuery, itemTypes, limit, recursive, Request.Headers);
|
|
var externalTask = _metadataService.SearchAllAsync(cleanQuery, limit, limit, limit);
|
|
|
|
var playlistTask = _settings.EnableExternalPlaylists
|
|
? _metadataService.SearchPlaylistsAsync(cleanQuery, limit)
|
|
: Task.FromResult(new List<ExternalPlaylist>());
|
|
|
|
await Task.WhenAll(jellyfinTask, externalTask, playlistTask);
|
|
|
|
var jellyfinResult = await jellyfinTask;
|
|
var externalResult = await externalTask;
|
|
var playlistResult = await playlistTask;
|
|
|
|
_logger.LogInformation("Search results: Jellyfin={JellyfinCount}, External Songs={ExtSongs}, Albums={ExtAlbums}, Artists={ExtArtists}, Playlists={Playlists}",
|
|
jellyfinResult != null ? "found" : "null",
|
|
externalResult.Songs.Count,
|
|
externalResult.Albums.Count,
|
|
externalResult.Artists.Count,
|
|
playlistResult.Count);
|
|
|
|
// Parse Jellyfin results into domain models
|
|
var (localSongs, localAlbums, localArtists) = _modelMapper.ParseItemsResponse(jellyfinResult);
|
|
|
|
// Score and filter Jellyfin results by relevance
|
|
var scoredLocalSongs = ScoreSearchResults(cleanQuery, localSongs, s => s.Title, s => s.Artist, s => s.Album, isExternal: false);
|
|
var scoredLocalAlbums = ScoreSearchResults(cleanQuery, localAlbums, a => a.Title, a => a.Artist, _ => null, isExternal: false);
|
|
var scoredLocalArtists = ScoreSearchResults(cleanQuery, localArtists, a => a.Name, _ => null, _ => null, isExternal: false);
|
|
|
|
// Score external results with a small boost
|
|
var scoredExternalSongs = ScoreSearchResults(cleanQuery, externalResult.Songs, s => s.Title, s => s.Artist, s => s.Album, isExternal: true);
|
|
var scoredExternalAlbums = ScoreSearchResults(cleanQuery, externalResult.Albums, a => a.Title, a => a.Artist, _ => null, isExternal: true);
|
|
var scoredExternalArtists = ScoreSearchResults(cleanQuery, externalResult.Artists, a => a.Name, _ => null, _ => null, isExternal: true);
|
|
|
|
// Merge and sort by score (no filtering - just reorder by relevance)
|
|
var allSongs = scoredLocalSongs.Concat(scoredExternalSongs)
|
|
.OrderByDescending(x => x.Score)
|
|
.Select(x => x.Item)
|
|
.ToList();
|
|
|
|
var allAlbums = scoredLocalAlbums.Concat(scoredExternalAlbums)
|
|
.OrderByDescending(x => x.Score)
|
|
.Select(x => x.Item)
|
|
.ToList();
|
|
|
|
// Dedupe artists by name, keeping highest scored version
|
|
var artistScores = scoredLocalArtists.Concat(scoredExternalArtists)
|
|
.GroupBy(x => x.Item.Name, StringComparer.OrdinalIgnoreCase)
|
|
.Select(g => g.OrderByDescending(x => x.Score).First())
|
|
.OrderByDescending(x => x.Score)
|
|
.Select(x => x.Item)
|
|
.ToList();
|
|
|
|
// Convert to Jellyfin format
|
|
var mergedSongs = allSongs.Select(s => _responseBuilder.ConvertSongToJellyfinItem(s)).ToList();
|
|
var mergedAlbums = allAlbums.Select(a => _responseBuilder.ConvertAlbumToJellyfinItem(a)).ToList();
|
|
var mergedArtists = artistScores.Select(a => _responseBuilder.ConvertArtistToJellyfinItem(a)).ToList();
|
|
|
|
// Add playlists (score them too)
|
|
if (playlistResult.Count > 0)
|
|
{
|
|
var scoredPlaylists = playlistResult
|
|
.Select(p => new { Playlist = p, Score = FuzzyMatcher.CalculateSimilarity(cleanQuery, p.Name) })
|
|
.OrderByDescending(x => x.Score)
|
|
.Select(x => _responseBuilder.ConvertPlaylistToJellyfinItem(x.Playlist))
|
|
.ToList();
|
|
|
|
mergedAlbums.AddRange(scoredPlaylists);
|
|
}
|
|
|
|
_logger.LogInformation("Scored and filtered results: Songs={Songs}, Albums={Albums}, Artists={Artists}",
|
|
mergedSongs.Count, mergedAlbums.Count, mergedArtists.Count);
|
|
|
|
// Filter by item types if specified
|
|
var items = new List<Dictionary<string, object?>>();
|
|
|
|
_logger.LogInformation("Filtering by item types: {ItemTypes}", itemTypes == null ? "null" : string.Join(",", itemTypes));
|
|
|
|
if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("MusicArtist"))
|
|
{
|
|
_logger.LogInformation("Adding {Count} artists to results", mergedArtists.Count);
|
|
items.AddRange(mergedArtists);
|
|
}
|
|
if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("MusicAlbum") || itemTypes.Contains("Playlist"))
|
|
{
|
|
_logger.LogInformation("Adding {Count} albums to results", mergedAlbums.Count);
|
|
items.AddRange(mergedAlbums);
|
|
}
|
|
if (itemTypes == null || itemTypes.Length == 0 || itemTypes.Contains("Audio"))
|
|
{
|
|
_logger.LogInformation("Adding {Count} songs to results", mergedSongs.Count);
|
|
items.AddRange(mergedSongs);
|
|
}
|
|
|
|
// Apply pagination
|
|
var pagedItems = items.Skip(startIndex).Take(limit).ToList();
|
|
|
|
_logger.LogInformation("Returning {Count} items (total: {Total})", pagedItems.Count, items.Count);
|
|
|
|
try
|
|
{
|
|
// Return with PascalCase - use ContentResult to bypass JSON serialization issues
|
|
var response = new
|
|
{
|
|
Items = pagedItems,
|
|
TotalRecordCount = items.Count,
|
|
StartIndex = startIndex
|
|
};
|
|
|
|
_logger.LogInformation("About to serialize response...");
|
|
|
|
var json = System.Text.Json.JsonSerializer.Serialize(response, new System.Text.Json.JsonSerializerOptions
|
|
{
|
|
PropertyNamingPolicy = null,
|
|
DictionaryKeyPolicy = null
|
|
});
|
|
|
|
if (_logger.IsEnabled(LogLevel.Debug))
|
|
{
|
|
var preview = json.Length > 200 ? json[..200] : json;
|
|
_logger.LogDebug("JSON response preview: {Json}", preview);
|
|
}
|
|
|
|
return Content(json, "application/json");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error serializing search response");
|
|
throw;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets child items of a parent (tracks in album, albums for artist).
|
|
/// </summary>
|
|
private async Task<IActionResult> GetChildItems(
|
|
string parentId,
|
|
string? includeItemTypes,
|
|
int limit,
|
|
int startIndex,
|
|
string? sortBy)
|
|
{
|
|
// Check if this is an external playlist
|
|
if (PlaylistIdHelper.IsExternalPlaylist(parentId))
|
|
{
|
|
return await GetPlaylistTracks(parentId);
|
|
}
|
|
|
|
var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(parentId);
|
|
|
|
if (isExternal)
|
|
{
|
|
// Get external album or artist content
|
|
return await GetExternalChildItems(provider!, externalId!, includeItemTypes);
|
|
}
|
|
|
|
// Proxy to Jellyfin for local content
|
|
var result = await _proxyService.GetItemsAsync(
|
|
parentId: parentId,
|
|
includeItemTypes: ParseItemTypes(includeItemTypes),
|
|
sortBy: sortBy,
|
|
limit: limit,
|
|
startIndex: startIndex,
|
|
clientHeaders: Request.Headers);
|
|
|
|
if (result == null)
|
|
{
|
|
return _responseBuilder.CreateError(404, "Parent not found");
|
|
}
|
|
|
|
return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Quick search endpoint. Works with /Search/Hints and /Users/{userId}/Search/Hints.
|
|
/// </summary>
|
|
[HttpGet("Search/Hints", Order = 1)]
|
|
[HttpGet("Users/{userId}/Search/Hints", Order = 1)]
|
|
public async Task<IActionResult> SearchHints(
|
|
[FromQuery] string searchTerm,
|
|
[FromQuery] int limit = 20,
|
|
[FromQuery] string? includeItemTypes = null,
|
|
string? userId = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(searchTerm))
|
|
{
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
SearchHints = Array.Empty<object>(),
|
|
TotalRecordCount = 0
|
|
});
|
|
}
|
|
|
|
var cleanQuery = searchTerm.Trim().Trim('"');
|
|
var itemTypes = ParseItemTypes(includeItemTypes);
|
|
|
|
// Run searches in parallel
|
|
var jellyfinTask = _proxyService.SearchAsync(cleanQuery, itemTypes, limit, true, Request.Headers);
|
|
var externalTask = _metadataService.SearchAllAsync(cleanQuery, limit, limit, limit);
|
|
|
|
await Task.WhenAll(jellyfinTask, externalTask);
|
|
|
|
var jellyfinResult = await jellyfinTask;
|
|
var externalResult = await externalTask;
|
|
|
|
var (localSongs, localAlbums, localArtists) = _modelMapper.ParseItemsResponse(jellyfinResult);
|
|
|
|
// Merge and convert to search hints format
|
|
var allSongs = localSongs.Concat(externalResult.Songs).Take(limit).ToList();
|
|
var allAlbums = localAlbums.Concat(externalResult.Albums).Take(limit).ToList();
|
|
|
|
// Dedupe artists by name
|
|
var artistNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
var allArtists = new List<Artist>();
|
|
foreach (var artist in localArtists.Concat(externalResult.Artists))
|
|
{
|
|
if (artistNames.Add(artist.Name))
|
|
{
|
|
allArtists.Add(artist);
|
|
}
|
|
}
|
|
|
|
return _responseBuilder.CreateSearchHintsResponse(
|
|
allSongs.Take(limit).ToList(),
|
|
allAlbums.Take(limit).ToList(),
|
|
allArtists.Take(limit).ToList());
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Items
|
|
|
|
/// <summary>
|
|
/// Gets a single item by ID.
|
|
/// </summary>
|
|
[HttpGet("Items/{itemId}")]
|
|
[HttpGet("Users/{userId}/Items/{itemId}")]
|
|
public async Task<IActionResult> GetItem(string itemId, string? userId = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(itemId))
|
|
{
|
|
return _responseBuilder.CreateError(400, "Missing item ID");
|
|
}
|
|
|
|
// Check for external playlist
|
|
if (PlaylistIdHelper.IsExternalPlaylist(itemId))
|
|
{
|
|
return await GetPlaylistAsAlbum(itemId);
|
|
}
|
|
|
|
var (isExternal, provider, type, externalId) = _localLibraryService.ParseExternalId(itemId);
|
|
|
|
if (isExternal)
|
|
{
|
|
return await GetExternalItem(provider!, type, externalId!);
|
|
}
|
|
|
|
// Proxy to Jellyfin
|
|
var result = await _proxyService.GetItemAsync(itemId, Request.Headers);
|
|
if (result == null)
|
|
{
|
|
return _responseBuilder.CreateError(404, "Item not found");
|
|
}
|
|
|
|
return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an external item (song, album, or artist).
|
|
/// </summary>
|
|
private async Task<IActionResult> GetExternalItem(string provider, string? type, string externalId)
|
|
{
|
|
switch (type)
|
|
{
|
|
case "song":
|
|
var song = await _metadataService.GetSongAsync(provider, externalId);
|
|
if (song == null) return _responseBuilder.CreateError(404, "Song not found");
|
|
return _responseBuilder.CreateSongResponse(song);
|
|
|
|
case "album":
|
|
var album = await _metadataService.GetAlbumAsync(provider, externalId);
|
|
if (album == null) return _responseBuilder.CreateError(404, "Album not found");
|
|
return _responseBuilder.CreateAlbumResponse(album);
|
|
|
|
case "artist":
|
|
var artist = await _metadataService.GetArtistAsync(provider, externalId);
|
|
if (artist == null) return _responseBuilder.CreateError(404, "Artist not found");
|
|
var albums = await _metadataService.GetArtistAlbumsAsync(provider, externalId);
|
|
|
|
// Fill in artist info for albums
|
|
foreach (var a in albums)
|
|
{
|
|
if (string.IsNullOrEmpty(a.Artist)) a.Artist = artist.Name;
|
|
if (string.IsNullOrEmpty(a.ArtistId)) a.ArtistId = artist.Id;
|
|
}
|
|
|
|
return _responseBuilder.CreateArtistResponse(artist, albums);
|
|
|
|
default:
|
|
// Try song first, then album
|
|
var s = await _metadataService.GetSongAsync(provider, externalId);
|
|
if (s != null) return _responseBuilder.CreateSongResponse(s);
|
|
|
|
var alb = await _metadataService.GetAlbumAsync(provider, externalId);
|
|
if (alb != null) return _responseBuilder.CreateAlbumResponse(alb);
|
|
|
|
return _responseBuilder.CreateError(404, "Item not found");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets child items for an external parent (album tracks or artist albums).
|
|
/// </summary>
|
|
private async Task<IActionResult> GetExternalChildItems(string provider, string externalId, string? includeItemTypes)
|
|
{
|
|
var itemTypes = ParseItemTypes(includeItemTypes);
|
|
|
|
// Check if asking for audio (album tracks)
|
|
if (itemTypes?.Contains("Audio") == true)
|
|
{
|
|
var album = await _metadataService.GetAlbumAsync(provider, externalId);
|
|
if (album == null)
|
|
{
|
|
return _responseBuilder.CreateError(404, "Album not found");
|
|
}
|
|
|
|
return _responseBuilder.CreateItemsResponse(album.Songs);
|
|
}
|
|
|
|
// Otherwise assume it's artist albums
|
|
var albums = await _metadataService.GetArtistAlbumsAsync(provider, externalId);
|
|
var artist = await _metadataService.GetArtistAsync(provider, externalId);
|
|
|
|
// Fill artist info
|
|
if (artist != null)
|
|
{
|
|
foreach (var a in albums)
|
|
{
|
|
if (string.IsNullOrEmpty(a.Artist)) a.Artist = artist.Name;
|
|
if (string.IsNullOrEmpty(a.ArtistId)) a.ArtistId = artist.Id;
|
|
}
|
|
}
|
|
|
|
return _responseBuilder.CreateAlbumsResponse(albums);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Artists
|
|
|
|
/// <summary>
|
|
/// Gets artists from the library.
|
|
/// Supports both /Artists and /Artists/AlbumArtists routes.
|
|
/// When searchTerm is provided, integrates external search results.
|
|
/// </summary>
|
|
[HttpGet("Artists", Order = 1)]
|
|
[HttpGet("Artists/AlbumArtists", Order = 1)]
|
|
public async Task<IActionResult> GetArtists(
|
|
[FromQuery] string? searchTerm,
|
|
[FromQuery] int limit = 50,
|
|
[FromQuery] int startIndex = 0)
|
|
{
|
|
_logger.LogInformation("GetArtists called: searchTerm={SearchTerm}, limit={Limit}", searchTerm, limit);
|
|
|
|
// If there's a search term, integrate external results
|
|
if (!string.IsNullOrWhiteSpace(searchTerm))
|
|
{
|
|
var cleanQuery = searchTerm.Trim().Trim('"');
|
|
_logger.LogInformation("Searching artists for: {Query}", cleanQuery);
|
|
|
|
// Run local and external searches in parallel
|
|
var jellyfinTask = _proxyService.GetArtistsAsync(searchTerm, limit, startIndex, Request.Headers);
|
|
var externalTask = _metadataService.SearchArtistsAsync(cleanQuery, limit);
|
|
|
|
await Task.WhenAll(jellyfinTask, externalTask);
|
|
|
|
var jellyfinResult = await jellyfinTask;
|
|
var externalArtists = await externalTask;
|
|
|
|
_logger.LogInformation("Artist search results: Jellyfin={JellyfinCount}, External={ExternalCount}",
|
|
jellyfinResult != null ? "found" : "null", externalArtists.Count);
|
|
|
|
// Parse Jellyfin artists
|
|
var localArtists = new List<Artist>();
|
|
if (jellyfinResult != null && jellyfinResult.RootElement.TryGetProperty("Items", out var items))
|
|
{
|
|
foreach (var item in items.EnumerateArray())
|
|
{
|
|
localArtists.Add(_modelMapper.ParseArtist(item));
|
|
}
|
|
}
|
|
|
|
// Merge and deduplicate by name
|
|
var artistNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
var mergedArtists = new List<Artist>();
|
|
|
|
foreach (var artist in localArtists)
|
|
{
|
|
if (artistNames.Add(artist.Name))
|
|
{
|
|
mergedArtists.Add(artist);
|
|
}
|
|
}
|
|
|
|
foreach (var artist in externalArtists)
|
|
{
|
|
if (artistNames.Add(artist.Name))
|
|
{
|
|
mergedArtists.Add(artist);
|
|
}
|
|
}
|
|
|
|
_logger.LogInformation("Returning {Count} merged artists", mergedArtists.Count);
|
|
|
|
// Convert to Jellyfin format
|
|
var artistItems = mergedArtists.Select(a => _responseBuilder.ConvertArtistToJellyfinItem(a)).ToList();
|
|
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
Items = artistItems,
|
|
TotalRecordCount = artistItems.Count,
|
|
StartIndex = startIndex
|
|
});
|
|
}
|
|
|
|
// No search term - just proxy to Jellyfin
|
|
var result = await _proxyService.GetArtistsAsync(searchTerm, limit, startIndex, Request.Headers);
|
|
|
|
if (result == null)
|
|
{
|
|
return new JsonResult(new Dictionary<string, object>
|
|
{
|
|
["Items"] = Array.Empty<object>(),
|
|
["TotalRecordCount"] = 0,
|
|
["StartIndex"] = startIndex
|
|
});
|
|
}
|
|
|
|
return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a single artist by ID or name.
|
|
/// This route has lower priority to avoid conflicting with Artists/AlbumArtists.
|
|
/// </summary>
|
|
[HttpGet("Artists/{artistIdOrName}", Order = 10)]
|
|
public async Task<IActionResult> GetArtist(string artistIdOrName)
|
|
{
|
|
var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(artistIdOrName);
|
|
|
|
if (isExternal)
|
|
{
|
|
var artist = await _metadataService.GetArtistAsync(provider!, externalId!);
|
|
if (artist == null)
|
|
{
|
|
return _responseBuilder.CreateError(404, "Artist not found");
|
|
}
|
|
|
|
var albums = await _metadataService.GetArtistAlbumsAsync(provider!, externalId!);
|
|
foreach (var a in albums)
|
|
{
|
|
if (string.IsNullOrEmpty(a.Artist)) a.Artist = artist.Name;
|
|
if (string.IsNullOrEmpty(a.ArtistId)) a.ArtistId = artist.Id;
|
|
}
|
|
|
|
return _responseBuilder.CreateArtistResponse(artist, albums);
|
|
}
|
|
|
|
// Get local artist from Jellyfin
|
|
var jellyfinArtist = await _proxyService.GetArtistAsync(artistIdOrName, Request.Headers);
|
|
if (jellyfinArtist == null)
|
|
{
|
|
return _responseBuilder.CreateError(404, "Artist not found");
|
|
}
|
|
|
|
var artistData = _modelMapper.ParseArtist(jellyfinArtist.RootElement);
|
|
var artistName = artistData.Name;
|
|
var localArtistId = artistData.Id;
|
|
|
|
// Get local albums
|
|
var localAlbumsResult = await _proxyService.GetItemsAsync(
|
|
parentId: null,
|
|
includeItemTypes: new[] { "MusicAlbum" },
|
|
sortBy: "SortName",
|
|
clientHeaders: Request.Headers);
|
|
|
|
var (_, localAlbums, _) = _modelMapper.ParseItemsResponse(localAlbumsResult);
|
|
|
|
// Filter to just this artist's albums
|
|
var artistAlbums = localAlbums
|
|
.Where(a => a.ArtistId == localArtistId ||
|
|
(a.Artist?.Equals(artistName, StringComparison.OrdinalIgnoreCase) ?? false))
|
|
.ToList();
|
|
|
|
// Search for external albums by this artist
|
|
var externalArtists = await _metadataService.SearchArtistsAsync(artistName, 1);
|
|
var externalAlbums = new List<Album>();
|
|
|
|
if (externalArtists.Count > 0)
|
|
{
|
|
var extArtist = externalArtists[0];
|
|
if (extArtist.Name.Equals(artistName, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
externalAlbums = await _metadataService.GetArtistAlbumsAsync("deezer", extArtist.ExternalId!);
|
|
|
|
// Set artist info to local artist so albums link back correctly
|
|
foreach (var a in externalAlbums)
|
|
{
|
|
if (string.IsNullOrEmpty(a.Artist)) a.Artist = artistName;
|
|
if (string.IsNullOrEmpty(a.ArtistId)) a.ArtistId = localArtistId;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Deduplicate albums by title
|
|
var localAlbumTitles = new HashSet<string>(artistAlbums.Select(a => a.Title), StringComparer.OrdinalIgnoreCase);
|
|
var mergedAlbums = artistAlbums.ToList();
|
|
mergedAlbums.AddRange(externalAlbums.Where(a => !localAlbumTitles.Contains(a.Title)));
|
|
|
|
return _responseBuilder.CreateArtistResponse(artistData, mergedAlbums);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Audio Streaming
|
|
|
|
/// <summary>
|
|
/// Downloads/streams audio. Works with local and external content.
|
|
/// </summary>
|
|
[HttpGet("Items/{itemId}/Download")]
|
|
[HttpGet("Items/{itemId}/File")]
|
|
public async Task<IActionResult> DownloadAudio(string itemId)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(itemId))
|
|
{
|
|
return BadRequest(new { error = "Missing item ID" });
|
|
}
|
|
|
|
var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
|
|
|
|
if (!isExternal)
|
|
{
|
|
// Build path for Jellyfin download/file endpoint
|
|
var endpoint = Request.Path.Value?.Contains("/File", StringComparison.OrdinalIgnoreCase) == true ? "File" : "Download";
|
|
var fullPath = $"Items/{itemId}/{endpoint}";
|
|
if (Request.QueryString.HasValue)
|
|
{
|
|
fullPath = $"{fullPath}{Request.QueryString.Value}";
|
|
}
|
|
|
|
return await ProxyJellyfinStream(fullPath, itemId);
|
|
}
|
|
|
|
// Handle external content
|
|
return await StreamExternalContent(provider!, externalId!);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Streams audio for a given item. Downloads on-demand for external content.
|
|
/// </summary>
|
|
[HttpGet("Audio/{itemId}/stream")]
|
|
[HttpGet("Audio/{itemId}/stream.{container}")]
|
|
public async Task<IActionResult> StreamAudio(string itemId, string? container = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(itemId))
|
|
{
|
|
return BadRequest(new { error = "Missing item ID" });
|
|
}
|
|
|
|
var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
|
|
|
|
if (!isExternal)
|
|
{
|
|
// Build path for Jellyfin stream
|
|
var fullPath = string.IsNullOrEmpty(container)
|
|
? $"Audio/{itemId}/stream"
|
|
: $"Audio/{itemId}/stream.{container}";
|
|
|
|
if (Request.QueryString.HasValue)
|
|
{
|
|
fullPath = $"{fullPath}{Request.QueryString.Value}";
|
|
}
|
|
|
|
return await ProxyJellyfinStream(fullPath, itemId);
|
|
}
|
|
|
|
// Handle external content
|
|
return await StreamExternalContent(provider!, externalId!);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Proxies a stream from Jellyfin with proper header forwarding.
|
|
/// </summary>
|
|
private async Task<IActionResult> ProxyJellyfinStream(string path, string itemId)
|
|
{
|
|
var jellyfinUrl = $"{_settings.Url?.TrimEnd('/')}/{path}";
|
|
|
|
try
|
|
{
|
|
var request = new HttpRequestMessage(HttpMethod.Get, jellyfinUrl);
|
|
|
|
// Forward auth headers
|
|
if (Request.Headers.TryGetValue("X-Emby-Authorization", out var embyAuth))
|
|
{
|
|
request.Headers.TryAddWithoutValidation("X-Emby-Authorization", embyAuth.ToString());
|
|
}
|
|
else if (Request.Headers.TryGetValue("Authorization", out var auth))
|
|
{
|
|
request.Headers.TryAddWithoutValidation("Authorization", auth.ToString());
|
|
}
|
|
|
|
// Forward Range header for seeking
|
|
if (Request.Headers.TryGetValue("Range", out var range))
|
|
{
|
|
request.Headers.TryAddWithoutValidation("Range", range.ToString());
|
|
}
|
|
|
|
var response = await _proxyService.HttpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
|
|
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
_logger.LogError("Jellyfin stream failed: {StatusCode} for {ItemId}", response.StatusCode, itemId);
|
|
return StatusCode((int)response.StatusCode);
|
|
}
|
|
|
|
// Set response status and headers
|
|
Response.StatusCode = (int)response.StatusCode;
|
|
|
|
var contentType = response.Content.Headers.ContentType?.ToString() ?? "audio/mpeg";
|
|
|
|
// Forward caching headers for client-side caching
|
|
if (response.Headers.ETag != null)
|
|
{
|
|
Response.Headers["ETag"] = response.Headers.ETag.ToString();
|
|
}
|
|
|
|
if (response.Content.Headers.LastModified.HasValue)
|
|
{
|
|
Response.Headers["Last-Modified"] = response.Content.Headers.LastModified.Value.ToString("R");
|
|
}
|
|
|
|
if (response.Headers.CacheControl != null)
|
|
{
|
|
Response.Headers["Cache-Control"] = response.Headers.CacheControl.ToString();
|
|
}
|
|
|
|
// Forward range headers for seeking
|
|
if (response.Content.Headers.ContentRange != null)
|
|
{
|
|
Response.Headers["Content-Range"] = response.Content.Headers.ContentRange.ToString();
|
|
}
|
|
|
|
if (response.Headers.AcceptRanges != null)
|
|
{
|
|
Response.Headers["Accept-Ranges"] = string.Join(", ", response.Headers.AcceptRanges);
|
|
}
|
|
|
|
if (response.Content.Headers.ContentLength.HasValue)
|
|
{
|
|
Response.Headers["Content-Length"] = response.Content.Headers.ContentLength.Value.ToString();
|
|
}
|
|
|
|
var stream = await response.Content.ReadAsStreamAsync();
|
|
return File(stream, contentType);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to proxy stream from Jellyfin for {ItemId}", itemId);
|
|
return StatusCode(500, new { error = $"Streaming failed: {ex.Message}" });
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Streams external content, using cache if available or downloading on-demand.
|
|
/// </summary>
|
|
private async Task<IActionResult> StreamExternalContent(string provider, string externalId)
|
|
{
|
|
// Check for locally cached file
|
|
var localPath = await _localLibraryService.GetLocalPathForExternalSongAsync(provider, externalId);
|
|
|
|
if (localPath != null && System.IO.File.Exists(localPath))
|
|
{
|
|
// Update last access time for cache cleanup
|
|
try
|
|
{
|
|
System.IO.File.SetLastAccessTimeUtc(localPath, DateTime.UtcNow);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to update last access time for {Path}", localPath);
|
|
}
|
|
|
|
var stream = System.IO.File.OpenRead(localPath);
|
|
return File(stream, GetContentType(localPath), enableRangeProcessing: true);
|
|
}
|
|
|
|
// Download and stream on-demand
|
|
try
|
|
{
|
|
var downloadStream = await _downloadService.DownloadAndStreamAsync(
|
|
provider,
|
|
externalId,
|
|
HttpContext.RequestAborted);
|
|
|
|
return File(downloadStream, "audio/mpeg", enableRangeProcessing: true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to stream external song {Provider}:{ExternalId}", provider, externalId);
|
|
return StatusCode(500, new { error = $"Streaming failed: {ex.Message}" });
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Universal audio endpoint that redirects to the stream endpoint.
|
|
/// </summary>
|
|
[HttpGet("Audio/{itemId}/universal")]
|
|
public Task<IActionResult> UniversalAudio(string itemId)
|
|
{
|
|
return StreamAudio(itemId);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Images
|
|
|
|
/// <summary>
|
|
/// Gets the primary image for an item.
|
|
/// </summary>
|
|
[HttpGet("Items/{itemId}/Images/{imageType}")]
|
|
[HttpGet("Items/{itemId}/Images/{imageType}/{imageIndex}")]
|
|
public async Task<IActionResult> GetImage(
|
|
string itemId,
|
|
string imageType,
|
|
int imageIndex = 0,
|
|
[FromQuery] int? maxWidth = null,
|
|
[FromQuery] int? maxHeight = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(itemId))
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
// Check for external playlist
|
|
if (PlaylistIdHelper.IsExternalPlaylist(itemId))
|
|
{
|
|
return await GetPlaylistImage(itemId);
|
|
}
|
|
|
|
var (isExternal, provider, type, externalId) = _localLibraryService.ParseExternalId(itemId);
|
|
|
|
if (!isExternal)
|
|
{
|
|
// Redirect to Jellyfin directly for local content images
|
|
var queryString = new List<string>();
|
|
if (maxWidth.HasValue) queryString.Add($"maxWidth={maxWidth.Value}");
|
|
if (maxHeight.HasValue) queryString.Add($"maxHeight={maxHeight.Value}");
|
|
|
|
var path = $"Items/{itemId}/Images/{imageType}";
|
|
if (imageIndex > 0)
|
|
{
|
|
path = $"Items/{itemId}/Images/{imageType}/{imageIndex}";
|
|
}
|
|
|
|
if (queryString.Any())
|
|
{
|
|
path = $"{path}?{string.Join("&", queryString)}";
|
|
}
|
|
|
|
var jellyfinUrl = $"{_settings.Url?.TrimEnd('/')}/{path}";
|
|
return Redirect(jellyfinUrl);
|
|
}
|
|
|
|
// Get external cover art URL
|
|
string? coverUrl = type switch
|
|
{
|
|
"artist" => (await _metadataService.GetArtistAsync(provider!, externalId!))?.ImageUrl,
|
|
"album" => (await _metadataService.GetAlbumAsync(provider!, externalId!))?.CoverArtUrl,
|
|
"song" => (await _metadataService.GetSongAsync(provider!, externalId!))?.CoverArtUrl,
|
|
_ => null
|
|
};
|
|
|
|
if (string.IsNullOrEmpty(coverUrl))
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
// Fetch and return the image using the proxy service's HttpClient
|
|
try
|
|
{
|
|
var response = await _proxyService.HttpClient.GetAsync(coverUrl);
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
var imageBytes = await response.Content.ReadAsByteArrayAsync();
|
|
var contentType = response.Content.Headers.ContentType?.ToString() ?? "image/jpeg";
|
|
return File(imageBytes, contentType);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to fetch cover art from {Url}", coverUrl);
|
|
return NotFound();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Lyrics
|
|
|
|
/// <summary>
|
|
/// Gets lyrics for an item.
|
|
/// </summary>
|
|
[HttpGet("Audio/{itemId}/Lyrics")]
|
|
[HttpGet("Items/{itemId}/Lyrics")]
|
|
public async Task<IActionResult> GetLyrics(string itemId)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(itemId))
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
|
|
|
|
Song? song = null;
|
|
|
|
if (isExternal)
|
|
{
|
|
song = await _metadataService.GetSongAsync(provider!, externalId!);
|
|
}
|
|
else
|
|
{
|
|
// For local songs, get metadata from Jellyfin
|
|
var item = await _proxyService.GetItemAsync(itemId, Request.Headers);
|
|
if (item != null && item.RootElement.TryGetProperty("Type", out var typeEl) &&
|
|
typeEl.GetString() == "Audio")
|
|
{
|
|
song = new Song
|
|
{
|
|
Title = item.RootElement.TryGetProperty("Name", out var name) ? name.GetString() ?? "" : "",
|
|
Artist = item.RootElement.TryGetProperty("AlbumArtist", out var artist) ? artist.GetString() ?? "" : "",
|
|
Album = item.RootElement.TryGetProperty("Album", out var album) ? album.GetString() ?? "" : "",
|
|
Duration = item.RootElement.TryGetProperty("RunTimeTicks", out var ticks) ? (int)(ticks.GetInt64() / 10000000) : 0
|
|
};
|
|
}
|
|
}
|
|
|
|
if (song == null)
|
|
{
|
|
return NotFound(new { error = "Song not found" });
|
|
}
|
|
|
|
// Try to get lyrics from LRCLIB
|
|
var lyricsService = HttpContext.RequestServices.GetService<LrclibService>();
|
|
if (lyricsService == null)
|
|
{
|
|
return NotFound(new { error = "Lyrics service not available" });
|
|
}
|
|
|
|
var lyrics = await lyricsService.GetLyricsAsync(
|
|
song.Title,
|
|
song.Artist ?? "",
|
|
song.Album ?? "",
|
|
song.Duration ?? 0);
|
|
|
|
if (lyrics == null)
|
|
{
|
|
return NotFound(new { error = "Lyrics not found" });
|
|
}
|
|
|
|
// Prefer synced lyrics, fall back to plain
|
|
var lyricsText = lyrics.SyncedLyrics ?? lyrics.PlainLyrics ?? "";
|
|
var isSynced = !string.IsNullOrEmpty(lyrics.SyncedLyrics);
|
|
|
|
// Parse LRC format into individual lines for Jellyfin
|
|
var lyricLines = new List<object>();
|
|
|
|
if (isSynced && !string.IsNullOrEmpty(lyrics.SyncedLyrics))
|
|
{
|
|
// Parse LRC format: [mm:ss.xx] text
|
|
var lines = lyrics.SyncedLyrics.Split('\n', StringSplitOptions.RemoveEmptyEntries);
|
|
foreach (var line in lines)
|
|
{
|
|
var match = System.Text.RegularExpressions.Regex.Match(line, @"^\[(\d+):(\d+)\.(\d+)\]\s*(.*)$");
|
|
if (match.Success)
|
|
{
|
|
var minutes = int.Parse(match.Groups[1].Value);
|
|
var seconds = int.Parse(match.Groups[2].Value);
|
|
var centiseconds = int.Parse(match.Groups[3].Value);
|
|
var text = match.Groups[4].Value;
|
|
|
|
// Convert to ticks (100 nanoseconds)
|
|
var totalMilliseconds = (minutes * 60 + seconds) * 1000 + centiseconds * 10;
|
|
var ticks = totalMilliseconds * 10000L;
|
|
|
|
lyricLines.Add(new
|
|
{
|
|
Start = ticks,
|
|
Text = text
|
|
});
|
|
}
|
|
}
|
|
}
|
|
else if (!string.IsNullOrEmpty(lyricsText))
|
|
{
|
|
// Plain lyrics - split by newlines and return each line separately
|
|
var lines = lyricsText.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
|
|
foreach (var line in lines)
|
|
{
|
|
lyricLines.Add(new
|
|
{
|
|
Start = (long?)null,
|
|
Text = line.Trim()
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No lyrics at all
|
|
lyricLines.Add(new
|
|
{
|
|
Start = (long?)null,
|
|
Text = ""
|
|
});
|
|
}
|
|
|
|
var response = new
|
|
{
|
|
Metadata = new
|
|
{
|
|
Artist = lyrics.ArtistName,
|
|
Album = lyrics.AlbumName,
|
|
Title = lyrics.TrackName,
|
|
Length = lyrics.Duration,
|
|
IsSynced = isSynced
|
|
},
|
|
Lyrics = lyricLines
|
|
};
|
|
|
|
return Ok(response);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Favorites
|
|
|
|
/// <summary>
|
|
/// Marks an item as favorite. For playlists, triggers a full download.
|
|
/// </summary>
|
|
[HttpPost("Users/{userId}/FavoriteItems/{itemId}")]
|
|
public async Task<IActionResult> MarkFavorite(string userId, string itemId)
|
|
{
|
|
// Check if this is an external playlist - trigger download
|
|
if (PlaylistIdHelper.IsExternalPlaylist(itemId))
|
|
{
|
|
if (_playlistSyncService == null)
|
|
{
|
|
return _responseBuilder.CreateError(500, "Playlist functionality not enabled");
|
|
}
|
|
|
|
_logger.LogInformation("Favoriting external playlist {PlaylistId}, triggering download", itemId);
|
|
|
|
// Start download in background
|
|
_ = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
await _playlistSyncService.DownloadFullPlaylistAsync(itemId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to download playlist {PlaylistId}", itemId);
|
|
}
|
|
});
|
|
|
|
return Ok(new { IsFavorite = true });
|
|
}
|
|
|
|
// Check if this is an external song/album
|
|
var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
|
|
if (isExternal)
|
|
{
|
|
_logger.LogInformation("Favoriting external item {ItemId}, copying to kept folder", itemId);
|
|
|
|
// Copy the track to kept folder in background
|
|
_ = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
await CopyExternalTrackToKeptAsync(itemId, provider!, externalId!);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to copy external track {ItemId} to kept folder", itemId);
|
|
}
|
|
});
|
|
|
|
return Ok(new { IsFavorite = true });
|
|
}
|
|
|
|
// For local Jellyfin items, proxy the request through
|
|
var endpoint = $"Users/{userId}/FavoriteItems/{itemId}";
|
|
|
|
try
|
|
{
|
|
using var request = new HttpRequestMessage(HttpMethod.Post, $"{_settings.Url?.TrimEnd('/')}/{endpoint}");
|
|
|
|
// Forward client authentication
|
|
if (Request.Headers.TryGetValue("X-Emby-Authorization", out var embyAuth))
|
|
{
|
|
request.Headers.TryAddWithoutValidation("X-Emby-Authorization", embyAuth.ToString());
|
|
}
|
|
else if (Request.Headers.TryGetValue("Authorization", out var auth))
|
|
{
|
|
request.Headers.TryAddWithoutValidation("Authorization", auth.ToString());
|
|
}
|
|
|
|
var response = await _proxyService.HttpClient.SendAsync(request);
|
|
|
|
if (response.IsSuccessStatusCode)
|
|
{
|
|
return Ok(new { IsFavorite = true });
|
|
}
|
|
|
|
_logger.LogWarning("Failed to favorite item in Jellyfin: {StatusCode}", response.StatusCode);
|
|
return _responseBuilder.CreateError((int)response.StatusCode, "Failed to mark favorite");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error favoriting item {ItemId}", itemId);
|
|
return _responseBuilder.CreateError(500, "Failed to mark favorite");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes an item from favorites.
|
|
/// </summary>
|
|
[HttpDelete("Users/{userId}/FavoriteItems/{itemId}")]
|
|
public async Task<IActionResult> UnmarkFavorite(string userId, string itemId)
|
|
{
|
|
// External items can't be unfavorited
|
|
var (isExternal, _, _) = _localLibraryService.ParseSongId(itemId);
|
|
if (isExternal || PlaylistIdHelper.IsExternalPlaylist(itemId))
|
|
{
|
|
return Ok(new { IsFavorite = false });
|
|
}
|
|
|
|
// Proxy to Jellyfin to unfavorite
|
|
var url = $"Users/{userId}/FavoriteItems/{itemId}";
|
|
|
|
try
|
|
{
|
|
using var request = new HttpRequestMessage(HttpMethod.Delete, $"{_settings.Url?.TrimEnd('/')}/{url}");
|
|
|
|
// Forward client authentication
|
|
if (Request.Headers.TryGetValue("X-Emby-Authorization", out var embyAuth))
|
|
{
|
|
request.Headers.TryAddWithoutValidation("X-Emby-Authorization", embyAuth.ToString());
|
|
}
|
|
else if (Request.Headers.TryGetValue("Authorization", out var auth))
|
|
{
|
|
request.Headers.TryAddWithoutValidation("Authorization", auth.ToString());
|
|
}
|
|
|
|
var response = await _proxyService.HttpClient.SendAsync(request);
|
|
|
|
if (response.IsSuccessStatusCode)
|
|
{
|
|
return Ok(new { IsFavorite = false });
|
|
}
|
|
|
|
return _responseBuilder.CreateError(500, "Failed to unfavorite item");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error unfavoriting item {ItemId}", itemId);
|
|
return _responseBuilder.CreateError(500, "Failed to unfavorite item");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Playlists
|
|
|
|
/// <summary>
|
|
/// Gets playlist tracks displayed as an album.
|
|
/// </summary>
|
|
private async Task<IActionResult> GetPlaylistAsAlbum(string playlistId)
|
|
{
|
|
try
|
|
{
|
|
var (provider, externalId) = PlaylistIdHelper.ParsePlaylistId(playlistId);
|
|
|
|
var playlist = await _metadataService.GetPlaylistAsync(provider, externalId);
|
|
if (playlist == null)
|
|
{
|
|
return _responseBuilder.CreateError(404, "Playlist not found");
|
|
}
|
|
|
|
var tracks = await _metadataService.GetPlaylistTracksAsync(provider, externalId);
|
|
|
|
// Cache tracks for playlist sync
|
|
if (_playlistSyncService != null)
|
|
{
|
|
foreach (var track in tracks)
|
|
{
|
|
if (!string.IsNullOrEmpty(track.ExternalId))
|
|
{
|
|
var trackId = $"ext-{provider}-{track.ExternalId}";
|
|
_playlistSyncService.AddTrackToPlaylistCache(trackId, playlistId);
|
|
}
|
|
}
|
|
_logger.LogDebug("Cached {Count} tracks for playlist {PlaylistId}", tracks.Count, playlistId);
|
|
}
|
|
|
|
return _responseBuilder.CreatePlaylistAsAlbumResponse(playlist, tracks);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error getting playlist {PlaylistId}", playlistId);
|
|
return _responseBuilder.CreateError(500, "Failed to get playlist");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets playlist tracks as child items.
|
|
/// </summary>
|
|
private async Task<IActionResult> GetPlaylistTracks(string playlistId)
|
|
{
|
|
try
|
|
{
|
|
_logger.LogInformation("=== GetPlaylistTracks called === PlaylistId: {PlaylistId}", playlistId);
|
|
|
|
// Check if this is an external playlist (Deezer/Qobuz) first
|
|
if (PlaylistIdHelper.IsExternalPlaylist(playlistId))
|
|
{
|
|
var (provider, externalId) = PlaylistIdHelper.ParsePlaylistId(playlistId);
|
|
var tracks = await _metadataService.GetPlaylistTracksAsync(provider, externalId);
|
|
return _responseBuilder.CreateItemsResponse(tracks);
|
|
}
|
|
|
|
// Check if this is a Spotify playlist (by ID)
|
|
_logger.LogInformation("Spotify Import Enabled: {Enabled}, Configured IDs: {Count}",
|
|
_spotifySettings.Enabled, _spotifySettings.PlaylistIds.Count);
|
|
|
|
if (_spotifySettings.Enabled &&
|
|
_spotifySettings.PlaylistIds.Any(id => id.Equals(playlistId, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
// Get playlist info from Jellyfin to get the name for matching missing tracks
|
|
_logger.LogInformation("Fetching playlist info from Jellyfin for ID: {PlaylistId}", playlistId);
|
|
var playlistInfo = await _proxyService.GetJsonAsync($"Items/{playlistId}", null, Request.Headers);
|
|
|
|
if (playlistInfo != null && playlistInfo.RootElement.TryGetProperty("Name", out var nameElement))
|
|
{
|
|
var playlistName = nameElement.GetString() ?? "";
|
|
_logger.LogInformation("✓ MATCHED! Intercepting Spotify playlist: {PlaylistName} (ID: {PlaylistId})",
|
|
playlistName, playlistId);
|
|
return await GetSpotifyPlaylistTracksAsync(playlistName, playlistId);
|
|
}
|
|
else
|
|
{
|
|
_logger.LogWarning("Could not get playlist name from Jellyfin for ID: {PlaylistId}", playlistId);
|
|
}
|
|
}
|
|
|
|
// Regular Jellyfin playlist - proxy through
|
|
var endpoint = $"Playlists/{playlistId}/Items";
|
|
if (Request.QueryString.HasValue)
|
|
{
|
|
endpoint = $"{endpoint}{Request.QueryString.Value}";
|
|
}
|
|
|
|
_logger.LogInformation("Proxying to Jellyfin: {Endpoint}", endpoint);
|
|
var result = await _proxyService.GetJsonAsync(endpoint, null, Request.Headers);
|
|
if (result == null)
|
|
{
|
|
return _responseBuilder.CreateError(404, "Playlist not found");
|
|
}
|
|
|
|
return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error getting playlist tracks {PlaylistId}", playlistId);
|
|
return _responseBuilder.CreateError(500, "Failed to get playlist tracks");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a playlist cover image.
|
|
/// </summary>
|
|
private async Task<IActionResult> GetPlaylistImage(string playlistId)
|
|
{
|
|
try
|
|
{
|
|
var (provider, externalId) = PlaylistIdHelper.ParsePlaylistId(playlistId);
|
|
var playlist = await _metadataService.GetPlaylistAsync(provider, externalId);
|
|
|
|
if (playlist == null || string.IsNullOrEmpty(playlist.CoverUrl))
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
var response = await _proxyService.HttpClient.GetAsync(playlist.CoverUrl);
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
var imageBytes = await response.Content.ReadAsByteArrayAsync();
|
|
var contentType = response.Content.Headers.ContentType?.ToString() ?? "image/jpeg";
|
|
return File(imageBytes, contentType);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to get playlist image {PlaylistId}", playlistId);
|
|
return NotFound();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Authentication
|
|
|
|
/// <summary>
|
|
/// Authenticates a user by username and password.
|
|
/// This is the primary login endpoint for Jellyfin clients.
|
|
/// </summary>
|
|
[HttpPost("Users/AuthenticateByName")]
|
|
public async Task<IActionResult> AuthenticateByName()
|
|
{
|
|
try
|
|
{
|
|
// Enable buffering to allow multiple reads of the request body
|
|
Request.EnableBuffering();
|
|
|
|
// Read the request body
|
|
using var reader = new StreamReader(Request.Body, leaveOpen: true);
|
|
var body = await reader.ReadToEndAsync();
|
|
|
|
// Reset stream position
|
|
Request.Body.Position = 0;
|
|
|
|
_logger.LogInformation("Authentication request received");
|
|
// DO NOT log request body or detailed headers - contains password
|
|
|
|
// Forward to Jellyfin server with client headers
|
|
var result = await _proxyService.PostJsonAsync("Users/AuthenticateByName", body, Request.Headers);
|
|
|
|
if (result == null)
|
|
{
|
|
_logger.LogWarning("Authentication failed - no response from Jellyfin");
|
|
return Unauthorized(new { error = "Authentication failed" });
|
|
}
|
|
|
|
_logger.LogInformation("Authentication successful");
|
|
return Content(result.RootElement.GetRawText(), "application/json");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error during authentication");
|
|
return StatusCode(500, new { error = $"Authentication error: {ex.Message}" });
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Recommendations & Instant Mix
|
|
|
|
/// <summary>
|
|
/// Gets similar items for a given item.
|
|
/// For external items, searches for similar content from the provider.
|
|
/// </summary>
|
|
[HttpGet("Items/{itemId}/Similar")]
|
|
[HttpGet("Songs/{itemId}/Similar")]
|
|
[HttpGet("Artists/{itemId}/Similar")]
|
|
public async Task<IActionResult> GetSimilarItems(
|
|
string itemId,
|
|
[FromQuery] int limit = 50,
|
|
[FromQuery] string? fields = null,
|
|
[FromQuery] string? userId = null)
|
|
{
|
|
var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
|
|
|
|
if (isExternal)
|
|
{
|
|
// Check if this is an artist
|
|
if (itemId.Contains("-artist-", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
// For external artists, return empty - we don't have similar artist functionality
|
|
_logger.LogDebug("Similar artists not supported for external artist {ItemId}", itemId);
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
Items = Array.Empty<object>(),
|
|
TotalRecordCount = 0
|
|
});
|
|
}
|
|
|
|
try
|
|
{
|
|
// Get the original song to find similar content
|
|
var song = await _metadataService.GetSongAsync(provider!, externalId!);
|
|
if (song == null)
|
|
{
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
Items = Array.Empty<object>(),
|
|
TotalRecordCount = 0
|
|
});
|
|
}
|
|
|
|
// Search for similar songs using artist and genre
|
|
var searchQuery = $"{song.Artist}";
|
|
var searchResult = await _metadataService.SearchSongsAsync(searchQuery, limit);
|
|
|
|
// Filter out the original song and convert to Jellyfin format
|
|
var similarSongs = searchResult
|
|
.Where(s => s.Id != itemId)
|
|
.Take(limit)
|
|
.Select(s => _responseBuilder.ConvertSongToJellyfinItem(s))
|
|
.ToList();
|
|
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
Items = similarSongs,
|
|
TotalRecordCount = similarSongs.Count
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to get similar items for external song {ItemId}", itemId);
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
Items = Array.Empty<object>(),
|
|
TotalRecordCount = 0
|
|
});
|
|
}
|
|
}
|
|
|
|
// For local items, determine the correct endpoint based on the request path
|
|
var endpoint = Request.Path.Value?.Contains("/Artists/", StringComparison.OrdinalIgnoreCase) == true
|
|
? $"Artists/{itemId}/Similar"
|
|
: $"Items/{itemId}/Similar";
|
|
|
|
var queryParams = new Dictionary<string, string>
|
|
{
|
|
["limit"] = limit.ToString()
|
|
};
|
|
|
|
if (!string.IsNullOrEmpty(fields))
|
|
{
|
|
queryParams["fields"] = fields;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(userId))
|
|
{
|
|
queryParams["userId"] = userId;
|
|
}
|
|
|
|
var result = await _proxyService.GetJsonAsync(endpoint, queryParams, Request.Headers);
|
|
|
|
if (result == null)
|
|
{
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
Items = Array.Empty<object>(),
|
|
TotalRecordCount = 0
|
|
});
|
|
}
|
|
|
|
return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an instant mix for a given item.
|
|
/// For external items, creates a mix from the artist's other songs.
|
|
/// </summary>
|
|
[HttpGet("Songs/{itemId}/InstantMix")]
|
|
[HttpGet("Items/{itemId}/InstantMix")]
|
|
public async Task<IActionResult> GetInstantMix(
|
|
string itemId,
|
|
[FromQuery] int limit = 50,
|
|
[FromQuery] string? fields = null,
|
|
[FromQuery] string? userId = null)
|
|
{
|
|
var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
|
|
|
|
if (isExternal)
|
|
{
|
|
try
|
|
{
|
|
// Get the original song
|
|
var song = await _metadataService.GetSongAsync(provider!, externalId!);
|
|
if (song == null)
|
|
{
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
Items = Array.Empty<object>(),
|
|
TotalRecordCount = 0
|
|
});
|
|
}
|
|
|
|
// Get artist's albums to build a mix
|
|
var mixSongs = new List<Song>();
|
|
|
|
// Try to get artist albums
|
|
if (!string.IsNullOrEmpty(song.ExternalProvider) && !string.IsNullOrEmpty(song.ArtistId))
|
|
{
|
|
var artistExternalId = song.ArtistId.Replace($"ext-{song.ExternalProvider}-artist-", "");
|
|
var albums = await _metadataService.GetArtistAlbumsAsync(song.ExternalProvider, artistExternalId);
|
|
|
|
// Get songs from a few albums
|
|
foreach (var album in albums.Take(3))
|
|
{
|
|
var fullAlbum = await _metadataService.GetAlbumAsync(song.ExternalProvider, album.ExternalId!);
|
|
if (fullAlbum != null)
|
|
{
|
|
mixSongs.AddRange(fullAlbum.Songs);
|
|
}
|
|
|
|
if (mixSongs.Count >= limit) break;
|
|
}
|
|
}
|
|
|
|
// If we don't have enough songs, search for more by the artist
|
|
if (mixSongs.Count < limit)
|
|
{
|
|
var searchResult = await _metadataService.SearchSongsAsync(song.Artist, limit);
|
|
mixSongs.AddRange(searchResult.Where(s => !mixSongs.Any(m => m.Id == s.Id)));
|
|
}
|
|
|
|
// Shuffle and limit
|
|
var random = new Random();
|
|
var shuffledMix = mixSongs
|
|
.Where(s => s.Id != itemId) // Exclude the seed song
|
|
.OrderBy(_ => random.Next())
|
|
.Take(limit)
|
|
.Select(s => _responseBuilder.ConvertSongToJellyfinItem(s))
|
|
.ToList();
|
|
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
Items = shuffledMix,
|
|
TotalRecordCount = shuffledMix.Count
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to create instant mix for external song {ItemId}", itemId);
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
Items = Array.Empty<object>(),
|
|
TotalRecordCount = 0
|
|
});
|
|
}
|
|
}
|
|
|
|
// For local items, proxy to Jellyfin
|
|
var queryParams = new Dictionary<string, string>
|
|
{
|
|
["limit"] = limit.ToString()
|
|
};
|
|
|
|
if (!string.IsNullOrEmpty(fields))
|
|
{
|
|
queryParams["fields"] = fields;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(userId))
|
|
{
|
|
queryParams["userId"] = userId;
|
|
}
|
|
|
|
var result = await _proxyService.GetJsonAsync($"Songs/{itemId}/InstantMix", queryParams, Request.Headers);
|
|
|
|
if (result == null)
|
|
{
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
Items = Array.Empty<object>(),
|
|
TotalRecordCount = 0
|
|
});
|
|
}
|
|
|
|
return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region System & Proxy
|
|
|
|
/// <summary>
|
|
/// Returns public server info.
|
|
/// </summary>
|
|
[HttpGet("System/Info/Public")]
|
|
public async Task<IActionResult> GetPublicSystemInfo()
|
|
{
|
|
var (success, serverName, version) = await _proxyService.TestConnectionAsync();
|
|
|
|
return _responseBuilder.CreateJsonResponse(new
|
|
{
|
|
LocalAddress = Request.Host.ToString(),
|
|
ServerName = serverName ?? "Allstarr",
|
|
Version = version ?? "1.0.0",
|
|
ProductName = "Allstarr (Jellyfin Proxy)",
|
|
OperatingSystem = Environment.OSVersion.Platform.ToString(),
|
|
Id = _settings.DeviceId,
|
|
StartupWizardCompleted = true
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Root path handler - redirects to Jellyfin web UI.
|
|
/// </summary>
|
|
[HttpGet("", Order = 99)]
|
|
public async Task<IActionResult> ProxyRootRequest()
|
|
{
|
|
return await ProxyRequest("web/index.html");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Catch-all endpoint that proxies unhandled requests to Jellyfin transparently.
|
|
/// This route has the lowest priority and should only match requests that don't have SearchTerm.
|
|
/// Blocks dangerous admin endpoints for security.
|
|
/// </summary>
|
|
[HttpGet("{**path}", Order = 100)]
|
|
[HttpPost("{**path}", Order = 100)]
|
|
public async Task<IActionResult> ProxyRequest(string path)
|
|
{
|
|
// DEBUG: Log EVERY request to see what's happening
|
|
_logger.LogWarning("ProxyRequest called with path: {Path}", path);
|
|
|
|
// Log endpoint usage to file for analysis
|
|
await LogEndpointUsageAsync(path, Request.Method);
|
|
|
|
// Block dangerous admin endpoints
|
|
var blockedPrefixes = new[]
|
|
{
|
|
"system/restart", // Server restart
|
|
"system/shutdown", // Server shutdown
|
|
"system/configuration", // System configuration changes
|
|
"system/logs", // Server logs access
|
|
"system/activitylog", // Activity log access
|
|
"plugins/", // Plugin management (install/uninstall/configure)
|
|
"scheduledtasks/", // Scheduled task management
|
|
"startup/", // Initial server setup
|
|
"users/new", // User creation
|
|
"library/refresh", // Library scan (expensive operation)
|
|
"library/virtualfolders", // Library folder management
|
|
"branding/", // Branding configuration
|
|
"displaypreferences/", // Display preferences (if not user-specific)
|
|
"notifications/admin" // Admin notifications
|
|
};
|
|
|
|
// Check if path matches any blocked prefix
|
|
if (blockedPrefixes.Any(prefix =>
|
|
path.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
_logger.LogWarning("BLOCKED: Access denied to admin endpoint: {Path} from {IP}",
|
|
path,
|
|
HttpContext.Connection.RemoteIpAddress);
|
|
return StatusCode(403, new
|
|
{
|
|
error = "Access to administrative endpoints is not allowed through this proxy",
|
|
path = path
|
|
});
|
|
}
|
|
|
|
// Intercept Spotify playlist requests by ID
|
|
if (_spotifySettings.Enabled &&
|
|
path.StartsWith("playlists/", StringComparison.OrdinalIgnoreCase) &&
|
|
path.Contains("/items", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
// Extract playlist ID from path: playlists/{id}/items
|
|
var parts = path.Split('/', StringSplitOptions.RemoveEmptyEntries);
|
|
if (parts.Length >= 2 && parts[0].Equals("playlists", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var playlistId = parts[1];
|
|
|
|
_logger.LogInformation("=== PLAYLIST REQUEST ===");
|
|
_logger.LogInformation("Playlist ID: {PlaylistId}", playlistId);
|
|
_logger.LogInformation("Spotify Enabled: {Enabled}", _spotifySettings.Enabled);
|
|
_logger.LogInformation("Configured IDs: {Ids}", string.Join(", ", _spotifySettings.PlaylistIds));
|
|
_logger.LogInformation("Is configured: {IsConfigured}", _spotifySettings.PlaylistIds.Contains(playlistId, StringComparer.OrdinalIgnoreCase));
|
|
|
|
// Check if this playlist ID is configured for Spotify injection
|
|
if (_spotifySettings.PlaylistIds.Any(id => id.Equals(playlistId, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
_logger.LogInformation("========================================");
|
|
_logger.LogInformation("=== INTERCEPTING SPOTIFY PLAYLIST ===");
|
|
_logger.LogInformation("Playlist ID: {PlaylistId}", playlistId);
|
|
_logger.LogInformation("========================================");
|
|
return await GetPlaylistTracks(playlistId);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle non-JSON responses (robots.txt, etc.)
|
|
if (path.EndsWith(".txt", StringComparison.OrdinalIgnoreCase) ||
|
|
path.EndsWith(".xml", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var fullPath = path;
|
|
if (Request.QueryString.HasValue)
|
|
{
|
|
fullPath = $"{path}{Request.QueryString.Value}";
|
|
}
|
|
|
|
var url = $"{_settings.Url?.TrimEnd('/')}/{fullPath}";
|
|
|
|
try
|
|
{
|
|
var response = await _proxyService.HttpClient.GetAsync(url);
|
|
var content = await response.Content.ReadAsStringAsync();
|
|
var contentType = response.Content.Headers.ContentType?.ToString() ?? "text/plain";
|
|
return Content(content, contentType);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to proxy non-JSON request for {Path}", path);
|
|
return NotFound();
|
|
}
|
|
}
|
|
|
|
// Check if this is a search request that should be handled by specific endpoints
|
|
var searchTerm = Request.Query["SearchTerm"].ToString();
|
|
|
|
if (!string.IsNullOrWhiteSpace(searchTerm))
|
|
{
|
|
_logger.LogInformation("ProxyRequest intercepting search request: Path={Path}, SearchTerm={SearchTerm}", path, searchTerm);
|
|
|
|
// Item search: /users/{userId}/items or /items
|
|
if (path.EndsWith("/items", StringComparison.OrdinalIgnoreCase) || path.Equals("items", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
_logger.LogInformation("Redirecting to SearchItems");
|
|
return await SearchItems(
|
|
searchTerm: searchTerm,
|
|
includeItemTypes: Request.Query["IncludeItemTypes"],
|
|
limit: int.TryParse(Request.Query["Limit"], out var limit) ? limit : 100,
|
|
startIndex: int.TryParse(Request.Query["StartIndex"], out var start) ? start : 0,
|
|
parentId: Request.Query["ParentId"],
|
|
sortBy: Request.Query["SortBy"],
|
|
recursive: Request.Query["Recursive"].ToString().Equals("true", StringComparison.OrdinalIgnoreCase),
|
|
userId: path.Contains("/users/", StringComparison.OrdinalIgnoreCase) && path.Split('/').Length > 2 ? path.Split('/')[2] : null);
|
|
}
|
|
|
|
// Artist search: /artists/albumartists or /artists
|
|
if (path.Contains("/artists", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
_logger.LogInformation("Redirecting to GetArtists");
|
|
return await GetArtists(
|
|
searchTerm: searchTerm,
|
|
limit: int.TryParse(Request.Query["Limit"], out var limit) ? limit : 50,
|
|
startIndex: int.TryParse(Request.Query["StartIndex"], out var start) ? start : 0);
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
// Include query string in the path
|
|
var fullPath = path;
|
|
if (Request.QueryString.HasValue)
|
|
{
|
|
fullPath = $"{path}{Request.QueryString.Value}";
|
|
}
|
|
|
|
JsonDocument? result;
|
|
|
|
if (HttpContext.Request.Method == HttpMethod.Post.Method)
|
|
{
|
|
// Enable buffering BEFORE any reads
|
|
Request.EnableBuffering();
|
|
|
|
// Log request details for debugging
|
|
_logger.LogInformation("POST request to {Path}: Method={Method}, ContentType={ContentType}, ContentLength={ContentLength}",
|
|
fullPath, Request.Method, Request.ContentType, Request.ContentLength);
|
|
|
|
// Read body using StreamReader with proper encoding
|
|
string body;
|
|
using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
|
|
{
|
|
body = await reader.ReadToEndAsync();
|
|
}
|
|
|
|
// Reset stream position after reading so it can be read again if needed
|
|
Request.Body.Position = 0;
|
|
|
|
if (string.IsNullOrWhiteSpace(body))
|
|
{
|
|
_logger.LogWarning("Empty POST body received from client for {Path}, ContentLength={ContentLength}, ContentType={ContentType}",
|
|
fullPath, Request.ContentLength, Request.ContentType);
|
|
|
|
// Log all headers to debug
|
|
_logger.LogWarning("Request headers: {Headers}",
|
|
string.Join(", ", Request.Headers.Select(h => $"{h.Key}={h.Value}")));
|
|
}
|
|
else
|
|
{
|
|
_logger.LogInformation("POST body received from client for {Path}: {BodyLength} bytes, ContentType={ContentType}",
|
|
fullPath, body.Length, Request.ContentType);
|
|
|
|
// Always log body content for playback endpoints to debug the issue
|
|
if (fullPath.Contains("Playing", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
_logger.LogInformation("POST body content from client: {Body}", body);
|
|
}
|
|
}
|
|
|
|
result = await _proxyService.PostJsonAsync(fullPath, body, Request.Headers);
|
|
}
|
|
else
|
|
{
|
|
// Forward GET requests transparently with authentication headers and query string
|
|
result = await _proxyService.GetJsonAsync(fullPath, null, Request.Headers);
|
|
}
|
|
|
|
if (result == null)
|
|
{
|
|
// Return 204 No Content for successful requests with no body
|
|
// (e.g., /sessions/playing, /sessions/playing/progress)
|
|
return NoContent();
|
|
}
|
|
|
|
// Modify response if it contains Spotify playlists to update ChildCount
|
|
if (_spotifySettings.Enabled && result.RootElement.TryGetProperty("Items", out var items))
|
|
{
|
|
_logger.LogInformation("Response has Items property, checking for Spotify playlists to update counts");
|
|
result = await UpdateSpotifyPlaylistCounts(result);
|
|
}
|
|
|
|
return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Proxy request failed for {Path}", path);
|
|
return _responseBuilder.CreateError(502, $"Proxy error: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helpers
|
|
|
|
/// <summary>
|
|
/// Updates ChildCount for Spotify playlists in the response to show total tracks (local + matched).
|
|
/// </summary>
|
|
private async Task<JsonDocument> UpdateSpotifyPlaylistCounts(JsonDocument response)
|
|
{
|
|
try
|
|
{
|
|
if (!response.RootElement.TryGetProperty("Items", out var items))
|
|
{
|
|
return response;
|
|
}
|
|
|
|
var itemsArray = items.EnumerateArray().ToList();
|
|
var modified = false;
|
|
var updatedItems = new List<Dictionary<string, object>>();
|
|
|
|
_logger.LogInformation("Checking {Count} items for Spotify playlists", itemsArray.Count);
|
|
|
|
foreach (var item in itemsArray)
|
|
{
|
|
var itemDict = JsonSerializer.Deserialize<Dictionary<string, object>>(item.GetRawText());
|
|
if (itemDict == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Check if this is a Spotify playlist
|
|
if (item.TryGetProperty("Id", out var idProp))
|
|
{
|
|
var playlistId = idProp.GetString();
|
|
_logger.LogDebug("Checking item with ID: {Id}", playlistId);
|
|
|
|
if (!string.IsNullOrEmpty(playlistId) &&
|
|
_spotifySettings.PlaylistIds.Any(id => id.Equals(playlistId, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
_logger.LogInformation("Found Spotify playlist: {Id}", playlistId);
|
|
|
|
// This is a Spotify playlist - get the actual track count
|
|
var playlistIndex = _spotifySettings.PlaylistIds.FindIndex(id =>
|
|
id.Equals(playlistId, StringComparison.OrdinalIgnoreCase));
|
|
|
|
if (playlistIndex >= 0 && playlistIndex < _spotifySettings.PlaylistNames.Count)
|
|
{
|
|
var playlistName = _spotifySettings.PlaylistNames[playlistIndex];
|
|
var missingTracksKey = $"spotify:missing:{playlistName}";
|
|
var missingTracks = await _cache.GetAsync<List<allstarr.Models.Spotify.MissingTrack>>(missingTracksKey);
|
|
|
|
_logger.LogInformation("Cache lookup for {Key}: {Count} tracks",
|
|
missingTracksKey, missingTracks?.Count ?? 0);
|
|
|
|
// Fallback to file cache
|
|
if (missingTracks == null || missingTracks.Count == 0)
|
|
{
|
|
_logger.LogInformation("Trying file cache for {Name}", playlistName);
|
|
missingTracks = await LoadMissingTracksFromFile(playlistName);
|
|
_logger.LogInformation("File cache result: {Count} tracks", missingTracks?.Count ?? 0);
|
|
}
|
|
|
|
if (missingTracks != null && missingTracks.Count > 0)
|
|
{
|
|
// Update ChildCount to show the number of tracks we'll provide
|
|
itemDict["ChildCount"] = missingTracks.Count;
|
|
modified = true;
|
|
_logger.LogInformation("✓ Updated ChildCount for Spotify playlist {Name} to {Count}",
|
|
playlistName, missingTracks.Count);
|
|
}
|
|
else
|
|
{
|
|
_logger.LogWarning("No missing tracks found for {Name}", playlistName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
updatedItems.Add(itemDict);
|
|
}
|
|
|
|
if (!modified)
|
|
{
|
|
_logger.LogInformation("No Spotify playlists found to update");
|
|
return response;
|
|
}
|
|
|
|
_logger.LogInformation("Modified {Count} Spotify playlists, rebuilding response",
|
|
updatedItems.Count(i => i.ContainsKey("ChildCount")));
|
|
|
|
// Rebuild the response with updated items
|
|
var responseDict = JsonSerializer.Deserialize<Dictionary<string, object>>(response.RootElement.GetRawText());
|
|
if (responseDict != null)
|
|
{
|
|
responseDict["Items"] = updatedItems;
|
|
var updatedJson = JsonSerializer.Serialize(responseDict);
|
|
return JsonDocument.Parse(updatedJson);
|
|
}
|
|
|
|
return response;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to update Spotify playlist counts");
|
|
return response;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Logs endpoint usage to a file for analysis.
|
|
/// Creates a CSV file with timestamp, method, path, and query string.
|
|
/// </summary>
|
|
private async Task LogEndpointUsageAsync(string path, string method)
|
|
{
|
|
try
|
|
{
|
|
var logDir = "/app/cache/endpoint-usage";
|
|
Directory.CreateDirectory(logDir);
|
|
|
|
var logFile = Path.Combine(logDir, "endpoints.csv");
|
|
var timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss");
|
|
var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
|
|
|
|
// Sanitize path and query for CSV (remove commas, quotes, newlines)
|
|
var sanitizedPath = path.Replace(",", ";").Replace("\"", "'").Replace("\n", " ").Replace("\r", " ");
|
|
var sanitizedQuery = queryString.Replace(",", ";").Replace("\"", "'").Replace("\n", " ").Replace("\r", " ");
|
|
|
|
var logLine = $"{timestamp},{method},{sanitizedPath},{sanitizedQuery}\n";
|
|
|
|
// Append to file (thread-safe)
|
|
await System.IO.File.AppendAllTextAsync(logFile, logLine);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Don't let logging failures break the request
|
|
_logger.LogDebug(ex, "Failed to log endpoint usage");
|
|
}
|
|
}
|
|
|
|
private static string[]? ParseItemTypes(string? includeItemTypes)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(includeItemTypes))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return includeItemTypes.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
|
|
}
|
|
|
|
private static string GetContentType(string filePath)
|
|
{
|
|
var extension = Path.GetExtension(filePath).ToLowerInvariant();
|
|
return extension switch
|
|
{
|
|
".mp3" => "audio/mpeg",
|
|
".flac" => "audio/flac",
|
|
".ogg" => "audio/ogg",
|
|
".m4a" => "audio/mp4",
|
|
".wav" => "audio/wav",
|
|
".aac" => "audio/aac",
|
|
_ => "audio/mpeg"
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scores search results based on fuzzy matching against the query.
|
|
/// Returns items with their relevance scores.
|
|
/// External results get a small boost to prioritize the larger catalog.
|
|
/// </summary>
|
|
private static List<(T Item, int Score)> ScoreSearchResults<T>(
|
|
string query,
|
|
List<T> items,
|
|
Func<T, string> titleField,
|
|
Func<T, string?> artistField,
|
|
Func<T, string?> albumField,
|
|
bool isExternal = false)
|
|
{
|
|
return items.Select(item =>
|
|
{
|
|
var title = titleField(item) ?? "";
|
|
var artist = artistField(item) ?? "";
|
|
var album = albumField(item) ?? "";
|
|
|
|
// Token-based fuzzy matching: split query and fields into words
|
|
var queryTokens = query.ToLower()
|
|
.Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries)
|
|
.ToList();
|
|
|
|
var fieldText = $"{title} {artist} {album}".ToLower();
|
|
var fieldTokens = fieldText
|
|
.Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries)
|
|
.ToList();
|
|
|
|
if (queryTokens.Count == 0) return (item, 0);
|
|
|
|
// Count how many query tokens match field tokens (with fuzzy tolerance)
|
|
var matchedTokens = 0;
|
|
foreach (var queryToken in queryTokens)
|
|
{
|
|
// Check if any field token matches this query token
|
|
var hasMatch = fieldTokens.Any(fieldToken =>
|
|
{
|
|
// Exact match or substring match
|
|
if (fieldToken.Contains(queryToken) || queryToken.Contains(fieldToken))
|
|
return true;
|
|
|
|
// Fuzzy match with Levenshtein distance
|
|
var similarity = FuzzyMatcher.CalculateSimilarity(queryToken, fieldToken);
|
|
return similarity >= 70; // 70% similarity threshold for individual words
|
|
});
|
|
|
|
if (hasMatch) matchedTokens++;
|
|
}
|
|
|
|
// Score = percentage of query tokens that matched
|
|
var baseScore = (matchedTokens * 100) / queryTokens.Count;
|
|
|
|
// Give external results a small boost (+5 points) to prioritize the larger catalog
|
|
var finalScore = isExternal ? Math.Min(100, baseScore + 5) : baseScore;
|
|
|
|
return (item, finalScore);
|
|
}).ToList();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Spotify Playlist Injection
|
|
|
|
/// <summary>
|
|
/// Gets tracks for a Spotify playlist by matching missing tracks against external providers
|
|
/// and merging with existing local tracks from Jellyfin.
|
|
/// </summary>
|
|
private async Task<IActionResult> GetSpotifyPlaylistTracksAsync(string spotifyPlaylistName, string playlistId)
|
|
{
|
|
try
|
|
{
|
|
var cacheKey = $"spotify:matched:{spotifyPlaylistName}";
|
|
var cachedTracks = await _cache.GetAsync<List<Song>>(cacheKey);
|
|
|
|
if (cachedTracks != null)
|
|
{
|
|
_logger.LogDebug("Returning {Count} cached matched tracks for {Playlist}",
|
|
cachedTracks.Count, spotifyPlaylistName);
|
|
return _responseBuilder.CreateItemsResponse(cachedTracks);
|
|
}
|
|
|
|
// Get existing Jellyfin playlist items (tracks the plugin already found)
|
|
var existingTracksResponse = await _proxyService.GetJsonAsync(
|
|
$"Playlists/{playlistId}/Items",
|
|
null,
|
|
Request.Headers);
|
|
|
|
var existingTracks = new List<Song>();
|
|
var existingSpotifyIds = new HashSet<string>();
|
|
|
|
if (existingTracksResponse != null &&
|
|
existingTracksResponse.RootElement.TryGetProperty("Items", out var items))
|
|
{
|
|
foreach (var item in items.EnumerateArray())
|
|
{
|
|
var song = _modelMapper.ParseSong(item);
|
|
existingTracks.Add(song);
|
|
|
|
// Track Spotify IDs to avoid duplicates
|
|
if (item.TryGetProperty("ProviderIds", out var providerIds) &&
|
|
providerIds.TryGetProperty("Spotify", out var spotifyId))
|
|
{
|
|
existingSpotifyIds.Add(spotifyId.GetString() ?? "");
|
|
}
|
|
}
|
|
_logger.LogInformation("Found {Count} existing tracks in Jellyfin playlist", existingTracks.Count);
|
|
}
|
|
|
|
var missingTracksKey = $"spotify:missing:{spotifyPlaylistName}";
|
|
var missingTracks = await _cache.GetAsync<List<allstarr.Models.Spotify.MissingTrack>>(missingTracksKey);
|
|
|
|
// Fallback to file cache if Redis is empty
|
|
if (missingTracks == null || missingTracks.Count == 0)
|
|
{
|
|
missingTracks = await LoadMissingTracksFromFile(spotifyPlaylistName);
|
|
|
|
// If we loaded from file, restore to Redis
|
|
if (missingTracks != null && missingTracks.Count > 0)
|
|
{
|
|
await _cache.SetAsync(missingTracksKey, missingTracks, TimeSpan.FromHours(24));
|
|
_logger.LogInformation("Restored {Count} missing tracks from file cache for {Playlist}",
|
|
missingTracks.Count, spotifyPlaylistName);
|
|
}
|
|
}
|
|
|
|
if (missingTracks == null || missingTracks.Count == 0)
|
|
{
|
|
_logger.LogInformation("No missing tracks found for {Playlist}, returning {Count} existing tracks",
|
|
spotifyPlaylistName, existingTracks.Count);
|
|
return _responseBuilder.CreateItemsResponse(existingTracks);
|
|
}
|
|
|
|
_logger.LogInformation("Matching {Count} missing tracks for {Playlist}",
|
|
missingTracks.Count, spotifyPlaylistName);
|
|
|
|
// Match missing tracks (excluding ones we already have locally)
|
|
var matchTasks = missingTracks
|
|
.Where(track => !existingSpotifyIds.Contains(track.SpotifyId))
|
|
.Select(async track =>
|
|
{
|
|
try
|
|
{
|
|
// Search with just title and artist for better matching
|
|
var query = $"{track.Title} {track.PrimaryArtist}";
|
|
var results = await _metadataService.SearchSongsAsync(query, limit: 5);
|
|
|
|
if (results.Count == 0)
|
|
return (track.SpotifyId, (Song?)null);
|
|
|
|
// Fuzzy match to find best result
|
|
var bestMatch = results
|
|
.Select(song => new
|
|
{
|
|
Song = song,
|
|
TitleScore = FuzzyMatcher.CalculateSimilarity(track.Title, song.Title),
|
|
ArtistScore = FuzzyMatcher.CalculateSimilarity(track.PrimaryArtist, song.Artist),
|
|
TotalScore = 0.0
|
|
})
|
|
.Select(x => new
|
|
{
|
|
x.Song,
|
|
x.TitleScore,
|
|
x.ArtistScore,
|
|
TotalScore = (x.TitleScore * 0.6) + (x.ArtistScore * 0.4) // Weight title more
|
|
})
|
|
.OrderByDescending(x => x.TotalScore)
|
|
.FirstOrDefault();
|
|
|
|
// Only return if match is good enough (>60% combined score)
|
|
if (bestMatch != null && bestMatch.TotalScore >= 60)
|
|
{
|
|
_logger.LogDebug("Matched '{Title}' by {Artist} -> '{MatchTitle}' by {MatchArtist} (score: {Score:F1})",
|
|
track.Title, track.PrimaryArtist,
|
|
bestMatch.Song.Title, bestMatch.Song.Artist,
|
|
bestMatch.TotalScore);
|
|
return (track.SpotifyId, (Song?)bestMatch.Song);
|
|
}
|
|
|
|
_logger.LogDebug("No good match for '{Title}' by {Artist} (best score: {Score:F1})",
|
|
track.Title, track.PrimaryArtist, bestMatch?.TotalScore ?? 0);
|
|
return (track.SpotifyId, (Song?)null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogDebug(ex, "Failed to match track: {Title} - {Artist}",
|
|
track.Title, track.PrimaryArtist);
|
|
return (track.SpotifyId, (Song?)null);
|
|
}
|
|
});
|
|
|
|
var matchResults = await Task.WhenAll(matchTasks);
|
|
var matchedBySpotifyId = matchResults
|
|
.Where(x => x.Item2 != null)
|
|
.ToDictionary(x => x.SpotifyId, x => x.Item2!);
|
|
|
|
// Build final track list in Spotify playlist order
|
|
var finalTracks = new List<Song>();
|
|
foreach (var missingTrack in missingTracks)
|
|
{
|
|
// Check if we have it locally first
|
|
var existingTrack = existingTracks.FirstOrDefault(t =>
|
|
t.Title.Equals(missingTrack.Title, StringComparison.OrdinalIgnoreCase) &&
|
|
t.Artist.Equals(missingTrack.PrimaryArtist, StringComparison.OrdinalIgnoreCase));
|
|
|
|
if (existingTrack != null)
|
|
{
|
|
finalTracks.Add(existingTrack);
|
|
}
|
|
else if (matchedBySpotifyId.TryGetValue(missingTrack.SpotifyId, out var matchedTrack))
|
|
{
|
|
finalTracks.Add(matchedTrack);
|
|
}
|
|
// Skip tracks we couldn't match
|
|
}
|
|
|
|
await _cache.SetAsync(cacheKey, finalTracks, TimeSpan.FromHours(1));
|
|
|
|
_logger.LogInformation("Final playlist: {Total} tracks ({Existing} local, {Matched} matched, {Missing} missing)",
|
|
finalTracks.Count,
|
|
existingTracks.Count,
|
|
matchedBySpotifyId.Count,
|
|
missingTracks.Count - existingTracks.Count - matchedBySpotifyId.Count);
|
|
|
|
return _responseBuilder.CreateItemsResponse(finalTracks);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error getting Spotify playlist tracks {PlaylistName}", spotifyPlaylistName);
|
|
return _responseBuilder.CreateError(500, "Failed to get Spotify playlist tracks");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies an external track to the kept folder when favorited.
|
|
/// </summary>
|
|
private async Task CopyExternalTrackToKeptAsync(string itemId, string provider, string externalId)
|
|
{
|
|
try
|
|
{
|
|
// Get the song metadata
|
|
var song = await _metadataService.GetSongAsync(provider, externalId);
|
|
if (song == null)
|
|
{
|
|
_logger.LogWarning("Could not find song metadata for {ItemId}", itemId);
|
|
return;
|
|
}
|
|
|
|
// Trigger download first
|
|
_logger.LogInformation("Downloading track for kept folder: {ItemId}", itemId);
|
|
string downloadPath;
|
|
|
|
try
|
|
{
|
|
downloadPath = await _downloadService.DownloadSongAsync(provider, externalId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to download track {ItemId}", itemId);
|
|
return;
|
|
}
|
|
|
|
// Create kept folder structure: /app/kept/Artist/Album/
|
|
var keptBasePath = "/app/kept";
|
|
var keptArtistPath = Path.Combine(keptBasePath, PathHelper.SanitizeFileName(song.Artist));
|
|
var keptAlbumPath = Path.Combine(keptArtistPath, PathHelper.SanitizeFileName(song.Album));
|
|
|
|
Directory.CreateDirectory(keptAlbumPath);
|
|
|
|
// Copy file to kept folder
|
|
var fileName = Path.GetFileName(downloadPath);
|
|
var keptFilePath = Path.Combine(keptAlbumPath, fileName);
|
|
|
|
if (System.IO.File.Exists(keptFilePath))
|
|
{
|
|
_logger.LogInformation("Track already exists in kept folder: {Path}", keptFilePath);
|
|
return;
|
|
}
|
|
|
|
System.IO.File.Copy(downloadPath, keptFilePath, overwrite: false);
|
|
_logger.LogInformation("✓ Copied favorited track to kept folder: {Path}", keptFilePath);
|
|
|
|
// Also copy cover art if it exists
|
|
var coverPath = Path.Combine(Path.GetDirectoryName(downloadPath)!, "cover.jpg");
|
|
if (System.IO.File.Exists(coverPath))
|
|
{
|
|
var keptCoverPath = Path.Combine(keptAlbumPath, "cover.jpg");
|
|
if (!System.IO.File.Exists(keptCoverPath))
|
|
{
|
|
System.IO.File.Copy(coverPath, keptCoverPath, overwrite: false);
|
|
_logger.LogDebug("Copied cover art to kept folder");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error copying external track {ItemId} to kept folder", itemId);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loads missing tracks from file cache as fallback when Redis is empty.
|
|
/// </summary>
|
|
private async Task<List<allstarr.Models.Spotify.MissingTrack>?> LoadMissingTracksFromFile(string playlistName)
|
|
{
|
|
try
|
|
{
|
|
var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
|
|
var filePath = Path.Combine("/app/cache/spotify", $"{safeName}_missing.json");
|
|
|
|
if (!System.IO.File.Exists(filePath))
|
|
{
|
|
_logger.LogDebug("No file cache found for {Playlist} at {Path}", playlistName, filePath);
|
|
return null;
|
|
}
|
|
|
|
var fileAge = DateTime.UtcNow - System.IO.File.GetLastWriteTimeUtc(filePath);
|
|
if (fileAge > TimeSpan.FromHours(24))
|
|
{
|
|
_logger.LogDebug("File cache for {Playlist} is too old ({Age:F1}h)", playlistName, fileAge.TotalHours);
|
|
return null;
|
|
}
|
|
|
|
var json = await System.IO.File.ReadAllTextAsync(filePath);
|
|
var tracks = JsonSerializer.Deserialize<List<allstarr.Models.Spotify.MissingTrack>>(json);
|
|
|
|
_logger.LogInformation("Loaded {Count} missing tracks from file cache for {Playlist} (age: {Age:F1}h)",
|
|
tracks?.Count ?? 0, playlistName, fileAge.TotalHours);
|
|
|
|
return tracks;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to load missing tracks from file for {Playlist}", playlistName);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Manual trigger endpoint to force fetch Spotify missing tracks.
|
|
/// GET /spotify/sync?api_key=YOUR_KEY
|
|
/// </summary>
|
|
[HttpGet("spotify/sync", Order = 1)]
|
|
[ServiceFilter(typeof(ApiKeyAuthFilter))]
|
|
public async Task<IActionResult> TriggerSpotifySync()
|
|
{
|
|
if (!_spotifySettings.Enabled)
|
|
{
|
|
return BadRequest(new { error = "Spotify Import is not enabled" });
|
|
}
|
|
|
|
_logger.LogInformation("Manual Spotify sync triggered");
|
|
|
|
var results = new Dictionary<string, object>();
|
|
|
|
for (int i = 0; i < _spotifySettings.PlaylistIds.Count; i++)
|
|
{
|
|
var playlistId = _spotifySettings.PlaylistIds[i];
|
|
|
|
try
|
|
{
|
|
// Use configured name if available, otherwise use ID
|
|
var playlistName = i < _spotifySettings.PlaylistNames.Count
|
|
? _spotifySettings.PlaylistNames[i]
|
|
: playlistId;
|
|
|
|
_logger.LogInformation("Fetching missing tracks for {Playlist} (ID: {Id})", playlistName, playlistId);
|
|
|
|
// Try to fetch the missing tracks file - search last 24 hours
|
|
var now = DateTime.UtcNow;
|
|
var searchStart = now.AddHours(-24);
|
|
|
|
var httpClient = new HttpClient();
|
|
var found = false;
|
|
|
|
// Search every minute for the last 24 hours (1440 attempts max)
|
|
for (var time = searchStart; time <= now; time = time.AddMinutes(1))
|
|
{
|
|
var filename = $"{playlistName}_missing_{time:yyyy-MM-dd_HH-mm}.json";
|
|
var url = $"{_settings.Url}/Viperinius.Plugin.SpotifyImport/MissingTracksFile" +
|
|
$"?name={Uri.EscapeDataString(filename)}&api_key={_settings.ApiKey}";
|
|
|
|
try
|
|
{
|
|
_logger.LogDebug("Trying {Filename}", filename);
|
|
var response = await httpClient.GetAsync(url);
|
|
if (response.IsSuccessStatusCode)
|
|
{
|
|
var json = await response.Content.ReadAsStringAsync();
|
|
var tracks = ParseMissingTracksJson(json);
|
|
|
|
if (tracks.Count > 0)
|
|
{
|
|
var cacheKey = $"spotify:missing:{playlistName}";
|
|
await _cache.SetAsync(cacheKey, tracks, TimeSpan.FromHours(24));
|
|
|
|
results[playlistName] = new {
|
|
status = "success",
|
|
tracks = tracks.Count,
|
|
filename = filename
|
|
};
|
|
|
|
_logger.LogInformation("✓ Cached {Count} missing tracks for {Playlist} from {Filename}",
|
|
tracks.Count, playlistName, filename);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogDebug(ex, "Failed to fetch {Filename}", filename);
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
results[playlistName] = new { status = "not_found", message = "No missing tracks file found" };
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error syncing playlist {PlaylistId}", playlistId);
|
|
results[playlistId] = new { status = "error", message = ex.Message };
|
|
}
|
|
}
|
|
|
|
return Ok(results);
|
|
}
|
|
|
|
private List<allstarr.Models.Spotify.MissingTrack> ParseMissingTracksJson(string json)
|
|
{
|
|
var tracks = new List<allstarr.Models.Spotify.MissingTrack>();
|
|
|
|
try
|
|
{
|
|
var doc = JsonDocument.Parse(json);
|
|
|
|
foreach (var item in doc.RootElement.EnumerateArray())
|
|
{
|
|
var track = new allstarr.Models.Spotify.MissingTrack
|
|
{
|
|
SpotifyId = item.GetProperty("Id").GetString() ?? "",
|
|
Title = item.GetProperty("Name").GetString() ?? "",
|
|
Album = item.GetProperty("AlbumName").GetString() ?? "",
|
|
Artists = item.GetProperty("ArtistNames")
|
|
.EnumerateArray()
|
|
.Select(a => a.GetString() ?? "")
|
|
.Where(a => !string.IsNullOrEmpty(a))
|
|
.ToList()
|
|
};
|
|
|
|
if (!string.IsNullOrEmpty(track.Title))
|
|
{
|
|
tracks.Add(track);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to parse missing tracks JSON");
|
|
}
|
|
|
|
return tracks;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Spotify Debug
|
|
|
|
/// <summary>
|
|
/// Clear Spotify playlist cache to force re-matching.
|
|
/// GET /spotify/clear-cache?api_key=YOUR_KEY
|
|
/// </summary>
|
|
[HttpGet("spotify/clear-cache")]
|
|
[ServiceFilter(typeof(ApiKeyAuthFilter))]
|
|
public async Task<IActionResult> ClearSpotifyCache()
|
|
{
|
|
if (!_spotifySettings.Enabled)
|
|
{
|
|
return BadRequest(new { error = "Spotify Import is not enabled" });
|
|
}
|
|
|
|
var cleared = new List<string>();
|
|
|
|
foreach (var playlistName in _spotifySettings.PlaylistNames)
|
|
{
|
|
var matchedKey = $"spotify:matched:{playlistName}";
|
|
await _cache.DeleteAsync(matchedKey);
|
|
cleared.Add(playlistName);
|
|
_logger.LogInformation("Cleared cache for {Playlist}", playlistName);
|
|
}
|
|
|
|
return Ok(new { status = "success", cleared = cleared });
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Debug & Monitoring
|
|
|
|
/// <summary>
|
|
/// Gets endpoint usage statistics from the log file.
|
|
/// GET /debug/endpoint-usage?api_key=YOUR_KEY
|
|
/// Optional query params: top=50 (default 100), since=2024-01-01
|
|
/// </summary>
|
|
[HttpGet("debug/endpoint-usage")]
|
|
[ServiceFilter(typeof(ApiKeyAuthFilter))]
|
|
public async Task<IActionResult> GetEndpointUsage(
|
|
[FromQuery] int top = 100,
|
|
[FromQuery] string? since = null)
|
|
{
|
|
try
|
|
{
|
|
var logFile = "/app/cache/endpoint-usage/endpoints.csv";
|
|
|
|
if (!System.IO.File.Exists(logFile))
|
|
{
|
|
return Ok(new
|
|
{
|
|
message = "No endpoint usage data collected yet",
|
|
endpoints = Array.Empty<object>()
|
|
});
|
|
}
|
|
|
|
var lines = await System.IO.File.ReadAllLinesAsync(logFile);
|
|
|
|
// Parse CSV and filter by date if provided
|
|
DateTime? sinceDate = null;
|
|
if (!string.IsNullOrEmpty(since) && DateTime.TryParse(since, out var parsedDate))
|
|
{
|
|
sinceDate = parsedDate;
|
|
}
|
|
|
|
var entries = lines
|
|
.Select(line => line.Split(','))
|
|
.Where(parts => parts.Length >= 3)
|
|
.Where(parts => !sinceDate.HasValue ||
|
|
(DateTime.TryParse(parts[0], out var entryDate) && entryDate >= sinceDate.Value))
|
|
.Select(parts => new
|
|
{
|
|
Timestamp = parts[0],
|
|
Method = parts.Length > 1 ? parts[1] : "",
|
|
Path = parts.Length > 2 ? parts[2] : "",
|
|
Query = parts.Length > 3 ? parts[3] : ""
|
|
})
|
|
.ToList();
|
|
|
|
// Group by path and count
|
|
var pathCounts = entries
|
|
.GroupBy(e => new { e.Method, e.Path })
|
|
.Select(g => new
|
|
{
|
|
Method = g.Key.Method,
|
|
Path = g.Key.Path,
|
|
Count = g.Count(),
|
|
FirstSeen = g.Min(e => e.Timestamp),
|
|
LastSeen = g.Max(e => e.Timestamp)
|
|
})
|
|
.OrderByDescending(x => x.Count)
|
|
.Take(top)
|
|
.ToList();
|
|
|
|
return Ok(new
|
|
{
|
|
totalRequests = entries.Count,
|
|
uniqueEndpoints = pathCounts.Count,
|
|
topEndpoints = pathCounts,
|
|
logFile = logFile,
|
|
logSize = new FileInfo(logFile).Length
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to get endpoint usage");
|
|
return StatusCode(500, new { error = ex.Message });
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clears the endpoint usage log file.
|
|
/// DELETE /debug/endpoint-usage?api_key=YOUR_KEY
|
|
/// </summary>
|
|
[HttpDelete("debug/endpoint-usage")]
|
|
[ServiceFilter(typeof(ApiKeyAuthFilter))]
|
|
public IActionResult ClearEndpointUsage()
|
|
{
|
|
try
|
|
{
|
|
var logFile = "/app/cache/endpoint-usage/endpoints.csv";
|
|
|
|
if (System.IO.File.Exists(logFile))
|
|
{
|
|
System.IO.File.Delete(logFile);
|
|
return Ok(new { status = "success", message = "Endpoint usage log cleared" });
|
|
}
|
|
|
|
return Ok(new { status = "success", message = "No log file to clear" });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to clear endpoint usage log");
|
|
return StatusCode(500, new { error = ex.Message });
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
// force rebuild Sun Jan 25 13:22:47 EST 2026
|