cal_core/
shared.rs

1use std::fmt::{Debug, Formatter};
2use std::collections::BTreeMap;
3use bson::DateTime;
4use serde::{Deserialize, Deserializer, Serialize};
5use serde_json::Value;
6
7#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
8#[serde(rename_all = "camelCase")]
9pub struct RecordReference {
10    #[serde(deserialize_with = "object_id_as_string", rename = "_id")]
11    pub id: String,
12    pub name: String,
13    #[serde(default)]
14    pub meta: BTreeMap<String, String>,
15}
16
17impl RecordReference {
18    /// Create a new RecordReference with empty metadata
19    pub fn new(id: String, name: String) -> Self {
20        Self {
21            id,
22            name,
23            meta: BTreeMap::new(),
24        }
25    }
26
27    /// Create a new RecordReference with metadata
28    pub fn with_meta(id: String, name: String, meta: BTreeMap<String, String>) -> Self {
29        Self { id, name, meta }
30    }
31
32    /// Create from a HashMap (for compatibility)
33    pub fn with_meta_from_hashmap(id: String, name: String, meta: std::collections::HashMap<String, String>) -> Self {
34        Self {
35            id,
36            name,
37            meta: meta.into_iter().collect()
38        }
39    }
40
41    /// Convenience methods matching Java API
42    pub fn id(&self) -> &str {
43        &self.id
44    }
45
46    pub fn name(&self) -> &str {
47        &self.name
48    }
49}
50
51pub fn from_str<'de, D>(deserializer: D) -> Result<u16, D::Error>
52where
53    D: Deserializer<'de>,
54{
55    let value = Value::deserialize(deserializer)?;
56    if value.is_string() {
57        Ok(value.as_str().unwrap().parse().unwrap())
58    } else if value.is_u64() {
59        Ok(value.as_u64().unwrap() as u16)
60    } else if value.is_i64() {
61        Ok(value.as_i64().unwrap() as u16)
62    } else {
63        Err(serde::de::Error::custom("Cannot map extension to u16"))
64    }
65}
66
67pub fn object_id_as_string<'de, D>(deserializer: D) -> Result<String, D::Error>
68where
69    D: Deserializer<'de>,
70{
71    let value = Value::deserialize(deserializer)?;
72    if value.is_string() {
73        Ok(value.as_str().unwrap().to_string())
74    } else {
75        match value.get("$oid") {
76            Some(v) => Ok(v.as_str().unwrap().to_string()),
77            None => Err(serde::de::Error::custom("Oid is required")),
78        }
79    }
80}
81
82pub fn build_timestamp() -> DateTime {
83    DateTime::now()
84}
85
86pub fn build_id() -> String {
87    bson::uuid::Uuid::new().to_string()
88}
89
90impl Debug for RecordReference {
91    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
92        f.debug_struct("RecordReference")
93            .field("id", &self.id)
94            .field("name", &self.name)
95            .field("meta", &self.meta)
96            .finish()
97    }
98}