kanidmd_lib/valueset/
url.rs

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

kanidmd_lib/valueset/
url.rs
