rustploy-gui 0.1.0

Rustploy — desktop client (glacier-ui) for the Rustploy PaaS daemon
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

//! Os servidores que o usuário já usou nesta máquina.

use std::path::PathBuf;

use serde_json::Value;

/// Um servidor conhecido.
pub(super) struct Saved {
    pub url: String,
    pub token: Option<String>,
}

/// Arquivo do `storage` do glacier para a janela principal.
fn storage_path() -> PathBuf {
    shared::fallback_data_dir()
        .join(".glacier-storage")
        .join("app.json")
}

/// Lê a lista salva.
pub(super) fn list() -> Vec<Saved> {
    let Ok(texto) = std::fs::read_to_string(storage_path()) else {
        return Vec::new();
    };
    let Ok(doc) = serde_json::from_str::<Value>(&texto) else {
        return Vec::new();
    };

    doc.get("saved_servers")
        .and_then(Value::as_array)
        .map(|itens| {
            itens
                .iter()
                .filter_map(|s| {
                    let url = s.get("url")?.as_str()?.trim();
                    if url.is_empty() {
                        return None;
                    }
                    Some(Saved {
                        url: url.to_string(),
                        token: s
                            .get("token")
                            .and_then(Value::as_str)
                            .map(str::trim)
                            .filter(|t| !t.is_empty())
                            .map(str::to_owned),
                    })
                })
                .collect()
        })
        .unwrap_or_default()
}

/// Token salvo para uma URL, comparando de forma tolerante à barra final — a
/// mesma normalização que a sessão faz, para "https://x.dev/" e "https://x.dev"
/// não virarem servidores diferentes.
pub(super) fn token_for(url: &str) -> Option<String> {
    let alvo = url.trim().trim_end_matches('/');
    list()
        .into_iter()
        .find(|s| s.url.trim_end_matches('/') == alvo)
        .and_then(|s| s.token)
}

/// A listagem que sai pela API: URL e se há token guardado — nunca o token.
pub(super) fn as_json() -> Value {
    let itens: Vec<Value> = list()
        .into_iter()
        .map(|s| {
            serde_json::json!({
                "url": s.url,
                "has_saved_token": s.token.is_some(),
            })
        })
        .collect();

    serde_json::json!({ "count": itens.len(), "servers": itens })
}