joshpatra/allstarr
1
0
Fork 0
mirror of https://github.com/SoPat712/allstarr.git synced 2026-02-09 23:55:10 -05:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

refactor: extract BaseDownloadService to eliminate code duplication between providers

Browse Source
This commit is contained in:
V1ck3s
2026-01-08 19:39:06 +01:00
parent 43c9a2e808
commit c38291efa3
3 changed files with 495 additions and 817 deletions
Download Patch File Download Diff File Expand all files Collapse all files

400
octo-fiesta/Services/Qobuz/QobuzDownloadService.cs
View File

@@ -2,9 +2,9 @@ using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using octo_fiesta.Models;
using octo_fiesta.Services;
using octo_fiesta.Services.Deezer;
using octo_fiesta.Services.Local;
using octo_fiesta.Services.Common;
using octo_fiesta.Services.Deezer;
using Microsoft.Extensions.Options;
using IOFile = System.IO.File;
@@ -14,24 +14,14 @@ namespace octo_fiesta.Services.Qobuz;
/// Download service implementation for Qobuz
/// Handles track downloading with MD5 signature for authentication
/// </summary>
public class QobuzDownloadService : IDownloadService
public class QobuzDownloadService : BaseDownloadService
{
private readonly HttpClient _httpClient;
private readonly IConfiguration _configuration;
private readonly ILocalLibraryService _localLibraryService;
private readonly IMusicMetadataService _metadataService;
private readonly QobuzBundleService _bundleService;
private readonly SubsonicSettings _subsonicSettings;
private readonly ILogger<QobuzDownloadService> _logger;
private readonly string _downloadPath;
private readonly string? _userAuthToken;
private readonly string? _userId;
private readonly string? _preferredQuality;
private readonly Dictionary<string, DownloadInfo> _activeDownloads = new();
private readonly SemaphoreSlim _downloadLock = new(1, 1);
private const string BaseUrl = "https://www.qobuz.com/api.json/0.2/";
// Quality format IDs
@@ -40,6 +30,8 @@ public class QobuzDownloadService : IDownloadService
private const int FormatFlac24Low = 7; // 24-bit < 96kHz
private const int FormatFlac24High = 27; // 24-bit >= 96kHz
protected override string ProviderName => "qobuz";
public QobuzDownloadService(
IHttpClientFactory httpClientFactory,
IConfiguration configuration,
@@ -49,252 +41,57 @@ public class QobuzDownloadService : IDownloadService
IOptions<SubsonicSettings> subsonicSettings,
IOptions<QobuzSettings> qobuzSettings,
ILogger<QobuzDownloadService> logger)
: base(configuration, localLibraryService, metadataService, subsonicSettings.Value, logger)
{
_httpClient = httpClientFactory.CreateClient();
_configuration = configuration;
_localLibraryService = localLibraryService;
_metadataService = metadataService;
_bundleService = bundleService;
_subsonicSettings = subsonicSettings.Value;
_logger = logger;
_downloadPath = configuration["Library:DownloadPath"] ?? "./downloads";
var qobuzConfig = qobuzSettings.Value;
_userAuthToken = qobuzConfig.UserAuthToken;
_userId = qobuzConfig.UserId;
_preferredQuality = qobuzConfig.Quality;
if (!Directory.Exists(_downloadPath))
{
Directory.CreateDirectory(_downloadPath);
}
}
#region IDownloadService Implementation
#region BaseDownloadService Implementation
public async Task<string> DownloadSongAsync(string externalProvider, string externalId, CancellationToken cancellationToken = default)
{
return await DownloadSongInternalAsync(externalProvider, externalId, triggerAlbumDownload: true, cancellationToken);
}
/// <summary>
/// Internal method for downloading a song with control over album download triggering
/// </summary>
private async Task<string> DownloadSongInternalAsync(string externalProvider, string externalId, bool triggerAlbumDownload, CancellationToken cancellationToken = default)
{
if (externalProvider != "qobuz")
{
throw new NotSupportedException($"Provider '{externalProvider}' is not supported");
}
var songId = $"ext-{externalProvider}-{externalId}";
// Check if already downloaded
var existingPath = await _localLibraryService.GetLocalPathForExternalSongAsync(externalProvider, externalId);
if (existingPath != null && IOFile.Exists(existingPath))
{
_logger.LogInformation("Song already downloaded: {Path}", existingPath);
return existingPath;
}
// Check if download in progress
if (_activeDownloads.TryGetValue(songId, out var activeDownload) && activeDownload.Status == DownloadStatus.InProgress)
{
_logger.LogInformation("Download already in progress for {SongId}", songId);
while (_activeDownloads.TryGetValue(songId, out activeDownload) && activeDownload.Status == DownloadStatus.InProgress)
{
await Task.Delay(500, cancellationToken);
}
if (activeDownload?.Status == DownloadStatus.Completed && activeDownload.LocalPath != null)
{
return activeDownload.LocalPath;
}
throw new Exception(activeDownload?.ErrorMessage ?? "Download failed");
}
await _downloadLock.WaitAsync(cancellationToken);
try
{
// Get metadata
var song = await _metadataService.GetSongAsync(externalProvider, externalId);
if (song == null)
{
throw new Exception("Song not found");
}
var downloadInfo = new DownloadInfo
{
SongId = songId,
ExternalId = externalId,
ExternalProvider = externalProvider,
Status = DownloadStatus.InProgress,
StartedAt = DateTime.UtcNow
};
_activeDownloads[songId] = downloadInfo;
try
{
var localPath = await DownloadTrackAsync(externalId, song, cancellationToken);
downloadInfo.Status = DownloadStatus.Completed;
downloadInfo.LocalPath = localPath;
downloadInfo.CompletedAt = DateTime.UtcNow;
song.LocalPath = localPath;
await _localLibraryService.RegisterDownloadedSongAsync(song, localPath);
// Trigger a Subsonic library rescan (with debounce)
_ = Task.Run(async () =>
{
try
{
await _localLibraryService.TriggerLibraryScanAsync();
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Failed to trigger library scan after download");
}
});
// If download mode is Album and triggering is enabled, start background download of remaining tracks
if (triggerAlbumDownload && _subsonicSettings.DownloadMode == DownloadMode.Album && !string.IsNullOrEmpty(song.AlbumId))
{
var albumExternalId = ExtractExternalIdFromAlbumId(song.AlbumId);
if (!string.IsNullOrEmpty(albumExternalId))
{
_logger.LogInformation("Download mode is Album, triggering background download for album {AlbumId}", albumExternalId);
DownloadRemainingAlbumTracksInBackground(externalProvider, albumExternalId, externalId);
}
}
_logger.LogInformation("Download completed: {Path}", localPath);
return localPath;
}
catch (Exception ex)
{
downloadInfo.Status = DownloadStatus.Failed;
downloadInfo.ErrorMessage = ex.Message;
_logger.LogError(ex, "Download failed for {SongId}", songId);
throw;
}
}
finally
{
_downloadLock.Release();
}
}
public async Task<Stream> DownloadAndStreamAsync(string externalProvider, string externalId, CancellationToken cancellationToken = default)
{
var localPath = await DownloadSongAsync(externalProvider, externalId, cancellationToken);
return IOFile.OpenRead(localPath);
}
public DownloadInfo? GetDownloadStatus(string songId)
{
_activeDownloads.TryGetValue(songId, out var info);
return info;
}
public async Task<bool> IsAvailableAsync()
public override async Task<bool> IsAvailableAsync()
{
if (string.IsNullOrEmpty(_userAuthToken) || string.IsNullOrEmpty(_userId))
{
_logger.LogWarning("Qobuz user auth token or user ID not configured");
Logger.LogWarning("Qobuz user auth token or user ID not configured");
return false;
}
try
{
// Try to extract app ID and secrets
await _bundleService.GetAppIdAsync();
await _bundleService.GetSecretsAsync();
return true;
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Qobuz service not available");
Logger.LogWarning(ex, "Qobuz service not available");
return false;
}
}
public void DownloadRemainingAlbumTracksInBackground(string externalProvider, string albumExternalId, string excludeTrackExternalId)
protected override string? ExtractExternalIdFromAlbumId(string albumId)
{
if (externalProvider != "qobuz")
const string prefix = "ext-qobuz-album-";
if (albumId.StartsWith(prefix))
{
_logger.LogWarning("Provider '{Provider}' is not supported for album download", externalProvider);
return;
return albumId[prefix.Length..];
}
_ = Task.Run(async () =>
{
try
{
await DownloadRemainingAlbumTracksAsync(albumExternalId, excludeTrackExternalId);
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to download remaining album tracks for album {AlbumId}", albumExternalId);
}
});
return null;
}
private async Task DownloadRemainingAlbumTracksAsync(string albumExternalId, string excludeTrackExternalId)
{
_logger.LogInformation("Starting background download for album {AlbumId} (excluding track {TrackId})",
albumExternalId, excludeTrackExternalId);
var album = await _metadataService.GetAlbumAsync("qobuz", albumExternalId);
if (album == null)
{
_logger.LogWarning("Album {AlbumId} not found, cannot download remaining tracks", albumExternalId);
return;
}
var tracksToDownload = album.Songs
.Where(s => s.ExternalId != excludeTrackExternalId && !string.IsNullOrEmpty(s.ExternalId))
.ToList();
_logger.LogInformation("Found {Count} additional tracks to download for album '{AlbumTitle}'",
tracksToDownload.Count, album.Title);
foreach (var track in tracksToDownload)
{
try
{
var existingPath = await _localLibraryService.GetLocalPathForExternalSongAsync("qobuz", track.ExternalId!);
if (existingPath != null && IOFile.Exists(existingPath))
{
_logger.LogDebug("Track {TrackId} already downloaded, skipping", track.ExternalId);
continue;
}
_logger.LogInformation("Downloading track '{Title}' from album '{Album}'", track.Title, album.Title);
await DownloadSongInternalAsync("qobuz", track.ExternalId!, triggerAlbumDownload: false, CancellationToken.None);
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Failed to download track {TrackId} '{Title}'", track.ExternalId, track.Title);
}
}
_logger.LogInformation("Completed background download for album '{AlbumTitle}'", album.Title);
}
#endregion
#region Qobuz Download Methods
private async Task<string> DownloadTrackAsync(string trackId, Song song, CancellationToken cancellationToken)
protected override async Task<string> DownloadTrackAsync(string trackId, Song song, CancellationToken cancellationToken)
{
// Get the download URL with signature
var downloadInfo = await GetTrackDownloadUrlAsync(trackId, cancellationToken);
_logger.LogInformation("Download URL obtained for: {Title} - {Artist}", song.Title, song.Artist);
_logger.LogInformation("Quality: {BitDepth}bit/{SamplingRate}kHz, Format: {MimeType}",
Logger.LogInformation("Download URL obtained for: {Title} - {Artist}", song.Title, song.Artist);
Logger.LogInformation("Quality: {BitDepth}bit/{SamplingRate}kHz, Format: {MimeType}",
downloadInfo.BitDepth, downloadInfo.SamplingRate, downloadInfo.MimeType);
// Check if it's a demo/sample
@@ -308,7 +105,7 @@ public class QobuzDownloadService : IDownloadService
// Build organized folder structure using AlbumArtist (fallback to Artist for singles)
var artistForPath = song.AlbumArtist ?? song.Artist;
var outputPath = PathHelper.BuildTrackPath(_downloadPath, artistForPath, song.Album, song.Title, song.Track, extension);
var outputPath = PathHelper.BuildTrackPath(DownloadPath, artistForPath, song.Album, song.Title, song.Track, extension);
var albumFolder = Path.GetDirectoryName(outputPath)!;
EnsureDirectoryExists(albumFolder);
@@ -331,6 +128,10 @@ public class QobuzDownloadService : IDownloadService
return outputPath;
}
#endregion
#region Qobuz Download Methods
/// <summary>
/// Gets the download URL for a track with proper MD5 signature
/// </summary>
@@ -365,7 +166,7 @@ public class QobuzDownloadService : IDownloadService
// Check if quality was downgraded
if (result.WasQualityDowngraded)
{
_logger.LogWarning("Requested quality not available, Qobuz downgraded to {BitDepth}bit/{SamplingRate}kHz",
Logger.LogWarning("Requested quality not available, Qobuz downgraded to {BitDepth}bit/{SamplingRate}kHz",
result.BitDepth, result.SamplingRate);
}
@@ -374,7 +175,7 @@ public class QobuzDownloadService : IDownloadService
catch (Exception ex)
{
lastException = ex;
_logger.LogDebug("Failed to get download URL with secret {SecretIndex}, format {Format}: {Error}",
Logger.LogDebug("Failed to get download URL with secret {SecretIndex}, format {Format}: {Error}",
secretIndex, format, ex.Message);
}
}
@@ -389,12 +190,10 @@ public class QobuzDownloadService : IDownloadService
var appId = await _bundleService.GetAppIdAsync();
var signature = ComputeMD5Signature(trackId, formatId, unix, secret);
// Build URL with required parameters (app_id goes in header only, not in URL params)
var url = $"{BaseUrl}track/getFileUrl?format_id={formatId}&intent=stream&request_ts={unix}&track_id={trackId}&request_sig={signature}";
using var request = new HttpRequestMessage(HttpMethod.Get, url);
// Add required headers (matching qobuz-dl Python implementation)
request.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0");
request.Headers.Add("X-App-Id", appId);
@@ -404,20 +203,16 @@ public class QobuzDownloadService : IDownloadService
}
var response = await _httpClient.SendAsync(request, cancellationToken);
// Read response body
var responseBody = await response.Content.ReadAsStringAsync(cancellationToken);
// Log error response if not successful
if (!response.IsSuccessStatusCode)
{
_logger.LogDebug("Qobuz getFileUrl failed - Status: {StatusCode}, TrackId: {TrackId}, FormatId: {FormatId}",
Logger.LogDebug("Qobuz getFileUrl failed - Status: {StatusCode}, TrackId: {TrackId}, FormatId: {FormatId}",
response.StatusCode, trackId, formatId);
throw new HttpRequestException($"Response status code does not indicate success: {response.StatusCode} ({response.ReasonPhrase})");
}
var json = responseBody;
var doc = JsonDocument.Parse(json);
var doc = JsonDocument.Parse(responseBody);
var root = doc.RootElement;
if (!root.TryGetProperty("url", out var urlElement) || string.IsNullOrEmpty(urlElement.GetString()))
@@ -430,16 +225,12 @@ public class QobuzDownloadService : IDownloadService
var bitDepth = root.TryGetProperty("bit_depth", out var bd) ? bd.GetInt32() : 16;
var samplingRate = root.TryGetProperty("sampling_rate", out var sr) ? sr.GetDouble() : 44.1;
// Check if it's a sample/demo
var isSample = root.TryGetProperty("sample", out var sampleEl) && sampleEl.GetBoolean();
// If sampling_rate is null/0, it's likely a demo
if (samplingRate == 0)
{
isSample = true;
}
// Check for quality restrictions/downgrades
var wasDowngraded = false;
if (root.TryGetProperty("restrictions", out var restrictions))
{
@@ -470,12 +261,9 @@ public class QobuzDownloadService : IDownloadService
/// <summary>
/// Computes MD5 signature for track download request
/// Format based on qobuz-dl: trackgetFileUrlformat_id{X}intentstreamtrack_id{Y}{TIMESTAMP}{SECRET}
/// </summary>
private string ComputeMD5Signature(string trackId, int formatId, long timestamp, string secret)
{
// EXACT format from qobuz-dl Python implementation:
// "trackgetFileUrlformat_id{}intentstreamtrack_id{}{}{}".format(fmt_id, track_id, unix, secret)
var toSign = $"trackgetFileUrlformat_id{formatId}intentstreamtrack_id{trackId}{timestamp}{secret}";
using var md5 = MD5.Create();
@@ -492,7 +280,7 @@ public class QobuzDownloadService : IDownloadService
{
if (string.IsNullOrEmpty(quality))
{
return FormatFlac24High; // Default to highest quality
return FormatFlac24High;
}
return quality.ToUpperInvariant() switch
@@ -507,148 +295,18 @@ public class QobuzDownloadService : IDownloadService
}
/// <summary>
/// Gets the list of format IDs to try in priority order (highest to lowest)
/// Gets the list of format IDs to try in priority order
/// </summary>
private List<int> GetFormatPriority(int preferredFormat)
{
var allFormats = new List<int> { FormatFlac24High, FormatFlac24Low, FormatFlac16, FormatMp3320 };
// Start with preferred format, then try others in descending quality order
var priority = new List<int> { preferredFormat };
priority.AddRange(allFormats.Where(f => f != preferredFormat));
return priority;
}
/// <summary>
/// Writes ID3/Vorbis metadata and cover art to the audio file
/// </summary>
private async Task WriteMetadataAsync(string filePath, Song song, CancellationToken cancellationToken)
{
try
{
_logger.LogInformation("Writing metadata to: {Path}", filePath);
using var tagFile = TagLib.File.Create(filePath);
tagFile.Tag.Title = song.Title;
tagFile.Tag.Performers = new[] { song.Artist };
tagFile.Tag.Album = song.Album;
tagFile.Tag.AlbumArtists = new[] { !string.IsNullOrEmpty(song.AlbumArtist) ? song.AlbumArtist : song.Artist };
if (song.Track.HasValue)
tagFile.Tag.Track = (uint)song.Track.Value;
if (song.TotalTracks.HasValue)
tagFile.Tag.TrackCount = (uint)song.TotalTracks.Value;
if (song.DiscNumber.HasValue)
tagFile.Tag.Disc = (uint)song.DiscNumber.Value;
if (song.Year.HasValue)
tagFile.Tag.Year = (uint)song.Year.Value;
if (!string.IsNullOrEmpty(song.Genre))
tagFile.Tag.Genres = new[] { song.Genre };
if (song.Bpm.HasValue)
tagFile.Tag.BeatsPerMinute = (uint)song.Bpm.Value;
if (song.Contributors.Count > 0)
tagFile.Tag.Composers = song.Contributors.ToArray();
if (!string.IsNullOrEmpty(song.Copyright))
tagFile.Tag.Copyright = song.Copyright;
var comments = new List<string>();
if (!string.IsNullOrEmpty(song.Isrc))
comments.Add($"ISRC: {song.Isrc}");
if (comments.Count > 0)
tagFile.Tag.Comment = string.Join(" | ", comments);
// Download and embed cover art
var coverUrl = song.CoverArtUrlLarge ?? song.CoverArtUrl;
if (!string.IsNullOrEmpty(coverUrl))
{
try
{
var coverData = await DownloadCoverArtAsync(coverUrl, cancellationToken);
if (coverData != null && coverData.Length > 0)
{
var mimeType = coverUrl.Contains(".png") ? "image/png" : "image/jpeg";
var picture = new TagLib.Picture
{
Type = TagLib.PictureType.FrontCover,
MimeType = mimeType,
Description = "Cover",
Data = new TagLib.ByteVector(coverData)
};
tagFile.Tag.Pictures = new TagLib.IPicture[] { picture };
_logger.LogInformation("Cover art embedded: {Size} bytes", coverData.Length);
}
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Failed to download cover art from {Url}", coverUrl);
}
}
tagFile.Save();
_logger.LogInformation("Metadata written successfully to: {Path}", filePath);
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to write metadata to: {Path}", filePath);
}
}
private async Task<byte[]?> DownloadCoverArtAsync(string url, CancellationToken cancellationToken)
{
try
{
var response = await _httpClient.GetAsync(url, cancellationToken);
response.EnsureSuccessStatusCode();
return await response.Content.ReadAsByteArrayAsync(cancellationToken);
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Failed to download cover art from {Url}", url);
return null;
}
}
#endregion
#region Utility Methods
private static string? ExtractExternalIdFromAlbumId(string albumId)
{
const string prefix = "ext-qobuz-album-";
if (albumId.StartsWith(prefix))
{
return albumId[prefix.Length..];
}
return null;
}
private void EnsureDirectoryExists(string path)
{
try
{
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
_logger.LogDebug("Created directory: {Path}", path);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to create directory: {Path}", path);
throw;
}
}
#endregion
private class QobuzDownloadResult