Make "download album lyrics" and similar buttons respect skip lyrics …

…option

src-tauri/src/db.rs

@@ -474,8 +474,20 @@ pub fn get_tracks(db: &Connection) -> Result<Vec<PersistentTrack>> {
     Ok(tracks)
 }
 
-pub fn get_track_ids(db: &Connection) -> Result<Vec<i64>> {
-    let mut statement = db.prepare("SELECT id FROM tracks ORDER BY title_lower ASC")?;
+pub fn get_track_ids(without_plain_lyrics: bool, without_synced_lyrics: bool, db: &Connection) -> Result<Vec<i64>> {
+    let base_query = "SELECT id FROM tracks";
+
+    let lyrics_conditions: &str = match (without_plain_lyrics, without_synced_lyrics) {
+        (true, true) => " WHERE txt_lyrics IS NULL AND lrc_lyrics IS NULL AND instrumental = false",
+        (true, false) => " WHERE txt_lyrics IS NULL AND instrumental = false",
+        (false, true) => " WHERE lrc_lyrics IS NULL AND instrumental = false",
+        (false, false) => "",
+    };
+
+    let full_query = format!("{}{} ORDER BY title_lower ASC",
+        base_query, lyrics_conditions);
+
+    let mut statement = db.prepare(&full_query)?;
     let mut rows = statement.query([])?;
     let mut track_ids: Vec<i64> = Vec::new();
 
@@ -514,18 +526,6 @@ pub fn get_search_track_ids(query_str: &String, db: &Connection) -> Result<Vec<i
     Ok(track_ids)
 }
 
-pub fn get_no_lyrics_track_ids(db: &Connection) -> Result<Vec<i64>> {
-    let mut statement = db.prepare("SELECT id FROM tracks WHERE lrc_lyrics IS NULL AND instrumental != true ORDER BY title_lower ASC")?;
-    let mut rows = statement.query([])?;
-    let mut track_ids: Vec<i64> = Vec::new();
-
-    while let Some(row) = rows.next()? {
-        track_ids.push(row.get("id")?);
-    }
-
-    Ok(track_ids)
-}
-
 pub fn get_albums(db: &Connection) -> Result<Vec<PersistentAlbum>> {
     let mut statement = db.prepare(indoc! {"
       SELECT albums.id, albums.name, albums.album_artist_name AS album_artist_name, albums.album_artist_name,
@@ -708,14 +708,24 @@ pub fn get_album_tracks(album_id: i64, db: &Connection) -> Result<Vec<Persistent
     Ok(tracks)
 }
 
-pub fn get_album_track_ids(album_id: i64, db: &Connection) -> Result<Vec<i64>> {
-    let mut statement = db.prepare(indoc! {"
-    SELECT tracks.id
-    FROM tracks
-    JOIN albums ON tracks.album_id = albums.id
-    WHERE tracks.album_id = ?
-    ORDER BY track_number ASC
-  "})?;
+pub fn get_album_track_ids(album_id: i64, without_plain_lyrics: bool, without_synced_lyrics: bool, db: &Connection) -> Result<Vec<i64>> {
+    let base_query = indoc! {"
+      SELECT tracks.id
+      FROM tracks
+      JOIN albums ON tracks.album_id = albums.id
+      WHERE tracks.album_id = ?"};
+
+    let lyrics_conditions = match (without_plain_lyrics, without_synced_lyrics) {
+        (true, true) => " AND txt_lyrics IS NULL AND lrc_lyrics IS NULL AND tracks.instrumental = false",
+        (true, false) => " AND txt_lyrics IS NULL AND tracks.instrumental = false",
+        (false, true) => " AND lrc_lyrics IS NULL AND tracks.instrumental = false",
+        (false, false) => "",
+    };
+
+    let full_query = format!("{}{} ORDER BY tracks.track_number ASC",
+        base_query, lyrics_conditions);
+
+    let mut statement = db.prepare(&full_query)?;
     let mut rows = statement.query([album_id])?;
     let mut tracks: Vec<i64> = Vec::new();
 
@@ -767,15 +777,25 @@ pub fn get_artist_tracks(artist_id: i64, db: &Connection) -> Result<Vec<Persiste
     Ok(tracks)
 }
 
-pub fn get_artist_track_ids(artist_id: i64, db: &Connection) -> Result<Vec<i64>> {
-    let mut statement = db.prepare(indoc! {"
+pub fn get_artist_track_ids(artist_id: i64, without_plain_lyrics: bool, without_synced_lyrics: bool, db: &Connection) -> Result<Vec<i64>> {
+    let base_query = indoc! {"
       SELECT tracks.id
       FROM tracks
       JOIN albums ON tracks.album_id = albums.id
       JOIN artists ON tracks.artist_id = artists.id
-      WHERE tracks.artist_id = ?
-      ORDER BY albums.name_lower ASC, tracks.track_number ASC
-  "})?;
+      WHERE tracks.artist_id = ?"};
+
+    let lyrics_conditions = match (without_plain_lyrics, without_synced_lyrics) {
+        (true, true) => " AND txt_lyrics IS NULL AND lrc_lyrics IS NULL AND tracks.instrumental = false",
+        (true, false) => " AND txt_lyrics IS NULL AND tracks.instrumental = false",
+        (false, true) => " AND lrc_lyrics IS NULL AND tracks.instrumental = false",
+        (false, false) => "",
+    };
+
+    let full_query = format!("{}{} ORDER BY albums.name_lower ASC, tracks.track_number ASC",
+        base_query, lyrics_conditions);
+
+    let mut statement = db.prepare(&full_query)?;
     let mut rows = statement.query([artist_id])?;
     let mut tracks: Vec<i64> = Vec::new();
 

src-tauri/src/library.rs

@@ -51,17 +51,13 @@ pub fn get_tracks(conn: &Connection) -> Result<Vec<PersistentTrack>> {
     db::get_tracks(conn)
 }
 
-pub fn get_track_ids(search_query: Option<String>, conn: &Connection) -> Result<Vec<i64>> {
+pub fn get_track_ids(search_query: Option<String>, without_plain_lyrics: bool, without_synced_lyrics: bool, conn: &Connection) -> Result<Vec<i64>> {
     match search_query {
         Some(search_query) => db::get_search_track_ids(&search_query, conn),
-        None => db::get_track_ids(conn),
+        None => db::get_track_ids(without_plain_lyrics, without_synced_lyrics, conn),
     }
 }
 
-pub fn get_no_lyrics_track_ids(conn: &Connection) -> Result<Vec<i64>> {
-    db::get_no_lyrics_track_ids(conn)
-}
-
 pub fn get_track(id: i64, conn: &Connection) -> Result<PersistentTrack> {
     db::get_track_by_id(id, conn)
 }
@@ -98,12 +94,12 @@ pub fn get_artist_tracks(artist_id: i64, conn: &Connection) -> Result<Vec<Persis
     db::get_artist_tracks(artist_id, conn)
 }
 
-pub fn get_album_track_ids(album_id: i64, conn: &Connection) -> Result<Vec<i64>> {
-    db::get_album_track_ids(album_id, conn)
+pub fn get_album_track_ids(album_id: i64, without_plain_lyrics: bool, without_synced_lyrics: bool, conn: &Connection) -> Result<Vec<i64>> {
+    db::get_album_track_ids(album_id, without_plain_lyrics, without_synced_lyrics, conn)
 }
 
-pub fn get_artist_track_ids(artist_id: i64, conn: &Connection) -> Result<Vec<i64>> {
-    db::get_artist_track_ids(artist_id, conn)
+pub fn get_artist_track_ids(artist_id: i64, without_plain_lyrics: bool, without_synced_lyrics: bool, conn: &Connection) -> Result<Vec<i64>> {
+    db::get_artist_track_ids(artist_id, without_plain_lyrics, without_synced_lyrics, conn)
 }
 
 pub fn get_init(conn: &Connection) -> Result<bool> {

src-tauri/src/main.rs

@@ -151,21 +151,14 @@ async fn get_tracks(app_state: State<'_, AppState>) -> Result<Vec<PersistentTrac
 #[tauri::command]
 async fn get_track_ids(
     search_query: Option<String>,
+    without_plain_lyrics: Option<bool>,
+    without_synced_lyrics: Option<bool>,
     app_state: State<'_, AppState>,
 ) -> Result<Vec<i64>, String> {
     let conn_guard = app_state.db.lock().unwrap();
     let conn = conn_guard.as_ref().unwrap();
     let search_query = search_query.filter(|s| !s.is_empty());
-    let track_ids = library::get_track_ids(search_query, conn).map_err(|err| err.to_string())?;
-
-    Ok(track_ids)
-}
-
-#[tauri::command]
-async fn get_no_lyrics_track_ids(app_state: State<'_, AppState>) -> Result<Vec<i64>, String> {
-    let conn_guard = app_state.db.lock().unwrap();
-    let conn = conn_guard.as_ref().unwrap();
-    let track_ids = library::get_no_lyrics_track_ids(conn).map_err(|err| err.to_string())?;
+    let track_ids = library::get_track_ids(search_query, without_plain_lyrics.unwrap_or(false), without_synced_lyrics.unwrap_or(false), conn).map_err(|err| err.to_string())?;
 
     Ok(track_ids)
 }
@@ -269,24 +262,28 @@ async fn get_artist_tracks(
 #[tauri::command]
 async fn get_album_track_ids(
     album_id: i64,
+    without_plain_lyrics: Option<bool>,
+    without_synced_lyrics: Option<bool>,
     app_state: State<'_, AppState>,
 ) -> Result<Vec<i64>, String> {
     let conn_guard = app_state.db.lock().unwrap();
     let conn = conn_guard.as_ref().unwrap();
-    let track_ids = library::get_album_track_ids(album_id, conn).map_err(|err| err.to_string())?;
+    let track_ids = library::get_album_track_ids(album_id, without_plain_lyrics.unwrap_or(false), without_synced_lyrics.unwrap_or(false), conn).map_err(|err| err.to_string())?;
 
     Ok(track_ids)
 }
 
 #[tauri::command]
 async fn get_artist_track_ids(
     artist_id: i64,
+    without_plain_lyrics: Option<bool>,
+    without_synced_lyrics: Option<bool>,
     app_state: State<'_, AppState>,
 ) -> Result<Vec<i64>, String> {
     let conn_guard = app_state.db.lock().unwrap();
     let conn = conn_guard.as_ref().unwrap();
     let track_ids =
-        library::get_artist_track_ids(artist_id, conn).map_err(|err| err.to_string())?;
+        library::get_artist_track_ids(artist_id, without_plain_lyrics.unwrap_or(false), without_synced_lyrics.unwrap_or(false), conn).map_err(|err| err.to_string())?;
 
     Ok(track_ids)
 }
@@ -752,7 +749,6 @@ async fn main() {
             refresh_library,
             get_tracks,
             get_track_ids,
-            get_no_lyrics_track_ids,
             get_track,
             get_albums,
             get_album_ids,

src/components/library/AlbumList.vue

@@ -72,7 +72,6 @@ const openAlbum = async (album) => {
 onMounted(async () => {
   if (props.isActive) {
     albumIds.value = await invoke('get_album_ids')
-    console.log(albumIds.value)
   }
 })
 

src/components/library/ArtistList.vue

@@ -72,7 +72,6 @@ const openArtist = async (artist) => {
 onMounted(async () => {
   if (props.isActive) {
     artistIds.value = await invoke('get_artist_ids')
-    console.log(artistIds.value)
   }
 })
 

src/components/library/LibraryHeader.vue

@@ -105,12 +105,10 @@ const downloadAllLyrics = async () => {
 
   try {
     const config = await invoke('get_config')
-    let downloadTrackIds
-    if (config.skip_not_needed_tracks) {
-      downloadTrackIds = await invoke('get_no_lyrics_track_ids')
-    } else {
-      downloadTrackIds = await invoke('get_track_ids')
-    }
+    let downloadTrackIds = await invoke('get_track_ids', {
+      withoutPlainLyrics: false,
+      withoutSyncedLyrics: config.skip_not_needed_tracks
+    })
     addToQueue(downloadTrackIds)
   } catch (error) {
     // TODO handle error by showing an error popup, etc...

src/components/library/album-list/AlbumItem.vue

@@ -34,7 +34,12 @@ const { addToQueue } = useDownloader()
 const album = ref(null)
 
 const downloadLyricsMultiple = async () => {
-  const trackIds = await invoke('get_album_track_ids', { albumId: album.value.id })
+  const config = await invoke('get_config')
+  const trackIds = await invoke('get_album_track_ids', {
+    albumId: album.value.id,
+    withoutPlainLyrics: false,
+    withoutSyncedLyrics: config.skip_not_needed_tracks
+  })
   addToQueue(trackIds)
 }
 

src/components/library/album-list/AlbumTrackList.vue

@@ -111,7 +111,13 @@ const downloadLyrics = (track) => {
 }
 
 const downloadAlbumLyrics = async () => {
-  addToQueue(trackIds.value)
+  const config = await invoke('get_config')
+  const downloadTrackIds = await invoke('get_album_track_ids', {
+    albumId: props.album.id,
+    withoutPlainLyrics: false,
+    withoutSyncedLyrics: config.skip_not_needed_tracks
+  })
+  addToQueue(downloadTrackIds)
 }
 
 onMounted(async () => {

src/components/library/artist-list/ArtistItem.vue

@@ -32,7 +32,12 @@ const { addToQueue } = useDownloader()
 const artist = ref(null)
 
 const downloadLyricsMultiple = async () => {
-  const trackIds = await invoke('get_artist_track_ids', { artistId: artist.value.id })
+  const config = await invoke('get_config')
+  const trackIds = await invoke('get_artist_track_ids', {
+    artistId: artist.value.id,
+    withoutPlainLyrics: false,
+    withoutSyncedLyrics: config.skip_not_needed_tracks
+  })
   addToQueue(trackIds)
 }
 

src/components/library/artist-list/ArtistTrackList.vue

@@ -109,7 +109,13 @@ const downloadLyrics = (track) => {
 }
 
 const downloadArtistLyrics = async () => {
-  addToQueue(trackIds.value)
+  const config = await invoke('get_config')
+  const downloadTrackIds = await invoke('get_artist_track_ids', {
+    artistId: props.artist.id,
+    withoutPlainLyrics: false,
+    withoutSyncedLyrics: config.skip_not_needed_tracks
+  })
+  addToQueue(downloadTrackIds)
 }
 
 onMounted(async () => {