dialtone_common 0.1.0

Dialtone Common Code
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::rest::sites::theme::Theme;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;

#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub struct SiteInfo {
    pub host_name: String,
    pub site_data: SiteData,
    pub created_at: DateTime<Utc>,
    pub modified_at: DateTime<Utc>,
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub struct SiteData {
    pub public: PublicSiteInfo,
    pub simple_code_for_registration: Option<String>,
    pub auto_approved_registrations: Vec<RegistrationMethod>,
}

impl Default for SiteData {
    fn default() -> Self {
        Self {
            public: Default::default(),
            simple_code_for_registration: None,
            auto_approved_registrations: vec![],
        }
    }
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub struct PublicSiteInfo {
    pub names: SiteNames,
    pub client_defaults: ClientDefaults,
    pub registration_methods: Vec<RegistrationMethod>,
}

impl Default for PublicSiteInfo {
    fn default() -> Self {
        Self {
            names: Default::default(),
            client_defaults: Default::default(),
            registration_methods: vec![],
        }
    }
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub enum RegistrationMethod {
    OpenRegistration,
    SimpleCode,
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub struct SiteNames {
    pub short_name: String,
    pub long_name: String,
}

impl Default for SiteNames {
    fn default() -> Self {
        Self {
            short_name: Default::default(),
            long_name: Default::default(),
        }
    }
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub struct ClientDefaults {
    pub dialtone_webclient: DialtoneWebClient,
    #[serde(flatten)]
    pub other_clients: HashMap<String, Value>,
}

impl Default for ClientDefaults {
    fn default() -> Self {
        Self {
            dialtone_webclient: Default::default(),
            other_clients: Default::default(),
        }
    }
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
pub struct DialtoneWebClient {
    pub default_theme: Theme,
}

impl Default for DialtoneWebClient {
    fn default() -> Self {
        Self {
            default_theme: Theme::GreenOnBlack,
        }
    }
}

#[cfg(test)]
mod site_data_tests {
    use serde_json::Error;

    use super::*;

    #[test]
    #[allow(non_snake_case)]
    fn GIVEN_json_for_client_defaults_WHEN_parsed_THEN_default_theme_is_correct() {
        let input = r#"
            {
                "dialtone_webclient": 
                {
                    "default_theme": "green on black"
                }
            }
        "#;

        let json: Result<ClientDefaults, Error> = serde_json::from_str(input);

        let output = json.expect("parsing client defaults");
        assert_eq!(output.dialtone_webclient.default_theme, Theme::GreenOnBlack);
    }

    #[test]
    #[allow(non_snake_case)]
    fn GIVEN_json_for_client_defaults_with_unknown_client_WHEN_parsed_THEN_unknown_default_is_parsed(
    ) {
        let input = r#"
            {
                "dialtone_webclient": 
                {
                    "default_theme": "green on black"
                },
                "foo_client": {
                    "bar": true
                }
            }
        "#;

        let json: Result<ClientDefaults, Error> = serde_json::from_str(input);

        let output = json.expect("parsing client defaults");
        assert_eq!(output.dialtone_webclient.default_theme, Theme::GreenOnBlack);
        output
            .other_clients
            .get("foo_client")
            .expect("foo client not in hashmap");
    }
}