mirror of
https://github.com/SoPat712/allstarr.git
synced 2026-02-09 23:55:10 -05:00
Josh Patra
375e1894f3
Features: - SpotifyApiClient: Direct Spotify API client using sp_dc session cookie - SpotifyLyricsService: Fetch synced lyrics from Spotify's color-lyrics API - SpotifyPlaylistFetcher: Get playlists with correct track ordering and ISRC codes - SpotifyTrackMatchingService: ISRC-based exact track matching for external providers Improvements: - Lyrics endpoint now prioritizes: 1) Jellyfin embedded, 2) Spotify synced, 3) LRCLIB - Fixed playback progress reporting - removed incorrect body wrapping for Jellyfin API - Added SpotifyApiSettings configuration model Security: - Session cookie and client ID properly masked in startup logs - All credentials read from environment variables only
606 lines
25 KiB
C#
606 lines
25 KiB
C#
using allstarr.Models.Settings;
|
|
using allstarr.Services;
|
|
using allstarr.Services.Deezer;
|
|
using allstarr.Services.Qobuz;
|
|
using allstarr.Services.SquidWTF;
|
|
using allstarr.Services.Local;
|
|
using allstarr.Services.Validation;
|
|
using allstarr.Services.Subsonic;
|
|
using allstarr.Services.Jellyfin;
|
|
using allstarr.Services.Common;
|
|
using allstarr.Services.Lyrics;
|
|
using allstarr.Middleware;
|
|
using allstarr.Filters;
|
|
using Microsoft.Extensions.Http;
|
|
using System.Text;
|
|
|
|
var builder = WebApplication.CreateBuilder(args);
|
|
|
|
// Decode SquidWTF API base URLs once at startup
|
|
var squidWtfApiUrls = DecodeSquidWtfUrls();
|
|
static List<string> DecodeSquidWtfUrls()
|
|
{
|
|
var encodedUrls = new[]
|
|
{
|
|
"aHR0cHM6Ly90cml0b24uc3F1aWQud3Rm", // triton
|
|
"aHR0cHM6Ly90aWRhbC1hcGkuYmluaW11bS5vcmc=", // binimum
|
|
"aHR0cHM6Ly90aWRhbC5raW5vcGx1cy5vbmxpbmU=", // kinoplus
|
|
"aHR0cHM6Ly9oaWZpLXR3by5zcG90aXNhdmVyLm5ldA==", // spoti-2
|
|
"aHR0cHM6Ly9oaWZpLW9uZS5zcG90aXNhdmVyLm5ldA==", // spoti-1
|
|
"aHR0cHM6Ly93b2xmLnFxZGwuc2l0ZQ==", // wolf
|
|
"aHR0cDovL2h1bmQucXFkbC5zaXRl", // hund
|
|
"aHR0cHM6Ly9rYXR6ZS5xcWRsLnNpdGU=", // katze
|
|
"aHR0cHM6Ly92b2dlbC5xcWRsLnNpdGU=", // vogel
|
|
"aHR0cHM6Ly9tYXVzLnFxZGwuc2l0ZQ==" // maus
|
|
};
|
|
|
|
return encodedUrls
|
|
.Select(encoded => Encoding.UTF8.GetString(Convert.FromBase64String(encoded)))
|
|
.ToList();
|
|
}
|
|
|
|
// Determine backend type FIRST
|
|
var backendType = builder.Configuration.GetValue<BackendType>("Backend:Type");
|
|
|
|
// Configure Kestrel for large responses over VPN/Tailscale
|
|
builder.WebHost.ConfigureKestrel(serverOptions =>
|
|
{
|
|
serverOptions.Limits.MaxResponseBufferSize = null; // Disable response buffering limit
|
|
serverOptions.Limits.MaxRequestBodySize = null; // Allow large request bodies
|
|
serverOptions.Limits.MinResponseDataRate = null; // Disable minimum data rate for slow connections
|
|
});
|
|
|
|
// Add response compression for large JSON responses (helps with Tailscale/VPN MTU issues)
|
|
builder.Services.AddResponseCompression(options =>
|
|
{
|
|
options.EnableForHttps = true;
|
|
options.MimeTypes = new[] { "application/json", "text/json" };
|
|
});
|
|
|
|
// Add services to the container - conditionally register controllers
|
|
builder.Services.AddControllers()
|
|
.AddJsonOptions(options =>
|
|
{
|
|
// Use original property names (PascalCase) to match Jellyfin API
|
|
options.JsonSerializerOptions.PropertyNamingPolicy = null;
|
|
options.JsonSerializerOptions.DictionaryKeyPolicy = null;
|
|
})
|
|
.ConfigureApplicationPartManager(manager =>
|
|
{
|
|
// Remove the default controller feature provider
|
|
var defaultProvider = manager.FeatureProviders
|
|
.OfType<Microsoft.AspNetCore.Mvc.Controllers.ControllerFeatureProvider>()
|
|
.FirstOrDefault();
|
|
if (defaultProvider != null)
|
|
{
|
|
manager.FeatureProviders.Remove(defaultProvider);
|
|
}
|
|
// Add our custom provider that filters by backend type
|
|
manager.FeatureProviders.Add(new BackendControllerFeatureProvider(backendType));
|
|
});
|
|
|
|
builder.Services.AddHttpClient();
|
|
builder.Services.ConfigureAll<HttpClientFactoryOptions>(options =>
|
|
{
|
|
options.HttpMessageHandlerBuilderActions.Add(builder =>
|
|
{
|
|
builder.PrimaryHandler = new HttpClientHandler
|
|
{
|
|
AllowAutoRedirect = true,
|
|
MaxAutomaticRedirections = 5
|
|
};
|
|
});
|
|
});
|
|
builder.Services.AddEndpointsApiExplorer();
|
|
builder.Services.AddSwaggerGen();
|
|
builder.Services.AddHttpContextAccessor();
|
|
|
|
// Exception handling
|
|
builder.Services.AddExceptionHandler<GlobalExceptionHandler>();
|
|
builder.Services.AddProblemDetails();
|
|
|
|
// Configuration - register both settings, active one determined by backend type
|
|
builder.Services.Configure<SubsonicSettings>(
|
|
builder.Configuration.GetSection("Subsonic"));
|
|
builder.Services.Configure<JellyfinSettings>(
|
|
builder.Configuration.GetSection("Jellyfin"));
|
|
builder.Services.Configure<DeezerSettings>(
|
|
builder.Configuration.GetSection("Deezer"));
|
|
builder.Services.Configure<QobuzSettings>(
|
|
builder.Configuration.GetSection("Qobuz"));
|
|
builder.Services.Configure<SquidWTFSettings>(
|
|
builder.Configuration.GetSection("SquidWTF"));
|
|
builder.Services.Configure<RedisSettings>(
|
|
builder.Configuration.GetSection("Redis"));
|
|
// Configure Spotify Import settings with custom playlist parsing from env var
|
|
builder.Services.Configure<SpotifyImportSettings>(options =>
|
|
{
|
|
builder.Configuration.GetSection("SpotifyImport").Bind(options);
|
|
|
|
// Debug: Check what Bind() populated
|
|
Console.WriteLine($"DEBUG: After Bind(), Playlists.Count = {options.Playlists.Count}");
|
|
Console.WriteLine($"DEBUG: After Bind(), PlaylistIds.Count = {options.PlaylistIds.Count}");
|
|
Console.WriteLine($"DEBUG: After Bind(), PlaylistNames.Count = {options.PlaylistNames.Count}");
|
|
|
|
// Parse SPOTIFY_IMPORT_PLAYLISTS env var (JSON array format)
|
|
// Format: [["Name","Id","first|last"],["Name2","Id2","first|last"]]
|
|
var playlistsEnv = builder.Configuration.GetValue<string>("SpotifyImport:Playlists");
|
|
if (!string.IsNullOrWhiteSpace(playlistsEnv))
|
|
{
|
|
Console.WriteLine($"Found SPOTIFY_IMPORT_PLAYLISTS env var: {playlistsEnv.Length} chars");
|
|
try
|
|
{
|
|
// Parse as JSON array of arrays
|
|
var playlistArrays = System.Text.Json.JsonSerializer.Deserialize<string[][]>(playlistsEnv);
|
|
if (playlistArrays != null && playlistArrays.Length > 0)
|
|
{
|
|
Console.WriteLine($"Parsed {playlistArrays.Length} playlists from JSON format");
|
|
foreach (var arr in playlistArrays)
|
|
{
|
|
if (arr.Length >= 2)
|
|
{
|
|
var config = new SpotifyPlaylistConfig
|
|
{
|
|
Name = arr[0].Trim(),
|
|
Id = arr[1].Trim(),
|
|
LocalTracksPosition = arr.Length >= 3 &&
|
|
arr[2].Trim().Equals("last", StringComparison.OrdinalIgnoreCase)
|
|
? LocalTracksPosition.Last
|
|
: LocalTracksPosition.First
|
|
};
|
|
options.Playlists.Add(config);
|
|
Console.WriteLine($" Added: {config.Name} (ID: {config.Id}, Position: {config.LocalTracksPosition})");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("JSON format was empty or invalid, will try legacy format");
|
|
}
|
|
}
|
|
catch (System.Text.Json.JsonException ex)
|
|
{
|
|
Console.WriteLine($"Warning: Failed to parse SPOTIFY_IMPORT_PLAYLISTS: {ex.Message}");
|
|
Console.WriteLine("Expected format: [[\"Name\",\"Id\",\"first|last\"],[\"Name2\",\"Id2\",\"first|last\"]]");
|
|
Console.WriteLine("Will try legacy format instead");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("No SPOTIFY_IMPORT_PLAYLISTS env var found, will try legacy format");
|
|
}
|
|
|
|
// Legacy support: Parse old SPOTIFY_IMPORT_PLAYLIST_IDS/NAMES env vars
|
|
// Only used if new Playlists format is not configured
|
|
// Check if we have legacy env vars to parse
|
|
var playlistIdsEnv = builder.Configuration.GetValue<string>("SpotifyImport:PlaylistIds");
|
|
var playlistNamesEnv = builder.Configuration.GetValue<string>("SpotifyImport:PlaylistNames");
|
|
var hasLegacyConfig = !string.IsNullOrWhiteSpace(playlistIdsEnv) || !string.IsNullOrWhiteSpace(playlistNamesEnv);
|
|
|
|
if (hasLegacyConfig && options.Playlists.Count == 0)
|
|
{
|
|
Console.WriteLine("Parsing legacy Spotify playlist format...");
|
|
|
|
#pragma warning disable CS0618 // Type or member is obsolete
|
|
|
|
// Clear any auto-bound values from the Bind() call above
|
|
// The auto-binder doesn't handle comma-separated strings correctly
|
|
options.PlaylistIds.Clear();
|
|
options.PlaylistNames.Clear();
|
|
options.PlaylistLocalTracksPositions.Clear();
|
|
|
|
if (!string.IsNullOrWhiteSpace(playlistIdsEnv))
|
|
{
|
|
options.PlaylistIds = playlistIdsEnv
|
|
.Split(',', StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(id => id.Trim())
|
|
.Where(id => !string.IsNullOrEmpty(id))
|
|
.ToList();
|
|
Console.WriteLine($" Parsed {options.PlaylistIds.Count} playlist IDs from env var");
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(playlistNamesEnv))
|
|
{
|
|
options.PlaylistNames = playlistNamesEnv
|
|
.Split(',', StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(name => name.Trim())
|
|
.Where(name => !string.IsNullOrEmpty(name))
|
|
.ToList();
|
|
Console.WriteLine($" Parsed {options.PlaylistNames.Count} playlist names from env var");
|
|
}
|
|
|
|
var playlistPositionsEnv = builder.Configuration.GetValue<string>("SpotifyImport:PlaylistLocalTracksPositions");
|
|
if (!string.IsNullOrWhiteSpace(playlistPositionsEnv))
|
|
{
|
|
options.PlaylistLocalTracksPositions = playlistPositionsEnv
|
|
.Split(',', StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(pos => pos.Trim())
|
|
.Where(pos => !string.IsNullOrEmpty(pos))
|
|
.ToList();
|
|
Console.WriteLine($" Parsed {options.PlaylistLocalTracksPositions.Count} playlist positions from env var");
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine(" No playlist positions env var found, will use defaults");
|
|
}
|
|
|
|
// Convert legacy format to new Playlists array
|
|
Console.WriteLine($" Converting {options.PlaylistIds.Count} playlists to new format...");
|
|
for (int i = 0; i < options.PlaylistIds.Count; i++)
|
|
{
|
|
var name = i < options.PlaylistNames.Count ? options.PlaylistNames[i] : options.PlaylistIds[i];
|
|
var position = LocalTracksPosition.First; // Default
|
|
|
|
// Parse position if provided
|
|
if (i < options.PlaylistLocalTracksPositions.Count)
|
|
{
|
|
var posStr = options.PlaylistLocalTracksPositions[i];
|
|
if (posStr.Equals("last", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
position = LocalTracksPosition.Last;
|
|
}
|
|
}
|
|
|
|
options.Playlists.Add(new SpotifyPlaylistConfig
|
|
{
|
|
Name = name,
|
|
Id = options.PlaylistIds[i],
|
|
LocalTracksPosition = position
|
|
});
|
|
Console.WriteLine($" [{i}] {name} (ID: {options.PlaylistIds[i]}, Position: {position})");
|
|
}
|
|
#pragma warning restore CS0618
|
|
}
|
|
else if (hasLegacyConfig && options.Playlists.Count > 0)
|
|
{
|
|
// Bind() incorrectly populated Playlists from legacy env vars
|
|
// Clear it and re-parse properly
|
|
Console.WriteLine($"DEBUG: Bind() incorrectly populated {options.Playlists.Count} playlists, clearing and re-parsing...");
|
|
options.Playlists.Clear();
|
|
options.PlaylistIds.Clear();
|
|
options.PlaylistNames.Clear();
|
|
options.PlaylistLocalTracksPositions.Clear();
|
|
|
|
Console.WriteLine("Parsing legacy Spotify playlist format...");
|
|
|
|
#pragma warning disable CS0618 // Type or member is obsolete
|
|
|
|
if (!string.IsNullOrWhiteSpace(playlistIdsEnv))
|
|
{
|
|
options.PlaylistIds = playlistIdsEnv
|
|
.Split(',', StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(id => id.Trim())
|
|
.Where(id => !string.IsNullOrEmpty(id))
|
|
.ToList();
|
|
Console.WriteLine($" Parsed {options.PlaylistIds.Count} playlist IDs from env var");
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(playlistNamesEnv))
|
|
{
|
|
options.PlaylistNames = playlistNamesEnv
|
|
.Split(',', StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(name => name.Trim())
|
|
.Where(name => !string.IsNullOrEmpty(name))
|
|
.ToList();
|
|
Console.WriteLine($" Parsed {options.PlaylistNames.Count} playlist names from env var");
|
|
}
|
|
|
|
var playlistPositionsEnv = builder.Configuration.GetValue<string>("SpotifyImport:PlaylistLocalTracksPositions");
|
|
if (!string.IsNullOrWhiteSpace(playlistPositionsEnv))
|
|
{
|
|
options.PlaylistLocalTracksPositions = playlistPositionsEnv
|
|
.Split(',', StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(pos => pos.Trim())
|
|
.Where(pos => !string.IsNullOrEmpty(pos))
|
|
.ToList();
|
|
Console.WriteLine($" Parsed {options.PlaylistLocalTracksPositions.Count} playlist positions from env var");
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine(" No playlist positions env var found, will use defaults");
|
|
}
|
|
|
|
// Convert legacy format to new Playlists array
|
|
Console.WriteLine($" Converting {options.PlaylistIds.Count} playlists to new format...");
|
|
for (int i = 0; i < options.PlaylistIds.Count; i++)
|
|
{
|
|
var name = i < options.PlaylistNames.Count ? options.PlaylistNames[i] : options.PlaylistIds[i];
|
|
var position = LocalTracksPosition.First; // Default
|
|
|
|
// Parse position if provided
|
|
if (i < options.PlaylistLocalTracksPositions.Count)
|
|
{
|
|
var posStr = options.PlaylistLocalTracksPositions[i];
|
|
if (posStr.Equals("last", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
position = LocalTracksPosition.Last;
|
|
}
|
|
}
|
|
|
|
options.Playlists.Add(new SpotifyPlaylistConfig
|
|
{
|
|
Name = name,
|
|
Id = options.PlaylistIds[i],
|
|
LocalTracksPosition = position
|
|
});
|
|
Console.WriteLine($" [{i}] {name} (ID: {options.PlaylistIds[i]}, Position: {position})");
|
|
}
|
|
#pragma warning restore CS0618
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine($"Using new Playlists format: {options.Playlists.Count} playlists configured");
|
|
}
|
|
|
|
// Log configuration at startup
|
|
Console.WriteLine($"Spotify Import: Enabled={options.Enabled}, SyncHour={options.SyncStartHour}:{options.SyncStartMinute:D2}, WindowHours={options.SyncWindowHours}");
|
|
Console.WriteLine($"Spotify Import Playlists: {options.Playlists.Count} configured");
|
|
foreach (var playlist in options.Playlists)
|
|
{
|
|
Console.WriteLine($" - {playlist.Name} (ID: {playlist.Id}, LocalTracks: {playlist.LocalTracksPosition})");
|
|
}
|
|
});
|
|
|
|
// Get shared settings from the active backend config
|
|
MusicService musicService;
|
|
bool enableExternalPlaylists;
|
|
|
|
if (backendType == BackendType.Jellyfin)
|
|
{
|
|
musicService = builder.Configuration.GetValue<MusicService>("Jellyfin:MusicService");
|
|
enableExternalPlaylists = builder.Configuration.GetValue<bool>("Jellyfin:EnableExternalPlaylists", true);
|
|
}
|
|
else
|
|
{
|
|
// Default to Subsonic
|
|
musicService = builder.Configuration.GetValue<MusicService>("Subsonic:MusicService");
|
|
enableExternalPlaylists = builder.Configuration.GetValue<bool>("Subsonic:EnableExternalPlaylists", true);
|
|
}
|
|
|
|
// Business services - shared across backends
|
|
builder.Services.AddSingleton<RedisCacheService>();
|
|
builder.Services.AddSingleton<ILocalLibraryService, LocalLibraryService>();
|
|
builder.Services.AddSingleton<LrclibService>();
|
|
|
|
// Register backend-specific services
|
|
if (backendType == BackendType.Jellyfin)
|
|
{
|
|
// Jellyfin services
|
|
builder.Services.AddSingleton<JellyfinResponseBuilder>();
|
|
builder.Services.AddSingleton<JellyfinModelMapper>();
|
|
builder.Services.AddScoped<JellyfinProxyService>();
|
|
builder.Services.AddSingleton<JellyfinSessionManager>();
|
|
builder.Services.AddScoped<JellyfinAuthFilter>();
|
|
builder.Services.AddScoped<allstarr.Filters.ApiKeyAuthFilter>();
|
|
}
|
|
else
|
|
{
|
|
// Subsonic services (default)
|
|
builder.Services.AddSingleton<SubsonicRequestParser>();
|
|
builder.Services.AddSingleton<SubsonicResponseBuilder>();
|
|
builder.Services.AddSingleton<SubsonicModelMapper>();
|
|
builder.Services.AddScoped<SubsonicProxyService>();
|
|
}
|
|
|
|
// Register music service based on configuration
|
|
// IMPORTANT: Primary service MUST be registered LAST because ASP.NET Core DI
|
|
// will use the last registered implementation when injecting IMusicMetadataService/IDownloadService
|
|
if (musicService == MusicService.Qobuz)
|
|
{
|
|
// If playlists enabled, register Deezer FIRST (secondary provider)
|
|
if (enableExternalPlaylists)
|
|
{
|
|
builder.Services.AddSingleton<IMusicMetadataService, DeezerMetadataService>();
|
|
builder.Services.AddSingleton<IDownloadService, DeezerDownloadService>();
|
|
builder.Services.AddSingleton<PlaylistSyncService>();
|
|
}
|
|
|
|
// Qobuz services (primary) - registered LAST to be injected by default
|
|
builder.Services.AddSingleton<QobuzBundleService>();
|
|
builder.Services.AddSingleton<IMusicMetadataService, QobuzMetadataService>();
|
|
builder.Services.AddSingleton<IDownloadService, QobuzDownloadService>();
|
|
}
|
|
else if (musicService == MusicService.Deezer)
|
|
{
|
|
// If playlists enabled, register Qobuz FIRST (secondary provider)
|
|
if (enableExternalPlaylists)
|
|
{
|
|
builder.Services.AddSingleton<QobuzBundleService>();
|
|
builder.Services.AddSingleton<IMusicMetadataService, QobuzMetadataService>();
|
|
builder.Services.AddSingleton<IDownloadService, QobuzDownloadService>();
|
|
builder.Services.AddSingleton<PlaylistSyncService>();
|
|
}
|
|
|
|
// Deezer services (primary, default) - registered LAST to be injected by default
|
|
builder.Services.AddSingleton<IMusicMetadataService, DeezerMetadataService>();
|
|
builder.Services.AddSingleton<IDownloadService, DeezerDownloadService>();
|
|
}
|
|
else if (musicService == MusicService.SquidWTF)
|
|
{
|
|
// SquidWTF services - pass decoded URLs with fallback support
|
|
builder.Services.AddSingleton<IMusicMetadataService>(sp =>
|
|
new SquidWTFMetadataService(
|
|
sp.GetRequiredService<IHttpClientFactory>(),
|
|
sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SubsonicSettings>>(),
|
|
sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(),
|
|
sp.GetRequiredService<ILogger<SquidWTFMetadataService>>(),
|
|
sp.GetRequiredService<RedisCacheService>(),
|
|
squidWtfApiUrls));
|
|
builder.Services.AddSingleton<IDownloadService>(sp =>
|
|
new SquidWTFDownloadService(
|
|
sp.GetRequiredService<IHttpClientFactory>(),
|
|
sp.GetRequiredService<IConfiguration>(),
|
|
sp.GetRequiredService<ILocalLibraryService>(),
|
|
sp.GetRequiredService<IMusicMetadataService>(),
|
|
sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SubsonicSettings>>(),
|
|
sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(),
|
|
sp,
|
|
sp.GetRequiredService<ILogger<SquidWTFDownloadService>>(),
|
|
squidWtfApiUrls));
|
|
}
|
|
|
|
// Startup validation - register validators based on backend
|
|
if (backendType == BackendType.Jellyfin)
|
|
{
|
|
builder.Services.AddSingleton<IStartupValidator, JellyfinStartupValidator>();
|
|
}
|
|
else
|
|
{
|
|
builder.Services.AddSingleton<IStartupValidator, SubsonicStartupValidator>();
|
|
}
|
|
|
|
builder.Services.AddSingleton<IStartupValidator, DeezerStartupValidator>();
|
|
builder.Services.AddSingleton<IStartupValidator, QobuzStartupValidator>();
|
|
builder.Services.AddSingleton<IStartupValidator>(sp =>
|
|
new SquidWTFStartupValidator(
|
|
sp.GetRequiredService<Microsoft.Extensions.Options.IOptions<SquidWTFSettings>>(),
|
|
sp.GetRequiredService<IHttpClientFactory>().CreateClient(),
|
|
squidWtfApiUrls));
|
|
|
|
// Register orchestrator as hosted service
|
|
builder.Services.AddHostedService<StartupValidationOrchestrator>();
|
|
|
|
// Register cache cleanup service (only runs when StorageMode is Cache)
|
|
builder.Services.AddHostedService<CacheCleanupService>();
|
|
|
|
// Register Spotify API client, lyrics service, and settings for direct API access
|
|
// Configure from environment variables with SPOTIFY_API_ prefix
|
|
builder.Services.Configure<allstarr.Models.Settings.SpotifyApiSettings>(options =>
|
|
{
|
|
builder.Configuration.GetSection("SpotifyApi").Bind(options);
|
|
|
|
// Override from environment variables
|
|
var enabled = builder.Configuration.GetValue<string>("SpotifyApi:Enabled");
|
|
if (!string.IsNullOrEmpty(enabled))
|
|
{
|
|
options.Enabled = enabled.Equals("true", StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
|
|
var clientId = builder.Configuration.GetValue<string>("SpotifyApi:ClientId");
|
|
if (!string.IsNullOrEmpty(clientId))
|
|
{
|
|
options.ClientId = clientId;
|
|
}
|
|
|
|
var clientSecret = builder.Configuration.GetValue<string>("SpotifyApi:ClientSecret");
|
|
if (!string.IsNullOrEmpty(clientSecret))
|
|
{
|
|
options.ClientSecret = clientSecret;
|
|
}
|
|
|
|
var sessionCookie = builder.Configuration.GetValue<string>("SpotifyApi:SessionCookie");
|
|
if (!string.IsNullOrEmpty(sessionCookie))
|
|
{
|
|
options.SessionCookie = sessionCookie;
|
|
}
|
|
|
|
var cacheDuration = builder.Configuration.GetValue<int?>("SpotifyApi:CacheDurationMinutes");
|
|
if (cacheDuration.HasValue)
|
|
{
|
|
options.CacheDurationMinutes = cacheDuration.Value;
|
|
}
|
|
|
|
var preferIsrc = builder.Configuration.GetValue<string>("SpotifyApi:PreferIsrcMatching");
|
|
if (!string.IsNullOrEmpty(preferIsrc))
|
|
{
|
|
options.PreferIsrcMatching = preferIsrc.Equals("true", StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
|
|
// Log configuration (mask sensitive values)
|
|
Console.WriteLine($"SpotifyApi Configuration:");
|
|
Console.WriteLine($" Enabled: {options.Enabled}");
|
|
Console.WriteLine($" ClientId: {(string.IsNullOrEmpty(options.ClientId) ? "(not set)" : options.ClientId[..8] + "...")}");
|
|
Console.WriteLine($" SessionCookie: {(string.IsNullOrEmpty(options.SessionCookie) ? "(not set)" : "***" + options.SessionCookie[^8..])}");
|
|
Console.WriteLine($" CacheDurationMinutes: {options.CacheDurationMinutes}");
|
|
Console.WriteLine($" PreferIsrcMatching: {options.PreferIsrcMatching}");
|
|
});
|
|
builder.Services.AddSingleton<allstarr.Services.Spotify.SpotifyApiClient>();
|
|
|
|
// Register Spotify lyrics service (uses Spotify's color-lyrics API)
|
|
builder.Services.AddSingleton<allstarr.Services.Lyrics.SpotifyLyricsService>();
|
|
|
|
// Register Spotify playlist fetcher (uses direct Spotify API when SpotifyApi is enabled)
|
|
builder.Services.AddSingleton<allstarr.Services.Spotify.SpotifyPlaylistFetcher>();
|
|
builder.Services.AddHostedService(sp => sp.GetRequiredService<allstarr.Services.Spotify.SpotifyPlaylistFetcher>());
|
|
|
|
// Register Spotify missing tracks fetcher (legacy - only runs when SpotifyImport is enabled and SpotifyApi is disabled)
|
|
builder.Services.AddHostedService<allstarr.Services.Spotify.SpotifyMissingTracksFetcher>();
|
|
|
|
// Register Spotify track matching service (pre-matches tracks with rate limiting)
|
|
builder.Services.AddHostedService<allstarr.Services.Spotify.SpotifyTrackMatchingService>();
|
|
|
|
builder.Services.AddCors(options =>
|
|
{
|
|
options.AddDefaultPolicy(policy =>
|
|
{
|
|
policy.AllowAnyOrigin()
|
|
.AllowAnyMethod()
|
|
.AllowAnyHeader()
|
|
.WithExposedHeaders("X-Content-Duration", "X-Total-Count", "X-Nd-Authorization");
|
|
});
|
|
});
|
|
|
|
var app = builder.Build();
|
|
|
|
// Configure the HTTP request pipeline.
|
|
app.UseExceptionHandler(_ => { }); // Global exception handler
|
|
|
|
// Enable response compression EARLY in the pipeline
|
|
app.UseResponseCompression();
|
|
|
|
// Enable WebSocket support
|
|
app.UseWebSockets(new WebSocketOptions
|
|
{
|
|
KeepAliveInterval = TimeSpan.FromSeconds(120)
|
|
});
|
|
|
|
// Add WebSocket proxy middleware (BEFORE routing)
|
|
app.UseMiddleware<WebSocketProxyMiddleware>();
|
|
|
|
if (app.Environment.IsDevelopment())
|
|
{
|
|
app.UseSwagger();
|
|
app.UseSwaggerUI();
|
|
}
|
|
|
|
app.UseHttpsRedirection();
|
|
|
|
app.UseAuthorization();
|
|
|
|
app.UseCors();
|
|
|
|
app.MapControllers();
|
|
|
|
// Health check endpoint for monitoring
|
|
app.MapGet("/health", () => Results.Ok(new { status = "healthy", timestamp = DateTime.UtcNow }));
|
|
|
|
app.Run();
|
|
|
|
/// <summary>
|
|
/// Controller feature provider that conditionally registers controllers based on backend type.
|
|
/// This prevents route conflicts between JellyfinController and SubsonicController catch-all routes.
|
|
/// </summary>
|
|
class BackendControllerFeatureProvider : Microsoft.AspNetCore.Mvc.Controllers.ControllerFeatureProvider
|
|
{
|
|
private readonly BackendType _backendType;
|
|
|
|
public BackendControllerFeatureProvider(BackendType backendType)
|
|
{
|
|
_backendType = backendType;
|
|
}
|
|
|
|
protected override bool IsController(System.Reflection.TypeInfo typeInfo)
|
|
{
|
|
var isController = base.IsController(typeInfo);
|
|
if (!isController) return false;
|
|
|
|
// Only register the controller matching the configured backend type
|
|
return _backendType switch
|
|
{
|
|
BackendType.Jellyfin => typeInfo.Name == "JellyfinController",
|
|
BackendType.Subsonic => typeInfo.Name == "SubsonicController",
|
|
_ => false
|
|
};
|
|
}
|
|
}
|