diff --git a/core/discovery/qobuz.py b/core/discovery/qobuz.py new file mode 100644 index 00000000..3f08f6ae --- /dev/null +++ b/core/discovery/qobuz.py @@ -0,0 +1,299 @@ +"""Background worker for Qobuz playlist discovery. + +`run_qobuz_discovery_worker(playlist_id, deps)` is the function the +Qobuz discovery start-endpoint submits to its executor to match each +Qobuz playlist track against Spotify (preferred) or the configured +fallback metadata source (iTunes / Deezer / Discogs / MusicBrainz). + +Mirrors `core/discovery/deezer.py` exactly — Qobuz playlists arrive as +dicts (not dataclasses) from `core/qobuz_client.py:get_playlist`, so +this worker uses dict-style access on track data and wraps each entry +in a SimpleNamespace before handing it to the shared +`_search_spotify_for_tidal_track` helper. +""" + +from __future__ import annotations + +import logging +import time +import types +from dataclasses import dataclass +from typing import Any, Callable + +logger = logging.getLogger(__name__) + + +@dataclass +class QobuzDiscoveryDeps: + """Bundle of cross-cutting deps the Qobuz discovery worker needs.""" + qobuz_discovery_states: dict + spotify_client: Any + pause_enrichment_workers: Callable[[str], dict] + resume_enrichment_workers: Callable[[dict, str], None] + get_active_discovery_source: Callable[[], str] + get_metadata_fallback_client: Callable[[], Any] + get_discovery_cache_key: Callable + get_database: Callable[[], Any] + validate_discovery_cache_artist: Callable + search_spotify_for_tidal_track: Callable + build_discovery_wing_it_stub: Callable + add_activity_item: Callable + sync_discovery_results_to_mirrored: Callable + + +def run_qobuz_discovery_worker(playlist_id, deps: QobuzDiscoveryDeps): + """Background worker for Qobuz discovery process (Spotify preferred, fallback metadata source).""" + _ew_state = {} + try: + _ew_state = deps.pause_enrichment_workers('Qobuz discovery') + state = deps.qobuz_discovery_states[playlist_id] + playlist = state['playlist'] + + # Determine which provider to use + discovery_source = deps.get_active_discovery_source() + use_spotify = (discovery_source == 'spotify') and deps.spotify_client and deps.spotify_client.is_spotify_authenticated() + + # Initialize fallback client if needed + itunes_client_instance = None + if not use_spotify: + itunes_client_instance = deps.get_metadata_fallback_client() + + logger.info(f"Starting Qobuz discovery for: {playlist['name']} (using {discovery_source.upper()})") + + # Store discovery source in state for frontend + state['discovery_source'] = discovery_source + + successful_discoveries = 0 + tracks = playlist['tracks'] + + for i, qobuz_track in enumerate(tracks): + if state.get('cancelled', False): + break + + try: + track_name = qobuz_track['name'] + track_artists = qobuz_track['artists'] + track_id = qobuz_track['id'] + track_album = qobuz_track.get('album', '') + track_duration_ms = qobuz_track.get('duration_ms', 0) + + logger.info(f"[{i+1}/{len(tracks)}] Searching {discovery_source.upper()}: {track_name} by {', '.join(track_artists)}") + + # Check discovery cache first + cache_key = deps.get_discovery_cache_key(track_name, track_artists[0] if track_artists else '') + try: + cache_db = deps.get_database() + cached_match = cache_db.get_discovery_cache_match(cache_key[0], cache_key[1], discovery_source) + if cached_match and deps.validate_discovery_cache_artist(track_artists[0] if track_artists else '', cached_match): + logger.debug(f"CACHE HIT [{i+1}/{len(tracks)}]: {track_name} by {', '.join(track_artists)}") + cached_artists = cached_match.get('artists', []) + if cached_artists: + cached_artist_str = ', '.join( + a if isinstance(a, str) else a.get('name', '') for a in cached_artists + ) + else: + cached_artist_str = '' + cached_album = cached_match.get('album', '') + if isinstance(cached_album, dict): + cached_album = cached_album.get('name', '') + + result = { + 'qobuz_track': { + 'id': track_id, + 'name': track_name, + 'artists': track_artists or [], + 'album': track_album, + 'duration_ms': track_duration_ms, + }, + 'spotify_data': cached_match, + 'match_data': cached_match, + 'status': 'Found', + 'status_class': 'found', + 'spotify_track': cached_match.get('name', ''), + 'spotify_artist': cached_artist_str, + 'spotify_album': cached_album, + 'spotify_id': cached_match.get('id', ''), + 'discovery_source': discovery_source, + 'index': i + } + successful_discoveries += 1 + state['spotify_matches'] = successful_discoveries + state['discovery_results'].append(result) + state['discovery_progress'] = int(((i + 1) / len(tracks)) * 100) + continue + except Exception as cache_err: + logger.error(f"Cache lookup error: {cache_err}") + + # SimpleNamespace duck-type for _search_spotify_for_tidal_track + track_ns = types.SimpleNamespace( + id=track_id, + name=track_name, + artists=track_artists, + album=track_album, + duration_ms=track_duration_ms + ) + + track_result = deps.search_spotify_for_tidal_track( + track_ns, + use_spotify=use_spotify, + itunes_client=itunes_client_instance + ) + + result = { + 'qobuz_track': { + 'id': track_id, + 'name': track_name, + 'artists': track_artists or [], + 'album': track_album, + 'duration_ms': track_duration_ms, + }, + 'spotify_data': None, + 'match_data': None, + 'status': 'Not Found', + 'status_class': 'not-found', + 'spotify_track': '', + 'spotify_artist': '', + 'spotify_album': '', + 'discovery_source': discovery_source + } + + match_confidence = 0.0 + + if use_spotify and isinstance(track_result, tuple): + track_obj, raw_track_data, match_confidence = track_result + album_obj = raw_track_data.get('album', {}) if raw_track_data else {} + if isinstance(album_obj, dict) and not album_obj.get('name') and track_obj.album: + album_obj['name'] = track_obj.album + elif not album_obj and track_obj.album: + album_obj = {'name': track_obj.album} + if isinstance(album_obj, dict) and not album_obj.get('release_date'): + album_obj['release_date'] = getattr(track_obj, 'release_date', '') or '' + _album_images = album_obj.get('images', []) if isinstance(album_obj, dict) else [] + _image_url = _album_images[0].get('url', '') if _album_images else (getattr(track_obj, 'image_url', '') or '') + + match_data = { + 'id': track_obj.id, + 'name': track_obj.name, + 'artists': track_obj.artists, + 'album': album_obj, + 'duration_ms': track_obj.duration_ms, + 'external_urls': track_obj.external_urls, + 'image_url': _image_url, + 'source': 'spotify' + } + if raw_track_data and raw_track_data.get('track_number'): + match_data['track_number'] = raw_track_data['track_number'] + if raw_track_data and raw_track_data.get('disc_number'): + match_data['disc_number'] = raw_track_data['disc_number'] + result['spotify_data'] = match_data + result['match_data'] = match_data + result['status'] = 'Found' + result['status_class'] = 'found' + result['spotify_track'] = track_obj.name + result['spotify_artist'] = ', '.join(track_obj.artists) if isinstance(track_obj.artists, list) else str(track_obj.artists) + result['spotify_album'] = album_obj.get('name', '') if isinstance(album_obj, dict) else str(album_obj) + result['spotify_id'] = track_obj.id + result['confidence'] = match_confidence + successful_discoveries += 1 + state['spotify_matches'] = successful_discoveries + + elif not use_spotify and track_result and isinstance(track_result, dict): + match_confidence = track_result.pop('confidence', 0.80) + match_data = track_result + match_data['source'] = discovery_source + _fb_album = match_data.get('album', {}) + _fb_images = _fb_album.get('images', []) if isinstance(_fb_album, dict) else [] + if _fb_images and 'image_url' not in match_data: + match_data['image_url'] = _fb_images[0].get('url', '') + result['spotify_data'] = match_data + result['match_data'] = match_data + result['status'] = 'Found' + result['status_class'] = 'found' + result['spotify_track'] = match_data.get('name', '') + itunes_artists = match_data.get('artists', []) + result['spotify_artist'] = ', '.join(a if isinstance(a, str) else a.get('name', '') for a in itunes_artists) if itunes_artists else '' + result['spotify_album'] = match_data.get('album', {}).get('name', '') if isinstance(match_data.get('album'), dict) else match_data.get('album', '') + result['spotify_id'] = match_data.get('id', '') + result['confidence'] = match_confidence + successful_discoveries += 1 + state['spotify_matches'] = successful_discoveries + + # Save to discovery cache if match found + if result['status_class'] == 'found' and result.get('match_data'): + try: + cache_db = deps.get_database() + cache_db.save_discovery_cache_match( + cache_key[0], cache_key[1], discovery_source, match_confidence, + result['match_data'], track_name, + track_artists[0] if track_artists else '' + ) + logger.info(f"CACHE SAVED: {track_name} (confidence: {match_confidence:.3f})") + except Exception as cache_err: + logger.error(f"Cache save error: {cache_err}") + + # Auto Wing It fallback for unmatched tracks + if result['status_class'] == 'not-found': + qobuz_t = result.get('qobuz_track', {}) + stub = deps.build_discovery_wing_it_stub( + qobuz_t.get('name', ''), + ', '.join(qobuz_t.get('artists', [])), + qobuz_t.get('duration_ms', 0) + ) + result['status'] = 'Wing It' + result['status_class'] = 'wing-it' + result['spotify_data'] = stub + result['match_data'] = stub + result['spotify_track'] = qobuz_t.get('name', '') + result['spotify_artist'] = ', '.join(qobuz_t.get('artists', [])) + result['wing_it_fallback'] = True + result['confidence'] = 0 + successful_discoveries += 1 + state['spotify_matches'] = successful_discoveries + state['wing_it_count'] = state.get('wing_it_count', 0) + 1 + + result['index'] = i + state['discovery_results'].append(result) + state['discovery_progress'] = int(((i + 1) / len(tracks)) * 100) + + time.sleep(0.1) + + except Exception as e: + logger.error(f"Error processing track {i+1}: {e}") + result = { + 'qobuz_track': { + 'name': qobuz_track.get('name', 'Unknown'), + 'artists': qobuz_track.get('artists', []), + }, + 'spotify_data': None, + 'match_data': None, + 'status': 'Error', + 'status_class': 'error', + 'spotify_track': '', + 'spotify_artist': '', + 'spotify_album': '', + 'error': str(e), + 'discovery_source': discovery_source, + 'index': i + } + state['discovery_results'].append(result) + state['discovery_progress'] = int(((i + 1) / len(tracks)) * 100) + + # Mark as complete + state['phase'] = 'discovered' + state['status'] = 'discovered' + state['discovery_progress'] = 100 + + source_label = discovery_source.upper() + deps.add_activity_item("", f"Qobuz Discovery Complete ({source_label})", f"'{playlist['name']}' - {successful_discoveries}/{len(tracks)} tracks found", "Now") + + logger.info(f"Qobuz discovery complete ({source_label}): {successful_discoveries}/{len(tracks)} tracks found") + + deps.sync_discovery_results_to_mirrored('qobuz', playlist_id, state.get('discovery_results', []), discovery_source, profile_id=state.get('_profile_id', 1)) + + except Exception as e: + logger.error(f"Error in Qobuz discovery worker: {e}") + if playlist_id in deps.qobuz_discovery_states: + deps.qobuz_discovery_states[playlist_id]['phase'] = 'error' + deps.qobuz_discovery_states[playlist_id]['status'] = f'error: {str(e)}' + finally: + deps.resume_enrichment_workers(_ew_state, 'Qobuz discovery') diff --git a/core/qobuz_client.py b/core/qobuz_client.py index 1cb58a66..c2cf4e13 100644 --- a/core/qobuz_client.py +++ b/core/qobuz_client.py @@ -711,6 +711,241 @@ class QobuzClient(DownloadSourcePlugin): logger.error(f"Error getting Qobuz track {track_id}: {e}") return None + # ===================== Playlists & Favorites ===================== + # + # Qobuz playlist sync surface — mirrors the Tidal client contract + # (see core/tidal_client.py:629 + :1227) so the Sync page's + # per-service handlers can render Qobuz playlists in the same + # discovery / mirror flow. Returns normalized dicts rather than + # dataclasses to match the rest of this client's idiom. + # + # Favorite Tracks ride on the same `get_playlist()` entry point via + # the virtual ID below — same pattern as Tidal's COLLECTION_PLAYLIST_ID + # so sync-services.js can treat favorites as just another playlist + # card without per-service special-casing. + QOBUZ_FAVORITES_ID = "qobuz-favorites" + QOBUZ_FAVORITES_NAME = "Favorite Tracks" + QOBUZ_FAVORITES_DESCRIPTION = "Your favorited tracks on Qobuz" + + # Page size for paginated playlist + favorite listings. Qobuz caps at + # 500 per page; 100 is a safe middle ground for responsiveness. + _PLAYLIST_PAGE_SIZE = 100 + + def _normalize_qobuz_playlist(self, p: Dict) -> Dict: + """Project a Qobuz playlist dict into the shape the Sync page expects.""" + image = p.get('images', []) or [] + image_url = image[0] if image else (p.get('image_rectangle', [None])[0] if p.get('image_rectangle') else None) + if not image_url: + image_url = p.get('image', '') or '' + return { + 'id': str(p.get('id', '')), + 'name': p.get('name', 'Unknown Playlist'), + 'description': p.get('description', '') or '', + 'public': bool(p.get('is_public', False)), + 'track_count': int(p.get('tracks_count', 0) or 0), + 'image_url': image_url, + 'external_urls': {'qobuz': f"https://play.qobuz.com/playlist/{p.get('id', '')}"} if p.get('id') else {}, + } + + def _normalize_qobuz_track(self, t: Dict) -> Dict: + """Project a Qobuz track dict into the shape the Sync page expects.""" + performer = t.get('performer') or {} + album = t.get('album') or {} + album_artist = album.get('artist') or {} + + # Artist names — Qobuz can stash the artist on performer, album.artist, + # or composer depending on the track. Prefer performer, fall back to + # album artist, then composer, then "Unknown Artist". + artist_name = ( + performer.get('name') + or album_artist.get('name') + or (t.get('composer') or {}).get('name') + or 'Unknown Artist' + ) + + album_image = album.get('image') or {} + image_url = album_image.get('large') or album_image.get('small') or album_image.get('thumbnail') or '' + + return { + 'id': str(t.get('id', '')), + 'name': t.get('title', '') or '', + 'artists': [artist_name], + 'album': album.get('title', '') or '', + 'duration_ms': int(t.get('duration', 0) or 0) * 1000, + 'image_url': image_url, + 'external_urls': {'qobuz': f"https://play.qobuz.com/track/{t.get('id', '')}"} if t.get('id') else {}, + 'explicit': bool(t.get('parental_warning', False)), + } + + def get_user_playlists(self) -> List[Dict[str, Any]]: + """Fetch the authenticated user's Qobuz playlists. + + Returns metadata only (no tracks) — track lists are fetched + on-demand via `get_playlist()` when the user selects one. + Matches the Tidal `get_user_playlists_metadata_only` contract + so the Sync page renderer can treat both services uniformly. + """ + if not self.is_authenticated(): + logger.warning("Qobuz not authenticated — cannot list playlists") + return [] + + playlists: List[Dict[str, Any]] = [] + offset = 0 + while True: + data = self._api_request('playlist/getUserPlaylists', { + 'limit': self._PLAYLIST_PAGE_SIZE, + 'offset': offset, + }) + if not data: + break + + container = data.get('playlists') or {} + items = container.get('items', []) or [] + if not items: + break + + for raw in items: + try: + playlists.append(self._normalize_qobuz_playlist(raw)) + except Exception as exc: + logger.debug(f"Skipping malformed Qobuz playlist entry: {exc}") + + total = int(container.get('total', len(playlists)) or len(playlists)) + offset += len(items) + if offset >= total or len(items) < self._PLAYLIST_PAGE_SIZE: + break + + logger.info(f"Retrieved {len(playlists)} Qobuz user playlists") + return playlists + + def get_playlist(self, playlist_id: str) -> Optional[Dict[str, Any]]: + """Fetch a Qobuz playlist with its full tracklist. + + Recognizes the virtual ``qobuz-favorites`` ID and dispatches to + ``get_user_favorite_tracks`` so the Sync page can treat + favorites as just another playlist card (same pattern as + Tidal's ``tidal-favorites``). + """ + if not self.is_authenticated(): + logger.warning("Qobuz not authenticated — cannot fetch playlist") + return None + + if str(playlist_id) == self.QOBUZ_FAVORITES_ID: + tracks = self.get_user_favorite_tracks() + return { + 'id': self.QOBUZ_FAVORITES_ID, + 'name': self.QOBUZ_FAVORITES_NAME, + 'description': self.QOBUZ_FAVORITES_DESCRIPTION, + 'public': False, + 'track_count': len(tracks), + 'image_url': '', + 'external_urls': {}, + 'tracks': tracks, + } + + # Paginate tracks ourselves — Qobuz's playlist/get only returns + # the first ~50 tracks even with limit=500 on some accounts. + tracks: List[Dict[str, Any]] = [] + offset = 0 + playlist_meta: Optional[Dict] = None + while True: + data = self._api_request('playlist/get', { + 'playlist_id': playlist_id, + 'extra': 'tracks', + 'limit': self._PLAYLIST_PAGE_SIZE, + 'offset': offset, + }) + if not data: + break + + if playlist_meta is None: + playlist_meta = data + + track_container = data.get('tracks') or {} + items = track_container.get('items', []) or [] + if not items: + break + + for raw in items: + try: + tracks.append(self._normalize_qobuz_track(raw)) + except Exception as exc: + logger.debug(f"Skipping malformed Qobuz playlist track: {exc}") + + total = int(track_container.get('total', len(tracks)) or len(tracks)) + offset += len(items) + if offset >= total or len(items) < self._PLAYLIST_PAGE_SIZE: + break + + if playlist_meta is None: + logger.warning(f"Qobuz playlist {playlist_id} not found") + return None + + normalized = self._normalize_qobuz_playlist(playlist_meta) + normalized['tracks'] = tracks + normalized['track_count'] = len(tracks) + logger.info(f"Retrieved Qobuz playlist '{normalized['name']}' with {len(tracks)} tracks") + return normalized + + def get_user_favorite_tracks(self, limit: int = 500) -> List[Dict[str, Any]]: + """Fetch the authenticated user's favorited tracks. + + Mirrors ``TidalClient.get_collection_tracks`` — the Sync page's + Favorite Tracks card pulls from here on click. + """ + if not self.is_authenticated(): + logger.warning("Qobuz not authenticated — cannot list favorite tracks") + return [] + + tracks: List[Dict[str, Any]] = [] + offset = 0 + while len(tracks) < limit: + page_size = min(self._PLAYLIST_PAGE_SIZE, limit - len(tracks)) + data = self._api_request('favorite/getUserFavorites', { + 'type': 'tracks', + 'limit': page_size, + 'offset': offset, + }) + if not data: + break + + container = data.get('tracks') or {} + items = container.get('items', []) or [] + if not items: + break + + for raw in items: + try: + tracks.append(self._normalize_qobuz_track(raw)) + except Exception as exc: + logger.debug(f"Skipping malformed Qobuz favorite track: {exc}") + + total = int(container.get('total', len(tracks)) or len(tracks)) + offset += len(items) + if offset >= total or len(items) < page_size: + break + + logger.info(f"Retrieved {len(tracks)} Qobuz favorite tracks") + return tracks + + def get_user_favorite_tracks_count(self) -> int: + """Cheap track-count lookup for the Favorite Tracks card metadata. + + Mirrors ``TidalClient.get_collection_tracks_count`` — avoids + fetching the full list just to populate the card's track-count + chip on the Sync page. + """ + if not self.is_authenticated(): + return 0 + data = self._api_request('favorite/getUserFavorites', { + 'type': 'tracks', + 'limit': 1, + 'offset': 0, + }) + if not data: + return 0 + return int((data.get('tracks') or {}).get('total', 0) or 0) + async def search(self, query: str, timeout: int = None, progress_callback=None) -> Tuple[List[TrackResult], List[AlbumResult]]: """ Search Qobuz for tracks (async, Soulseek-compatible interface). diff --git a/tests/test_qobuz_playlists.py b/tests/test_qobuz_playlists.py new file mode 100644 index 00000000..3a3a9bea --- /dev/null +++ b/tests/test_qobuz_playlists.py @@ -0,0 +1,402 @@ +"""Unit tests for QobuzClient playlist + favorites methods. + +Covers the Sync-page parity added for github issue #677: +- `get_user_playlists` paginates + normalizes the playlist list +- `get_playlist` paginates the tracklist + normalizes track shape +- `get_playlist` recognizes the virtual `qobuz-favorites` ID and + dispatches to `get_user_favorite_tracks` (same pattern as Tidal's + COLLECTION_PLAYLIST_ID) +- `get_user_favorite_tracks_count` reads the cheap count-only path +""" + +from __future__ import annotations + +import sys +import types +from typing import Any, Dict, List + +import pytest + + +@pytest.fixture +def qobuz_client_module(): + """Import core.qobuz_client with config_manager stubbed to a mutable + in-memory dict. Snapshots and restores sys.modules entries on + teardown so downstream tests still see the real config. + """ + config_state: Dict[str, Any] = {} + + class _StubConfigManager: + def get(self, key, default=None): + cur: Any = config_state + for part in key.split('.'): + if isinstance(cur, dict) and part in cur: + cur = cur[part] + else: + return default + return cur + + def set(self, key, value): + cur: Any = config_state + parts = key.split('.') + for part in parts[:-1]: + cur = cur.setdefault(part, {}) + cur[parts[-1]] = value + + original_modules = { + name: sys.modules.get(name) + for name in ('config', 'config.settings', 'core.qobuz_client') + } + + if 'config' not in sys.modules: + sys.modules['config'] = types.ModuleType('config') + settings_mod = types.ModuleType('config.settings') + settings_mod.config_manager = _StubConfigManager() + sys.modules['config.settings'] = settings_mod + + sys.modules.pop('core.qobuz_client', None) + try: + import core.qobuz_client as qobuz_client_module + yield qobuz_client_module, config_state + finally: + for name, original in original_modules.items(): + if original is None: + sys.modules.pop(name, None) + else: + sys.modules[name] = original + + +@pytest.fixture +def authed_client(qobuz_client_module): + """A QobuzClient with stub credentials so is_authenticated() returns True.""" + module, config = qobuz_client_module + config['qobuz'] = { + 'session': { + 'app_id': 'APP-1', + 'app_secret': 'SECRET-1', + 'user_auth_token': 'TOKEN-1', + } + } + client = module.QobuzClient() + client.reload_credentials() + assert client.is_authenticated() is True + return client + + +def _install_api_responder(client, responder): + """Replace `_api_request` with a deterministic responder for the test.""" + client._api_request = responder # type: ignore[method-assign] + + +# --------------------------------------------------------------------------- +# get_user_playlists — pagination + normalization +# --------------------------------------------------------------------------- + + +def test_get_user_playlists_returns_normalized_metadata(authed_client): + calls: List[Dict[str, Any]] = [] + + def responder(endpoint, params=None): + calls.append({'endpoint': endpoint, 'params': params}) + return { + 'playlists': { + 'items': [ + { + 'id': 1001, + 'name': 'My Mix', + 'description': 'on repeat', + 'is_public': True, + 'tracks_count': 12, + 'images': ['https://qobuz.example/cover.jpg'], + }, + ], + 'total': 1, + } + } + + _install_api_responder(authed_client, responder) + playlists = authed_client.get_user_playlists() + + assert calls == [{ + 'endpoint': 'playlist/getUserPlaylists', + 'params': {'limit': 100, 'offset': 0}, + }] + assert playlists == [{ + 'id': '1001', + 'name': 'My Mix', + 'description': 'on repeat', + 'public': True, + 'track_count': 12, + 'image_url': 'https://qobuz.example/cover.jpg', + 'external_urls': {'qobuz': 'https://play.qobuz.com/playlist/1001'}, + }] + + +def test_get_user_playlists_paginates_until_total_reached(authed_client): + # Two pages of 100 each, third page returns empty to verify the loop + # terminates on `total` rather than waiting for an empty page. + page_one = [{'id': i, 'name': f'P{i}', 'tracks_count': 0} for i in range(100)] + page_two = [{'id': 100 + i, 'name': f'P{100 + i}', 'tracks_count': 0} for i in range(50)] + calls: List[int] = [] + + def responder(endpoint, params=None): + calls.append(params['offset']) + if params['offset'] == 0: + return {'playlists': {'items': page_one, 'total': 150}} + if params['offset'] == 100: + return {'playlists': {'items': page_two, 'total': 150}} + return {'playlists': {'items': [], 'total': 150}} + + _install_api_responder(authed_client, responder) + playlists = authed_client.get_user_playlists() + + assert len(playlists) == 150 + assert calls == [0, 100] # No third request needed + + +def test_get_user_playlists_returns_empty_when_unauthenticated(qobuz_client_module): + module, _ = qobuz_client_module + client = module.QobuzClient() # no credentials configured + assert client.is_authenticated() is False + + def responder(endpoint, params=None): + raise AssertionError('should not hit the API when unauthenticated') + + _install_api_responder(client, responder) + assert client.get_user_playlists() == [] + + +# --------------------------------------------------------------------------- +# get_playlist — track pagination + normalization +# --------------------------------------------------------------------------- + + +def test_get_playlist_normalizes_tracks(authed_client): + def responder(endpoint, params=None): + assert endpoint == 'playlist/get' + return { + 'id': 2002, + 'name': 'Deep Cuts', + 'description': '', + 'is_public': False, + 'tracks_count': 1, + 'images': ['https://qobuz.example/dc.jpg'], + 'tracks': { + 'items': [ + { + 'id': 555, + 'title': 'Forgotten Track', + 'duration': 240, + 'parental_warning': True, + 'performer': {'name': 'Some Artist'}, + 'album': { + 'title': 'Some Album', + 'image': {'large': 'https://qobuz.example/art.jpg'}, + }, + }, + ], + 'total': 1, + }, + } + + _install_api_responder(authed_client, responder) + playlist = authed_client.get_playlist('2002') + + assert playlist is not None + assert playlist['id'] == '2002' + assert playlist['name'] == 'Deep Cuts' + assert playlist['track_count'] == 1 + assert playlist['tracks'] == [{ + 'id': '555', + 'name': 'Forgotten Track', + 'artists': ['Some Artist'], + 'album': 'Some Album', + 'duration_ms': 240_000, + 'image_url': 'https://qobuz.example/art.jpg', + 'external_urls': {'qobuz': 'https://play.qobuz.com/track/555'}, + 'explicit': True, + }] + + +def test_get_playlist_routes_favorites_virtual_id(authed_client): + """The virtual `qobuz-favorites` ID must dispatch to the favorites + endpoint rather than the playlist/get endpoint — mirrors Tidal's + COLLECTION_PLAYLIST_ID pattern.""" + seen_endpoints: List[str] = [] + + def responder(endpoint, params=None): + seen_endpoints.append(endpoint) + # favorite/getUserFavorites is the only endpoint that should fire + return { + 'tracks': { + 'items': [ + { + 'id': 777, + 'title': 'Liked Song', + 'duration': 180, + 'performer': {'name': 'Loved Artist'}, + 'album': {'title': 'Heart Album', 'image': {'large': 'https://q.example/h.jpg'}}, + }, + ], + 'total': 1, + } + } + + _install_api_responder(authed_client, responder) + playlist = authed_client.get_playlist(authed_client.QOBUZ_FAVORITES_ID) + + assert playlist is not None + assert playlist['id'] == authed_client.QOBUZ_FAVORITES_ID + assert playlist['name'] == authed_client.QOBUZ_FAVORITES_NAME + assert playlist['track_count'] == 1 + assert playlist['tracks'][0]['name'] == 'Liked Song' + # Only the favorites endpoint should have been hit — no playlist/get. + assert seen_endpoints == ['favorite/getUserFavorites'] + + +def test_get_playlist_paginates_track_list(authed_client): + page_one_tracks = [ + {'id': i, 'title': f'T{i}', 'duration': 100, 'performer': {'name': 'A'}, 'album': {'title': 'Alb', 'image': {}}} + for i in range(100) + ] + page_two_tracks = [ + {'id': 100 + i, 'title': f'T{100 + i}', 'duration': 100, 'performer': {'name': 'A'}, 'album': {'title': 'Alb', 'image': {}}} + for i in range(25) + ] + offsets: List[int] = [] + + def responder(endpoint, params=None): + offsets.append(params['offset']) + if params['offset'] == 0: + return { + 'id': 'X', 'name': 'Long', 'description': '', 'is_public': False, + 'tracks_count': 125, 'images': [], + 'tracks': {'items': page_one_tracks, 'total': 125}, + } + if params['offset'] == 100: + return { + 'id': 'X', 'name': 'Long', 'description': '', 'is_public': False, + 'tracks_count': 125, 'images': [], + 'tracks': {'items': page_two_tracks, 'total': 125}, + } + return {'tracks': {'items': [], 'total': 125}} + + _install_api_responder(authed_client, responder) + playlist = authed_client.get_playlist('X') + + assert playlist is not None + assert len(playlist['tracks']) == 125 + assert playlist['track_count'] == 125 + assert offsets == [0, 100] + + +def test_get_playlist_returns_none_when_unauthenticated(qobuz_client_module): + module, _ = qobuz_client_module + client = module.QobuzClient() + assert client.get_playlist('whatever') is None + + +# --------------------------------------------------------------------------- +# get_user_favorite_tracks + get_user_favorite_tracks_count +# --------------------------------------------------------------------------- + + +def test_get_user_favorite_tracks_paginates(authed_client): + def make_items(start, count): + return [ + {'id': start + i, 'title': f'F{start + i}', 'duration': 200, + 'performer': {'name': 'Fav Artist'}, + 'album': {'title': 'Fav Album', 'image': {}}} + for i in range(count) + ] + + offsets: List[int] = [] + + def responder(endpoint, params=None): + assert endpoint == 'favorite/getUserFavorites' + assert params['type'] == 'tracks' + offsets.append(params['offset']) + if params['offset'] == 0: + return {'tracks': {'items': make_items(0, 100), 'total': 130}} + if params['offset'] == 100: + return {'tracks': {'items': make_items(100, 30), 'total': 130}} + return {'tracks': {'items': [], 'total': 130}} + + _install_api_responder(authed_client, responder) + tracks = authed_client.get_user_favorite_tracks() + + assert len(tracks) == 130 + assert offsets == [0, 100] + assert tracks[0]['name'] == 'F0' + assert tracks[-1]['name'] == 'F129' + + +def test_get_user_favorite_tracks_count_uses_cheap_call(authed_client): + captured: Dict[str, Any] = {} + + def responder(endpoint, params=None): + captured['endpoint'] = endpoint + captured['params'] = params + return {'tracks': {'items': [], 'total': 4242}} + + _install_api_responder(authed_client, responder) + count = authed_client.get_user_favorite_tracks_count() + + assert count == 4242 + # Single request with limit=1 — must not iterate the full list. + assert captured == { + 'endpoint': 'favorite/getUserFavorites', + 'params': {'type': 'tracks', 'limit': 1, 'offset': 0}, + } + + +def test_get_user_favorite_tracks_count_returns_zero_when_unauthenticated(qobuz_client_module): + module, _ = qobuz_client_module + client = module.QobuzClient() + assert client.get_user_favorite_tracks_count() == 0 + + +# --------------------------------------------------------------------------- +# Track normalization fallbacks — artist resolution chain +# --------------------------------------------------------------------------- + + +def test_track_normalization_falls_back_to_album_artist(authed_client): + """When `performer.name` is missing, album.artist.name should win + over the bare 'Unknown Artist' default.""" + def responder(endpoint, params=None): + return { + 'id': 'P', 'name': 'p', 'description': '', 'is_public': False, + 'tracks_count': 1, 'images': [], + 'tracks': { + 'items': [{ + 'id': 1, 'title': 'X', 'duration': 10, + 'album': { + 'title': 'A', + 'artist': {'name': 'Album Artist'}, + 'image': {'large': ''}, + }, + }], + 'total': 1, + } + } + + _install_api_responder(authed_client, responder) + playlist = authed_client.get_playlist('P') + assert playlist['tracks'][0]['artists'] == ['Album Artist'] + + +def test_track_normalization_uses_unknown_artist_when_all_sources_empty(authed_client): + def responder(endpoint, params=None): + return { + 'id': 'P', 'name': 'p', 'description': '', 'is_public': False, + 'tracks_count': 1, 'images': [], + 'tracks': { + 'items': [{'id': 1, 'title': 'X', 'duration': 10}], + 'total': 1, + } + } + + _install_api_responder(authed_client, responder) + playlist = authed_client.get_playlist('P') + assert playlist['tracks'][0]['artists'] == ['Unknown Artist'] diff --git a/web_server.py b/web_server.py index f5b817fb..b6f3ea6a 100644 --- a/web_server.py +++ b/web_server.py @@ -1586,6 +1586,7 @@ def _shutdown_runtime_components(): (import_singles_executor, "import singles executor"), (tidal_discovery_executor, "tidal discovery executor"), (deezer_discovery_executor, "deezer discovery executor"), + (qobuz_discovery_executor, "qobuz discovery executor"), (spotify_public_discovery_executor, "spotify public discovery executor"), (youtube_discovery_executor, "youtube discovery executor"), (beatport_discovery_executor, "beatport discovery executor"), @@ -21847,6 +21848,655 @@ def cancel_deezer_sync(playlist_id): return jsonify({"error": str(e)}), 500 +# =================================================================== +# QOBUZ PLAYLIST DISCOVERY API ENDPOINTS +# =================================================================== +# +# Mirrors the Tidal + Deezer endpoint set for parity on the Sync page. +# Qobuz playlists arrive from `core/qobuz_client.py` as dicts (matching +# the Deezer client's shape), so the state + endpoint code follows the +# Deezer template rather than Tidal's dataclass-based one. Github issue +# #677. + +# Global state for Qobuz playlist discovery management +qobuz_discovery_states = {} # Key: playlist_id, Value: discovery state +qobuz_discovery_executor = ThreadPoolExecutor(max_workers=3, thread_name_prefix="qobuz_discovery") + + +def _get_qobuz_client_for_sync(): + """Resolve the Qobuz client via the download orchestrator. + + The orchestrator owns the canonical instance (same one Settings → + Connections authenticates against), so the Sync page tab always sees + fresh auth state without a second login flow. + """ + if not download_orchestrator or not hasattr(download_orchestrator, 'client'): + return None + try: + return download_orchestrator.client("qobuz") + except Exception as exc: + logger.debug(f"Qobuz client lookup failed: {exc}") + return None + + +@app.route('/api/qobuz/playlists', methods=['GET']) +def get_qobuz_playlists(): + """Fetches the authenticated user's Qobuz playlists (metadata only). + + Tracks are fetched on demand by the per-playlist detail endpoint — + matches the Tidal + Deezer behaviour so the Sync page renderer can + treat all three services uniformly. + """ + qobuz = _get_qobuz_client_for_sync() + if not qobuz or not qobuz.is_authenticated(): + return jsonify({"error": "Qobuz not authenticated."}), 401 + + try: + playlists = qobuz.get_user_playlists() + + playlist_data = [] + for p in playlists: + playlist_data.append({ + "id": p['id'], + "name": p['name'], + "owner": "You", + "track_count": p.get('track_count', 0), + "image_url": p.get('image_url') or None, + "description": p.get('description', ''), + "tracks": [] + }) + + # Append virtual "Favorite Tracks" entry at the END (mirrors + # Tidal's COLLECTION_PLAYLIST_ID pattern — count only here, full + # fetch deferred to the per-playlist detail endpoint). + try: + from core.qobuz_client import QobuzClient as _QobuzClientTypeRef + favorites_count = qobuz.get_user_favorite_tracks_count() + if favorites_count > 0: + playlist_data.append({ + "id": qobuz.QOBUZ_FAVORITES_ID, + "name": qobuz.QOBUZ_FAVORITES_NAME, + "owner": "You", + "track_count": favorites_count, + "image_url": None, + "description": qobuz.QOBUZ_FAVORITES_DESCRIPTION, + "tracks": [], + }) + logger.info( + f"Added virtual '{qobuz.QOBUZ_FAVORITES_NAME}' playlist with {favorites_count} tracks (count only)" + ) + except Exception as favorites_error: + logger.error(f"Failed to add Qobuz Favorite Tracks playlist: {favorites_error}") + + logger.info(f"Loaded {len(playlist_data)} Qobuz playlists") + return jsonify(playlist_data) + except Exception as e: + logger.error(f"Error loading Qobuz playlists: {e}") + return jsonify({"error": str(e)}), 500 + + +@app.route('/api/qobuz/playlist/', methods=['GET']) +def get_qobuz_playlist_tracks(playlist_id): + """Fetches full track details for a specific Qobuz playlist.""" + qobuz = _get_qobuz_client_for_sync() + if not qobuz or not qobuz.is_authenticated(): + return jsonify({"error": "Qobuz not authenticated."}), 401 + + try: + logger.info(f"Getting full Qobuz playlist with tracks for: {playlist_id}") + full_playlist = qobuz.get_playlist(playlist_id) + if not full_playlist: + return jsonify({"error": "Playlist not found or unable to access."}), 404 + + tracks = full_playlist.get('tracks') or [] + if not tracks: + return jsonify({"error": "This playlist appears to have no tracks or they cannot be accessed"}), 403 + + logger.info(f"Loaded {len(tracks)} tracks from Qobuz playlist: {full_playlist['name']}") + + playlist_dict = { + 'id': full_playlist['id'], + 'name': full_playlist['name'], + 'description': full_playlist.get('description', ''), + 'owner': 'You', + 'track_count': len(tracks), + 'image_url': full_playlist.get('image_url') or None, + 'tracks': tracks, + } + return jsonify(playlist_dict) + except Exception as e: + logger.error(f"Error getting Qobuz playlist tracks: {e}") + return jsonify({"error": str(e)}), 500 + + +@app.route('/api/qobuz/discovery/start/', methods=['POST']) +def start_qobuz_discovery(playlist_id): + """Start Spotify discovery process for a Qobuz playlist.""" + try: + qobuz = _get_qobuz_client_for_sync() + if not qobuz or not qobuz.is_authenticated(): + return jsonify({"error": "Qobuz not authenticated."}), 401 + + if playlist_id in qobuz_discovery_states: + existing_state = qobuz_discovery_states[playlist_id] + if existing_state['phase'] == 'discovering': + return jsonify({"error": "Discovery already in progress"}), 400 + + if not existing_state.get('playlist'): + playlist_data = qobuz.get_playlist(playlist_id) + if not playlist_data: + return jsonify({"error": "Qobuz playlist not found"}), 404 + existing_state['playlist'] = playlist_data + + existing_state['phase'] = 'discovering' + existing_state['status'] = 'discovering' + existing_state['last_accessed'] = time.time() + state = existing_state + else: + playlist_data = qobuz.get_playlist(playlist_id) + + if not playlist_data: + return jsonify({"error": "Qobuz playlist not found"}), 404 + + if not playlist_data.get('tracks'): + return jsonify({"error": "Playlist has no tracks"}), 400 + + state = { + 'playlist': playlist_data, + 'phase': 'discovering', + 'status': 'discovering', + 'discovery_progress': 0, + 'spotify_matches': 0, + 'spotify_total': len(playlist_data['tracks']), + 'discovery_results': [], + 'sync_playlist_id': None, + 'converted_spotify_playlist_id': None, + 'download_process_id': None, + 'created_at': time.time(), + 'last_accessed': time.time(), + 'discovery_future': None, + 'sync_progress': {} + } + qobuz_discovery_states[playlist_id] = state + + playlist_name = state['playlist']['name'] + track_count = len(state['playlist']['tracks']) + add_activity_item("", "Qobuz Discovery Started", f"'{playlist_name}' - {track_count} tracks", "Now") + + qobuz_discovery_states[playlist_id]['_profile_id'] = get_current_profile_id() + future = qobuz_discovery_executor.submit(_run_qobuz_discovery_worker, playlist_id) + state['discovery_future'] = future + + logger.info(f"Started Spotify discovery for Qobuz playlist: {playlist_name}") + return jsonify({"success": True, "message": "Discovery started"}) + + except Exception as e: + logger.error(f"Error starting Qobuz discovery: {e}") + return jsonify({"error": str(e)}), 500 + + +@app.route('/api/qobuz/discovery/status/', methods=['GET']) +def get_qobuz_discovery_status(playlist_id): + """Get real-time discovery status for a Qobuz playlist.""" + try: + if playlist_id not in qobuz_discovery_states: + return jsonify({"error": "Qobuz discovery not found"}), 404 + + state = qobuz_discovery_states[playlist_id] + state['last_accessed'] = time.time() + + response = { + 'phase': state['phase'], + 'status': state['status'], + 'progress': state['discovery_progress'], + 'spotify_matches': state['spotify_matches'], + 'spotify_total': state['spotify_total'], + 'results': state['discovery_results'], + 'complete': state['phase'] == 'discovered' + } + + return jsonify(response) + + except Exception as e: + logger.error(f"Error getting Qobuz discovery status: {e}") + return jsonify({"error": str(e)}), 500 + + +@app.route('/api/qobuz/discovery/update_match', methods=['POST']) +def update_qobuz_discovery_match(): + """Update a Qobuz discovery result with a manually selected Spotify track.""" + try: + data = request.get_json() + identifier = data.get('identifier') # playlist_id + track_index = data.get('track_index') + spotify_track = data.get('spotify_track') + + if not identifier or track_index is None or not spotify_track: + return jsonify({'error': 'Missing required fields'}), 400 + + state = qobuz_discovery_states.get(identifier) + if not state: + return jsonify({'error': 'Discovery state not found'}), 404 + + if track_index >= len(state['discovery_results']): + return jsonify({'error': 'Invalid track index'}), 400 + + result = state['discovery_results'][track_index] + old_status = result.get('status') + + result['status'] = 'Found' + result['status_class'] = 'found' + result['spotify_track'] = spotify_track['name'] + result['spotify_artist'] = _join_artist_names(spotify_track['artists']) if isinstance(spotify_track['artists'], list) else _extract_artist_name(spotify_track['artists']) + result['spotify_album'] = spotify_track['album'] + result['spotify_id'] = spotify_track['id'] + + duration_ms = spotify_track.get('duration_ms', 0) + if duration_ms: + minutes = duration_ms // 60000 + seconds = (duration_ms % 60000) // 1000 + result['duration'] = f"{minutes}:{seconds:02d}" + else: + result['duration'] = '0:00' + + # Manual match from the fix modal — build rich spotify_data matching + # the normal discovery shape, clear wing-it flag since the user + # picked a real metadata match. + result['spotify_data'] = _build_fix_modal_spotify_data(spotify_track) + result['wing_it_fallback'] = False + result['manual_match'] = True + + if old_status != 'found' and old_status != 'Found': + state['spotify_matches'] = state.get('spotify_matches', 0) + 1 + + logger.info(f"Manual match updated: qobuz - {identifier} - track {track_index}") + logger.info(f" → {result['spotify_artist']} - {result['spotify_track']}") + + try: + original_track = result.get('qobuz_track', {}) + original_name = original_track.get('name', spotify_track['name']) + original_artists = original_track.get('artists', []) + original_artist = original_artists[0] if original_artists else '' + + cache_key = _get_discovery_cache_key(original_name, original_artist) + artists_list = spotify_track['artists'] + if isinstance(artists_list, list): + artists_list = [a if isinstance(a, str) else a.get('name', '') for a in artists_list] + image_url = spotify_track.get('image_url') or '' + album_raw = spotify_track.get('album', '') + if isinstance(album_raw, dict): + album_obj = dict(album_raw) + if image_url and not album_obj.get('image_url'): + album_obj['image_url'] = image_url + if image_url and not album_obj.get('images'): + album_obj['images'] = [{'url': image_url}] + else: + album_obj = {'name': album_raw or ''} + if image_url: + album_obj['image_url'] = image_url + album_obj['images'] = [{'url': image_url}] + + matched_data = { + 'id': spotify_track['id'], + 'name': spotify_track['name'], + 'artists': artists_list, + 'album': album_obj, + 'duration_ms': spotify_track.get('duration_ms', 0), + 'image_url': image_url, + 'source': 'spotify', + } + cache_db = get_database() + cache_db.save_discovery_cache_match( + cache_key[0], cache_key[1], _get_active_discovery_source(), 1.0, matched_data, + original_name, original_artist + ) + logger.info(f"Manual fix saved to discovery cache: {original_name} by {original_artist}") + except Exception as cache_err: + logger.error(f"Error saving manual fix to discovery cache: {cache_err}") + + return jsonify({'success': True, 'result': result}) + + except Exception as e: + logger.error(f"Error updating Qobuz discovery match: {e}") + return jsonify({'error': str(e)}), 500 + + +@app.route('/api/qobuz/playlists/states', methods=['GET']) +def get_qobuz_playlist_states(): + """Get all stored Qobuz playlist discovery states for frontend hydration.""" + try: + states = [] + current_time = time.time() + + for playlist_id, state in qobuz_discovery_states.items(): + state['last_accessed'] = current_time + + state_info = { + 'playlist_id': playlist_id, + 'phase': state['phase'], + 'status': state['status'], + 'discovery_progress': state['discovery_progress'], + 'spotify_matches': state['spotify_matches'], + 'spotify_total': state['spotify_total'], + 'discovery_results': state['discovery_results'], + 'converted_spotify_playlist_id': state.get('converted_spotify_playlist_id'), + 'download_process_id': state.get('download_process_id'), + 'last_accessed': state['last_accessed'] + } + states.append(state_info) + + logger.info(f"Returning {len(states)} stored Qobuz playlist states for hydration") + return jsonify({"states": states}) + + except Exception as e: + logger.error(f"Error getting Qobuz playlist states: {e}") + return jsonify({"error": str(e)}), 500 + + +@app.route('/api/qobuz/state/', methods=['GET']) +def get_qobuz_playlist_state(playlist_id): + """Get specific Qobuz playlist state (detailed version).""" + try: + if playlist_id not in qobuz_discovery_states: + return jsonify({"error": "Qobuz playlist not found"}), 404 + + state = qobuz_discovery_states[playlist_id] + state['last_accessed'] = time.time() + + response = { + 'playlist_id': playlist_id, + 'playlist': state['playlist'], + 'phase': state['phase'], + 'status': state['status'], + 'discovery_progress': state['discovery_progress'], + 'spotify_matches': state['spotify_matches'], + 'spotify_total': state['spotify_total'], + 'discovery_results': state['discovery_results'], + 'sync_playlist_id': state.get('sync_playlist_id'), + 'converted_spotify_playlist_id': state.get('converted_spotify_playlist_id'), + 'download_process_id': state.get('download_process_id'), + 'sync_progress': state.get('sync_progress', {}), + 'last_accessed': state['last_accessed'] + } + + return jsonify(response) + + except Exception as e: + logger.error(f"Error getting Qobuz playlist state: {e}") + return jsonify({"error": str(e)}), 500 + + +@app.route('/api/qobuz/reset/', methods=['POST']) +def reset_qobuz_playlist(playlist_id): + """Reset Qobuz playlist to fresh phase (clear discovery/sync data).""" + try: + if playlist_id not in qobuz_discovery_states: + return jsonify({"error": "Qobuz playlist not found"}), 404 + + state = qobuz_discovery_states[playlist_id] + + if 'discovery_future' in state and state['discovery_future']: + state['discovery_future'].cancel() + + state['phase'] = 'fresh' + state['status'] = 'fresh' + state['discovery_results'] = [] + state['discovery_progress'] = 0 + state['spotify_matches'] = 0 + state['sync_playlist_id'] = None + state['converted_spotify_playlist_id'] = None + state['download_process_id'] = None + state['sync_progress'] = {} + state['discovery_future'] = None + state['last_accessed'] = time.time() + + logger.info(f"Reset Qobuz playlist to fresh: {playlist_id}") + return jsonify({"success": True, "message": "Playlist reset to fresh phase"}) + + except Exception as e: + logger.error(f"Error resetting Qobuz playlist: {e}") + return jsonify({"error": str(e)}), 500 + + +@app.route('/api/qobuz/delete/', methods=['POST']) +def delete_qobuz_playlist(playlist_id): + """Delete Qobuz playlist state completely.""" + try: + if playlist_id not in qobuz_discovery_states: + return jsonify({"error": "Qobuz playlist not found"}), 404 + + state = qobuz_discovery_states[playlist_id] + + if 'discovery_future' in state and state['discovery_future']: + state['discovery_future'].cancel() + + del qobuz_discovery_states[playlist_id] + + logger.info(f"Deleted Qobuz playlist state: {playlist_id}") + return jsonify({"success": True, "message": "Playlist deleted"}) + + except Exception as e: + logger.error(f"Error deleting Qobuz playlist: {e}") + return jsonify({"error": str(e)}), 500 + + +@app.route('/api/qobuz/update_phase/', methods=['POST']) +def update_qobuz_playlist_phase(playlist_id): + """Update Qobuz playlist phase (used when modal closes to reset from download_complete to discovered).""" + try: + if playlist_id not in qobuz_discovery_states: + return jsonify({"error": "Qobuz playlist not found"}), 404 + + data = request.get_json() + if not data or 'phase' not in data: + return jsonify({"error": "Phase not provided"}), 400 + + new_phase = data['phase'] + valid_phases = ['fresh', 'discovering', 'discovered', 'syncing', 'sync_complete', 'downloading', 'download_complete'] + + if new_phase not in valid_phases: + return jsonify({"error": f"Invalid phase. Must be one of: {', '.join(valid_phases)}"}), 400 + + state = qobuz_discovery_states[playlist_id] + old_phase = state.get('phase', 'unknown') + state['phase'] = new_phase + state['last_accessed'] = time.time() + + if 'download_process_id' in data: + state['download_process_id'] = data['download_process_id'] + if 'converted_spotify_playlist_id' in data: + state['converted_spotify_playlist_id'] = data['converted_spotify_playlist_id'] + + logger.info(f"Updated Qobuz playlist {playlist_id} phase: {old_phase} → {new_phase}") + return jsonify({"success": True, "message": f"Phase updated to {new_phase}", "old_phase": old_phase, "new_phase": new_phase}) + + except Exception as e: + logger.error(f"Error updating Qobuz playlist phase: {e}") + return jsonify({"error": str(e)}), 500 + + +# Qobuz discovery worker logic lives in core/discovery/qobuz.py. +from core.discovery import qobuz as _discovery_qobuz + + +def _build_qobuz_discovery_deps(): + """Build the QobuzDiscoveryDeps bundle from web_server.py globals on each call.""" + return _discovery_qobuz.QobuzDiscoveryDeps( + qobuz_discovery_states=qobuz_discovery_states, + spotify_client=spotify_client, + pause_enrichment_workers=_pause_enrichment_workers, + resume_enrichment_workers=_resume_enrichment_workers, + get_active_discovery_source=_get_active_discovery_source, + get_metadata_fallback_client=_get_metadata_fallback_client, + get_discovery_cache_key=_get_discovery_cache_key, + get_database=get_database, + validate_discovery_cache_artist=_validate_discovery_cache_artist, + search_spotify_for_tidal_track=_search_spotify_for_tidal_track, + build_discovery_wing_it_stub=_build_discovery_wing_it_stub, + add_activity_item=add_activity_item, + sync_discovery_results_to_mirrored=_sync_discovery_results_to_mirrored, + ) + + +def _run_qobuz_discovery_worker(playlist_id): + return _discovery_qobuz.run_qobuz_discovery_worker(playlist_id, _build_qobuz_discovery_deps()) + + +def convert_qobuz_results_to_spotify_tracks(discovery_results): + """Convert Qobuz discovery results to Spotify tracks format for sync.""" + spotify_tracks = [] + + for result in discovery_results: + if result.get('spotify_data'): + spotify_data = result['spotify_data'] + + track = { + 'id': spotify_data['id'], + 'name': spotify_data['name'], + 'artists': spotify_data['artists'], + 'album': spotify_data['album'], + 'duration_ms': spotify_data.get('duration_ms', 0) + } + if spotify_data.get('track_number'): + track['track_number'] = spotify_data['track_number'] + if spotify_data.get('disc_number'): + track['disc_number'] = spotify_data['disc_number'] + spotify_tracks.append(track) + elif result.get('spotify_track') and result.get('status_class') == 'found': + track = { + 'id': result.get('spotify_id', 'unknown'), + 'name': result.get('spotify_track', 'Unknown Track'), + 'artists': [result.get('spotify_artist', 'Unknown Artist')] if result.get('spotify_artist') else ['Unknown Artist'], + 'album': result.get('spotify_album', 'Unknown Album'), + 'duration_ms': 0 + } + spotify_tracks.append(track) + + logger.info(f"Converted {len(spotify_tracks)} Qobuz matches to Spotify tracks for sync") + return spotify_tracks + + +# =================================================================== +# QOBUZ SYNC API ENDPOINTS +# =================================================================== + +@app.route('/api/qobuz/sync/start/', methods=['POST']) +def start_qobuz_sync(playlist_id): + """Start sync process for a Qobuz playlist using discovered Spotify tracks.""" + try: + if playlist_id not in qobuz_discovery_states: + return jsonify({"error": "Qobuz playlist not found"}), 404 + + state = qobuz_discovery_states[playlist_id] + state['last_accessed'] = time.time() + + if state['phase'] not in ['discovered', 'sync_complete', 'download_complete']: + return jsonify({"error": "Qobuz playlist not ready for sync"}), 400 + + spotify_tracks = convert_qobuz_results_to_spotify_tracks(state['discovery_results']) + if not spotify_tracks: + return jsonify({"error": "No Spotify matches found for sync"}), 400 + + sync_playlist_id = f"qobuz_{playlist_id}" + playlist_name = state['playlist']['name'] + + add_activity_item("", "Qobuz Sync Started", f"'{playlist_name}' - {len(spotify_tracks)} tracks", "Now") + + state['phase'] = 'syncing' + state['sync_playlist_id'] = sync_playlist_id + state['sync_progress'] = {} + + sync_data = { + 'playlist_id': sync_playlist_id, + 'playlist_name': playlist_name, + 'tracks': spotify_tracks + } + + with sync_lock: + sync_states[sync_playlist_id] = {"status": "starting", "progress": {}} + + playlist_image_url = state['playlist'].get('image_url', '') + future = sync_executor.submit(_run_sync_task, sync_playlist_id, sync_data['playlist_name'], spotify_tracks, None, get_current_profile_id(), playlist_image_url) + active_sync_workers[sync_playlist_id] = future + + logger.info(f"Started Qobuz sync for: {playlist_name} ({len(spotify_tracks)} tracks)") + return jsonify({"success": True, "sync_playlist_id": sync_playlist_id}) + + except Exception as e: + logger.error(f"Error starting Qobuz sync: {e}") + return jsonify({"error": str(e)}), 500 + + +@app.route('/api/qobuz/sync/status/', methods=['GET']) +def get_qobuz_sync_status(playlist_id): + """Get sync status for a Qobuz playlist.""" + try: + if playlist_id not in qobuz_discovery_states: + return jsonify({"error": "Qobuz playlist not found"}), 404 + + state = qobuz_discovery_states[playlist_id] + state['last_accessed'] = time.time() + sync_playlist_id = state.get('sync_playlist_id') + + if not sync_playlist_id: + return jsonify({"error": "No sync in progress"}), 404 + + with sync_lock: + sync_state = sync_states.get(sync_playlist_id, {}) + + response = { + 'phase': state['phase'], + 'sync_status': sync_state.get('status', 'unknown'), + 'progress': sync_state.get('progress', {}), + 'complete': sync_state.get('status') == 'finished', + 'error': sync_state.get('error') + } + + if sync_state.get('status') == 'finished': + state['phase'] = 'sync_complete' + state['sync_progress'] = sync_state.get('progress', {}) + playlist_name = state['playlist']['name'] + add_activity_item("", "Sync Complete", f"Qobuz playlist '{playlist_name}' synced successfully", "Now") + elif sync_state.get('status') == 'error': + state['phase'] = 'discovered' + playlist_name = state['playlist']['name'] + add_activity_item("", "Sync Failed", f"Qobuz playlist '{playlist_name}' sync failed", "Now") + + return jsonify(response) + + except Exception as e: + logger.error(f"Error getting Qobuz sync status: {e}") + return jsonify({"error": str(e)}), 500 + + +@app.route('/api/qobuz/sync/cancel/', methods=['POST']) +def cancel_qobuz_sync(playlist_id): + """Cancel sync for a Qobuz playlist.""" + try: + if playlist_id not in qobuz_discovery_states: + return jsonify({"error": "Qobuz playlist not found"}), 404 + + state = qobuz_discovery_states[playlist_id] + state['last_accessed'] = time.time() + sync_playlist_id = state.get('sync_playlist_id') + + if sync_playlist_id: + with sync_lock: + sync_states[sync_playlist_id] = {"status": "cancelled"} + if sync_playlist_id in active_sync_workers: + del active_sync_workers[sync_playlist_id] + + state['phase'] = 'discovered' + state['sync_playlist_id'] = None + state['sync_progress'] = {} + + return jsonify({"success": True, "message": "Qobuz sync cancelled"}) + + except Exception as e: + logger.error(f"Error cancelling Qobuz sync: {e}") + return jsonify({"error": str(e)}), 500 + + # =================================================================== # SPOTIFY PUBLIC PLAYLIST DISCOVERY API ENDPOINTS # =================================================================== diff --git a/webui/index.html b/webui/index.html index b22dd056..d590d158 100644 --- a/webui/index.html +++ b/webui/index.html @@ -943,6 +943,9 @@ + @@ -993,6 +996,17 @@ + +
+
+

Your Qobuz Playlists

+ +
+
+
Click 'Refresh' to load your Qobuz playlists.
+
+
+
diff --git a/webui/static/core.js b/webui/static/core.js index 8e272f10..9a1bd1e4 100644 --- a/webui/static/core.js +++ b/webui/static/core.js @@ -67,6 +67,11 @@ let deezerPlaylistStates = {}; let deezerArlPlaylists = []; let deezerArlPlaylistsLoaded = false; +// --- Qobuz Playlist State Management (mirrors Tidal — github issue #677) --- +let qobuzPlaylists = []; +let qobuzPlaylistStates = {}; // Key: playlist_id, Value: playlist state with phases +let qobuzPlaylistsLoaded = false; + // --- Beatport Chart State Management (Similar to YouTube/Tidal) --- let beatportChartStates = {}; // Key: chart_hash, Value: chart state with phases let beatportContentState = { diff --git a/webui/static/downloads.js b/webui/static/downloads.js index a8c590cf..18798508 100644 --- a/webui/static/downloads.js +++ b/webui/static/downloads.js @@ -64,10 +64,11 @@ function _wingItAction(urlHash, action) { const tracks = state.tracks || state.rawTracks || state.playlist?.tracks || []; const name = state.playlistName || state.name || state.playlist?.name || 'Playlist'; const isTidal = state.is_tidal_playlist; + const isQobuz = state.is_qobuz_playlist; const isLB = state.is_listenbrainz_playlist; const isBeatport = state.is_beatport_playlist; const isDeezer = state.is_deezer_playlist; - const source = isLB ? 'ListenBrainz' : isTidal ? 'Tidal' : isDeezer ? 'Deezer' : isBeatport ? 'Beatport' : 'YouTube'; + const source = isLB ? 'ListenBrainz' : isTidal ? 'Tidal' : isQobuz ? 'Qobuz' : isDeezer ? 'Deezer' : isBeatport ? 'Beatport' : 'YouTube'; if (!tracks.length) { showToast('No tracks available for Wing It', 'error'); @@ -347,10 +348,11 @@ async function _wingItFromModal(urlHash) { const tracks = state.tracks || state.rawTracks || state.playlist?.tracks || []; const name = state.playlistName || state.name || state.playlist?.name || 'Playlist'; const isTidal = state.is_tidal_playlist; + const isQobuz = state.is_qobuz_playlist; const isLB = state.is_listenbrainz_playlist; const isBeatport = state.is_beatport_playlist; const isDeezer = state.is_deezer_playlist; - const source = isLB ? 'ListenBrainz' : isTidal ? 'Tidal' : isDeezer ? 'Deezer' : isBeatport ? 'Beatport' : 'YouTube'; + const source = isLB ? 'ListenBrainz' : isTidal ? 'Tidal' : isQobuz ? 'Qobuz' : isDeezer ? 'Deezer' : isBeatport ? 'Beatport' : 'YouTube'; if (!tracks.length) { showToast('No tracks available for Wing It', 'error'); diff --git a/webui/static/helper.js b/webui/static/helper.js index 36c8389c..e83a5b89 100644 --- a/webui/static/helper.js +++ b/webui/static/helper.js @@ -3415,6 +3415,7 @@ function closeHelperSearch() { const WHATS_NEW = { '2.5.9': [ { date: 'Unreleased — dev cycle' }, + { title: 'Qobuz playlist sync', desc: 'new Qobuz tab on the Sync page. Connect Qobuz in Settings → Connections, hit Refresh on the tab, and your Qobuz playlists + Favorite Tracks show up alongside Tidal and Deezer. clicks run the same discovery → sync → download flow as the other sources.', page: 'sync' }, { title: 'Import search: show when results came from the fallback source', desc: 'if you picked MusicBrainz (or Discogs / iTunes / etc.) as your primary metadata source but the Import album search ended up serving Deezer cards, you had no idea — the chain silently fell through when the primary returned nothing. now each card shows a small "via Deezer" label when the source differs from your primary, and a banner above the grid spells it out when all results came from the fallback. backend behavior unchanged.' }, { date: 'May 21, 2026 — 2.5.9 release' }, { title: 'Now-playing modal: lyrics panel', desc: 'new lyrics panel below the player controls in the expanded now-playing modal. fetches from LRClib via /api/lyrics/fetch, but prefers the local .lrc / .txt sidecar files SoulSync drops next to your audio during post-processing so downloaded tracks show lyrics instantly with zero network. synced LRC (timestamped) highlights the active line and auto-scrolls it into the middle of the viewport on every audio timeupdate; plain text renders without highlighting. status chip shows whether the result came back Synced or Plain. panel is collapsed by default — click the Lyrics header to expand. cached per track so revisiting a track doesn\'t refetch.' }, @@ -3495,6 +3496,17 @@ const WHATS_NEW = { // Section shape: { title, description, features: [bullet strings], // usage_note?: 'optional hint shown at the bottom' } const VERSION_MODAL_SECTIONS = [ + { + title: "Qobuz Playlist Sync", + description: "Qobuz joins Tidal and Deezer as a first-class playlist sync source on the Sync page. Browse your Qobuz playlists and Favorite Tracks, run them through the same discovery flow as Tidal, sync the resulting Spotify-matched tracks, and queue downloads — same multi-step pipeline you already know.", + features: [ + "new Qobuz tab on the Sync page, listed between Deezer and Deezer Link", + "lists your Qobuz user playlists plus a Favorite Tracks entry (same virtual-playlist treatment Tidal gets)", + "click any card to fire discovery (Spotify-preferred, your primary metadata fallback otherwise), then sync or download just like Tidal / Deezer playlists", + "uses the Qobuz auth token you already configured for downloads — no extra connection step", + ], + usage_note: "Sync → Qobuz → 🔄 Refresh", + }, { title: "2.5.9 Release Stability Pass", description: "this release ties together the new release-based download sources and a set of fixes from real user reports: HiFi instance detection, Jellyfin full refreshes, transient SQLite disk I/O failures, and wrong-artist Album Completeness fills.", diff --git a/webui/static/style.css b/webui/static/style.css index c4914cbd..728d3e95 100644 --- a/webui/static/style.css +++ b/webui/static/style.css @@ -11453,6 +11453,10 @@ body.helper-mode-active #dashboard-activity-feed:hover { background-image: url('data:image/svg+xml;charset=utf-8,'); } +.qobuz-icon { + background-image: url('data:image/svg+xml;charset=utf-8,'); +} + .beatport-icon { background-image: url('data:image/svg+xml;charset=utf-8,'); } diff --git a/webui/static/sync-services.js b/webui/static/sync-services.js index c7fd1863..b70ce0e7 100644 --- a/webui/static/sync-services.js +++ b/webui/static/sync-services.js @@ -1362,16 +1362,17 @@ async function openDownloadMissingModalForTidal(virtualPlaylistId, playlistName, // Generate hero section with dynamic source detection (same as YouTube/Beatport) const source = virtualPlaylistId.startsWith('beatport_') ? 'Beatport' : virtualPlaylistId.startsWith('tidal_') ? 'Tidal' : - virtualPlaylistId.startsWith('listenbrainz_') ? 'ListenBrainz' : - virtualPlaylistId.startsWith('spotify_public_') ? 'Spotify' : - virtualPlaylistId.startsWith('spotify:') ? 'Spotify' : - virtualPlaylistId.startsWith('discover_') ? 'SoulSync' : - virtualPlaylistId.startsWith('seasonal_') ? 'SoulSync' : - virtualPlaylistId.startsWith('spotify_library_') ? 'SoulSync' : - virtualPlaylistId.startsWith('build_playlist_') ? 'SoulSync' : - virtualPlaylistId.startsWith('decade_') ? 'SoulSync' : - virtualPlaylistId === 'build_playlist_custom' ? 'SoulSync' : - 'YouTube'; + virtualPlaylistId.startsWith('qobuz_') ? 'Qobuz' : + virtualPlaylistId.startsWith('listenbrainz_') ? 'ListenBrainz' : + virtualPlaylistId.startsWith('spotify_public_') ? 'Spotify' : + virtualPlaylistId.startsWith('spotify:') ? 'Spotify' : + virtualPlaylistId.startsWith('discover_') ? 'SoulSync' : + virtualPlaylistId.startsWith('seasonal_') ? 'SoulSync' : + virtualPlaylistId.startsWith('spotify_library_') ? 'SoulSync' : + virtualPlaylistId.startsWith('build_playlist_') ? 'SoulSync' : + virtualPlaylistId.startsWith('decade_') ? 'SoulSync' : + virtualPlaylistId === 'build_playlist_custom' ? 'SoulSync' : + 'YouTube'; const heroContext = { type: 'playlist', @@ -1490,6 +1491,933 @@ async function openDownloadMissingModalForTidal(virtualPlaylistId, playlistName, } +// =================================================================== +// QOBUZ PLAYLIST MANAGEMENT (mirrors Tidal — github issue #677) +// =================================================================== +// +// Functional parity with the Tidal sync flow above. Backend at +// /api/qobuz/* mirrors /api/tidal/* one-for-one, so the handler shape +// is intentionally a direct port of the Tidal set. Per-card key in +// CSS selectors is `qobuz-card-${id}` (no colon — same constraint as +// Tidal: `:` parses as a CSS pseudo-class operator). + +async function loadQobuzPlaylists() { + const container = document.getElementById('qobuz-playlist-container'); + const refreshBtn = document.getElementById('qobuz-refresh-btn'); + + container.innerHTML = `
🔄 Loading Qobuz playlists...
`; + refreshBtn.disabled = true; + refreshBtn.textContent = '🔄 Loading...'; + + try { + const response = await fetch('/api/qobuz/playlists'); + if (!response.ok) { + const error = await response.json(); + throw new Error(error.error || 'Failed to fetch Qobuz playlists'); + } + + qobuzPlaylists = await response.json(); + renderQobuzPlaylists(); + qobuzPlaylistsLoaded = true; + + console.log(`🎵 Loaded ${qobuzPlaylists.length} Qobuz playlists`); + + // Auto-mirror Qobuz playlists in the background (same pattern as Tidal). + // Cards render instantly from metadata; tracks load per-playlist + // without blocking the UI. + for (const p of qobuzPlaylists) { + if (p.tracks && p.tracks.length > 0) { + mirrorPlaylist('qobuz', p.id, p.name, p.tracks.map(t => ({ + track_name: t.name || '', artist_name: Array.isArray(t.artists) ? t.artists[0] : (t.artists || ''), + album_name: typeof t.album === 'string' ? t.album : '', duration_ms: t.duration_ms || 0, + source_track_id: t.id || '' + })), { owner: p.owner, image_url: p.image_url, description: p.description }); + continue; + } + try { + const fullResp = await fetch(`/api/qobuz/playlist/${p.id}`); + if (fullResp.ok) { + const fullData = await fullResp.json(); + if (fullData.tracks && fullData.tracks.length > 0) { + p.tracks = fullData.tracks; + p.track_count = fullData.tracks.length; + const countEl = document.querySelector(`#qobuz-card-${p.id} .playlist-card-track-count`); + if (countEl) countEl.textContent = `${fullData.tracks.length} tracks`; + mirrorPlaylist('qobuz', p.id, p.name, fullData.tracks.map(t => ({ + track_name: t.name || '', artist_name: Array.isArray(t.artists) ? t.artists[0] : (t.artists || ''), + album_name: typeof t.album === 'string' ? t.album : '', duration_ms: t.duration_ms || 0, + source_track_id: t.id || '' + })), { owner: p.owner, image_url: p.image_url, description: p.description }); + } + } + } catch (e) { + console.warn(`Failed to fetch tracks for Qobuz playlist ${p.name}: ${e.message}`); + } + } + + await loadQobuzPlaylistStatesFromBackend(); + + } catch (error) { + container.innerHTML = `
❌ Error: ${error.message}
`; + showToast(`Error loading Qobuz playlists: ${error.message}`, 'error'); + } finally { + refreshBtn.disabled = false; + refreshBtn.textContent = '🔄 Refresh'; + } +} + +function renderQobuzPlaylists() { + const container = document.getElementById('qobuz-playlist-container'); + if (qobuzPlaylists.length === 0) { + container.innerHTML = `
No Qobuz playlists found.
`; + return; + } + + container.innerHTML = qobuzPlaylists.map(p => { + if (!qobuzPlaylistStates[p.id]) { + qobuzPlaylistStates[p.id] = { + phase: 'fresh', + playlist: p + }; + } + return createQobuzCard(p); + }).join(''); + + qobuzPlaylists.forEach(p => { + const card = document.getElementById(`qobuz-card-${p.id}`); + if (card) { + card.addEventListener('click', () => handleQobuzCardClick(p.id)); + } + }); +} + +function createQobuzCard(playlist) { + const state = qobuzPlaylistStates[playlist.id]; + const phase = state.phase; + + let buttonText = getActionButtonText(phase); + let phaseText = getPhaseText(phase); + let phaseColor = getPhaseColor(phase); + + return ` +
+
🎵
+
+
${escapeHtml(playlist.name)}
+
+ ${playlist.track_count} tracks + ${phaseText} +
+
+
+ +
+ +
+ `; +} + +async function handleQobuzCardClick(playlistId) { + const state = qobuzPlaylistStates[playlistId]; + if (!state) { + console.error(`❌ [Card Click] No state found for Qobuz playlist: ${playlistId}`); + showToast('Playlist state not found - try refreshing the page', 'error'); + return; + } + if (!state.playlist) { + console.error(`❌ [Card Click] No playlist data found for Qobuz playlist: ${playlistId}`); + showToast('Playlist data missing - try refreshing the page', 'error'); + return; + } + if (!state.phase) state.phase = 'fresh'; + + console.log(`🎵 [Card Click] Qobuz card clicked: ${playlistId}, Phase: ${state.phase}`); + + if (state.phase === 'fresh') { + if (!state.playlist.tracks || state.playlist.tracks.length === 0) { + console.log(`🎵 Fetching tracks for Qobuz playlist: ${state.playlist.name}`); + showLoadingOverlay(`Loading ${state.playlist.name}...`); + try { + const resp = await fetch(`/api/qobuz/playlist/${playlistId}`); + if (resp.ok) { + const fullData = await resp.json(); + if (fullData.tracks && fullData.tracks.length > 0) { + state.playlist.tracks = fullData.tracks.map(t => ({ + id: t.id, name: t.name, artists: t.artists || [], + album: t.album || '', duration_ms: t.duration_ms || 0, + track_number: t.track_number || 0 + })); + const countEl = document.querySelector(`#qobuz-card-${playlistId} .playlist-card-track-count`); + if (countEl) countEl.textContent = `${state.playlist.tracks.length} tracks`; + } + } + } catch (e) { + console.error(`Failed to fetch Qobuz playlist tracks: ${e}`); + hideLoadingOverlay(); + } + } + + if (!state.playlist.tracks || state.playlist.tracks.length === 0) { + hideLoadingOverlay(); + showToast('Could not load tracks for this playlist', 'error'); + return; + } + + hideLoadingOverlay(); + console.log(`🎵 Ready with ${state.playlist.tracks.length} Qobuz tracks for discovery`); + openQobuzDiscoveryModal(playlistId, state.playlist); + + } else if (state.phase === 'discovering' || state.phase === 'discovered' || state.phase === 'syncing' || state.phase === 'sync_complete') { + console.log(`🎵 [Card Click] Opening Qobuz discovery modal for ${state.phase} phase`); + + if (state.phase === 'discovered' && (!state.discovery_results || state.discovery_results.length === 0)) { + try { + const stateResponse = await fetch(`/api/qobuz/state/${playlistId}`); + if (stateResponse.ok) { + const fullState = await stateResponse.json(); + if (fullState.discovery_results) { + state.discovery_results = fullState.discovery_results; + state.spotify_matches = fullState.spotify_matches || state.spotify_matches; + state.discovery_progress = fullState.discovery_progress || state.discovery_progress; + qobuzPlaylistStates[playlistId] = { ...qobuzPlaylistStates[playlistId], ...state }; + } + } + } catch (error) { + console.error(`❌ [Card Click] Failed to fetch Qobuz discovery results: ${error}`); + } + } + + openQobuzDiscoveryModal(playlistId, state.playlist); + } else if (state.phase === 'downloading' || state.phase === 'download_complete') { + if (state.convertedSpotifyPlaylistId) { + if (activeDownloadProcesses[state.convertedSpotifyPlaylistId]) { + const process = activeDownloadProcesses[state.convertedSpotifyPlaylistId]; + if (process.modalElement) { + process.modalElement.style.display = 'flex'; + } else { + await rehydrateQobuzDownloadModal(playlistId, state); + } + } else { + await rehydrateQobuzDownloadModal(playlistId, state); + } + } else { + if (state.discovery_results && state.discovery_results.length > 0) { + openQobuzDiscoveryModal(playlistId, state.playlist); + } else { + showToast('Unable to open download modal - missing playlist data', 'error'); + } + } + } +} + +async function rehydrateQobuzDownloadModal(playlistId, state) { + try { + if (!state || !state.playlist) { + showToast('Cannot open download modal - invalid playlist data', 'error'); + return; + } + + if (!state.discovery_results) { + const stateResponse = await fetch(`/api/qobuz/state/${playlistId}`); + if (stateResponse.ok) { + const fullState = await stateResponse.json(); + state.discovery_results = fullState.discovery_results; + state.convertedSpotifyPlaylistId = fullState.converted_spotify_playlist_id; + state.download_process_id = fullState.download_process_id; + } else { + showToast('Error loading playlist data', 'error'); + return; + } + } + + const spotifyTracks = []; + for (const result of state.discovery_results) { + if (result.spotify_data) spotifyTracks.push(result.spotify_data); + } + + if (spotifyTracks.length === 0) { + showToast('No Spotify matches found for download', 'error'); + return; + } + + const virtualPlaylistId = state.convertedSpotifyPlaylistId; + const playlistName = state.playlist.name; + + await openDownloadMissingModalForTidal(virtualPlaylistId, playlistName, spotifyTracks); + + if (state.download_process_id) { + const process = activeDownloadProcesses[virtualPlaylistId]; + if (process) { + process.status = state.phase === 'download_complete' ? 'complete' : 'running'; + process.batchId = state.download_process_id; + + const beginBtn = document.getElementById(`begin-analysis-btn-${virtualPlaylistId}`); + const cancelBtn = document.getElementById(`cancel-all-btn-${virtualPlaylistId}`); + + if (state.phase === 'downloading') { + if (beginBtn) beginBtn.style.display = 'none'; + if (cancelBtn) cancelBtn.style.display = 'inline-block'; + startModalDownloadPolling(virtualPlaylistId); + } else if (state.phase === 'download_complete') { + if (beginBtn) beginBtn.style.display = 'none'; + if (cancelBtn) cancelBtn.style.display = 'none'; + try { + const response = await fetch(`/api/playlists/${state.download_process_id}/download_status`); + if (response.ok) { + const data = await response.json(); + if (data.phase === 'complete' && data.tasks) { + updateCompletedModalResults(virtualPlaylistId, data); + } + } + } catch (error) { + showToast('Could not load download results - modal may show incomplete data', 'warning', 3000); + } + } + } + } + } catch (error) { + console.error(`❌ Error rehydrating Qobuz download modal:`, error); + showToast('Error opening download modal', 'error'); + } +} + +function updateQobuzCardPhase(playlistId, phase) { + const state = qobuzPlaylistStates[playlistId]; + if (!state) return; + + state.phase = phase; + + const card = document.getElementById(`qobuz-card-${playlistId}`); + if (card) { + const newCardHtml = createQobuzCard(state.playlist); + card.outerHTML = newCardHtml; + + const newCard = document.getElementById(`qobuz-card-${playlistId}`); + if (newCard) { + newCard.addEventListener('click', () => handleQobuzCardClick(playlistId)); + } + + if ((phase === 'syncing' || phase === 'sync_complete') && state.lastSyncProgress) { + setTimeout(() => { + updateQobuzCardSyncProgress(playlistId, state.lastSyncProgress); + }, 0); + } + } +} + +async function openQobuzDiscoveryModal(playlistId, playlistData) { + console.log(`🎵 Opening Qobuz discovery modal: ${playlistData.name}`); + const fakeUrlHash = `qobuz_${playlistId}`; + + const qobuzCardState = qobuzPlaylistStates[playlistId]; + const isAlreadyDiscovered = qobuzCardState && (qobuzCardState.phase === 'discovered' || qobuzCardState.phase === 'syncing' || qobuzCardState.phase === 'sync_complete'); + const isCurrentlyDiscovering = qobuzCardState && qobuzCardState.phase === 'discovering'; + + let transformedResults = []; + let actualMatches = 0; + if (isAlreadyDiscovered && qobuzCardState.discovery_results) { + transformedResults = qobuzCardState.discovery_results.map((result, index) => { + const isFound = result.status === 'found' || + result.status === '✅ Found' || + result.status === 'Found' || + result.status_class === 'found' || + result.spotify_data || + result.spotify_track; + if (isFound) actualMatches++; + + return { + index: index, + yt_track: result.qobuz_track ? result.qobuz_track.name : 'Unknown', + yt_artist: result.qobuz_track ? (result.qobuz_track.artists ? result.qobuz_track.artists.join(', ') : 'Unknown') : 'Unknown', + status: isFound ? '✅ Found' : '❌ Not Found', + status_class: isFound ? 'found' : 'not-found', + spotify_track: result.spotify_data ? result.spotify_data.name : (result.spotify_track || '-'), + spotify_artist: result.spotify_data && result.spotify_data.artists ? + (Array.isArray(result.spotify_data.artists) + ? result.spotify_data.artists + .map(a => (typeof a === 'object' && a !== null) ? (a.name || '') : a) + .filter(Boolean) + .join(', ') || '-' + : result.spotify_data.artists) + : (result.spotify_artist || '-'), + spotify_album: result.spotify_data ? (typeof result.spotify_data.album === 'object' ? result.spotify_data.album.name : result.spotify_data.album) : (result.spotify_album || '-'), + spotify_data: result.spotify_data, + spotify_id: result.spotify_id, + manual_match: result.manual_match + }; + }); + } + + const modalPhase = qobuzCardState ? qobuzCardState.phase : 'fresh'; + youtubePlaylistStates[fakeUrlHash] = { + phase: modalPhase, + playlist: { name: playlistData.name, tracks: playlistData.tracks }, + is_qobuz_playlist: true, + qobuz_playlist_id: playlistId, + discovery_progress: isAlreadyDiscovered ? 100 : 0, + spotify_matches: isAlreadyDiscovered ? actualMatches : 0, + spotifyMatches: isAlreadyDiscovered ? actualMatches : 0, + spotify_total: playlistData.tracks.length, + discovery_results: transformedResults, + discoveryResults: transformedResults, + discoveryProgress: isAlreadyDiscovered ? 100 : 0 + }; + + if (!isAlreadyDiscovered && !isCurrentlyDiscovering) { + try { + const response = await fetch(`/api/qobuz/discovery/start/${playlistId}`, { method: 'POST' }); + const result = await response.json(); + if (result.error) { + showToast(`Error starting discovery: ${result.error}`, 'error'); + return; + } + qobuzPlaylistStates[playlistId].phase = 'discovering'; + updateQobuzCardPhase(playlistId, 'discovering'); + youtubePlaylistStates[fakeUrlHash].phase = 'discovering'; + startQobuzDiscoveryPolling(fakeUrlHash, playlistId); + } catch (error) { + showToast(`Error starting discovery: ${error.message}`, 'error'); + } + } else if (isCurrentlyDiscovering) { + startQobuzDiscoveryPolling(fakeUrlHash, playlistId); + } else if (qobuzCardState && qobuzCardState.phase === 'syncing') { + startQobuzSyncPolling(fakeUrlHash); + } + + openYouTubeDiscoveryModal(fakeUrlHash); +} + +function startQobuzDiscoveryPolling(fakeUrlHash, playlistId) { + if (activeYouTubePollers[fakeUrlHash]) { + clearInterval(activeYouTubePollers[fakeUrlHash]); + } + + if (socketConnected) { + socket.emit('discovery:subscribe', { ids: [playlistId] }); + _discoveryProgressCallbacks[playlistId] = (data) => { + if (data.error) { + if (activeYouTubePollers[fakeUrlHash]) { clearInterval(activeYouTubePollers[fakeUrlHash]); delete activeYouTubePollers[fakeUrlHash]; } + socket.emit('discovery:unsubscribe', { ids: [playlistId] }); delete _discoveryProgressCallbacks[playlistId]; + return; + } + const transformed = { + progress: data.progress, spotify_matches: data.spotify_matches, spotify_total: data.spotify_total, + complete: data.complete, + results: (data.results || []).map((r, i) => { + const isWingIt = r.wing_it_fallback || r.status_class === 'wing-it'; + const isFound = !isWingIt && (r.status === 'found' || r.status === '✅ Found' || r.status === 'Found' || r.status_class === 'found' || r.spotify_data || r.spotify_track); + return { + index: i, yt_track: r.qobuz_track ? r.qobuz_track.name : 'Unknown', + yt_artist: r.qobuz_track ? (r.qobuz_track.artists ? r.qobuz_track.artists.join(', ') : 'Unknown') : 'Unknown', + status: isWingIt ? '🎯 Wing It' : (isFound ? '✅ Found' : '❌ Not Found'), + status_class: isWingIt ? 'wing-it' : (isFound ? 'found' : 'not-found'), + spotify_track: r.spotify_data ? r.spotify_data.name : (r.spotify_track || '-'), + spotify_artist: r.spotify_data && r.spotify_data.artists + ? (Array.isArray(r.spotify_data.artists) + ? (r.spotify_data.artists + .map(a => (typeof a === 'object' && a !== null) ? (a.name || '') : a) + .filter(Boolean) + .join(', ') || '-') + : r.spotify_data.artists) + : (r.spotify_artist || '-'), + spotify_album: r.spotify_data ? (typeof r.spotify_data.album === 'object' ? r.spotify_data.album.name : r.spotify_data.album) : (r.spotify_album || '-'), + spotify_data: r.spotify_data, spotify_id: r.spotify_id, manual_match: r.manual_match, + wing_it_fallback: isWingIt + }; + }) + }; + const st = youtubePlaylistStates[fakeUrlHash]; + if (st) { + st.discovery_progress = data.progress; st.discoveryProgress = data.progress; + st.spotify_matches = data.spotify_matches; st.spotifyMatches = data.spotify_matches; + st.discovery_results = data.results; st.discoveryResults = transformed.results; + st.phase = data.phase; + updateYouTubeDiscoveryModal(fakeUrlHash, transformed); + } + if (qobuzPlaylistStates[playlistId]) { + qobuzPlaylistStates[playlistId].phase = data.phase; + qobuzPlaylistStates[playlistId].discovery_results = data.results; + qobuzPlaylistStates[playlistId].spotify_matches = data.spotify_matches; + qobuzPlaylistStates[playlistId].discovery_progress = data.progress; + updateQobuzCardPhase(playlistId, data.phase); + } + updateQobuzCardProgress(playlistId, data); + if (data.complete) { + if (activeYouTubePollers[fakeUrlHash]) { clearInterval(activeYouTubePollers[fakeUrlHash]); delete activeYouTubePollers[fakeUrlHash]; } + socket.emit('discovery:unsubscribe', { ids: [playlistId] }); delete _discoveryProgressCallbacks[playlistId]; + } + }; + } + + const pollInterval = setInterval(async () => { + try { + const response = await fetch(`/api/qobuz/discovery/status/${playlistId}`); + const status = await response.json(); + if (status.error) { + clearInterval(pollInterval); + delete activeYouTubePollers[fakeUrlHash]; + return; + } + + const transformedStatus = { + progress: status.progress, + spotify_matches: status.spotify_matches, + spotify_total: status.spotify_total, + complete: status.complete, + results: status.results.map((result, index) => { + const isFound = result.status === 'found' || + result.status === '✅ Found' || + result.status === 'Found' || + result.status_class === 'found' || + result.spotify_data || + result.spotify_track; + return { + index: index, + yt_track: result.qobuz_track ? result.qobuz_track.name : 'Unknown', + yt_artist: result.qobuz_track ? (result.qobuz_track.artists ? result.qobuz_track.artists.join(', ') : 'Unknown') : 'Unknown', + status: isFound ? '✅ Found' : '❌ Not Found', + status_class: isFound ? 'found' : 'not-found', + spotify_track: result.spotify_data ? result.spotify_data.name : (result.spotify_track || '-'), + spotify_artist: result.spotify_data && result.spotify_data.artists + ? (Array.isArray(result.spotify_data.artists) + ? (result.spotify_data.artists + .map(a => (typeof a === 'object' && a !== null) ? (a.name || '') : a) + .filter(Boolean) + .join(', ') || '-') + : result.spotify_data.artists) + : (result.spotify_artist || '-'), + spotify_album: result.spotify_data ? (typeof result.spotify_data.album === 'object' ? result.spotify_data.album.name : result.spotify_data.album) : (result.spotify_album || '-'), + spotify_data: result.spotify_data, + spotify_id: result.spotify_id, + manual_match: result.manual_match + }; + }) + }; + + const state = youtubePlaylistStates[fakeUrlHash]; + if (state) { + state.discovery_progress = status.progress; + state.discoveryProgress = status.progress; + state.spotify_matches = status.spotify_matches; + state.spotifyMatches = status.spotify_matches; + state.discovery_results = status.results; + state.discoveryResults = transformedStatus.results; + state.phase = status.phase; + + updateYouTubeDiscoveryModal(fakeUrlHash, transformedStatus); + + if (qobuzPlaylistStates[playlistId]) { + qobuzPlaylistStates[playlistId].phase = status.phase; + qobuzPlaylistStates[playlistId].discovery_results = status.results; + qobuzPlaylistStates[playlistId].spotify_matches = status.spotify_matches; + qobuzPlaylistStates[playlistId].discovery_progress = status.progress; + updateQobuzCardPhase(playlistId, status.phase); + } + updateQobuzCardProgress(playlistId, status); + } + + if (status.complete) { + clearInterval(pollInterval); + delete activeYouTubePollers[fakeUrlHash]; + } + } catch (error) { + clearInterval(pollInterval); + delete activeYouTubePollers[fakeUrlHash]; + } + }, 1000); + + activeYouTubePollers[fakeUrlHash] = pollInterval; +} + +async function loadQobuzPlaylistStatesFromBackend() { + try { + const response = await fetch('/api/qobuz/playlists/states'); + if (!response.ok) { + const error = await response.json(); + throw new Error(error.error || 'Failed to fetch Qobuz playlist states'); + } + + const data = await response.json(); + const states = data.states || []; + if (states.length === 0) return; + + for (const stateInfo of states) { + await applyQobuzPlaylistState(stateInfo); + } + + for (const stateInfo of states) { + if ((stateInfo.phase === 'downloading' || stateInfo.phase === 'download_complete') && + stateInfo.converted_spotify_playlist_id && stateInfo.download_process_id) { + + const convertedPlaylistId = stateInfo.converted_spotify_playlist_id; + if (!activeDownloadProcesses[convertedPlaylistId]) { + try { + const playlistData = qobuzPlaylists.find(p => p.id === stateInfo.playlist_id); + if (!playlistData) continue; + + const spotifyTracks = qobuzPlaylistStates[stateInfo.playlist_id]?.discovery_results + ?.filter(result => result.spotify_data) + ?.map(result => result.spotify_data) || []; + + if (spotifyTracks.length > 0) { + await openDownloadMissingModalForTidal(convertedPlaylistId, playlistData.name, spotifyTracks); + const process = activeDownloadProcesses[convertedPlaylistId]; + if (process) { + process.status = 'running'; + process.batchId = stateInfo.download_process_id; + const beginBtn = document.getElementById(`begin-analysis-btn-${convertedPlaylistId}`); + const cancelBtn = document.getElementById(`cancel-all-btn-${convertedPlaylistId}`); + if (beginBtn) beginBtn.style.display = 'none'; + if (cancelBtn) cancelBtn.style.display = 'inline-block'; + startModalDownloadPolling(convertedPlaylistId); + } + } + } catch (error) { + console.error(`❌ Error rehydrating Qobuz download modal for ${stateInfo.playlist_id}:`, error); + } + } + } + } + } catch (error) { + console.error('❌ Error loading Qobuz playlist states:', error); + } +} + +async function applyQobuzPlaylistState(stateInfo) { + const { playlist_id, phase, discovery_progress, spotify_matches, discovery_results, converted_spotify_playlist_id, download_process_id } = stateInfo; + + try { + const playlistData = qobuzPlaylists.find(p => p.id === playlist_id); + if (!playlistData) return; + + if (!qobuzPlaylistStates[playlist_id]) { + qobuzPlaylistStates[playlist_id] = { playlist: playlistData, phase: 'fresh' }; + } + + qobuzPlaylistStates[playlist_id].phase = phase; + qobuzPlaylistStates[playlist_id].discovery_progress = discovery_progress; + qobuzPlaylistStates[playlist_id].spotify_matches = spotify_matches; + qobuzPlaylistStates[playlist_id].discovery_results = discovery_results; + qobuzPlaylistStates[playlist_id].convertedSpotifyPlaylistId = converted_spotify_playlist_id; + qobuzPlaylistStates[playlist_id].download_process_id = download_process_id; + qobuzPlaylistStates[playlist_id].playlist = playlistData; + + if (phase !== 'fresh' && phase !== 'discovering') { + try { + const stateResponse = await fetch(`/api/qobuz/state/${playlist_id}`); + if (stateResponse.ok) { + const fullState = await stateResponse.json(); + if (fullState.discovery_results && qobuzPlaylistStates[playlist_id]) { + qobuzPlaylistStates[playlist_id].discovery_results = fullState.discovery_results; + qobuzPlaylistStates[playlist_id].discovery_progress = fullState.discovery_progress; + qobuzPlaylistStates[playlist_id].spotify_matches = fullState.spotify_matches; + qobuzPlaylistStates[playlist_id].convertedSpotifyPlaylistId = fullState.converted_spotify_playlist_id; + qobuzPlaylistStates[playlist_id].download_process_id = fullState.download_process_id; + } + } + } catch (error) { + console.warn(`⚠️ Error fetching full Qobuz discovery results for ${playlistData.name}:`, error.message); + } + } + + updateQobuzCardPhase(playlist_id, phase); + + if (phase === 'discovered' && qobuzPlaylistStates[playlist_id]) { + const progressInfo = { + spotify_total: playlistData.track_count || playlistData.tracks?.length || 0, + spotify_matches: qobuzPlaylistStates[playlist_id].spotify_matches || 0 + }; + updateQobuzCardProgress(playlist_id, progressInfo); + } + + if (phase === 'discovering') { + const fakeUrlHash = `qobuz_${playlist_id}`; + startQobuzDiscoveryPolling(fakeUrlHash, playlist_id); + } else if (phase === 'syncing') { + const fakeUrlHash = `qobuz_${playlist_id}`; + startQobuzSyncPolling(fakeUrlHash); + } + } catch (error) { + console.error(`❌ Error applying Qobuz playlist state for ${playlist_id}:`, error); + } +} + +function updateQobuzCardProgress(playlistId, progress) { + const state = qobuzPlaylistStates[playlistId]; + if (!state) return; + const card = document.getElementById(`qobuz-card-${playlistId}`); + if (!card) return; + const progressElement = card.querySelector('.playlist-card-progress'); + if (!progressElement) return; + + const total = progress.spotify_total || 0; + const matches = progress.spotify_matches || 0; + const failed = total - matches; + const percentage = total > 0 ? Math.round((matches / total) * 100) : 0; + + progressElement.textContent = `♪ ${total} / ✓ ${matches} / ✗ ${failed} / ${percentage}%`; + progressElement.classList.remove('hidden'); +} + +async function startQobuzPlaylistSync(urlHash) { + try { + const state = youtubePlaylistStates[urlHash]; + if (!state || !state.is_qobuz_playlist) { + console.error('❌ Invalid Qobuz playlist state for sync'); + return; + } + + const playlistId = state.qobuz_playlist_id; + const response = await fetch(`/api/qobuz/sync/start/${playlistId}`, { method: 'POST' }); + const result = await response.json(); + if (result.error) { + showToast(`Error starting sync: ${result.error}`, 'error'); + return; + } + + const syncPlaylistId = result.sync_playlist_id; + if (state) state.syncPlaylistId = syncPlaylistId; + + updateQobuzCardPhase(playlistId, 'syncing'); + updateQobuzModalButtons(urlHash, 'syncing'); + startQobuzSyncPolling(urlHash, syncPlaylistId); + showToast('Qobuz playlist sync started!', 'success'); + } catch (error) { + showToast(`Error starting sync: ${error.message}`, 'error'); + } +} + +function startQobuzSyncPolling(urlHash, syncPlaylistId) { + if (activeYouTubePollers[urlHash]) { + clearInterval(activeYouTubePollers[urlHash]); + } + + const state = youtubePlaylistStates[urlHash]; + const playlistId = state.qobuz_playlist_id; + syncPlaylistId = syncPlaylistId || (state && state.syncPlaylistId); + + if (socketConnected && syncPlaylistId) { + socket.emit('sync:subscribe', { playlist_ids: [syncPlaylistId] }); + _syncProgressCallbacks[syncPlaylistId] = (data) => { + const progress = data.progress || {}; + updateQobuzCardSyncProgress(playlistId, progress); + updateQobuzModalSyncProgress(urlHash, progress); + + if (data.status === 'finished') { + if (activeYouTubePollers[urlHash]) { clearInterval(activeYouTubePollers[urlHash]); delete activeYouTubePollers[urlHash]; } + socket.emit('sync:unsubscribe', { playlist_ids: [syncPlaylistId] }); + delete _syncProgressCallbacks[syncPlaylistId]; + if (qobuzPlaylistStates[playlistId]) qobuzPlaylistStates[playlistId].phase = 'sync_complete'; + if (youtubePlaylistStates[urlHash]) youtubePlaylistStates[urlHash].phase = 'sync_complete'; + updateQobuzCardPhase(playlistId, 'sync_complete'); + updateQobuzModalButtons(urlHash, 'sync_complete'); + showToast('Qobuz playlist sync complete!', 'success'); + } else if (data.status === 'error' || data.status === 'cancelled') { + if (activeYouTubePollers[urlHash]) { clearInterval(activeYouTubePollers[urlHash]); delete activeYouTubePollers[urlHash]; } + socket.emit('sync:unsubscribe', { playlist_ids: [syncPlaylistId] }); + delete _syncProgressCallbacks[syncPlaylistId]; + if (qobuzPlaylistStates[playlistId]) qobuzPlaylistStates[playlistId].phase = 'discovered'; + if (youtubePlaylistStates[urlHash]) youtubePlaylistStates[urlHash].phase = 'discovered'; + updateQobuzCardPhase(playlistId, 'discovered'); + updateQobuzModalButtons(urlHash, 'discovered'); + showToast(`Sync failed: ${data.error || 'Unknown error'}`, 'error'); + } + }; + } + + const pollFunction = async () => { + if (socketConnected) return; + try { + const response = await fetch(`/api/qobuz/sync/status/${playlistId}`); + const status = await response.json(); + if (status.error) { + clearInterval(pollInterval); + delete activeYouTubePollers[urlHash]; + return; + } + updateQobuzCardSyncProgress(playlistId, status.progress); + updateQobuzModalSyncProgress(urlHash, status.progress); + + if (status.complete) { + clearInterval(pollInterval); + delete activeYouTubePollers[urlHash]; + if (qobuzPlaylistStates[playlistId]) qobuzPlaylistStates[playlistId].phase = 'sync_complete'; + if (youtubePlaylistStates[urlHash]) youtubePlaylistStates[urlHash].phase = 'sync_complete'; + updateQobuzCardPhase(playlistId, 'sync_complete'); + updateQobuzModalButtons(urlHash, 'sync_complete'); + showToast('Qobuz playlist sync complete!', 'success'); + } else if (status.sync_status === 'error') { + clearInterval(pollInterval); + delete activeYouTubePollers[urlHash]; + if (qobuzPlaylistStates[playlistId]) qobuzPlaylistStates[playlistId].phase = 'discovered'; + if (youtubePlaylistStates[urlHash]) youtubePlaylistStates[urlHash].phase = 'discovered'; + updateQobuzCardPhase(playlistId, 'discovered'); + updateQobuzModalButtons(urlHash, 'discovered'); + showToast(`Sync failed: ${status.error || 'Unknown error'}`, 'error'); + } + } catch (error) { + if (activeYouTubePollers[urlHash]) { + clearInterval(activeYouTubePollers[urlHash]); + delete activeYouTubePollers[urlHash]; + } + } + }; + + if (!socketConnected) pollFunction(); + const pollInterval = setInterval(pollFunction, 1000); + activeYouTubePollers[urlHash] = pollInterval; +} + +async function cancelQobuzSync(urlHash) { + try { + const state = youtubePlaylistStates[urlHash]; + if (!state || !state.is_qobuz_playlist) return; + + const playlistId = state.qobuz_playlist_id; + const response = await fetch(`/api/qobuz/sync/cancel/${playlistId}`, { method: 'POST' }); + const result = await response.json(); + if (result.error) { + showToast(`Error cancelling sync: ${result.error}`, 'error'); + return; + } + + if (activeYouTubePollers[urlHash]) { + clearInterval(activeYouTubePollers[urlHash]); + delete activeYouTubePollers[urlHash]; + } + + const syncId = state && state.syncPlaylistId; + if (syncId && _syncProgressCallbacks[syncId]) { + if (socketConnected) socket.emit('sync:unsubscribe', { playlist_ids: [syncId] }); + delete _syncProgressCallbacks[syncId]; + } + + updateQobuzCardPhase(playlistId, 'discovered'); + updateQobuzModalButtons(urlHash, 'discovered'); + showToast('Qobuz sync cancelled', 'info'); + } catch (error) { + showToast(`Error cancelling sync: ${error.message}`, 'error'); + } +} + +function updateQobuzCardSyncProgress(playlistId, progress) { + const state = qobuzPlaylistStates[playlistId]; + if (!state || !state.playlist || !progress) return; + state.lastSyncProgress = progress; + + const card = document.getElementById(`qobuz-card-${playlistId}`); + if (!card) return; + + const progressElement = card.querySelector('.playlist-card-progress'); + + let statusCounterHTML = ''; + if (progress && progress.total_tracks > 0) { + const matched = progress.matched_tracks || 0; + const failed = progress.failed_tracks || 0; + const total = progress.total_tracks || 0; + const processed = matched + failed; + const percentage = total > 0 ? Math.round((processed / total) * 100) : 0; + + statusCounterHTML = ` +
+ ♪ ${total} + / + ✓ ${matched} + / + ✗ ${failed} + (${percentage}%) +
+ `; + } + + if (statusCounterHTML) { + progressElement.innerHTML = statusCounterHTML; + } +} + +function updateQobuzModalSyncProgress(urlHash, progress) { + const statusDisplay = document.getElementById(`tidal-sync-status-${urlHash}`); + if (!statusDisplay || !progress) return; + + const totalEl = document.getElementById(`tidal-total-${urlHash}`); + const matchedEl = document.getElementById(`tidal-matched-${urlHash}`); + const failedEl = document.getElementById(`tidal-failed-${urlHash}`); + const percentageEl = document.getElementById(`tidal-percentage-${urlHash}`); + + const total = progress.total_tracks || 0; + const matched = progress.matched_tracks || 0; + const failed = progress.failed_tracks || 0; + + if (totalEl) totalEl.textContent = total; + if (matchedEl) matchedEl.textContent = matched; + if (failedEl) failedEl.textContent = failed; + + if (total > 0) { + const processed = matched + failed; + const percentage = Math.round((processed / total) * 100); + if (percentageEl) percentageEl.textContent = percentage; + } +} + +function updateQobuzModalButtons(urlHash, phase) { + const modal = document.getElementById(`youtube-discovery-modal-${urlHash}`); + if (!modal) return; + + const footerLeft = modal.querySelector('.modal-footer-left'); + if (footerLeft) { + footerLeft.innerHTML = getModalActionButtons(urlHash, phase); + } +} + +async function startQobuzDownloadMissing(urlHash) { + try { + const state = youtubePlaylistStates[urlHash]; + if (!state || !state.is_qobuz_playlist) return; + + const discoveryResults = state.discoveryResults || state.discovery_results; + if (!discoveryResults) { + showToast('No discovery results available for download', 'error'); + return; + } + + const spotifyTracks = []; + for (const result of discoveryResults) { + if (result.spotify_data) { + spotifyTracks.push(result.spotify_data); + } else if (result.spotify_track && result.status_class === 'found') { + const albumData = result.spotify_album || 'Unknown Album'; + const albumObject = typeof albumData === 'object' && albumData !== null + ? albumData + : { name: typeof albumData === 'string' ? albumData : 'Unknown Album', album_type: 'album', images: [] }; + spotifyTracks.push({ + id: result.spotify_id || 'unknown', + name: result.spotify_track || 'Unknown Track', + artists: result.spotify_artist ? [result.spotify_artist] : ['Unknown Artist'], + album: albumObject, + duration_ms: 0 + }); + } + } + + if (spotifyTracks.length === 0) { + showToast('No Spotify matches found for download', 'error'); + return; + } + + const virtualPlaylistId = `qobuz_${state.qobuz_playlist_id}`; + const playlistName = state.playlist.name; + state.convertedSpotifyPlaylistId = virtualPlaylistId; + + const discoveryModal = document.getElementById(`youtube-discovery-modal-${urlHash}`); + if (discoveryModal) discoveryModal.classList.add('hidden'); + + await openDownloadMissingModalForTidal(virtualPlaylistId, playlistName, spotifyTracks); + } catch (error) { + showToast(`Error starting downloads: ${error.message}`, 'error'); + } +} + + // =================================================================== // DEEZER ARL PLAYLIST MANAGEMENT (Spotify-identical pattern) // =================================================================== @@ -2833,6 +3761,13 @@ function initializeSyncPage() { deezerArlRefreshBtn.addEventListener('click', loadDeezerArlPlaylists); } + // Logic for the Qobuz refresh button + const qobuzRefreshBtn = document.getElementById('qobuz-refresh-btn'); + if (qobuzRefreshBtn) { + qobuzRefreshBtn.removeEventListener('click', loadQobuzPlaylists); + qobuzRefreshBtn.addEventListener('click', loadQobuzPlaylists); + } + // Logic for the Deezer Link parse button const deezerParseBtn = document.getElementById('deezer-parse-btn'); if (deezerParseBtn) { @@ -7288,6 +8223,8 @@ function openYouTubeDiscoveryModal(urlHash) { console.log('🔄 Resuming sync polling...'); if (state.is_tidal_playlist) { startTidalSyncPolling(urlHash); + } else if (state.is_qobuz_playlist) { + startQobuzSyncPolling(urlHash); } else if (state.is_deezer_playlist) { startDeezerSyncPolling(urlHash); } else if (state.is_spotify_public_playlist) { @@ -7301,8 +8238,9 @@ function openYouTubeDiscoveryModal(urlHash) { } } } else { - // Create new modal (support YouTube, Tidal, Deezer, Beatport, ListenBrainz, Spotify Public, and Mirrored) + // Create new modal (support YouTube, Tidal, Qobuz, Deezer, Beatport, ListenBrainz, Spotify Public, and Mirrored) const isTidal = state.is_tidal_playlist; + const isQobuz = state.is_qobuz_playlist; const isDeezer = state.is_deezer_playlist; const isSpotifyPublic = state.is_spotify_public_playlist; const isBeatport = state.is_beatport_playlist; @@ -7313,18 +8251,20 @@ function openYouTubeDiscoveryModal(urlHash) { isSpotifyPublic ? '🎵 Spotify Playlist Discovery' : isDeezer ? '🎵 Deezer Playlist Discovery' : isTidal ? '🎵 Tidal Playlist Discovery' : - isBeatport ? '🎵 Beatport Chart Discovery' : - isLastfmRadio ? '📻 Last.fm Radio Discovery' : - isListenBrainz ? '🎵 ListenBrainz Playlist Discovery' : - '🎵 YouTube Playlist Discovery'; + isQobuz ? '🎵 Qobuz Playlist Discovery' : + isBeatport ? '🎵 Beatport Chart Discovery' : + isLastfmRadio ? '📻 Last.fm Radio Discovery' : + isListenBrainz ? '🎵 ListenBrainz Playlist Discovery' : + '🎵 YouTube Playlist Discovery'; const sourceLabel = isMirrored ? (state.mirrored_source ? state.mirrored_source.charAt(0).toUpperCase() + state.mirrored_source.slice(1) : 'Source') : isSpotifyPublic ? 'Spotify' : isDeezer ? 'Deezer' : isTidal ? 'Tidal' : - isBeatport ? 'Beatport' : - isLastfmRadio ? 'Last.fm' : - isListenBrainz ? 'LB' : - 'YT'; + isQobuz ? 'Qobuz' : + isBeatport ? 'Beatport' : + isLastfmRadio ? 'Last.fm' : + isListenBrainz ? 'LB' : + 'YT'; const modalHtml = ` `; + } else if (isQobuz) { + // Qobuz reuses the tidal-* id namespace for the sync-status row + // because updateQobuzModalSyncProgress targets those exact IDs. + // Keeping the markup byte-identical to Tidal avoids a separate + // CSS pass; only the cancel handler differs. + return ` + +
+ ♪ 0 + / + ✓ 0 + / + ✗ 0 + (0%) +
+ `; } else if (isDeezer) { return ` @@ -7680,6 +8641,8 @@ function getModalActionButtons(urlHash, phase, state = null) { syncCompleteButtons += ``; } else if (isTidal) { syncCompleteButtons += ``; + } else if (isQobuz) { + syncCompleteButtons += ``; } else if (isSpotifyPublic) { syncCompleteButtons += ``; } else if (isBeatport) { @@ -7695,6 +8658,8 @@ function getModalActionButtons(urlHash, phase, state = null) { syncCompleteButtons += ``; } else if (isTidal) { syncCompleteButtons += ``; + } else if (isQobuz) { + syncCompleteButtons += ``; } else if (isSpotifyPublic) { syncCompleteButtons += ``; } else if (isBeatport) { @@ -7707,7 +8672,7 @@ function getModalActionButtons(urlHash, phase, state = null) { // Rediscover button (only for sources with reset endpoints) if (isBeatport) { syncCompleteButtons += ``; - } else if (!isListenBrainz && !isTidal && !isDeezer && !isSpotifyPublic) { + } else if (!isListenBrainz && !isTidal && !isQobuz && !isDeezer && !isSpotifyPublic) { syncCompleteButtons += ``; } @@ -7725,6 +8690,8 @@ function getModalActionButtons(urlHash, phase, state = null) { dlCompleteButtons += ``; } else if (isTidal) { dlCompleteButtons += ``; + } else if (isQobuz) { + dlCompleteButtons += ``; } else if (isDeezer) { dlCompleteButtons += ``; } else if (isSpotifyPublic) { @@ -7741,6 +8708,8 @@ function getModalActionButtons(urlHash, phase, state = null) { dlCompleteButtons += ``; } else if (isTidal) { dlCompleteButtons += ``; + } else if (isQobuz) { + dlCompleteButtons += ``; } else if (isDeezer) { dlCompleteButtons += ``; } else if (isSpotifyPublic) { @@ -7755,7 +8724,7 @@ function getModalActionButtons(urlHash, phase, state = null) { // Rediscover button (only for sources with reset endpoints) if (isBeatport) { dlCompleteButtons += ``; - } else if (!isListenBrainz && !isTidal && !isDeezer && !isSpotifyPublic) { + } else if (!isListenBrainz && !isTidal && !isQobuz && !isDeezer && !isSpotifyPublic) { dlCompleteButtons += ``; } @@ -7766,8 +8735,8 @@ function getModalActionButtons(urlHash, phase, state = null) { } } -function getModalDescription(phase, isTidal = false, isBeatport = false, isListenBrainz = false, isMirrored = false, isDeezer = false, isSpotifyPublic = false, isLastfmRadio = false) { - const source = isMirrored ? 'mirrored' : (isSpotifyPublic ? 'Spotify' : (isDeezer ? 'Deezer' : (isLastfmRadio ? 'Last.fm Radio' : (isListenBrainz ? 'ListenBrainz' : (isBeatport ? 'Beatport' : (isTidal ? 'Tidal' : 'YouTube')))))); +function getModalDescription(phase, isTidal = false, isBeatport = false, isListenBrainz = false, isMirrored = false, isDeezer = false, isSpotifyPublic = false, isLastfmRadio = false, isQobuz = false) { + const source = isMirrored ? 'mirrored' : (isSpotifyPublic ? 'Spotify' : (isDeezer ? 'Deezer' : (isLastfmRadio ? 'Last.fm Radio' : (isListenBrainz ? 'ListenBrainz' : (isBeatport ? 'Beatport' : (isQobuz ? 'Qobuz' : (isTidal ? 'Tidal' : 'YouTube'))))))); switch (phase) { case 'fresh': return `Ready to discover clean ${currentMusicSourceName} metadata for ${source} tracks...`; @@ -7799,12 +8768,13 @@ function getInitialProgressText(phase, isTidal = false, isBeatport = false, isLi function generateTableRowsFromState(state, urlHash) { const isTidal = state.is_tidal_playlist; + const isQobuz = state.is_qobuz_playlist; const isDeezer = state.is_deezer_playlist; const isSpotifyPublic = state.is_spotify_public_playlist; const isBeatport = state.is_beatport_playlist; const isListenBrainz = state.is_listenbrainz_playlist; const isMirrored = state.is_mirrored_playlist; - const platform = isMirrored ? 'mirrored' : (isSpotifyPublic ? 'spotify_public' : (isDeezer ? 'deezer' : (isListenBrainz ? 'listenbrainz' : (isTidal ? 'tidal' : (isBeatport ? 'beatport' : 'youtube'))))); + const platform = isMirrored ? 'mirrored' : (isSpotifyPublic ? 'spotify_public' : (isDeezer ? 'deezer' : (isListenBrainz ? 'listenbrainz' : (isTidal ? 'tidal' : (isQobuz ? 'qobuz' : (isBeatport ? 'beatport' : 'youtube')))))); // Support both camelCase and snake_case const discoveryResults = state.discoveryResults || state.discovery_results; @@ -7969,7 +8939,8 @@ function updateYouTubeDiscoveryModal(urlHash, status) { (state?.is_deezer_playlist ? 'deezer' : (state?.is_listenbrainz_playlist ? 'listenbrainz' : (state?.is_tidal_playlist ? 'tidal' : - (state?.is_beatport_playlist ? 'beatport' : 'youtube'))))); + (state?.is_qobuz_playlist ? 'qobuz' : + (state?.is_beatport_playlist ? 'beatport' : 'youtube')))))); actionsCell.innerHTML = generateDiscoveryActionButton(result, urlHash, platform); } }); @@ -8453,6 +9424,7 @@ async function startYouTubeDownloadMissing(urlHash) { const isListenBrainz = state.is_listenbrainz_playlist; const isBeatport = state.is_beatport_playlist; const isTidal = state.is_tidal_playlist; + const isQobuz = state.is_qobuz_playlist; const isDeezer = state.is_deezer_playlist; // Convert discovery results to a format compatible with the download modal @@ -8489,7 +9461,7 @@ async function startYouTubeDownloadMissing(urlHash) { } // Create a virtual playlist for the download system - const virtualPlaylistId = isListenBrainz ? `listenbrainz_${urlHash}` : (isDeezer ? `deezer_${urlHash}` : (isBeatport ? `beatport_${urlHash}` : (isTidal ? `tidal_${urlHash}` : `youtube_${urlHash}`))); + const virtualPlaylistId = isListenBrainz ? `listenbrainz_${urlHash}` : (isDeezer ? `deezer_${urlHash}` : (isBeatport ? `beatport_${urlHash}` : (isTidal ? `tidal_${urlHash}` : (isQobuz ? `qobuz_${urlHash}` : `youtube_${urlHash}`)))); const playlistName = state.playlist.name; // Store reference for card navigation