kanidmd_lib/valueset/
datetime.rs

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        match pv {
109            PartialValue::DateTime(u) => self.set.iter().all(|set_value| set_value < u),
110            _ => false,
111        }
112    }
113
114    fn len(&self) -> usize {
115        self.set.len()
116    }
117
118    fn generate_idx_eq_keys(&self) -> Vec<String> {
119        self.set
120            .iter()
121            .map(|odt| {
122                debug_assert_eq!(odt.offset(), time::UtcOffset::UTC);
123                #[allow(clippy::expect_used)]
124                odt.format(&Rfc3339)
125                    .expect("Failed to format timestamp into RFC3339")
126            })
127            .collect()
128    }
129
130    fn syntax(&self) -> SyntaxType {
131        SyntaxType::DateTime
132    }
133
134    fn validate(&self, _schema_attr: &SchemaAttribute) -> bool {
135        true
136    }
137
138    fn to_proto_string_clone_iter(&self) -> Box<dyn Iterator<Item = String> + '_> {
139        Box::new(self.set.iter().map(|odt| {
140            debug_assert_eq!(odt.offset(), time::UtcOffset::UTC);
141            #[allow(clippy::expect_used)]
142            odt.format(&Rfc3339)
143                .expect("Failed to format timestamp into RFC3339")
144        }))
145    }
146
147    fn to_scim_value(&self) -> Option<ScimResolveStatus> {
148        self.set.iter().next().copied().map(|v| v.into())
149    }
150
151    fn to_db_valueset_v2(&self) -> DbValueSetV2 {
152        DbValueSetV2::DateTime(
153            self.set
154                .iter()
155                .map(|odt| {
156                    debug_assert_eq!(odt.offset(), time::UtcOffset::UTC);
157                    #[allow(clippy::expect_used)]
158                    odt.format(&Rfc3339)
159                        .expect("Failed to format timestamp into RFC3339")
160                })
161                .collect(),
162        )
163    }
164
165    fn to_partialvalue_iter(&self) -> Box<dyn Iterator<Item = PartialValue> + '_> {
166        Box::new(self.set.iter().cloned().map(PartialValue::DateTime))
167    }
168
169    fn to_value_iter(&self) -> Box<dyn Iterator<Item = Value> + '_> {
170        Box::new(self.set.iter().cloned().map(Value::DateTime))
171    }
172
173    fn equal(&self, other: &ValueSet) -> bool {
174        if let Some(other) = other.as_datetime_set() {
175            &self.set == other
176        } else {
177            debug_assert!(false);
178            false
179        }
180    }
181
182    fn merge(&mut self, other: &ValueSet) -> Result<(), OperationError> {
183        if let Some(b) = other.as_datetime_set() {
184            mergesets!(self.set, b)
185        } else {
186            debug_assert!(false);
187            Err(OperationError::InvalidValueState)
188        }
189    }
190
191    fn to_datetime_single(&self) -> Option<OffsetDateTime> {
192        if self.set.len() == 1 {
193            self.set.iter().cloned().take(1).next()
194        } else {
195            None
196        }
197    }
198
199    fn as_datetime_set(&self) -> Option<&SmolSet<[OffsetDateTime; 1]>> {
200        Some(&self.set)
201    }
202}
203
204#[cfg(test)]
205mod tests {
206    use super::ValueSetDateTime;
207    use crate::prelude::ValueSet;
208    use std::time::Duration;
209    use time::OffsetDateTime;
210
211    #[test]
212    fn test_scim_datetime() {
213        let odt = OffsetDateTime::UNIX_EPOCH + Duration::from_secs(69_420);
214        let vs: ValueSet = ValueSetDateTime::new(odt);
215
216        crate::valueset::scim_json_reflexive(&vs, r#""1970-01-01T19:17:00Z""#);
217
218        // Test that we can parse json values into a valueset.
219        crate::valueset::scim_json_put_reflexive::<ValueSetDateTime>(&vs, &[])
220    }
221}
kanidmd_lib/valueset/datetime.rs

kanidmd_lib/valueset/
datetime.rs
