feat(slint): add-to-playlist duplicate modal + playlist importer port

Add-to-playlist (Slices 0-3):
- qbz-core: check_playlist_duplicates + pure compute_playlist_duplicates
  (reuses qbz_models::PlaylistDuplicateResult) + unit tests.
- PlaylistDuplicateConfirmModal (Add all / Add new only / Cancel); the
  duplicate check runs on the Qobuz->Qobuz picker branch only (local/Plex
  add directly, mirroring Tauri); the track-id Vec lives Rust-side in a
  stash, never in Slint.
- Inline create-and-add in the picker (online create_playlist, offline ->
  local playlist per D8) + client-side filter (Slint 1.16 has no string
  contains, routed through a Rust callback) + success toasts.

Playlist importer (1:1 Tauri port):
- New headless crate qbz-playlist-import (Spotify/Apple/Tidal/Deezer
  scrapers, Qobuz matcher, importer, progress sink, shared http client;
  copy-not-move from src-tauri, zero tauri deps; 40 unit tests green).
- PlaylistImportModal (two-step fetch-preview -> import with live progress
  bar / log / summary) + controller + sidebar PLAYLISTS menu entry point.

Reco logging staged behind TODO(reco-v1) markers (golden rule: playlist
recommendations ship in Slint v1 once the reco engine is extracted to a
shared crate).

cc
This commit is contained in:
vicrodh committed 2026-06-11 22:03:46 -06:00
1 parent 999ded11ff
commit 3689a5fda8
33 files changed
+5664 -129

No files matched your search

File diff suppressed because it is too large. Load diff
+486
View File
@@ -0,0 +1,486 @@
//! Playlist Importer controller — the Rust side of the "Import Playlist"
//! modal (PlaylistImportModal.slint), a 1:1 port of Tauri's
//! PlaylistImportModal.svelte driven by the headless `qbz-playlist-import`
//! crate. Every interpolated string (log lines, status line, summary
//! block) is formatted HERE and pushed into PlaylistImportState
//! pre-formatted; provider detection lives here too (Slint 1.16 strings
//! have no `.contains`, so every URL keystroke round-trips through
//! `url-edited`).
//!
//! Close-mid-import semantics (spec §1.8): closing the modal never cancels
//! the tokio import task. On completion the toast + sidebar refresh still
//! fire (main.rs arm); navigation happens only while the modal is still
//! open AND the run's generation is current. [`GENERATION`] is bumped on
//! every open() and execute(), so a stale run's sink events / completion
//! can never touch a reopened modal's fresh state.
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{LazyLock, Mutex};
use slint::{ComponentHandle, Model, ModelRc, VecModel};
use qbz_playlist_import::{
detect_provider_key, ImportEvent, ImportPhase, ImportPlaylist, ImportProgressSink,
ImportProvider, ImportSummary, ProviderKey,
};
use crate::{AppWindow, ImportLogEntry, PlaylistImportState, SidebarState};
/// Rust-side mirror of the Svelte component state that never reaches the
/// UI (sidebar.rs module-state pattern). Reset wholesale on every open.
#[derive(Default)]
struct Session {
preview: Option<ImportPlaylist>,
/// Trimmed URL the preview was fetched for (Svelte `previewUrl`).
preview_url: String,
/// Provider locked at fetch time; survives URL edits until the reset
/// paths clear it (Svelte `lockedProvider`).
locked_provider: Option<ProviderKey>,
/// Trimmed URL of the last completed import (Svelte `lastImportedUrl`).
last_imported_url: String,
/// 5%-milestone tracker for the matching log lines (-1 = none yet).
last_logged_percent: i32,
/// Mirror of the modal's rename field, kept fresh by `name-edited`
/// and read at execute time (Svelte `customName`).
custom_name: String,
}
static SESSION: LazyLock<Mutex<Session>> = LazyLock::new(|| Mutex::new(Session::default()));
/// Import generation (§1.8): bumped on every open() and execute(). Sink
/// events and task completions carry the generation they were spawned
/// with; a mismatch means the modal was reset for a fresh run, so the
/// stale run may only fire toast + sidebar refresh, never modal writes.
static GENERATION: AtomicU64 = AtomicU64::new(0);
pub fn current_generation() -> u64 {
GENERATION.load(Ordering::SeqCst)
}
fn bump_generation() -> u64 {
GENERATION.fetch_add(1, Ordering::SeqCst) + 1
}
/// Open the modal fully reset — Tauri remounts the Svelte component on
/// every open, so nothing persists. Event-loop thread.
pub fn open(window: &AppWindow) {
// Invalidate any in-flight run's modal writes before resetting.
bump_generation();
*SESSION.lock().unwrap() = Session::default();
let state = window.global::<PlaylistImportState>();
state.set_url("".into());
state.set_custom_name("".into());
state.set_loading(false);
state.set_error("".into());
state.set_active_provider("".into());
state.set_can_fetch(false);
state.set_show_preview(false);
state.set_import_completed(false);
state.set_progress_visible(false);
state.set_has_progress(false);
state.set_progress(0.0);
state.set_status_line("".into());
state.set_current_track("".into());
state.set_log(ModelRc::new(VecModel::from(Vec::<ImportLogEntry>::new())));
clear_summary(window);
// Folder dropdown from the sidebar's folder list — the exact
// create-playlist builder pattern: index 0 = "No folder" (id "").
let folders = window.global::<SidebarState>().get_folders();
let mut opts: Vec<slint::SharedString> = vec!["No folder".into()];
let mut ids: Vec<slint::SharedString> = vec!["".into()];
for i in 0..folders.row_count() {
if let Some(f) = folders.row_data(i) {
opts.push(f.name);
ids.push(f.id);
}
}
state.set_folder_options(ModelRc::new(VecModel::from(opts)));
state.set_folder_ids(ModelRc::new(VecModel::from(ids)));
state.set_folder_index(0);
state.set_open(true);
}
/// Recompute the URL-derived properties on every keystroke (Svelte's
/// derived detectedProvider / activeProvider / isValid / showPreview),
/// plus the post-completion fresh-import reset path. Event-loop thread.
pub fn on_url_edited(window: &AppWindow, text: &str) {
let state = window.global::<PlaylistImportState>();
let trimmed = text.trim();
let detected = detect_provider_key(text);
let mut s = SESSION.lock().unwrap();
// After a completed import, editing the URL away from the imported
// one rearms the modal for a fresh import without reopening.
if state.get_import_completed() && trimmed != s.last_imported_url {
s.locked_provider = None;
state.set_import_completed(false);
state.set_error("".into());
state.set_log(ModelRc::new(VecModel::from(Vec::<ImportLogEntry>::new())));
state.set_progress_visible(false);
state.set_has_progress(false);
state.set_progress(0.0);
state.set_status_line("".into());
state.set_current_track("".into());
clear_summary(window);
}
let active = s.locked_provider.or(detected);
state.set_active_provider(active.map(|p| p.as_str()).unwrap_or("").into());
state.set_can_fetch(detected.is_some() && !crate::offline_mode::engine().is_offline());
state.set_show_preview(s.preview.is_some() && trimmed == s.preview_url);
}
/// Keep the session's rename mirror fresh (read back by
/// [`begin_execute`]). Fired on every name-LineEdit keystroke.
pub fn on_name_edited(text: &str) {
SESSION.lock().unwrap().custom_name = text.to_string();
}
/// Step A gate + reset (Svelte handlePreview's pre-invoke block). Returns
/// the URL to fetch, or None when the gate fails. Event-loop thread.
pub fn begin_fetch(window: &AppWindow) -> Option<String> {
let state = window.global::<PlaylistImportState>();
if state.get_loading() || !state.get_can_fetch() {
return None;
}
let url = state.get_url().to_string();
let detected = detect_provider_key(&url)?;
{
let mut s = SESSION.lock().unwrap();
s.preview = None;
s.preview_url.clear();
s.locked_provider = Some(detected);
}
state.set_loading(true);
state.set_error("".into());
state.set_show_preview(false);
state.set_import_completed(false);
state.set_active_provider(detected.as_str().into());
state.set_has_progress(false);
state.set_progress(0.0);
state.set_status_line("".into());
state.set_current_track("".into());
clear_summary(window);
state.set_log(ModelRc::new(VecModel::from(Vec::<ImportLogEntry>::new())));
push_log(window, "Checking playlist link...".to_string(), "info");
state.set_progress_visible(true);
Some(url)
}
/// Preview fetch succeeded (Svelte handlePreview's try arm). Event-loop.
pub fn apply_preview_ok(window: &AppWindow, url: &str, preview: ImportPlaylist) {
let state = window.global::<PlaylistImportState>();
let count = preview.tracks.len();
let provider = provider_display_name(&preview.provider);
state.set_custom_name(preview.name.as_str().into());
{
let mut s = SESSION.lock().unwrap();
s.custom_name = preview.name.clone();
s.preview_url = url.trim().to_string();
s.preview = Some(preview);
}
push_log(
window,
format!("Found {} tracks from {}.", count, provider),
"success",
);
state.set_loading(false);
// The URL input is disabled during the fetch, so it still equals the
// fetched URL — step B (rename + Import) becomes visible.
state.set_show_preview(
state.get_url().trim() == SESSION.lock().unwrap().preview_url.as_str(),
);
}
/// Preview fetch failed (Svelte handlePreview's catch arm). Event-loop.
pub fn apply_preview_err(window: &AppWindow, err: &str) {
let state = window.global::<PlaylistImportState>();
state.set_error(err.into());
push_log(window, format!("Import failed: {}", err), "error");
state.set_loading(false);
}
/// Everything the execute task needs, snapshotted on the event loop.
pub struct ExecuteArgs {
pub url: String,
pub name_override: Option<String>,
/// Local folder id chosen in the dropdown ("" = no folder).
pub folder_id: String,
/// The run's generation (§1.8), carried by the sink and the
/// completion arms.
pub generation: u64,
}
/// Step B gate + reset (Svelte handleExecute's pre-invoke block).
/// Event-loop thread.
pub fn begin_execute(window: &AppWindow) -> Option<ExecuteArgs> {
let state = window.global::<PlaylistImportState>();
if state.get_loading() || state.get_import_completed() {
return None;
}
let (url, name_override) = {
let mut s = SESSION.lock().unwrap();
let source_name = s.preview.as_ref()?.name.clone();
// Rename goes out only when it differs from the source name; an
// empty rename falls back to the source name (Appendix A).
let custom = s.custom_name.trim().to_string();
let name_override = if custom != source_name && !custom.is_empty() {
Some(custom)
} else {
None
};
s.last_logged_percent = -1;
(s.preview_url.clone(), name_override)
};
let folder_id = {
let ids = state.get_folder_ids();
ids.row_data(state.get_folder_index() as usize)
.map(|s| s.to_string())
.unwrap_or_default()
};
state.set_loading(true);
state.set_error("".into());
state.set_progress_visible(true);
Some(ExecuteArgs {
url,
name_override,
folder_id,
generation: bump_generation(),
})
}
/// One sink event onto the modal — the two Svelte event listeners. The
/// generation is checked by the caller (SlintSink). Event-loop thread.
pub fn apply_event(window: &AppWindow, event: ImportEvent) {
let state = window.global::<PlaylistImportState>();
match event {
ImportEvent::Phase(phase) => match phase {
ImportPhase::Matching => {
push_log(window, "Searching Qobuz catalog...".to_string(), "info");
}
// Creating / Adding re-fire once per created part — log each,
// as Tauri does.
ImportPhase::Creating => {
push_log(window, "Creating playlist...".to_string(), "success");
}
ImportPhase::Adding => {
push_log(window, "Adding tracks to playlist...".to_string(), "info");
}
},
ImportEvent::Progress(p) => {
// Bar + status update on EVERY event (Tauri parity, no
// coalescing).
state.set_has_progress(p.total > 0);
if p.total > 0 {
state.set_progress(p.current as f32 / p.total as f32);
}
if p.phase == "adding" {
// Status line per phase — deliberate owner deviation from
// the Tauri modal, which reused the "Matching tracks…"
// string here (see qbz_playlist_import::sink::ImportPhase).
let line = format!("Adding tracks: {} / {}", p.current, p.total);
state.set_status_line(line.as_str().into());
// One log line per 50-track chunk event (chunk counts,
// not tracks) — Tauri logs every adding event.
push_log(window, line, "info");
} else if p.total > 0 {
let line = format!(
"Matching tracks: {} / {} ({} found)",
group_thousands(p.current),
group_thousands(p.total),
group_thousands(p.matched_so_far)
);
state.set_status_line(line.as_str().into());
// Matching is high-frequency (one event per track): log
// only at 5% milestones, exactly like the Svelte listener.
let pct = (p.current as u64 * 100 / p.total as u64) as i32;
let should_log = {
let mut s = SESSION.lock().unwrap();
if pct >= s.last_logged_percent + 5 {
s.last_logged_percent = pct;
true
} else {
false
}
};
if should_log {
push_log(window, line, "info");
}
}
state.set_current_track(p.current_track.unwrap_or_default().into());
}
}
}
/// Import finished (Svelte handleExecute's success arm): completion logs
/// + summary block + import-completed. Toast / sidebar refresh /
/// navigation live in the main.rs arm (§1.8: those fire even after
/// close; this fn is generation-guarded by the caller). Event-loop.
pub fn apply_execute_ok(window: &AppWindow, summary: &ImportSummary) {
let state = window.global::<PlaylistImportState>();
{
let mut s = SESSION.lock().unwrap();
s.last_imported_url = s.preview_url.clone();
}
state.set_import_completed(true);
push_log(
window,
format!(
"Imported {} of {} tracks into QBZ.",
summary.matched_tracks, summary.total_tracks
),
"success",
);
if !summary.qobuz_playlist_ids.is_empty() {
if summary.parts_created > 1 {
push_log(window, parts_line(summary.parts_created), "success");
} else {
push_log(window, "Playlist created in Qobuz™.".to_string(), "success");
}
} else {
push_log(window, "No matching tracks found.".to_string(), "error");
}
// Summary block (pre-formatted; "" = hidden). `playlist_name` is the
// name the playlist was created under — rename included (deliberate
// owner fix vs the Tauri original, see qbz_playlist_import::importer).
state.set_summary_playlist(format!("Playlist: {}", summary.playlist_name).into());
state.set_summary_matched(
format!(
"Tracks matched: {} / {}",
summary.matched_tracks, summary.total_tracks
)
.into(),
);
state.set_summary_skipped(format!("Skipped: {}", summary.skipped_tracks).into());
state.set_summary_parts(if summary.parts_created > 1 {
parts_line(summary.parts_created).into()
} else {
"".into()
});
// The bar/status hide with loading, as in Tauri (`loading` gates the
// bar there).
state.set_has_progress(false);
state.set_status_line("".into());
state.set_current_track("".into());
state.set_loading(false);
}
/// Import failed (Svelte handleExecute's catch arm). The error toast
/// lives in the main.rs arm. Event-loop thread.
pub fn apply_execute_err(window: &AppWindow, err: &str) {
let state = window.global::<PlaylistImportState>();
state.set_error(err.into());
push_log(window, format!("Import failed: {}", err), "error");
state.set_has_progress(false);
state.set_status_line("".into());
state.set_current_track("".into());
state.set_loading(false);
}
/// Streams crate events onto the modal via the established
/// `upgrade_in_event_loop` cross-thread hop — one hop per event, the same
/// frequency profile as the artwork/scan pipelines (Tauri also updated
/// the bar per event, no coalescing).
pub struct SlintSink {
weak: slint::Weak<AppWindow>,
generation: u64,
}
impl SlintSink {
pub fn new(weak: slint::Weak<AppWindow>, generation: u64) -> Self {
Self { weak, generation }
}
}
impl ImportProgressSink for SlintSink {
fn emit(&self, event: ImportEvent) {
let generation = self.generation;
let _ = self.weak.upgrade_in_event_loop(move |w| {
// Stale generation = the modal was reset (reopened) while
// this run was in flight — its events must never touch the
// fresh modal state (§1.8).
if generation == current_generation() {
apply_event(&w, event);
}
});
}
}
/// Append one pre-formatted line to the conversion log (append-only
/// VecModel). Event-loop thread.
fn push_log(window: &AppWindow, message: String, status: &str) {
let state = window.global::<PlaylistImportState>();
let log = state.get_log();
let entry = ImportLogEntry {
message: message.into(),
status: status.into(),
};
if let Some(vec) = log.as_any().downcast_ref::<VecModel<ImportLogEntry>>() {
vec.push(entry);
} else {
// First write after the .slint default literal — swap in a
// VecModel (open()/begin_fetch() normally install one already).
let mut entries: Vec<ImportLogEntry> = log.iter().collect();
entries.push(entry);
state.set_log(ModelRc::new(VecModel::from(entries)));
}
}
fn clear_summary(window: &AppWindow) {
let state = window.global::<PlaylistImportState>();
state.set_summary_playlist("".into());
state.set_summary_matched("".into());
state.set_summary_skipped("".into());
state.set_summary_parts("".into());
}
/// "Split into {count} playlists (Qobuz 2000-track limit)" — used as both
/// a log line and the summary parts line, as in Tauri.
fn parts_line(count: u32) -> String {
format!("Split into {} playlists (Qobuz 2000-track limit)", count)
}
/// Display names for the "Found N tracks from {provider}." log (Svelte
/// formatProvider). The enum is exhaustive, so Svelte's "Unknown" arm is
/// unreachable here.
fn provider_display_name(provider: &ImportProvider) -> &'static str {
match provider {
ImportProvider::Spotify => "Spotify",
ImportProvider::AppleMusic => "Apple Music",
ImportProvider::Tidal => "Tidal",
ImportProvider::Deezer => "Deezer",
}
}
/// `toLocaleString()` twin for the matching log/status numbers
/// ("12,345"). Tauri rendered these with the user's locale; fixed en-US
/// grouping is the deliberate choice here.
fn group_thousands(n: u32) -> String {
let digits = n.to_string();
let mut out = String::with_capacity(digits.len() + digits.len() / 3);
for (i, ch) in digits.chars().enumerate() {
if i > 0 && (digits.len() - i) % 3 == 0 {
out.push(',');
}
out.push(ch);
}
out
}
#[cfg(test)]
mod tests {
use super::group_thousands;
#[test]
fn group_thousands_matches_to_locale_string() {
assert_eq!(group_thousands(0), "0");
assert_eq!(group_thousands(999), "999");
assert_eq!(group_thousands(1000), "1,000");
assert_eq!(group_thousands(12345), "12,345");
assert_eq!(group_thousands(1234567), "1,234,567");
}
}
+10 -1
View File
@@ -23,6 +23,7 @@ pub fn open(window: &AppWindow, track_id: &str) {
state.set_track_id(track_id.into());
state.set_track_ids(ModelRc::new(VecModel::from(Vec::<slint::SharedString>::new())));
state.set_playlists(ModelRc::new(VecModel::from(Vec::<PlaylistPickItem>::new())));
state.set_filter_matches(0);
state.set_local_mode(false);
state.set_loading(true);
state.set_open(true);
@@ -39,6 +40,7 @@ pub fn open_multi(window: &AppWindow, ids: &[String], local: bool) {
let model: Vec<slint::SharedString> = ids.iter().map(|s| s.clone().into()).collect();
state.set_track_ids(ModelRc::new(VecModel::from(model)));
state.set_playlists(ModelRc::new(VecModel::from(Vec::<PlaylistPickItem>::new())));
state.set_filter_matches(0);
state.set_local_mode(local);
state.set_loading(true);
state.set_open(true);
@@ -88,7 +90,8 @@ where
pub fn apply(window: &AppWindow, playlists: Vec<PickPlaylist>) {
let items: Vec<PlaylistPickItem> = playlists
.into_iter()
.map(|p| PlaylistPickItem {
.enumerate()
.map(|(i, p)| PlaylistPickItem {
id: p.id.into(),
name: p.name.into(),
tracks_line: if p.tracks > 0 {
@@ -97,9 +100,15 @@ pub fn apply(window: &AppWindow, playlists: Vec<PickPlaylist>) {
"".into()
},
is_local: p.is_local,
// No filter yet on (re)load — every row matches, ranked in
// list order.
filter_rank: i as i32,
})
.collect();
let state = window.global::<PlaylistPickerState>();
state.set_filter_matches(items.len() as i32);
state.set_playlists(ModelRc::new(VecModel::from(items)));
// Reset the filter affordance whenever the list is repopulated.
state.set_filter("".into());
state.set_loading(false);
}