Account Export & Import, Onboarding Migration Option

Author: sagevk

src-tauri/src/account.rs

@@ -0,0 +1,239 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fs;
+
+use crate::playlists::{self, Playlist};
+use crate::scan::scan_dir;
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct ExportTrack {
+    pub title: String,
+    pub artist: String,
+    pub album: String,
+    pub duration: f64,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct ExportPlaylist {
+    pub name: String,
+    pub tracks: Vec<ExportTrack>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct AccountExport {
+    pub version: u32,
+    pub tracks: Vec<ExportTrack>,
+    pub playlists: Vec<ExportPlaylist>,
+    pub favorites: Vec<ExportTrack>,
+}
+
+#[derive(Serialize)]
+pub struct ImportResult {
+    pub playlists_created: usize,
+    pub favorites_restored: usize,
+    pub tracks_already_present: usize,
+    pub tracks_to_download: Vec<ExportTrack>,
+}
+
+fn norm_key(title: &str, artist: &str) -> String {
+    format!(
+        "{}::{}",
+        title.trim().to_lowercase(),
+        artist.trim().to_lowercase()
+    )
+}
+
+#[tauri::command]
+pub async fn export_account(dir: String) -> Result<String, String> {
+    let lib = scan_dir(dir);
+    let path_to_meta: HashMap<String, ExportTrack> = lib
+        .iter()
+        .map(|t| {
+            (
+                t.path.clone(),
+                ExportTrack {
+                    title: t.title.clone(),
+                    artist: t.artist.clone(),
+                    album: t.album.clone(),
+                    duration: t.duration,
+                },
+            )
+        })
+        .collect();
+
+    let tracks: Vec<ExportTrack> = lib
+        .iter()
+        .map(|t| ExportTrack {
+            title: t.title.clone(),
+            artist: t.artist.clone(),
+            album: t.album.clone(),
+            duration: t.duration,
+        })
+        .collect();
+
+    let pl_dir = playlists::pl_dir();
+    let mut pls = Vec::new();
+    let entries = fs::read_dir(&pl_dir).map_err(|e| format!("readdir: {e}"))?;
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.extension().map_or(false, |e| e == "json") {
+            if let Ok(data) = fs::read_to_string(&path) {
+                if let Ok(pl) = serde_json::from_str::<Playlist>(&data) {
+                    if pl.id != playlists::FAVS_ID {
+                        let pl_tracks: Vec<ExportTrack> = pl
+                            .tracks
+                            .iter()
+                            .filter_map(|p| path_to_meta.get(p).cloned())
+                            .collect();
+                        pls.push(ExportPlaylist {
+                            name: pl.name,
+                            tracks: pl_tracks,
+                        });
+                    }
+                }
+            }
+        }
+    }
+
+    playlists::ensure_favs();
+    let favs_pl = playlists::read_pl(playlists::FAVS_ID)?;
+    let favorites: Vec<ExportTrack> = favs_pl
+        .tracks
+        .iter()
+        .filter_map(|p| path_to_meta.get(p).cloned())
+        .collect();
+
+    let export = AccountExport {
+        version: 1,
+        tracks,
+        playlists: pls,
+        favorites,
+    };
+
+    serde_json::to_string_pretty(&export).map_err(|e| format!("json: {e}"))
+}
+
+#[tauri::command]
+pub async fn import_account(data: String, dir: String) -> Result<ImportResult, String> {
+    let export: AccountExport =
+        serde_json::from_str(&data).map_err(|e| format!("parse: {e}"))?;
+
+    let lib = scan_dir(dir.clone());
+    let lib_keys: HashMap<String, String> = lib
+        .iter()
+        .map(|t| (norm_key(&t.title, &t.artist), t.path.clone()))
+        .collect();
+
+    let mut present = 0usize;
+    let mut missing: Vec<ExportTrack> = Vec::new();
+
+    for t in &export.tracks {
+        let key = norm_key(&t.title, &t.artist);
+        if lib_keys.contains_key(&key) {
+            present += 1;
+        } else {
+            missing.push(t.clone());
+        }
+    }
+
+    let mut pl_count = 0usize;
+    for ep in &export.playlists {
+        let id = format!(
+            "pl_{}",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_millis()
+        );
+        std::thread::sleep(std::time::Duration::from_millis(1));
+
+        let track_paths: Vec<String> = ep
+            .tracks
+            .iter()
+            .filter_map(|t| lib_keys.get(&norm_key(&t.title, &t.artist)).cloned())
+            .collect();
+
+        let pl = Playlist {
+            id,
+            name: ep.name.clone(),
+            description: String::new(),
+            cover: None,
+            tracks: track_paths,
+        };
+        playlists::write_pl(&pl)?;
+        pl_count += 1;
+    }
+
+    playlists::ensure_favs();
+    let mut favs = playlists::read_pl(playlists::FAVS_ID)?;
+    let mut fav_count = 0usize;
+    for ft in &export.favorites {
+        let key = norm_key(&ft.title, &ft.artist);
+        if let Some(path) = lib_keys.get(&key) {
+            if !favs.tracks.contains(path) {
+                favs.tracks.push(path.clone());
+                fav_count += 1;
+            }
+        }
+    }
+    playlists::write_pl(&favs)?;
+
+    Ok(ImportResult {
+        playlists_created: pl_count,
+        favorites_restored: fav_count,
+        tracks_already_present: present,
+        tracks_to_download: missing,
+    })
+}
+
+#[tauri::command]
+pub async fn import_fill_playlists(data: String, dir: String) -> Result<(), String> {
+    let export: AccountExport =
+        serde_json::from_str(&data).map_err(|e| format!("parse: {e}"))?;
+
+    let lib = scan_dir(dir);
+    let lib_keys: HashMap<String, String> = lib
+        .iter()
+        .map(|t| (norm_key(&t.title, &t.artist), t.path.clone()))
+        .collect();
+
+    let pl_dir = playlists::pl_dir();
+    let entries = fs::read_dir(&pl_dir).map_err(|e| format!("readdir: {e}"))?;
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.extension().map_or(false, |e| e == "json") {
+            if let Ok(file_data) = fs::read_to_string(&path) {
+                if let Ok(mut pl) = serde_json::from_str::<Playlist>(&file_data) {
+                    if pl.id == playlists::FAVS_ID {
+                        continue;
+                    }
+                    if let Some(ep) = export.playlists.iter().find(|e| e.name == pl.name) {
+                        for et in &ep.tracks {
+                            let key = norm_key(&et.title, &et.artist);
+                            if let Some(track_path) = lib_keys.get(&key) {
+                                if !pl.tracks.contains(track_path) {
+                                    pl.tracks.push(track_path.clone());
+                                }
+                            }
+                        }
+                        playlists::write_pl(&pl)?;
+                    }
+                }
+            }
+        }
+    }
+
+    playlists::ensure_favs();
+    let mut favs = playlists::read_pl(playlists::FAVS_ID)?;
+    for ft in &export.favorites {
+        let key = norm_key(&ft.title, &ft.artist);
+        if let Some(path) = lib_keys.get(&key) {
+            if !favs.tracks.contains(path) {
+                favs.tracks.push(path.clone());
+            }
+        }
+    }
+    playlists::write_pl(&favs)?;
+
+    Ok(())
+}

src-tauri/src/discover.rs

@@ -457,6 +457,11 @@ async fn dz_lookup(artist: &str, title: &str) -> Option<(String, String)> {
     None
 }
 
+#[tauri::command]
+pub async fn lookup_cover(artist: String, title: String) -> Option<String> {
+    dz_lookup(&artist, &title).await.map(|(cover, _)| cover)
+}
+
 #[derive(Serialize, Clone)]
 pub struct YtImportProgress {
     pub phase: String,

src-tauri/src/lib.rs

@@ -8,16 +8,18 @@ mod spotify;
 mod playlists;
 mod track_ops;
 mod audio_device;
+mod account;
 
 use scan::{scan_dir, get_cover, stream_file, fetch_lyrics, fetch_ttml};
-use discover::{search_tracks, search_albums, search_artists, get_album_tracks, get_artist_albums, download_track, yt_playlist_tracks};
+use discover::{search_tracks, search_albums, search_artists, get_album_tracks, get_artist_albums, download_track, yt_playlist_tracks, lookup_cover};
 use rpc::{rpc_on, rpc_off, rpc_set, rpc_clr, rpc_cover};
 use tray::tray_set;
 use ytdlp_setup::{check_ytdlp, install_ytdlp, check_ytdlp_update, check_ffmpeg, install_ffmpeg};
 use spotify::{sp_save_client_id, sp_load_client_id, sp_authorize, sp_load_tokens, sp_disconnect, sp_fresh_token, sp_playlists, sp_playlist_tracks, sp_liked_tracks};
 use playlists::{pl_list, pl_create, pl_rename, pl_delete, pl_get, pl_add_track, pl_remove_track, pl_cover, pl_set_cover, pl_favs, pl_fav_toggle};
 use track_ops::delete_track;
 use audio_device::get_audio_device;
+use account::{export_account, import_account, import_fill_playlists};
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
@@ -27,7 +29,7 @@ pub fn run() {
         .plugin(tauri_plugin_shell::init())
         .manage(rpc::init())
         .manage(tray::init())
-        .invoke_handler(tauri::generate_handler![scan_dir, get_cover, stream_file, fetch_lyrics, fetch_ttml, search_tracks, search_albums, search_artists, get_album_tracks, get_artist_albums, download_track, yt_playlist_tracks, rpc_on, rpc_off, rpc_set, rpc_clr, rpc_cover, tray_set, check_ytdlp, install_ytdlp, check_ytdlp_update, check_ffmpeg, install_ffmpeg, sp_save_client_id, sp_load_client_id, sp_authorize, sp_load_tokens, sp_disconnect, sp_fresh_token, sp_playlists, sp_playlist_tracks, sp_liked_tracks, pl_list, pl_create, pl_rename, pl_delete, pl_get, pl_add_track, pl_remove_track, pl_cover, pl_set_cover, pl_favs, pl_fav_toggle, delete_track, get_audio_device])
+        .invoke_handler(tauri::generate_handler![scan_dir, get_cover, stream_file, fetch_lyrics, fetch_ttml, search_tracks, search_albums, search_artists, get_album_tracks, get_artist_albums, download_track, yt_playlist_tracks, rpc_on, rpc_off, rpc_set, rpc_clr, rpc_cover, tray_set, check_ytdlp, install_ytdlp, check_ytdlp_update, check_ffmpeg, install_ffmpeg, sp_save_client_id, sp_load_client_id, sp_authorize, sp_load_tokens, sp_disconnect, sp_fresh_token, sp_playlists, sp_playlist_tracks, sp_liked_tracks, pl_list, pl_create, pl_rename, pl_delete, pl_get, pl_add_track, pl_remove_track, pl_cover, pl_set_cover, pl_favs, pl_fav_toggle, delete_track, get_audio_device, export_account, import_account, import_fill_playlists, lookup_cover])
         .setup(|app| {
             #[cfg(target_os = "linux")]
             {

src-tauri/src/playlists.rs

@@ -14,7 +14,7 @@ pub struct Playlist {
     pub tracks: Vec<String>,
 }
 
-fn pl_dir() -> PathBuf {
+pub(crate) fn pl_dir() -> PathBuf {
     let d = dirs::data_dir()
         .unwrap_or_else(|| dirs::home_dir().unwrap_or_default().join(".local/share"))
         .join("gs-music")
@@ -23,25 +23,25 @@ fn pl_dir() -> PathBuf {
     d
 }
 
-fn pl_path(id: &str) -> PathBuf {
+pub(crate) fn pl_path(id: &str) -> PathBuf {
     pl_dir().join(format!("{id}.json"))
 }
 
-fn read_pl(id: &str) -> Result<Playlist, String> {
+pub(crate) fn read_pl(id: &str) -> Result<Playlist, String> {
     let p = pl_path(id);
     let data = fs::read_to_string(&p).map_err(|e| format!("read: {e}"))?;
     serde_json::from_str(&data).map_err(|e| format!("parse: {e}"))
 }
 
-fn write_pl(pl: &Playlist) -> Result<(), String> {
+pub(crate) fn write_pl(pl: &Playlist) -> Result<(), String> {
     let p = pl_path(&pl.id);
     let data = serde_json::to_string_pretty(pl).map_err(|e| format!("json: {e}"))?;
     fs::write(&p, data).map_err(|e| format!("write: {e}"))
 }
 
-const FAVS_ID: &str = "__favorites";
+pub(crate) const FAVS_ID: &str = "__favorites";
 
-fn ensure_favs() {
+pub(crate) fn ensure_favs() {
     let p = pl_path(FAVS_ID);
     if !p.exists() {
         let pl = Playlist {

src-tauri/tauri.conf.json

@@ -30,6 +30,7 @@
     }
   },
   "bundle": {
+    "targets": [],
     "icon": [
       "icons/32x32.png",
       "icons/64x64.png",

src/pages/discover/onboarding/step_migrate/index.tsx

@@ -12,6 +12,7 @@ import { YtTracksView } from "../views/yt_tracks";
 import { MigratingView } from "../views/migrating";
 import { DoneView } from "../views/done";
 import { HomeView } from "../views/home";
+import { use_account_export, ImportOverlay } from "@/pages/settings/account_export";
 
 type View =
   | "home"
@@ -50,6 +51,7 @@ export function StepMigrate({ on_next }: Props) {
   const [mig_done, set_mig_done] = useState(0);
   const [mig_current, set_mig_current] = useState("");
   const [did_migrate, set_did_migrate] = useState(false);
+  const { import_account: gs_import, import_state } = use_account_export();
 
   const dl_id_ref = useRef(0);
   const batch_ids = useRef<Set<number>>(new Set());
@@ -453,11 +455,21 @@ export function StepMigrate({ on_next }: Props) {
             did_migrate={did_migrate}
             on_spotify={open_spotify}
             on_youtube={() => set_view("yt_input")}
+            on_gs_import={async () => {
+              await gs_import(true);
+              set_did_migrate(true);
+              set_view("done");
+            }}
             on_next={on_next}
           />
         );
     }
   }
 
-  return <div style={box}>{render_view()}</div>;
+  return (
+    <div style={box}>
+      {render_view()}
+      {import_state && <ImportOverlay state={import_state} />}
+    </div>
+  );
 }