tnnl 0.1.17

tnnl gives you full control over whether and when your IoT devices should be reachable from the internet
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

use serde::{Deserialize, Serialize};
use serde_json::{Map, Number, Value};
use uuid::Uuid;

use crate::{apperror::AppError, session::LoginInfo};

#[derive(Serialize, Deserialize, Debug)]
pub struct Command {
    #[serde(rename = "commandId")]
    pub command_id: u32,
    #[serde(rename = "command")]
    pub command: String,
    #[serde(rename = "data")]
    pub data: Value,
}

pub struct CommandWithoutId {
    pub command: String,
    pub data: Value,
}

impl Command {
    pub fn to_json_buffer(&self) -> Result<Vec<u8>, AppError> {
        serde_json::to_vec(self).map_err(|_| AppError::new("serialization failed"))
    }
}

impl CommandWithoutId {
    pub fn to_command(self: CommandWithoutId, command_id: u32) -> Command {
        Command {
            command: self.command,
            data: self.data,
            command_id,
        }
    }

    pub fn create_send_info(
        login_info: LoginInfo,
        client: String,
        protocol_version: u32,
    ) -> CommandWithoutId {
        let mut data = Map::new();

        let client_id = login_info
            .client_id
            .unwrap_or_else(|| Uuid::new_v4().to_string());
        let client_name = login_info
            .client_name
            .unwrap_or_else(|| "rust-client".to_string());

        data.insert("name".to_string(), Value::String(client_name));
        data.insert("id".to_string(), Value::String(client_id));
        data.insert("token".to_string(), Value::String(login_info.token));
        if let Some(mac) = login_info.mac {
            data.insert("mac".to_string(), Value::String(mac));
        }
        data.insert("client".to_string(), Value::String(client));
        data.insert(
            "protocolVersion".to_string(),
            Value::Number(Number::from(protocol_version)),
        );

        if let Some(package_version) = option_env!("CARGO_PKG_VERSION") {
            data.insert(
                "packageVersion".to_string(),
                Value::String(package_version.to_string()),
            );
        }
        if let Some(package_name) = option_env!("CARGO_PKG_NAME") {
            data.insert(
                "packageName".to_string(),
                Value::String(package_name.to_string()),
            );
        }

        CommandWithoutId {
            command: "info".to_string(),
            data: serde_json::Value::Object(data),
        }
    }

    pub fn create_post_upload(data: Map<String, Value>) -> CommandWithoutId {
        CommandWithoutId {
            command: "postUpload".to_string(),
            data: serde_json::Value::Object(data),
        }
    }

    pub fn create_get_download() -> CommandWithoutId {
        let data = Map::new();
        CommandWithoutId {
            command: "getDownload".to_string(),
            data: serde_json::Value::Object(data),
        }
    }

    pub fn create_get_site_info() -> CommandWithoutId {
        let data = Map::new();
        CommandWithoutId {
            command: "getSiteInfo".to_string(),
            data: serde_json::Value::Object(data),
        }
    }
}