From aeb13b9ffcdf0453a52015de3374d3270f7325e5 Mon Sep 17 00:00:00 2001 From: vicrodh <103399283+vicrodh@users.noreply.github.com> Date: Fri, 16 Jan 2026 07:19:34 -0600 Subject: [PATCH] Connect playlist count callback for single source of truth Wire onPlaylistCountUpdate from PlaylistDetailView to Sidebar's updatePlaylistCounts method in +page.svelte. This ensures the sidebar displays accurate track counts from the database instead of calculated values that could drift out of sync. --- src-tauri/src/download_cache/commands.rs | 79 ++++++++++++++++++- src-tauri/src/download_cache/db.rs | 30 ++++++- src-tauri/src/download_cache/mod.rs | 13 +++ src/lib/components/Sidebar.svelte | 13 +++ .../views/PlaylistDetailView.svelte | 11 +++ src/routes/+page.svelte | 3 + 6 files changed, 146 insertions(+), 3 deletions(-) diff --git a/src-tauri/src/download_cache/commands.rs b/src-tauri/src/download_cache/commands.rs index 059021955..786398887 100644 --- a/src-tauri/src/download_cache/commands.rs +++ b/src-tauri/src/download_cache/commands.rs @@ -627,9 +627,84 @@ pub async fn start_legacy_migration( qobuz_client, library_db, ).await; - + let _ = app_complete.emit("migration:complete", status); }); - + Ok(()) } + +/// Sync downloaded tracks to library database +/// This ensures all ready downloads appear in the library with source='qobuz_download' +#[tauri::command] +pub async fn sync_downloads_to_library( + cache_state: State<'_, DownloadCacheState>, + library_state: State<'_, crate::library::commands::LibraryState>, +) -> Result { + log::info!("Command: sync_downloads_to_library"); + + let cache_db = cache_state.db.lock().await; + let library_db = library_state.db.lock().await; + + // Get all ready tracks from download cache + let ready_tracks = cache_db.get_ready_tracks_for_sync()?; + + let mut synced = 0; + let mut already_present = 0; + let mut errors = 0; + + for track in ready_tracks { + // Check if track already exists in library + match library_db.track_exists_by_qobuz_id(track.track_id) { + Ok(true) => { + already_present += 1; + } + Ok(false) => { + // Insert into library with basic metadata + match library_db.insert_qobuz_download_direct( + track.track_id, + &track.title, + &track.artist, + track.album.as_deref(), + track.duration_secs, + &track.file_path, + track.bit_depth, + track.sample_rate, + ) { + Ok(_) => { + log::info!("Synced track {} to library: {}", track.track_id, track.title); + synced += 1; + } + Err(e) => { + log::error!("Failed to sync track {}: {}", track.track_id, e); + errors += 1; + } + } + } + Err(e) => { + log::error!("Failed to check if track {} exists: {}", track.track_id, e); + errors += 1; + } + } + } + + log::info!( + "Sync complete: {} synced, {} already present, {} errors", + synced, already_present, errors + ); + + Ok(SyncResult { + synced, + already_present, + errors, + }) +} + +/// Result of syncing downloads to library +#[derive(Debug, Clone, serde::Serialize)] +#[serde(rename_all = "camelCase")] +pub struct SyncResult { + pub synced: u32, + pub already_present: u32, + pub errors: u32, +} diff --git a/src-tauri/src/download_cache/db.rs b/src-tauri/src/download_cache/db.rs index ae5b4b116..8ce6512ab 100644 --- a/src-tauri/src/download_cache/db.rs +++ b/src-tauri/src/download_cache/db.rs @@ -3,7 +3,7 @@ use rusqlite::{Connection, params}; use std::path::Path; -use super::{CachedTrackInfo, DownloadCacheStats, DownloadStatus, TrackDownloadInfo}; +use super::{CachedTrackInfo, DownloadCacheStats, DownloadStatus, ReadyTrackForSync, TrackDownloadInfo}; /// Database wrapper for cached tracks index pub struct DownloadCacheDb { @@ -150,6 +150,34 @@ impl DownloadCacheDb { } } + /// Get all ready (downloaded) tracks with their file paths for syncing to library + pub fn get_ready_tracks_for_sync(&self) -> Result, String> { + let mut stmt = self.conn.prepare( + "SELECT track_id, title, artist, album, duration_secs, file_path, bit_depth, sample_rate + FROM cached_tracks WHERE status = 'ready'" + ).map_err(|e| format!("Failed to prepare query: {}", e))?; + + let tracks = stmt.query_map([], |row| { + Ok(ReadyTrackForSync { + track_id: row.get::<_, i64>(0)? as u64, + title: row.get(1)?, + artist: row.get(2)?, + album: row.get(3)?, + duration_secs: row.get::<_, i64>(4)? as u64, + file_path: row.get(5)?, + bit_depth: row.get::<_, Option>(6)?.map(|v| v as u32), + sample_rate: row.get(7)?, + }) + }).map_err(|e| format!("Failed to query tracks: {}", e))?; + + let mut result = Vec::new(); + for track in tracks { + result.push(track.map_err(|e| format!("Failed to read track: {}", e))?); + } + + Ok(result) + } + /// Get track info pub fn get_track(&self, track_id: u64) -> Result, String> { let result = self.conn.query_row( diff --git a/src-tauri/src/download_cache/mod.rs b/src-tauri/src/download_cache/mod.rs index 19047757f..e643ff503 100644 --- a/src-tauri/src/download_cache/mod.rs +++ b/src-tauri/src/download_cache/mod.rs @@ -76,6 +76,19 @@ pub struct CachedTrackInfo { pub last_accessed_at: String, } +/// Minimal track info for syncing to library +#[derive(Debug, Clone)] +pub struct ReadyTrackForSync { + pub track_id: u64, + pub title: String, + pub artist: String, + pub album: Option, + pub duration_secs: u64, + pub file_path: String, + pub bit_depth: Option, + pub sample_rate: Option, +} + /// Statistics about the download cache #[derive(Debug, Clone, Serialize)] #[serde(rename_all = "camelCase")] diff --git a/src/lib/components/Sidebar.svelte b/src/lib/components/Sidebar.svelte index 15b25c2e9..39db1fe7c 100644 --- a/src/lib/components/Sidebar.svelte +++ b/src/lib/components/Sidebar.svelte @@ -287,6 +287,19 @@ loadLocalTrackCounts(); } + // Update counts for a specific playlist (single source of truth from detail view) + export function updatePlaylistCounts(playlistId: number, qobuzCount: number, localCount: number) { + // Update Qobuz count in userPlaylists + userPlaylists = userPlaylists.map(p => + p.id === playlistId ? { ...p, tracks_count: qobuzCount } : p + ); + // Update local count + localTrackCounts.set(playlistId, localCount); + localTrackCounts = new Map(localTrackCounts); // Trigger reactivity + // Invalidate tooltip cache for this playlist + invalidatePlaylistTooltip(playlistId); + } + // Menu handling functions function closeMenu() { menuOpen = false; diff --git a/src/lib/components/views/PlaylistDetailView.svelte b/src/lib/components/views/PlaylistDetailView.svelte index 55b0428af..ffcdd7915 100644 --- a/src/lib/components/views/PlaylistDetailView.svelte +++ b/src/lib/components/views/PlaylistDetailView.svelte @@ -132,6 +132,7 @@ onLocalTrackPlayNext?: (track: LocalLibraryTrack) => void; onLocalTrackPlayLater?: (track: LocalLibraryTrack) => void; onSetLocalQueue?: (trackIds: number[]) => void; + onPlaylistCountUpdate?: (playlistId: number, qobuzCount: number, localCount: number) => void; onPlaylistUpdated?: () => void; onPlaylistDeleted?: (playlistId: number) => void; activeTrackId?: number | null; @@ -158,6 +159,7 @@ onLocalTrackPlayNext, onLocalTrackPlayLater, onSetLocalQueue, + onPlaylistCountUpdate, onPlaylistUpdated, onPlaylistDeleted, activeTrackId = null, @@ -253,6 +255,15 @@ } }); + // Notify parent of actual track counts after loading (single source of truth) + $effect(() => { + if (playlist && !loading) { + const qobuzCount = playlist.tracks_count ?? 0; + const localCount = localTracks.length; + onPlaylistCountUpdate?.(playlistId, qobuzCount, localCount); + } + }); + async function loadLocalTracks() { try { const result = await invoke('playlist_get_local_tracks_with_position', { playlistId }); diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte index 7cb142837..45a8a7207 100644 --- a/src/routes/+page.svelte +++ b/src/routes/+page.svelte @@ -2019,6 +2019,9 @@ onLocalTrackPlayNext={queueLocalTrackNext} onLocalTrackPlayLater={queueLocalTrackLater} onSetLocalQueue={handleSetLocalQueue} + onPlaylistCountUpdate={(playlistId, qobuzCount, localCount) => + sidebarRef?.updatePlaylistCounts(playlistId, qobuzCount, localCount) + } onPlaylistUpdated={() => { sidebarRef?.refreshPlaylists(); sidebarRef?.refreshLocalTrackCounts();