kanidmd_lib/valueset/
datetime.rs

Help
1use crate::prelude::*;
2use crate::schema::SchemaAttribute;
3use crate::valueset::{
4    DbValueSetV2, ScimResolveStatus, ValueSet, ValueSetResolveStatus, ValueSetScimPut,
5};
6use kanidm_proto::scim_v1::{client::ScimDateTime, JsonValue};
7use smolset::SmolSet;
8use time::OffsetDateTime;
9
10#[derive(Debug, Clone)]
11pub struct ValueSetDateTime {
12    set: SmolSet<[OffsetDateTime; 1]>,
13}
14
15impl ValueSetDateTime {
16    pub fn new(b: OffsetDateTime) -> Box<Self> {
17        let mut set = SmolSet::new();
18        set.insert(b);
19        Box::new(ValueSetDateTime { set })
20    }
21
22    pub fn push(&mut self, b: OffsetDateTime) -> bool {
23        self.set.insert(b)
24    }
25
26    pub fn from_dbvs2(data: Vec<String>) -> Result<ValueSet, OperationError> {
27        let set = data
28            .into_iter()
29            .map(|s| {
30                OffsetDateTime::parse(&s, &Rfc3339)
31                    .map(|odt| odt.to_offset(time::UtcOffset::UTC))
32                    .map_err(|_| OperationError::InvalidValueState)
33            })
34            .collect::<Result<_, _>>()?;
35        Ok(Box::new(ValueSetDateTime { set }))
36    }
37
38    // We need to allow this, because rust doesn't allow us to impl FromIterator on foreign
39    // types, and offset date time is foreign
40    #[allow(clippy::should_implement_trait)]
41    pub fn from_iter<T>(iter: T) -> Option<Box<Self>>
42    where
43        T: IntoIterator<Item = OffsetDateTime>,
44    {
45        let set = iter.into_iter().collect();
46        Some(Box::new(ValueSetDateTime { set }))
47    }
48}
49
50impl ValueSetScimPut for ValueSetDateTime {
51    fn from_scim_json_put(value: JsonValue) -> Result<ValueSetResolveStatus, OperationError> {
52        let ScimDateTime { date_time } = serde_json::from_value(value).map_err(|err| {
53            error!(?err, "SCIM DateTime syntax invalid");
54            OperationError::SC0010DateTimeSyntaxInvalid
55        })?;
56
57        let mut set = SmolSet::new();
58        set.insert(date_time);
59
60        Ok(ValueSetResolveStatus::Resolved(Box::new(
61            ValueSetDateTime { set },
62        )))
63    }
64}
65
66impl ValueSetT for ValueSetDateTime {
67    fn insert_checked(&mut self, value: Value) -> Result<bool, OperationError> {
68        match value {
69            Value::DateTime(u) => Ok(self.set.insert(u)),
70            _ => {
71                debug_assert!(false);
72                Err(OperationError::InvalidValueState)
73            }
74        }
75    }
76
77    fn clear(&mut self) {
78        self.set.clear();
79    }
80
81    fn remove(&mut self, pv: &PartialValue, _cid: &Cid) -> bool {
82        match pv {
83            PartialValue::DateTime(u) => self.set.remove(u),
84            _ => false,
85        }
86    }
87
88    fn contains(&self, pv: &PartialValue) -> bool {
89        match pv {
90            PartialValue::DateTime(u) => self.set.contains(u),
91            _ => false,
92        }
93    }
94
95    fn substring(&self, _pv: &PartialValue) -> bool {
96        false
97    }
98
99    fn startswith(&self, _pv: &PartialValue) -> bool {
100        false
101    }
102
103    fn endswith(&self, _pv: &PartialValue) -> bool {
104        false
105    }
106
107    fn lessthan(&self, _pv: &PartialValue) -> bool {
108        false
109    }
110
111    fn len(&self) -> usize {
112        self.set.len()
113    }
114
115    fn generate_idx_eq_keys(&self) -> Vec<String> {
116        self.set
117            .iter()
118            .map(|odt| {
119                debug_assert_eq!(odt.offset(), time::UtcOffset::UTC);
120                #[allow(clippy::expect_used)]
121                odt.format(&Rfc3339)
122                    .expect("Failed to format timestamp into RFC3339")
123            })
124            .collect()
125    }
126
127    fn syntax(&self) -> SyntaxType {
128        SyntaxType::DateTime
129    }
130
131    fn validate(&self, _schema_attr: &SchemaAttribute) -> bool {
132        true
133    }
134
135    fn to_proto_string_clone_iter(&self) -> Box<dyn Iterator<Item = String> + '_> {
136        Box::new(self.set.iter().map(|odt| {
137            debug_assert_eq!(odt.offset(), time::UtcOffset::UTC);
138            #[allow(clippy::expect_used)]
139            odt.format(&Rfc3339)
140                .expect("Failed to format timestamp into RFC3339")
141        }))
142    }
143
144    fn to_scim_value(&self) -> Option<ScimResolveStatus> {
145        self.set.iter().next().copied().map(|v| v.into())
146    }
147
148    fn to_db_valueset_v2(&self) -> DbValueSetV2 {
149        DbValueSetV2::DateTime(
150            self.set
151                .iter()
152                .map(|odt| {
153                    debug_assert_eq!(odt.offset(), time::UtcOffset::UTC);
154                    #[allow(clippy::expect_used)]
155                    odt.format(&Rfc3339)
156                        .expect("Failed to format timestamp into RFC3339")
157                })
158                .collect(),
159        )
160    }
161
162    fn to_partialvalue_iter(&self) -> Box<dyn Iterator<Item = PartialValue> + '_> {
163        Box::new(self.set.iter().cloned().map(PartialValue::DateTime))
164    }
165
166    fn to_value_iter(&self) -> Box<dyn Iterator<Item = Value> + '_> {
167        Box::new(self.set.iter().cloned().map(Value::DateTime))
168    }
169
170    fn equal(&self, other: &ValueSet) -> bool {
171        if let Some(other) = other.as_datetime_set() {
172            &self.set == other
173        } else {
174            debug_assert!(false);
175            false
176        }
177    }
178
179    fn merge(&mut self, other: &ValueSet) -> Result<(), OperationError> {
180        if let Some(b) = other.as_datetime_set() {
181            mergesets!(self.set, b)
182        } else {
183            debug_assert!(false);
184            Err(OperationError::InvalidValueState)
185        }
186    }
187
188    fn to_datetime_single(&self) -> Option<OffsetDateTime> {
189        if self.set.len() == 1 {
190            self.set.iter().cloned().take(1).next()
191        } else {
192            None
193        }
194    }
195
196    fn as_datetime_set(&self) -> Option<&SmolSet<[OffsetDateTime; 1]>> {
197        Some(&self.set)
198    }
199}
200
201#[cfg(test)]
202mod tests {
203    use super::ValueSetDateTime;
204    use crate::prelude::ValueSet;
205    use std::time::Duration;
206    use time::OffsetDateTime;
207
208    #[test]
209    fn test_scim_datetime() {
210        let odt = OffsetDateTime::UNIX_EPOCH + Duration::from_secs(69_420);
211        let vs: ValueSet = ValueSetDateTime::new(odt);
212
213        crate::valueset::scim_json_reflexive(&vs, r#""1970-01-01T19:17:00Z""#);
214
215        // Test that we can parse json values into a valueset.
216        crate::valueset::scim_json_put_reflexive::<ValueSetDateTime>(&vs, &[])
217    }
218}
kanidmd_lib/valueset/datetime.rs

kanidmd_lib/valueset/
datetime.rs
