daniel-c-harvey
33d6f34d8a
Background-job transcode (ffmpeg/libopus) after source store; pure C# Ogg walker builds the 0.5s-bucketed granule→byte seek index + captures the OpusHead/OpusTags setup header into a per-track sidecar in a new track-opus vault. Best-effort, additive, regenerated on replace-audio.
476 lines
24 KiB
C#
476 lines
24 KiB
C#
using DeepDrftAPI.Services.Opus;
|
|
using DeepDrftContent;
|
|
using DeepDrftContent.Constants;
|
|
using DeepDrftContent.Processors;
|
|
using DeepDrftData;
|
|
using DeepDrftModels.DTOs;
|
|
using DeepDrftModels.Enums;
|
|
using NetBlocks.Models;
|
|
using FileDb = DeepDrftContent.FileDatabase.Services.FileDatabase;
|
|
|
|
namespace DeepDrftAPI.Services;
|
|
|
|
/// <summary>
|
|
/// Host-internal orchestrator that makes DeepDrftAPI the single authority over both the
|
|
/// vault (FileDatabase) and SQL metadata (DeepDrftData). Owns the two-database write/delete
|
|
/// flow so the controller stays a thin HTTP boundary and no caller coordinates the two stores.
|
|
/// </summary>
|
|
public class UnifiedTrackService
|
|
{
|
|
internal const string TrackNotFoundMessage = "Track not found.";
|
|
|
|
/// <summary>
|
|
/// Stable marker prefixed onto a cardinality-rejection message so the controller can map this
|
|
/// specific failure to 409 Conflict (a well-formed request that violates a domain rule),
|
|
/// distinct from the 400 (malformed) and 500 (processing) paths. The human-readable detail
|
|
/// follows the marker and is what the CMS surfaces to the admin.
|
|
/// </summary>
|
|
internal const string CardinalityViolationMarker = "CARDINALITY_VIOLATION: ";
|
|
|
|
/// <summary>
|
|
/// Stable marker prefixed onto a duplicate-release rejection so the controller can map it to 409
|
|
/// Conflict, the same way <see cref="CardinalityViolationMarker"/> is mapped. Fires when an upload
|
|
/// with no explicit releaseId would create a release whose (title, artist) already exists in the
|
|
/// catalogue — the upload form is a create-new tool, never an edit/append path. The human-readable
|
|
/// detail follows the marker and is what the CMS surfaces to the admin.
|
|
/// </summary>
|
|
internal const string DuplicateReleaseMarker = "DUPLICATE_RELEASE: ";
|
|
|
|
private readonly TrackContentService _contentTrackContentService;
|
|
private readonly ITrackService _sqlTrackService;
|
|
private readonly FileDb _fileDatabase;
|
|
private readonly WaveformProfileService _waveformProfileService;
|
|
private readonly IOpusTranscodeQueue _opusTranscodeQueue;
|
|
private readonly ILogger<UnifiedTrackService> _logger;
|
|
|
|
public UnifiedTrackService(
|
|
TrackContentService contentTrackContentService,
|
|
ITrackService sqlTrackService,
|
|
FileDb fileDatabase,
|
|
WaveformProfileService waveformProfileService,
|
|
IOpusTranscodeQueue opusTranscodeQueue,
|
|
ILogger<UnifiedTrackService> logger)
|
|
{
|
|
_contentTrackContentService = contentTrackContentService;
|
|
_sqlTrackService = sqlTrackService;
|
|
_fileDatabase = fileDatabase;
|
|
_waveformProfileService = waveformProfileService;
|
|
_opusTranscodeQueue = opusTranscodeQueue;
|
|
_logger = logger;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Process a supported audio file (.wav, .mp3, .flac) into the vault, then persist its metadata
|
|
/// to SQL. On success the returned DTO carries the SQL-assigned Id. If the vault write succeeds
|
|
/// but the SQL persist fails, the audio is orphaned under EntryKey — logged loudly so it is
|
|
/// recoverable manually.
|
|
/// </summary>
|
|
public async Task<ResultContainer<TrackDto>> UploadAsync(
|
|
string tempFilePath,
|
|
string trackName,
|
|
string artist,
|
|
string? album,
|
|
string? genre,
|
|
string? description,
|
|
DateOnly? releaseDate,
|
|
long createdByUserId,
|
|
string? originalFileName,
|
|
ReleaseType releaseType,
|
|
ReleaseMedium medium,
|
|
int trackNumber,
|
|
long? releaseId,
|
|
CancellationToken ct)
|
|
{
|
|
// Resolve which release this track lands on BEFORE the vault write, so a rejected upload never
|
|
// orphans audio. Two paths:
|
|
// - releaseId is null → CREATE path: this is the first row of a submit. (title, artist) must
|
|
// NOT already exist — the upload form creates new releases only. A pre-existing match is a
|
|
// duplicate and is blocked (409).
|
|
// - releaseId is set → ATTACH path: rows 2..N of a within-batch multi-track Cut, attaching
|
|
// to the release row 1 just created. No (title, artist) lookup — the release id is
|
|
// authoritative — so the within-batch build is never mistaken for a pre-existing duplicate.
|
|
// Both paths run the cardinality guard `(liveCount + 1) > Max` (not Session/Mix-hardcoded, so a
|
|
// future bounded medium is covered by the same line).
|
|
ResolvedRelease? resolved = null;
|
|
if (!string.IsNullOrWhiteSpace(album))
|
|
{
|
|
if (releaseId is { } attachId)
|
|
{
|
|
var attachPeek = await _sqlTrackService.GetReleaseByTitleAndArtist(album, artist, ct);
|
|
if (!attachPeek.Success)
|
|
{
|
|
var error = attachPeek.Messages.FirstOrDefault()?.Message ?? "Unknown error";
|
|
_logger.LogError("UploadAsync: release peek failed for ({Album}, {Artist}): {Error}", album, artist, error);
|
|
return ResultContainer<TrackDto>.CreateFailResult($"Could not verify the release: {error}");
|
|
}
|
|
|
|
// The attach target must be the same release the natural key resolves to — a guard against
|
|
// a stale/forged releaseId pointing at a different (title, artist) than this row carries.
|
|
if (attachPeek.Value is not { } target || target.Id != attachId)
|
|
{
|
|
return ResultContainer<TrackDto>.CreateFailResult(
|
|
$"{DuplicateReleaseMarker}The release this track should attach to could not be found. " +
|
|
"Start the upload again.");
|
|
}
|
|
|
|
var cardinalityCheck = CheckCardinality(target);
|
|
if (cardinalityCheck is { } violation)
|
|
return ResultContainer<TrackDto>.CreateFailResult(violation);
|
|
|
|
resolved = new ResolvedRelease(target.Id);
|
|
}
|
|
else
|
|
{
|
|
var peek = await _sqlTrackService.GetReleaseByTitleAndArtist(album, artist, ct);
|
|
if (!peek.Success)
|
|
{
|
|
var error = peek.Messages.FirstOrDefault()?.Message ?? "Unknown error";
|
|
_logger.LogError("UploadAsync: release peek failed for ({Album}, {Artist}): {Error}", album, artist, error);
|
|
return ResultContainer<TrackDto>.CreateFailResult($"Could not verify the release: {error}");
|
|
}
|
|
|
|
// CREATE path: a pre-existing (title, artist) is a duplicate. Block it — the form never
|
|
// edits or appends to an existing release.
|
|
if (peek.Value is { } existing)
|
|
{
|
|
return ResultContainer<TrackDto>.CreateFailResult(
|
|
$"{DuplicateReleaseMarker}A release titled '{existing.Title}' by {existing.Artist} already " +
|
|
"exists. The upload form creates new releases only — use the edit tools to change an existing one.");
|
|
}
|
|
// resolved stays null → FindOrCreateRelease below creates the release.
|
|
}
|
|
}
|
|
|
|
var unpersisted = await _contentTrackContentService.AddTrackAsync(
|
|
tempFilePath, trackName, artist, album, genre, releaseDate, originalFileName: originalFileName);
|
|
|
|
if (unpersisted is null)
|
|
{
|
|
_logger.LogWarning("UploadAsync: content TrackContentService returned null for {TrackName}", trackName);
|
|
return ResultContainer<TrackDto>.CreateFailResult("Failed to process and store WAV.");
|
|
}
|
|
|
|
unpersisted.TrackNumber = trackNumber;
|
|
|
|
// Resolve the release FK before persisting the track. An upload with an album lands on the
|
|
// shared release (created on first sighting); an upload without one stays a loose track with
|
|
// a null ReleaseId. Release-cardinal metadata (artist/genre/description/releaseDate/type/uploader)
|
|
// rides on the release, not the track.
|
|
long? resolvedReleaseId = resolved?.Id;
|
|
if (!string.IsNullOrWhiteSpace(album) && resolvedReleaseId is null)
|
|
{
|
|
// CREATE path only: the duplicate guard above proved no (title, artist) match exists, so this
|
|
// mints the release. (The attach path already resolved the id from the pre-check above and
|
|
// skips FindOrCreateRelease entirely, so a within-batch row never re-runs the natural-key find.)
|
|
var releaseData = new ReleaseDto
|
|
{
|
|
Title = album,
|
|
Artist = artist,
|
|
Genre = genre,
|
|
Description = description,
|
|
ReleaseDate = releaseDate,
|
|
ReleaseType = releaseType,
|
|
Medium = medium,
|
|
CreatedByUserId = createdByUserId,
|
|
};
|
|
|
|
// FindOrCreateRelease either creates a fresh release (WasCreated = true) or returns the
|
|
// row the concurrent winner just inserted (WasCreated = false). In the CREATE path the
|
|
// duplicate peek above already verified no pre-existing row exists — so WasCreated = false
|
|
// means we lost a concurrent-insert race. Treat that as the duplicate condition: reject
|
|
// rather than silently attaching, keeping the DB unique index as the final safety net.
|
|
var releaseResult = await _sqlTrackService.FindOrCreateRelease(album, artist, releaseData, ct);
|
|
if (!releaseResult.Success)
|
|
{
|
|
var error = releaseResult.Messages.FirstOrDefault()?.Message ?? "Unknown error";
|
|
_logger.LogError(
|
|
"Track persisted to vault but release resolution failed. Orphaned entry: {EntryKey}. Error: {Error}",
|
|
unpersisted.EntryKey, error);
|
|
return ResultContainer<TrackDto>.CreateFailResult($"Track was uploaded but could not be saved: {error}");
|
|
}
|
|
|
|
var (resolvedRelease, wasCreated) = releaseResult.Value;
|
|
if (!wasCreated)
|
|
{
|
|
// The winning concurrent upload created this release between our peek and our insert.
|
|
// Reject with the same marker the pre-flight peek uses so the controller maps it to 409.
|
|
return ResultContainer<TrackDto>.CreateFailResult(
|
|
$"{DuplicateReleaseMarker}A release titled '{resolvedRelease.Title}' by {resolvedRelease.Artist} already " +
|
|
"exists. The upload form creates new releases only — use the edit tools to change an existing one.");
|
|
}
|
|
|
|
resolvedReleaseId = resolvedRelease.Id;
|
|
}
|
|
|
|
var trackDto = TrackConverter.Convert(unpersisted);
|
|
trackDto.ReleaseId = resolvedReleaseId;
|
|
trackDto.Release = null; // FK already resolved; Create must not re-resolve a detached graph.
|
|
|
|
var saveResult = await _sqlTrackService.Create(trackDto);
|
|
if (!saveResult.Success || saveResult.Value is null)
|
|
{
|
|
// Vault write succeeded, SQL persist failed — audio is orphaned in the tracks vault
|
|
// under EntryKey. Log loudly (include EntryKey) so it is recoverable manually.
|
|
var error = saveResult.Messages.FirstOrDefault()?.Message ?? "Unknown error";
|
|
_logger.LogError(
|
|
"Track persisted to vault but SQL save failed. Orphaned entry: {EntryKey}. Error: {Error}",
|
|
unpersisted.EntryKey, error);
|
|
return ResultContainer<TrackDto>.CreateFailResult($"Track was uploaded but could not be saved: {error}");
|
|
}
|
|
|
|
// Best-effort waveform datums: both stores succeeded, so the upload is a success regardless of
|
|
// the datum outcome. A missing datum renders as a flat seekbar / blank visualizer on the
|
|
// frontend, so a failure here is logged and swallowed — never fails the upload.
|
|
await TryStoreWaveformDatumsAsync(unpersisted.EntryKey, ct);
|
|
|
|
// Schedule the low-data Opus derive (OQ6 / §3.1a): the track is persisted and lossless-playable
|
|
// NOW; the transcode + seek-index build run on a background worker. Non-blocking and best-effort
|
|
// — the upload response never waits on it, and a transcode failure leaves the track lossless-only.
|
|
_opusTranscodeQueue.Enqueue(unpersisted.EntryKey);
|
|
|
|
return saveResult;
|
|
}
|
|
|
|
// The release a track resolved onto before the vault write. A null Id is the create path (mint
|
|
// below); a non-null Id is the attach path (a within-batch multi-track Cut row 2..N).
|
|
private readonly record struct ResolvedRelease(long Id);
|
|
|
|
// The cardinality guard shared by the attach path and (historically) the create path: a release
|
|
// already at its medium's Max rejects a further track. Returns the marker-prefixed rejection
|
|
// message, or null when the add is within limits. The create path never trips this (a brand-new
|
|
// release has zero tracks and admits its first), so only the attach path calls it today.
|
|
private static string? CheckCardinality(ReleaseDto release)
|
|
{
|
|
var cardinality = MediumRules.CardinalityOf(release.Medium);
|
|
if (release.TrackCount + 1 > cardinality.Max)
|
|
{
|
|
return $"{CardinalityViolationMarker}A {release.Medium} release holds a single track; " +
|
|
$"'{release.Title}' already has one — edit the existing track or choose a different release.";
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replace an existing track's audio in place: look up the SQL row, swap only the vault bytes
|
|
/// keyed by its EntryKey, regenerate both waveform datums from the new audio, then write the
|
|
/// new duration to SQL. Track id, EntryKey, release membership, track number, and all other
|
|
/// metadata are preserved. The waveform regen is best-effort (a missing datum renders as a flat
|
|
/// seekbar / blank visualizer downstream), so a datum failure is logged and swallowed rather than
|
|
/// failing the replace. The duration write is not best-effort — a failure is surfaced so derived
|
|
/// aggregates (e.g. MixRuntimeSeconds) do not silently go stale. No release-cardinality cascade
|
|
/// applies: the track count is unchanged, so the single-track-Mix case stays intact.
|
|
/// </summary>
|
|
public async Task<Result> ReplaceAudioAsync(long trackId, string tempFilePath, CancellationToken ct)
|
|
{
|
|
var lookup = await _sqlTrackService.GetById(trackId);
|
|
if (!lookup.Success)
|
|
{
|
|
var error = lookup.Messages.FirstOrDefault()?.Message ?? "unknown error";
|
|
_logger.LogError("ReplaceAudioAsync: GetById failed for track {TrackId}: {Error}", trackId, error);
|
|
return Result.CreateFailResult("Failed to load track.");
|
|
}
|
|
|
|
if (lookup.Value is null)
|
|
{
|
|
return Result.CreateFailResult(TrackNotFoundMessage);
|
|
}
|
|
|
|
var entryKey = lookup.Value.EntryKey;
|
|
|
|
var newAudio = await _contentTrackContentService.ReplaceTrackAudioAsync(entryKey, tempFilePath);
|
|
if (newAudio is null)
|
|
{
|
|
_logger.LogWarning("ReplaceAudioAsync: content swap returned null for track {TrackId} ({EntryKey})", trackId, entryKey);
|
|
return Result.CreateFailResult("Failed to process and store the replacement audio.");
|
|
}
|
|
|
|
// The old waveform no longer matches the new bytes. Regenerate both datums in place; keyed
|
|
// by the same EntryKey, the re-run overwrites the stale data (proven re-runnable). The
|
|
// freshly stored buffer is the authoritative source — no re-read of the vault needed.
|
|
try
|
|
{
|
|
await _waveformProfileService.ComputeAndStoreAsync(newAudio.Buffer, entryKey);
|
|
await _waveformProfileService.ComputeAndStoreHighResAsync(newAudio.Buffer, entryKey, newAudio.Duration);
|
|
}
|
|
catch (Exception ex) when (ex is not OperationCanceledException)
|
|
{
|
|
_logger.LogError(ex, "ReplaceAudioAsync: waveform regen failed for {EntryKey}; replace unaffected.", entryKey);
|
|
}
|
|
|
|
// Write the new duration to SQL. The vault bytes are already swapped, so this is the
|
|
// authoritative metadata update for the replace. A failure here is surfaced (unlike the
|
|
// best-effort waveform regen above) because a stale DurationSeconds silently corrupts
|
|
// derived aggregates (e.g. MixRuntimeSeconds on the home stats endpoint).
|
|
var durationWrite = await _sqlTrackService.SetDuration(trackId, newAudio.Duration, ct);
|
|
if (!durationWrite.Success)
|
|
{
|
|
var error = durationWrite.Messages.FirstOrDefault()?.Message ?? "Unknown error";
|
|
_logger.LogError(
|
|
"ReplaceAudioAsync: vault swap succeeded but SQL duration update failed for track {TrackId} ({EntryKey}): {Error}",
|
|
trackId, entryKey, error);
|
|
return Result.CreateFailResult("Audio replaced but duration metadata could not be updated.");
|
|
}
|
|
|
|
// The stale Opus artifact (if any) no longer matches the new source. Schedule a background
|
|
// regenerate — the transcode service overwrites the prior artifacts in place keyed by the same
|
|
// EntryKey. Best-effort, off the request thread, mirrors the waveform regen above.
|
|
_opusTranscodeQueue.Enqueue(entryKey);
|
|
|
|
return Result.CreatePassResult();
|
|
}
|
|
|
|
// Compute and store both waveform datums for a freshly uploaded track: the fixed 512-bucket profile
|
|
// the player-bar seeker consumes, and the duration-derived high-res datum the lava visualizer
|
|
// consumes (phase-12 §5 — every track now carries one, computed at upload). Both source the same
|
|
// audio: read it back from the vault once (the authoritative parsed duration + the stored buffer)
|
|
// rather than re-reading and re-parsing the temp file. Best-effort throughout — never fails upload.
|
|
private async Task TryStoreWaveformDatumsAsync(string entryKey, CancellationToken ct)
|
|
{
|
|
try
|
|
{
|
|
var audio = await _contentTrackContentService.GetAudioBinaryAsync(entryKey);
|
|
if (audio is null)
|
|
{
|
|
_logger.LogWarning(
|
|
"Waveform datum step: no audio in vault for {EntryKey} immediately after store; skipping.",
|
|
entryKey);
|
|
return;
|
|
}
|
|
|
|
await _waveformProfileService.ComputeAndStoreAsync(audio.Buffer, entryKey);
|
|
await _waveformProfileService.ComputeAndStoreHighResAsync(audio.Buffer, entryKey, audio.Duration);
|
|
}
|
|
catch (Exception ex) when (ex is not OperationCanceledException)
|
|
{
|
|
_logger.LogError(ex, "Waveform datum step failed for {EntryKey}; upload unaffected.", entryKey);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// One-time backfill: for every non-deleted track whose SQL duration is still null, read the
|
|
/// processor-extracted runtime from the vault audio (by EntryKey) and write it to SQL. The migration
|
|
/// cannot read the vault, so this runs at runtime after deploy. Idempotent — a re-run only touches
|
|
/// rows still missing a duration. Returns (updated, skipped) counts. A per-track vault miss or SQL
|
|
/// failure is logged and skipped, never aborting the batch.
|
|
/// </summary>
|
|
public async Task<ResultContainer<(int Updated, int Skipped)>> BackfillDurationsAsync(CancellationToken ct)
|
|
{
|
|
var missing = await _sqlTrackService.GetTracksMissingDuration(ct);
|
|
if (!missing.Success || missing.Value is null)
|
|
{
|
|
var error = missing.Messages.FirstOrDefault()?.Message ?? "Unknown error";
|
|
_logger.LogError("BackfillDurationsAsync: failed to load tracks missing duration: {Error}", error);
|
|
return ResultContainer<(int, int)>.CreateFailResult($"Could not load tracks: {error}");
|
|
}
|
|
|
|
var updated = 0;
|
|
var skipped = 0;
|
|
foreach (var track in missing.Value)
|
|
{
|
|
ct.ThrowIfCancellationRequested();
|
|
|
|
var audio = await _contentTrackContentService.GetAudioBinaryAsync(track.EntryKey);
|
|
if (audio is null)
|
|
{
|
|
_logger.LogWarning("BackfillDurationsAsync: no vault audio for {EntryKey} (track {Id}); skipping.",
|
|
track.EntryKey, track.Id);
|
|
skipped++;
|
|
continue;
|
|
}
|
|
|
|
var write = await _sqlTrackService.UpdateDuration(track.Id, audio.Duration, ct);
|
|
if (!write.Success)
|
|
{
|
|
var error = write.Messages.FirstOrDefault()?.Message ?? "Unknown error";
|
|
_logger.LogWarning("BackfillDurationsAsync: SQL update failed for track {Id}: {Error}", track.Id, error);
|
|
skipped++;
|
|
continue;
|
|
}
|
|
|
|
updated++;
|
|
}
|
|
|
|
_logger.LogInformation("BackfillDurationsAsync complete: {Updated} updated, {Skipped} skipped.", updated, skipped);
|
|
return ResultContainer<(int, int)>.CreatePassResult((updated, skipped));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete a track's SQL row, then its vault entry. SQL is the source of truth: a SQL delete
|
|
/// failure fails the operation (and leaves the vault untouched), but a subsequent vault delete
|
|
/// failure is logged as an orphan and swallowed — it is a maintenance concern, not user-facing.
|
|
/// </summary>
|
|
public async Task<Result> DeleteAsync(long id, CancellationToken ct)
|
|
{
|
|
var lookup = await _sqlTrackService.GetById(id);
|
|
if (!lookup.Success)
|
|
{
|
|
var error = lookup.Messages.FirstOrDefault()?.Message ?? "unknown error";
|
|
_logger.LogError("DeleteAsync: GetById failed for track {TrackId}: {Error}", id, error);
|
|
return Result.CreateFailResult("Failed to load track.");
|
|
}
|
|
|
|
if (lookup.Value is null)
|
|
{
|
|
return Result.CreateFailResult(TrackNotFoundMessage);
|
|
}
|
|
|
|
var entryKey = lookup.Value.EntryKey;
|
|
var releaseId = lookup.Value.ReleaseId;
|
|
|
|
var sqlDelete = await _sqlTrackService.Delete(id);
|
|
if (!sqlDelete.Success)
|
|
{
|
|
var error = sqlDelete.Messages.FirstOrDefault()?.Message ?? "unknown error";
|
|
_logger.LogError("DeleteAsync: SQL delete failed for track {TrackId}: {Error}", id, error);
|
|
return Result.CreateFailResult("Failed to delete track.");
|
|
}
|
|
|
|
// Cascade: if this was the last live track on its release, soft-delete the release too so it
|
|
// does not linger as a 0-track orphan in the albums browser. Non-fatal — the track delete
|
|
// already succeeded, so any failure here is logged and swallowed, not surfaced to the caller.
|
|
if (releaseId is { } rid)
|
|
{
|
|
await TrySoftDeleteEmptyReleaseAsync(rid, ct);
|
|
}
|
|
|
|
// Tri-state per FileDatabase's error-swallow contract: null = vault missing/error,
|
|
// false = entry not present, true = removed. Anything but a clean removal is an orphan.
|
|
var removed = await _fileDatabase.RemoveResourceAsync(VaultConstants.Tracks, entryKey);
|
|
if (removed is not true)
|
|
{
|
|
_logger.LogWarning(
|
|
"Vault delete did not remove entry after SQL delete. {TrackId} {EntryKey} outcome={Outcome}",
|
|
id, entryKey, removed);
|
|
}
|
|
|
|
return Result.CreatePassResult();
|
|
}
|
|
|
|
// Soft-delete the release only when no live tracks remain on it. Best-effort: a count or delete
|
|
// failure here never fails the track delete that triggered it — it is logged so an orphaned
|
|
// release can be cleaned up later (the migration backfill also catches pre-existing orphans).
|
|
private async Task TrySoftDeleteEmptyReleaseAsync(long releaseId, CancellationToken ct)
|
|
{
|
|
var countResult = await _sqlTrackService.CountLiveTracksByRelease(releaseId, ct);
|
|
if (!countResult.Success)
|
|
{
|
|
var error = countResult.Messages.FirstOrDefault()?.Message ?? "unknown error";
|
|
_logger.LogWarning("DeleteAsync: live-track count failed for release {ReleaseId}: {Error}", releaseId, error);
|
|
return;
|
|
}
|
|
|
|
if (countResult.Value > 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var releaseDelete = await _sqlTrackService.DeleteRelease(releaseId, ct);
|
|
if (!releaseDelete.Success)
|
|
{
|
|
var error = releaseDelete.Messages.FirstOrDefault()?.Message ?? "unknown error";
|
|
_logger.LogWarning("DeleteAsync: release soft-delete failed for {ReleaseId}: {Error}", releaseId, error);
|
|
}
|
|
}
|
|
}
|