new-home-application 0.1.3

New Home iot application framework. Meant to build application for the New Home Core
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
116
117
118
119
120
121
122
123
124
125

use serde_json::{Map, Value};

use crate::method::method_structure::MethodResult;

/// Implements the response formatter for json values
pub struct JsonResponseFormatter {
    response: Vec<Value>,
}

/// The Response formatter is meant to create a `Value` (mainly) for the `MethodResponse` struct
/// It collects all possible response data types
/// These types are meant for displaying by other applications
pub trait ResponseFormatter {
    /// Clears the response buffer
    fn clear(&mut self);

    /// Gets the response buffer as an `serde_json::Value`
    fn get_value(&self) -> Value;

    /// Adds an error formatted section to the internal buffer
    fn add_error(&mut self, message: &String);

    /// Adds an info formatted section to the internal buffer
    fn add_info(&mut self, message: &String);

    /// Adds a debug formatted section to the internal buffer
    fn add_debug(&mut self, message: &String);

    /// Adds a success formatted section to the internal buffer
    fn add_success(&mut self, message: &String);

    /// Adds a markdown formatted section to the internal buffer
    fn add_markdown(&mut self, message: &String);

    /// Adds a list formatted section to the internal buffer
    fn add_list(&mut self, items: Vec<Value>);

    /// Adds a table formatted section to the internal buffer
    fn add_table(&mut self, items: Map<String, Value>);
}

impl JsonResponseFormatter {
    /// Creates a new JSON formatter with an empty buffer
    pub fn new() -> Self {
        Self {
            response: vec![]
        }
    }

    /// Creates a basic `MethodResult` which contains the content with the error
    pub fn error(message: &String) -> MethodResult {
        let mut formatter = Self::new();
        formatter.add_error(message);

        formatter.as_result(1)
    }

    /// Creates a basic `MethodResult` which contains the wrapped items object
    pub fn table(items: Map<String, Value>) -> MethodResult {
        let mut formatter = Self::new();
        formatter.add_table(items);

        formatter.as_result(1)
    }

    /// Returns the buffer as a `MethodResult` with the given code
    pub fn as_result(&self, code: i8) -> MethodResult {
        MethodResult {
            code,
            message: Some(self.get_value()),
        }
    }

    fn get_named_value(&self, name: &str, value: &Value) -> Value {
        let mut map = Map::new();

        map.insert(String::from(name.clone()), value.clone());

        Value::from(map)
    }
}

impl ResponseFormatter for JsonResponseFormatter {
    fn clear(&mut self) {
        self.response.clear();
    }

    fn get_value(&self) -> Value {
        Value::from(self.response.clone())
    }

    fn add_error(&mut self, message: &String) {
        self.response.push(self.get_named_value("error", &Value::from(message.clone())));
    }

    fn add_info(&mut self, message: &String) {
        self.response.push(self.get_named_value("info", &Value::from(message.clone())));
    }

    fn add_debug(&mut self, message: &String) {
        self.response.push(self.get_named_value("debug", &Value::from(message.clone())));
    }

    fn add_success(&mut self, message: &String) {
        self.response.push(self.get_named_value("success", &Value::from(message.clone())));
    }

    fn add_markdown(&mut self, message: &String) {
        self.response.push(self.get_named_value("markdown", &Value::from(message.clone())));
    }

    fn add_list(&mut self, items: Vec<Value>) {
        self.response.push(self.get_named_value(
            "list",
            &Value::from(items),
        ))
    }

    fn add_table(&mut self, items: Map<String, Value>) {
        self.response.push(self.get_named_value(
            "table",
            &Value::from(items),
        ))
    }
}