kopuz-hooks 0.7.0

A modern, lightweight music player built with Rust and Dioxus.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! The debug-only "Database (debug)" settings panel. Lives here (the query
//! layer, which already depends on `db`) rather than in `pages`, so `pages` can
//! drop its `db` dependency entirely and lose the ability to name the
//! write-capable `db::Db`. Compiled to an empty element off the native debug
//! build.

use dioxus::prelude::*;

#[cfg(all(
    debug_assertions,
    not(any(target_arch = "wasm32", target_os = "android"))
))]
pub fn debug_db_section() -> Element {
    let db = use_context::<db::Db>();
    let gens = crate::db_reactivity::use_generations();
    let mut status = use_signal(String::new);

    let bump_all = move || {
        use crate::db_reactivity::Table;
        for t in [
            Table::Tracks,
            Table::Albums,
            Table::Playlists,
            Table::Favorites,
            Table::Folders,
            Table::Servers,
        ] {
            gens.bump(t);
        }
    };

    let db_reset = db.clone();
    let db_release = db.clone();
    let db_seed = db.clone();
    let db_import = db.clone();
    let db_vacuum = db.clone();
    let db_info = db.clone();

    rsx! {
        section {
            h2 {
                class: "text-lg font-semibold text-white/80 mb-4 border-b border-white/5 pb-2",
                "Database (debug)"
            }
            p { class: "text-xs text-white/40 mb-3",
                "Operates on the debug DB ({db::default_db_path().display()}) — never your release data."
            }
            div { class: "flex flex-wrap gap-3",
                button {
                    class: "px-4 py-2 rounded-lg bg-red-500/20 hover:bg-red-500/30 text-red-300 text-sm transition-colors",
                    onclick: move |_| {
                        let db = db_reset.clone();
                        spawn(async move {
                            match db.debug_reset(&db::default_db_path()).await {
                                Ok(()) => status.set("DB reset to empty schema".into()),
                                Err(e) => status.set(format!("reset failed: {e}")),
                            }
                            bump_all();
                        });
                    },
                    "Reset DB"
                }
                button {
                    class: "px-4 py-2 rounded-lg bg-white/10 hover:bg-white/20 text-white text-sm transition-colors",
                    onclick: move |_| {
                        let db = db_release.clone();
                        spawn(async move {
                            match db.debug_load_release(&db::release_db_path(), &db::default_db_path()).await {
                                Ok(()) => status.set("release DB copied in + migrated".into()),
                                Err(e) => status.set(format!("load release failed: {e}")),
                            }
                            bump_all();
                        });
                    },
                    "Load release DB"
                }
                button {
                    class: "px-4 py-2 rounded-lg bg-white/10 hover:bg-white/20 text-white text-sm transition-colors",
                    onclick: move |_| {
                        let db = db_import.clone();
                        spawn(async move {
                            match db.import_legacy_json(&db::config_dir()).await {
                                Ok(r) if r.ran => status.set(format!(
                                    "imported: {} tracks, {} albums, {} playlists, {} favorites",
                                    r.tracks, r.albums, r.playlists, r.favorites
                                )),
                                Ok(_) => status.set("import skipped (DB not empty)".into()),
                                Err(e) => status.set(format!("import failed: {e}")),
                            }
                            bump_all();
                        });
                    },
                    "Re-run JSON import"
                }
                button {
                    class: "px-4 py-2 rounded-lg bg-white/10 hover:bg-white/20 text-white text-sm transition-colors",
                    onclick: move |_| {
                        let db = db_seed.clone();
                        spawn(async move {
                            match db.debug_seed_synthetic(20_000).await {
                                Ok(()) => status.set("seeded 20k synthetic tracks".into()),
                                Err(e) => status.set(format!("seed failed: {e}")),
                            }
                            bump_all();
                        });
                    },
                    "Seed 20k tracks"
                }
                button {
                    class: "px-4 py-2 rounded-lg bg-white/10 hover:bg-white/20 text-white text-sm transition-colors",
                    onclick: move |_| {
                        let db = db_vacuum.clone();
                        spawn(async move {
                            match db.debug_vacuum().await {
                                Ok(()) => status.set("VACUUM done".into()),
                                Err(e) => status.set(format!("vacuum failed: {e}")),
                            }
                        });
                    },
                    "Vacuum"
                }
                button {
                    class: "px-4 py-2 rounded-lg bg-white/10 hover:bg-white/20 text-white text-sm transition-colors",
                    onclick: move |_| {
                        let db = db_info.clone();
                        spawn(async move {
                            match db.debug_info().await {
                                Ok(info) => status.set(info),
                                Err(e) => status.set(format!("info failed: {e}")),
                            }
                        });
                    },
                    "Schema info"
                }
            }
            if !status.read().is_empty() {
                pre { class: "text-xs text-white/60 mt-3 whitespace-pre-wrap", "{status}" }
            }
        }
    }
}

#[cfg(not(all(
    debug_assertions,
    not(any(target_arch = "wasm32", target_os = "android"))
)))]
pub fn debug_db_section() -> Element {
    rsx! {}
}