threexui-rs 2.9.3

Async Rust SDK for the 3x-ui panel API (targets 3x-ui v2.9.3)
Documentation 
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

use crate::models::settings::AllSetting;
use crate::{Client, Result};

pub struct SettingsApi<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> SettingsApi<'a> {
    pub async fn get_all(&self) -> Result<AllSetting> {
        self.client
            .post("panel/setting/all", &serde_json::json!({}))
            .await
    }

    pub async fn get_defaults(&self) -> Result<serde_json::Value> {
        self.client
            .post("panel/setting/defaultSettings", &serde_json::json!({}))
            .await
    }

    pub async fn update(&self, settings: &AllSetting) -> Result<()> {
        self.client
            .post_empty("panel/setting/update", settings)
            .await
    }

    pub async fn update_user(
        &self,
        old_username: &str,
        old_password: &str,
        new_username: &str,
        new_password: &str,
    ) -> Result<()> {
        let body = serde_json::json!({
            "oldUsername": old_username,
            "oldPassword": old_password,
            "newUsername": new_username,
            "newPassword": new_password,
        });
        self.client
            .post_empty("panel/setting/updateUser", &body)
            .await
    }

    pub async fn restart_panel(&self) -> Result<()> {
        self.client
            .post_empty("panel/setting/restartPanel", &serde_json::json!({}))
            .await
    }

    pub async fn default_xray_config(&self) -> Result<serde_json::Value> {
        self.client.get("panel/setting/getDefaultJsonConfig").await
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::ClientConfig;
    use wiremock::matchers::{method, path};
    use wiremock::{Mock, MockServer, ResponseTemplate};

    async fn auth_client(server: &MockServer) -> Client {
        Mock::given(method("POST"))
            .and(path("/login"))
            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
                "success": true, "msg": "", "obj": null
            })))
            .mount(server)
            .await;
        let config = ClientConfig::builder()
            .host("127.0.0.1")
            .port(server.address().port())
            .build()
            .unwrap();
        let client = Client::new(config);
        client.login("admin", "pass").await.unwrap();
        client
    }

    #[tokio::test]
    async fn get_all_returns_settings() {
        let server = MockServer::start().await;
        Mock::given(method("POST"))
            .and(path("/panel/setting/all"))
            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
                "success": true, "msg": "", "obj": {"webPort": 2053, "tgBotEnable": false}
            })))
            .mount(&server)
            .await;

        let client = auth_client(&server).await;
        let settings = client.settings().get_all().await.unwrap();
        assert_eq!(settings.web_port, 2053);
    }

    #[tokio::test]
    async fn update_user_succeeds() {
        let server = MockServer::start().await;
        Mock::given(method("POST"))
            .and(path("/panel/setting/updateUser"))
            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
                "success": true, "msg": "updated", "obj": null
            })))
            .mount(&server)
            .await;

        let client = auth_client(&server).await;
        client
            .settings()
            .update_user("admin", "old", "admin", "new123")
            .await
            .unwrap();
    }
}