1use crate::keri::core::serdering::SadValue;
2use crate::keri::KERIError;
3use indexmap::IndexMap;
4use serde::{Deserialize, Serialize};
5use std::default::Default;
6
7#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
10pub struct StateEERecord {
11 #[serde(default = "default_sequence_number")]
13 pub s: String,
14
15 #[serde(default)]
17 pub d: String,
18
19 #[serde(default)]
21 pub br: Option<Vec<String>>,
22
23 #[serde(default)]
25 pub ba: Option<Vec<String>>,
26}
27
28#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
31pub struct KeyStateRecord {
32 #[serde(default)]
34 pub vn: Vec<u8>,
35
36 #[serde(default)]
38 pub i: String,
39
40 #[serde(default = "default_sequence_number")]
42 pub s: String,
43
44 #[serde(default)]
46 pub p: String,
47
48 #[serde(default)]
50 pub d: String,
51
52 #[serde(default = "default_sequence_number")]
54 pub f: String,
55
56 #[serde(default)]
58 pub dt: String,
59
60 #[serde(default)]
62 pub et: String,
63
64 #[serde(default = "default_threshold")]
66 pub kt: String,
67
68 #[serde(default)]
70 pub k: Vec<String>,
71
72 #[serde(default = "default_threshold")]
74 pub nt: String,
75
76 #[serde(default)]
78 pub n: Vec<String>,
79
80 #[serde(default = "default_threshold")]
82 pub bt: String,
83
84 #[serde(default)]
86 pub b: Vec<String>,
87
88 #[serde(default)]
90 pub c: Vec<String>,
91
92 #[serde(default)]
94 pub ee: StateEERecord,
95
96 #[serde(default)]
98 pub di: String,
99}
100
101impl Default for StateEERecord {
102 fn default() -> Self {
103 StateEERecord {
104 s: "0".to_string(),
105 d: "".to_string(),
106 br: None,
107 ba: None,
108 }
109 }
110}
111
112impl Default for KeyStateRecord {
113 fn default() -> Self {
114 KeyStateRecord {
115 vn: Vec::new(),
116 i: "".to_string(),
117 s: "0".to_string(),
118 p: "".to_string(),
119 d: "".to_string(),
120 f: "0".to_string(),
121 dt: "".to_string(),
122 et: "".to_string(),
123 kt: "0".to_string(),
124 k: Vec::new(),
125 nt: "0".to_string(),
126 n: Vec::new(),
127 bt: "0".to_string(),
128 b: Vec::new(),
129 c: Vec::new(),
130 ee: StateEERecord::default(),
131 di: "".to_string(),
132 }
133 }
134}
135
136fn default_sequence_number() -> String {
138 "0".to_string()
139}
140
141fn default_threshold() -> String {
143 "0".to_string()
144}
145
146impl StateEERecord {
147 pub fn from_state_est_event(event: &StateEstEvent) -> Result<Self, KERIError> {
149 Ok(StateEERecord {
150 s: event.s.clone(),
151 d: event.d.clone(),
152 br: event.br.clone(),
153 ba: event.ba.clone(),
154 })
155 }
156
157 pub fn to_map(&self) -> IndexMap<String, SadValue> {
159 let mut map = IndexMap::new();
160 map.insert("s".to_string(), SadValue::String(self.s.clone()));
161 map.insert("d".to_string(), SadValue::String(self.d.clone()));
162 map.insert(
163 "br".to_string(),
164 SadValue::Array(
165 self.br
166 .clone()
167 .unwrap()
168 .iter()
169 .map(|s| SadValue::String(s.to_string()))
170 .collect(),
171 ),
172 );
173 map.insert(
174 "ba".to_string(),
175 SadValue::Array(
176 self.ba
177 .clone()
178 .unwrap()
179 .iter()
180 .map(|s| SadValue::String(s.to_string()))
181 .collect(),
182 ),
183 );
184
185 map
186 }
187
188 pub fn from_map(map: &IndexMap<String, SadValue>) -> Result<Self, KERIError> {
190 let s = match map.get("s") {
191 Some(SadValue::String(s)) => s.clone(),
192 _ => "0".to_string(),
193 };
194
195 let d = match map.get("d") {
196 Some(SadValue::String(d)) => d.clone(),
197 _ => "".to_string(),
198 };
199
200 let br = match map.get("br") {
201 Some(SadValue::Array(arr)) => {
202 let mut br_vec = Vec::new();
203 for item in arr {
204 if let SadValue::String(s) = item {
205 br_vec.push(s.clone());
206 }
207 }
208 Some(br_vec)
209 }
210 _ => None,
211 };
212
213 let ba = match map.get("ba") {
214 Some(SadValue::Array(arr)) => {
215 let mut ba_vec = Vec::new();
216 for item in arr {
217 if let SadValue::String(s) = item {
218 ba_vec.push(s.clone());
219 }
220 }
221 Some(ba_vec)
222 }
223 _ => None,
224 };
225
226 Ok(StateEERecord { s, d, br, ba })
227 }
228}
229
230impl KeyStateRecord {
231 pub fn to_map(&self) -> IndexMap<String, SadValue> {
233 let mut map = IndexMap::new();
234 map.insert(
235 "vn".to_string(),
236 SadValue::Array(
237 self.vn
238 .iter()
239 .map(|n| SadValue::Number(serde_json::Number::from(*n)))
240 .collect(),
241 ),
242 );
243 map.insert("i".to_string(), SadValue::String(self.i.clone()));
244 map.insert("s".to_string(), SadValue::String(self.s.clone()));
245 map.insert("p".to_string(), SadValue::String(self.p.clone()));
246 map.insert("d".to_string(), SadValue::String(self.d.clone()));
247 map.insert("f".to_string(), SadValue::String(self.f.clone()));
248 map.insert("dt".to_string(), SadValue::String(self.dt.clone()));
249 map.insert("et".to_string(), SadValue::String(self.et.clone()));
250 map.insert("kt".to_string(), SadValue::String(self.kt.clone()));
251 map.insert(
252 "k".to_string(),
253 SadValue::Array(
254 self.k
255 .iter()
256 .map(|s| SadValue::String(s.to_string()))
257 .collect(),
258 ),
259 );
260 map.insert("nt".to_string(), SadValue::String(self.nt.clone()));
261 map.insert(
262 "n".to_string(),
263 SadValue::Array(
264 self.n
265 .iter()
266 .map(|s| SadValue::String(s.to_string()))
267 .collect(),
268 ),
269 );
270 map.insert("bt".to_string(), SadValue::String(self.bt.clone()));
271 map.insert(
272 "b".to_string(),
273 SadValue::Array(
274 self.b
275 .iter()
276 .map(|s| SadValue::String(s.to_string()))
277 .collect(),
278 ),
279 );
280 map.insert(
281 "c".to_string(),
282 SadValue::Array(
283 self.c
284 .iter()
285 .map(|s| SadValue::String(s.to_string()))
286 .collect(),
287 ),
288 );
289 map.insert("ee".to_string(), SadValue::Object(self.ee.to_map()));
290 map.insert("di".to_string(), SadValue::String(self.di.clone()));
291
292 map
293 }
294
295 pub fn from_map(map: &IndexMap<String, SadValue>) -> Result<Self, KERIError> {
297 let vn = match map.get("vn") {
298 Some(SadValue::Array(arr)) => {
299 let mut vn_vec = Vec::new();
300 for item in arr {
301 if let SadValue::Number(n) = item {
302 if let Some(n) = n.as_u64() {
303 vn_vec.push(n as u8);
304 }
305 }
306 }
307 vn_vec
308 }
309 _ => Vec::new(),
310 };
311
312 let i = match map.get("i") {
313 Some(SadValue::String(i)) => i.clone(),
314 _ => "".to_string(),
315 };
316
317 let s = match map.get("s") {
318 Some(SadValue::String(s)) => s.clone(),
319 _ => "0".to_string(),
320 };
321
322 let p = match map.get("p") {
323 Some(SadValue::String(p)) => p.clone(),
324 _ => "".to_string(),
325 };
326
327 let d = match map.get("d") {
328 Some(SadValue::String(d)) => d.clone(),
329 _ => "".to_string(),
330 };
331
332 let f = match map.get("f") {
333 Some(SadValue::String(f)) => f.clone(),
334 _ => "0".to_string(),
335 };
336
337 let dt = match map.get("dt") {
338 Some(SadValue::String(dt)) => dt.clone(),
339 _ => "".to_string(),
340 };
341
342 let et = match map.get("et") {
343 Some(SadValue::String(et)) => et.clone(),
344 _ => "".to_string(),
345 };
346
347 let kt = match map.get("kt") {
348 Some(SadValue::String(kt)) => kt.clone(),
349 _ => "0".to_string(),
350 };
351
352 let k = match map.get("k") {
353 Some(SadValue::Array(arr)) => {
354 let mut k_vec = Vec::new();
355 for item in arr {
356 if let SadValue::String(s) = item {
357 k_vec.push(s.clone());
358 }
359 }
360 k_vec
361 }
362 _ => Vec::new(),
363 };
364
365 let nt = match map.get("nt") {
366 Some(SadValue::String(nt)) => nt.clone(),
367 _ => "0".to_string(),
368 };
369
370 let n = match map.get("n") {
371 Some(SadValue::Array(arr)) => {
372 let mut n_vec = Vec::new();
373 for item in arr {
374 if let SadValue::String(s) = item {
375 n_vec.push(s.clone());
376 }
377 }
378 n_vec
379 }
380 _ => Vec::new(),
381 };
382
383 let bt = match map.get("bt") {
384 Some(SadValue::String(bt)) => bt.clone(),
385 _ => "0".to_string(),
386 };
387
388 let b = match map.get("b") {
389 Some(SadValue::Array(arr)) => {
390 let mut b_vec = Vec::new();
391 for item in arr {
392 if let SadValue::String(s) = item {
393 b_vec.push(s.clone());
394 }
395 }
396 b_vec
397 }
398 _ => Vec::new(),
399 };
400
401 let c = match map.get("c") {
402 Some(SadValue::Array(arr)) => {
403 let mut c_vec = Vec::new();
404 for item in arr {
405 if let SadValue::String(s) = item {
406 c_vec.push(s.clone());
407 }
408 }
409 c_vec
410 }
411 _ => Vec::new(),
412 };
413
414 let ee = match map.get("ee") {
415 Some(SadValue::Object(obj)) => {
416 let ee_map: IndexMap<String, SadValue> =
417 obj.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
418 StateEERecord::from_map(&ee_map)?
419 }
420 _ => StateEERecord::default(),
421 };
422
423 let di = match map.get("di") {
424 Some(SadValue::String(di)) => di.clone(),
425 _ => "".to_string(),
426 };
427
428 Ok(KeyStateRecord {
429 vn,
430 i,
431 s,
432 p,
433 d,
434 f,
435 dt,
436 et,
437 kt,
438 k,
439 nt,
440 n,
441 bt,
442 b,
443 c,
444 ee,
445 di,
446 })
447 }
448}
449
450#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
452pub struct StateEstEvent {
453 pub s: String,
455
456 pub d: String,
458
459 #[serde(default)]
461 pub br: Option<Vec<String>>,
462
463 #[serde(default)]
465 pub ba: Option<Vec<String>>,
466}
467
468impl Default for StateEstEvent {
469 fn default() -> Self {
470 StateEstEvent {
471 s: "0".to_string(),
472 d: "".to_string(),
473 br: None,
474 ba: None,
475 }
476 }
477}