kftray_commons/models/
settings_model.rs

1use serde::{
2    Deserialize,
3    Serialize,
4};
5
6#[derive(Clone, Deserialize, Serialize, Debug)]
7pub struct AppSettings {
8    #[serde(default)]
9    pub disconnect_timeout_minutes: u32,
10
11    #[serde(default = "default_network_monitor")]
12    pub network_monitor: bool,
13
14    #[serde(default)]
15    pub http_logs_default_enabled: bool,
16
17    #[serde(default = "default_http_logs_max_file_size")]
18    pub http_logs_max_file_size: u64,
19
20    #[serde(default = "default_http_logs_retention_days")]
21    pub http_logs_retention_days: u64,
22
23    #[serde(default = "default_auto_update_enabled")]
24    pub auto_update_enabled: bool,
25
26    #[serde(default)]
27    pub last_update_check: Option<i64>,
28
29    #[serde(default)]
30    pub ssl_enabled: bool,
31
32    #[serde(default = "default_cert_validity")]
33    pub ssl_cert_validity_days: u16,
34
35    #[serde(default = "default_ssl_auto_regenerate")]
36    pub ssl_auto_regenerate: bool,
37
38    #[serde(default)]
39    pub ssl_ca_auto_install: bool,
40
41    #[serde(default = "default_global_shortcut")]
42    pub global_shortcut: String,
43
44    #[serde(default)]
45    pub mcp_server_enabled: bool,
46
47    #[serde(default = "default_mcp_server_port")]
48    pub mcp_server_port: u16,
49}
50
51fn default_network_monitor() -> bool {
52    true
53}
54
55fn default_http_logs_max_file_size() -> u64 {
56    10 * 1024 * 1024 // 10MB
57}
58
59fn default_http_logs_retention_days() -> u64 {
60    7
61}
62
63fn default_auto_update_enabled() -> bool {
64    true
65}
66
67fn default_cert_validity() -> u16 {
68    365
69}
70
71fn default_ssl_auto_regenerate() -> bool {
72    true
73}
74
75fn default_global_shortcut() -> String {
76    #[cfg(target_os = "macos")]
77    return "Cmd+Shift+F1".to_string();
78    #[cfg(not(target_os = "macos"))]
79    return "Ctrl+Shift+F1".to_string();
80}
81
82fn default_mcp_server_port() -> u16 {
83    3000
84}
85
86impl Default for AppSettings {
87    fn default() -> Self {
88        Self {
89            disconnect_timeout_minutes: 0,
90            network_monitor: default_network_monitor(),
91            http_logs_default_enabled: false,
92            http_logs_max_file_size: default_http_logs_max_file_size(),
93            http_logs_retention_days: default_http_logs_retention_days(),
94            auto_update_enabled: default_auto_update_enabled(),
95            last_update_check: None,
96            ssl_enabled: false,
97            ssl_cert_validity_days: default_cert_validity(),
98            ssl_auto_regenerate: default_ssl_auto_regenerate(),
99            ssl_ca_auto_install: false,
100            global_shortcut: default_global_shortcut(),
101            mcp_server_enabled: false,
102            mcp_server_port: default_mcp_server_port(),
103        }
104    }
105}
106
107impl AppSettings {
108    pub fn from_settings_manager(settings: &std::collections::HashMap<String, String>) -> Self {
109        let mut app_settings = AppSettings::default();
110
111        if let Some(value) = settings.get("disconnect_timeout_minutes") {
112            app_settings.disconnect_timeout_minutes = value.parse().unwrap_or(0);
113        }
114
115        if let Some(value) = settings.get("network_monitor") {
116            app_settings.network_monitor = value.parse().unwrap_or(true);
117        }
118
119        if let Some(value) = settings.get("http_logs_default_enabled") {
120            app_settings.http_logs_default_enabled = value.parse().unwrap_or(false);
121        }
122
123        if let Some(value) = settings.get("http_logs_max_file_size") {
124            app_settings.http_logs_max_file_size = value.parse().unwrap_or(10 * 1024 * 1024);
125        }
126
127        if let Some(value) = settings.get("http_logs_retention_days") {
128            app_settings.http_logs_retention_days = value.parse().unwrap_or(7);
129        }
130
131        if let Some(value) = settings.get("auto_update_enabled") {
132            app_settings.auto_update_enabled = value.parse().unwrap_or(true);
133        }
134
135        if let Some(value) = settings.get("last_update_check") {
136            app_settings.last_update_check = value.parse().ok();
137        }
138
139        if let Some(value) = settings.get("ssl_enabled") {
140            app_settings.ssl_enabled = value.parse().unwrap_or(false);
141        }
142
143        if let Some(value) = settings.get("ssl_cert_validity_days") {
144            app_settings.ssl_cert_validity_days = value.parse().unwrap_or(365);
145        }
146
147        if let Some(value) = settings.get("ssl_auto_regenerate") {
148            app_settings.ssl_auto_regenerate = value.parse().unwrap_or(true);
149        }
150
151        if let Some(value) = settings.get("ssl_ca_auto_install") {
152            app_settings.ssl_ca_auto_install = value.parse().unwrap_or(false);
153        }
154
155        if let Some(value) = settings.get("global_shortcut") {
156            app_settings.global_shortcut = value.clone();
157        }
158
159        if let Some(value) = settings.get("mcp_server_enabled") {
160            app_settings.mcp_server_enabled = value.parse().unwrap_or(false);
161        }
162
163        if let Some(value) = settings.get("mcp_server_port") {
164            app_settings.mcp_server_port = value.parse().unwrap_or(3000);
165        }
166
167        app_settings
168    }
169
170    pub fn to_settings_map(&self) -> std::collections::HashMap<String, String> {
171        let mut settings = std::collections::HashMap::new();
172
173        settings.insert(
174            "disconnect_timeout_minutes".to_string(),
175            self.disconnect_timeout_minutes.to_string(),
176        );
177        settings.insert(
178            "network_monitor".to_string(),
179            self.network_monitor.to_string(),
180        );
181        settings.insert(
182            "http_logs_default_enabled".to_string(),
183            self.http_logs_default_enabled.to_string(),
184        );
185        settings.insert(
186            "http_logs_max_file_size".to_string(),
187            self.http_logs_max_file_size.to_string(),
188        );
189        settings.insert(
190            "http_logs_retention_days".to_string(),
191            self.http_logs_retention_days.to_string(),
192        );
193        settings.insert(
194            "auto_update_enabled".to_string(),
195            self.auto_update_enabled.to_string(),
196        );
197
198        if let Some(timestamp) = self.last_update_check {
199            settings.insert("last_update_check".to_string(), timestamp.to_string());
200        }
201
202        settings.insert("ssl_enabled".to_string(), self.ssl_enabled.to_string());
203        settings.insert(
204            "ssl_cert_validity_days".to_string(),
205            self.ssl_cert_validity_days.to_string(),
206        );
207        settings.insert(
208            "ssl_auto_regenerate".to_string(),
209            self.ssl_auto_regenerate.to_string(),
210        );
211        settings.insert(
212            "ssl_ca_auto_install".to_string(),
213            self.ssl_ca_auto_install.to_string(),
214        );
215        settings.insert("global_shortcut".to_string(), self.global_shortcut.clone());
216        settings.insert(
217            "mcp_server_enabled".to_string(),
218            self.mcp_server_enabled.to_string(),
219        );
220        settings.insert(
221            "mcp_server_port".to_string(),
222            self.mcp_server_port.to_string(),
223        );
224
225        settings
226    }
227}
228
229#[cfg(test)]
230mod tests {
231    use std::collections::HashMap;
232
233    use super::*;
234
235    #[test]
236    fn test_default_app_settings() {
237        let settings = AppSettings::default();
238        assert_eq!(settings.disconnect_timeout_minutes, 0);
239        assert!(settings.network_monitor);
240        assert!(!settings.http_logs_default_enabled);
241        assert_eq!(settings.http_logs_max_file_size, 10 * 1024 * 1024);
242        assert_eq!(settings.http_logs_retention_days, 7);
243        assert!(settings.auto_update_enabled);
244        assert!(settings.last_update_check.is_none());
245        assert!(!settings.ssl_enabled);
246        assert_eq!(settings.ssl_cert_validity_days, 365);
247        assert!(settings.ssl_auto_regenerate);
248    }
249
250    #[test]
251    fn test_from_settings_manager() {
252        let mut settings_map = HashMap::new();
253        settings_map.insert("ssl_enabled".to_string(), "true".to_string());
254        settings_map.insert("ssl_cert_validity_days".to_string(), "180".to_string());
255        settings_map.insert("ssl_auto_regenerate".to_string(), "false".to_string());
256        settings_map.insert("network_monitor".to_string(), "false".to_string());
257
258        let app_settings = AppSettings::from_settings_manager(&settings_map);
259
260        assert!(app_settings.ssl_enabled);
261        assert_eq!(app_settings.ssl_cert_validity_days, 180);
262        assert!(!app_settings.ssl_auto_regenerate);
263        assert!(!app_settings.network_monitor);
264    }
265
266    #[test]
267    fn test_to_settings_map() {
268        let app_settings = AppSettings {
269            ssl_enabled: true,
270            ssl_cert_validity_days: 180,
271            ssl_auto_regenerate: false,
272            ..Default::default()
273        };
274
275        let settings_map = app_settings.to_settings_map();
276
277        assert_eq!(settings_map.get("ssl_enabled"), Some(&"true".to_string()));
278        assert_eq!(
279            settings_map.get("ssl_cert_validity_days"),
280            Some(&"180".to_string())
281        );
282        assert_eq!(
283            settings_map.get("ssl_auto_regenerate"),
284            Some(&"false".to_string())
285        );
286    }
287}
kftray_commons/models/settings_model.rs

kftray_commons/models/
settings_model.rs
