virittaa

import.rs (5077B)

---

 use anyhow::{Context, Result};
 use rusqlite::Connection;
 
 use crate::db::{LibraryDb, TrackReport};
 use crate::utils::format_primary_key;
 
 /// Convert a Mixxx key string (e.g. "Cm", "D", "Bbm") to virittaa format
 /// (e.g. "C Minor", "D Major", "Bb Minor"). Returns `None` for empty or
 /// unknown keys.
 fn convert_mixxx_key(raw: &str) -> Option<String> {
     let raw = raw.trim();
     if raw.is_empty() {
         return None;
     }
     // Mixxx minor keys end with 'm': "Cm", "C#m", "Bbm", etc.
     if raw.ends_with('m') && raw.len() > 1 {
         let root = &raw[..raw.len() - 1];
         Some(format!("{root} Minor"))
     } else {
         Some(format!("{raw} Major"))
     }
 }
 
 /// Import tracks from a Mixxx `SQLite` database into the sled library database.
 ///
 /// Reads the `library` and `track_locations` tables, skipping entries marked as
 /// deleted, and saves each track with its BPM and key.
 ///
 /// # Errors
 ///
 /// Returns an error if the Mixxx database cannot be opened or queried, or if
 /// sled writes fail.
 pub fn import_mixxx(db: &LibraryDb, mixxx_path: &str) -> Result<usize> {
     let conn = Connection::open(mixxx_path).with_context(|| "Failed to open Mixxx database")?;
 
     let mut stmt = conn.prepare(
         "SELECT l.artist, l.title, l.bpm, l.key \
          FROM library l \
          WHERE l.mixxx_deleted = 0 AND l.bpm IS NOT NULL AND l.bpm > 0",
     )?;
 
     let rows = stmt.query_map([], |row| {
         let artist: Option<String> = row.get(0)?;
         let title: Option<String> = row.get(1)?;
         let bpm: Option<f64> = row.get(2)?;
         let key_raw: Option<String> = row.get(3)?;
         Ok((artist, title, bpm, key_raw))
     })?;
 
     let mut entries = Vec::new();
     for row in rows {
         let (artist, title, bpm, key_raw) = row?;
         let key = key_raw.as_deref().and_then(convert_mixxx_key);
 
         let primary_key = format_primary_key(artist.as_deref(), title.as_deref());
 
         let report = TrackReport {
             artist,
             track: title,
             bpm,
             key,
             timestamp: Some(
                 std::time::SystemTime::now()
                     .duration_since(std::time::UNIX_EPOCH)
                     .unwrap_or_default()
                     .as_secs()
                     .cast_signed(),
             ),
         };
 
         entries.push((primary_key, report));
     }
 
     let count = entries.len();
     db.save_batch(&entries)?;
     Ok(count)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn convert_mixxx_major_keys() {
         assert_eq!(convert_mixxx_key("D"), Some("D Major".to_string()));
         assert_eq!(convert_mixxx_key("F#"), Some("F# Major".to_string()));
         assert_eq!(convert_mixxx_key("Bb"), Some("Bb Major".to_string()));
     }
 
     #[test]
     fn convert_mixxx_minor_keys() {
         assert_eq!(convert_mixxx_key("Cm"), Some("C Minor".to_string()));
         assert_eq!(convert_mixxx_key("C#m"), Some("C# Minor".to_string()));
         assert_eq!(convert_mixxx_key("Bbm"), Some("Bb Minor".to_string()));
     }
 
     #[test]
     fn convert_mixxx_key_trims_and_rejects_empty() {
         assert_eq!(convert_mixxx_key(""), None);
         assert_eq!(convert_mixxx_key("   "), None);
         assert_eq!(convert_mixxx_key("  Am  "), Some("A Minor".to_string()));
     }
 
     fn make_mixxx_db(path: &std::path::Path) {
         let conn = Connection::open(path).unwrap();
         conn.execute_batch(
             "CREATE TABLE library (
                  artist TEXT,
                  title TEXT,
                  bpm REAL,
                  key TEXT,
                  mixxx_deleted INTEGER
              );
              INSERT INTO library VALUES ('Aphex Twin', 'Xtal', 120.0, 'Am', 0);
              INSERT INTO library VALUES ('Boards of Canada', 'Roygbiv', 95.5, 'C', 0);
              -- Deleted rows are skipped.
              INSERT INTO library VALUES ('Deleted', 'Track', 100.0, 'D', 1);
              -- Rows without a usable BPM are skipped.
              INSERT INTO library VALUES ('No', 'Bpm', NULL, 'E', 0);
              INSERT INTO library VALUES ('Zero', 'Bpm', 0.0, 'F', 0);",
         )
         .unwrap();
     }
 
     #[test]
     fn import_mixxx_filters_and_converts() {
         let dir = tempfile::tempdir().unwrap();
         let mixxx_path = dir.path().join("mixxxdb.sqlite");
         make_mixxx_db(&mixxx_path);
 
         let db = LibraryDb::open(&dir.path().join("library")).unwrap();
         let count = import_mixxx(&db, mixxx_path.to_str().unwrap()).unwrap();
 
         // Only the two non-deleted, positive-BPM rows are imported.
         assert_eq!(count, 2);
         assert_eq!(db.count().unwrap(), 2);
 
         let xtal = db.get("Aphex Twin - Xtal").unwrap().unwrap();
         assert_eq!(xtal.key.as_deref(), Some("A Minor"));
         assert_eq!(xtal.bpm, Some(120.0));
 
         let roygbiv = db.get("Boards of Canada - Roygbiv").unwrap().unwrap();
         assert_eq!(roygbiv.key.as_deref(), Some("C Major"));
 
         assert!(db.get("Deleted - Track").unwrap().is_none());
         assert!(db.get("Zero - Bpm").unwrap().is_none());
     }
 }