Skip to main content

kanidmd_lib/constants/
entries.rs

1//! Constant Entries for the IDM
2use std::fmt::Display;
3
4use crate::value::PartialValue;
5use crate::value::Value;
6use crate::valueset::{ValueSet, ValueSetIutf8};
7pub use kanidm_proto::attribute::Attribute;
8use kanidm_proto::constants::*;
9use kanidm_proto::scim_v1::JsonValue;
10use kanidm_proto::scim_v1::ScimFilter;
11
12//TODO: This would do well in the proto lib
13// together with all the other definitions.
14// That way`OperationError::MissingClass` can
15// Directly reference the entryclass rather
16// than relying on its string name
17#[derive(Copy, Clone, Debug)]
18pub enum EntryClass {
19    AccessControlCreate,
20    AccessControlDelete,
21    AccessControlModify,
22    AccessControlProfile,
23    AccessControlReceiverEntryManager,
24    AccessControlReceiverGroup,
25    AccessControlSearch,
26    AccessControlTargetScope,
27    Account,
28    AccountPolicy,
29    AccountSignupRequest,
30    Application,
31    AssertionNonce,
32    AttributeType,
33    Builtin,
34    Class,
35    ClassType,
36    ClientCertificate,
37    Conflict,
38    DomainInfo,
39    DynGroup,
40    ExtensibleObject,
41    Feature,
42    Group,
43    KeyProvider,
44    KeyProviderInternal,
45    KeyObject,
46    KeyObjectHkdfS256,
47    KeyObjectJwtEs256,
48    KeyObjectJwtHs256,
49    KeyObjectJwtRs256,
50    KeyObjectJweA128GCM,
51    KeyObjectInternal,
52    MemberOf,
53    Memorial,
54    OAuth2Account,
55    OAuth2DeviceCodeSession,
56    OAuth2ResourceServer,
57    OAuth2ResourceServerBasic,
58    OAuth2ResourceServerPublic,
59    OAuth2Client,
60    Object,
61    OrgPerson,
62    OutboundMessage,
63    Person,
64    PosixAccount,
65    PosixGroup,
66    Recycled,
67    Service,
68    ServiceAccount,
69    SyncAccount,
70    SyncObject,
71    Tombstone,
72    User,
73    System,
74    SystemInfo,
75    SystemConfig,
76    #[cfg(any(test, debug_assertions))]
77    TestClass,
78}
79
80impl From<EntryClass> for ScimFilter {
81    fn from(ec: EntryClass) -> Self {
82        ScimFilter::Equal(Attribute::Class.into(), ec.into())
83    }
84}
85
86impl From<EntryClass> for &'static str {
87    fn from(val: EntryClass) -> Self {
88        match val {
89            EntryClass::AccessControlCreate => ACCESS_CONTROL_CREATE,
90            EntryClass::AccessControlDelete => ACCESS_CONTROL_DELETE,
91            EntryClass::AccessControlModify => ACCESS_CONTROL_MODIFY,
92            EntryClass::AccessControlProfile => ACCESS_CONTROL_PROFILE,
93            EntryClass::AccessControlReceiverEntryManager => ACCESS_CONTROL_RECEIVER_ENTRY_MANAGER,
94            EntryClass::AccessControlReceiverGroup => ACCESS_CONTROL_RECEIVER_GROUP,
95            EntryClass::AccessControlSearch => ACCESS_CONTROL_SEARCH,
96            EntryClass::AccessControlTargetScope => ACCESS_CONTROL_TARGET_SCOPE,
97            EntryClass::Account => ENTRYCLASS_ACCOUNT,
98            EntryClass::AccountPolicy => ENTRYCLASS_ACCOUNT_POLICY,
99            EntryClass::AccountSignupRequest => ENTRYCLASS_ACCOUNT_SIGNUP_REQUEST,
100            EntryClass::Application => ENTRYCLASS_APPLICATION,
101            EntryClass::AssertionNonce => ENTRYCLASS_ASSERTION_NONCE,
102            EntryClass::AttributeType => ENTRYCLASS_ATTRIBUTE_TYPE,
103            EntryClass::Builtin => ENTRYCLASS_BUILTIN,
104            EntryClass::Class => ENTRYCLASS_CLASS,
105            EntryClass::ClassType => ENTRYCLASS_CLASS_TYPE,
106            EntryClass::ClientCertificate => ENTRYCLASS_CLIENT_CERTIFICATE,
107            EntryClass::Conflict => ENTRYCLASS_CONFLICT,
108            EntryClass::DomainInfo => ENTRYCLASS_DOMAIN_INFO,
109            EntryClass::DynGroup => ENTRYCLASS_DYN_GROUP,
110            EntryClass::ExtensibleObject => ENTRYCLASS_EXTENSIBLE_OBJECT,
111            EntryClass::Feature => ENTRYCLASS_FEATURE,
112            EntryClass::Group => ENTRYCLASS_GROUP,
113            EntryClass::KeyProvider => ENTRYCLASS_KEY_PROVIDER,
114            EntryClass::KeyProviderInternal => ENTRYCLASS_KEY_PROVIDER_INTERNAL,
115            EntryClass::KeyObject => ENTRYCLASS_KEY_OBJECT,
116            EntryClass::KeyObjectHkdfS256 => ENTRYCLASS_KEY_OBJECT_HKDF_S256,
117            EntryClass::KeyObjectJwtEs256 => ENTRYCLASS_KEY_OBJECT_JWT_ES256,
118            EntryClass::KeyObjectJwtHs256 => ENTRYCLASS_KEY_OBJECT_JWT_HS256,
119            EntryClass::KeyObjectJwtRs256 => ENTRYCLASS_KEY_OBJECT_JWT_RS256,
120            EntryClass::KeyObjectJweA128GCM => ENTRYCLASS_KEY_OBJECT_JWE_A128GCM,
121            EntryClass::KeyObjectInternal => ENTRYCLASS_KEY_OBJECT_INTERNAL,
122            EntryClass::MemberOf => ENTRYCLASS_MEMBER_OF,
123            EntryClass::Memorial => ENTRYCLASS_MEMORIAL,
124            EntryClass::OAuth2Account => ENTRYCLASS_OAUTH2_ACCOUNT,
125            EntryClass::OAuth2Client => ENTRYCLASS_OAUTH2_CLIENT,
126            EntryClass::OAuth2DeviceCodeSession => OAUTH2_DEVICE_CODE_SESSION,
127            EntryClass::OAuth2ResourceServer => OAUTH2_RESOURCE_SERVER,
128            EntryClass::OAuth2ResourceServerBasic => OAUTH2_RESOURCE_SERVER_BASIC,
129            EntryClass::OAuth2ResourceServerPublic => OAUTH2_RESOURCE_SERVER_PUBLIC,
130            EntryClass::Object => ENTRYCLASS_OBJECT,
131            EntryClass::OrgPerson => ENTRYCLASS_ORG_PERSON,
132            EntryClass::OutboundMessage => ENTRYCLASS_OUTBOUND_MESSAGE,
133            EntryClass::Person => ENTRYCLASS_PERSON,
134            EntryClass::PosixAccount => ENTRYCLASS_POSIX_ACCOUNT,
135            EntryClass::PosixGroup => ENTRYCLASS_POSIX_GROUP,
136            EntryClass::Recycled => ENTRYCLASS_RECYCLED,
137            EntryClass::Service => ENTRYCLASS_SERVICE,
138            EntryClass::ServiceAccount => ENTRYCLASS_SERVICE_ACCOUNT,
139            EntryClass::SyncAccount => ENTRYCLASS_SYNC_ACCOUNT,
140            EntryClass::SyncObject => ENTRYCLASS_SYNC_OBJECT,
141            EntryClass::System => ENTRYCLASS_SYSTEM,
142            EntryClass::SystemConfig => ENTRYCLASS_SYSTEM_CONFIG,
143            EntryClass::SystemInfo => ENTRYCLASS_SYSTEM_INFO,
144            EntryClass::Tombstone => ENTRYCLASS_TOMBSTONE,
145            #[cfg(any(test, debug_assertions))]
146            EntryClass::TestClass => TEST_ENTRYCLASS_TEST_CLASS,
147            EntryClass::User => ENTRYCLASS_USER,
148        }
149    }
150}
151
152impl From<EntryClass> for JsonValue {
153    fn from(value: EntryClass) -> Self {
154        Self::String(value.as_ref().to_string())
155    }
156}
157
158impl AsRef<str> for EntryClass {
159    fn as_ref(&self) -> &str {
160        self.into()
161    }
162}
163
164impl From<&EntryClass> for &'static str {
165    fn from(value: &EntryClass) -> Self {
166        (*value).into()
167    }
168}
169
170impl From<EntryClass> for String {
171    fn from(val: EntryClass) -> Self {
172        let s: &'static str = val.into();
173        s.to_string()
174    }
175}
176
177impl From<EntryClass> for Value {
178    fn from(val: EntryClass) -> Self {
179        Value::new_iutf8(val.into())
180    }
181}
182
183impl From<EntryClass> for PartialValue {
184    fn from(val: EntryClass) -> Self {
185        PartialValue::new_iutf8(val.into())
186    }
187}
188
189impl From<EntryClass> for crate::prelude::AttrString {
190    fn from(val: EntryClass) -> Self {
191        crate::prelude::AttrString::from(val.to_string())
192    }
193}
194
195impl Display for EntryClass {
196    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> std::fmt::Result {
197        let s: String = (*self).into();
198        write!(f, "{s}")
199    }
200}
201
202impl EntryClass {
203    pub fn to_value(self) -> Value {
204        let s: &'static str = self.into();
205        Value::new_iutf8(s)
206    }
207
208    pub fn to_valueset(self) -> ValueSet {
209        let s: &'static str = self.into();
210        ValueSetIutf8::new(s)
211    }
212
213    pub fn to_partialvalue(self) -> PartialValue {
214        let s: &'static str = self.into();
215        PartialValue::new_iutf8(s)
216    }
217
218    /// Return a filter that'll match this class
219    pub fn as_f_eq(&self) -> crate::filter::FC {
220        crate::filter::f_eq(Attribute::Class, self.to_partialvalue())
221    }
222}
223
224// ============ TEST DATA ============
225#[cfg(test)]
226use crate::entry::{entry_init_fn, EntryInitNew};
227#[cfg(test)]
228use std::sync::LazyLock;
229
230#[cfg(test)]
231pub static E_TESTPERSON_1: LazyLock<EntryInitNew> = LazyLock::new(|| {
232    entry_init_fn([
233        (Attribute::Class, EntryClass::Object.to_value()),
234        (Attribute::Class, EntryClass::Account.to_value()),
235        (Attribute::Class, EntryClass::Person.to_value()),
236        (Attribute::Name, Value::new_iname("testperson1")),
237        (Attribute::DisplayName, Value::new_utf8s("Test Person 1")),
238        (
239            Attribute::Uuid,
240            Value::Uuid(super::uuids::UUID_TESTPERSON_1),
241        ),
242    ])
243});
244#[cfg(test)]
245pub static E_TESTPERSON_2: LazyLock<EntryInitNew> = LazyLock::new(|| {
246    entry_init_fn([
247        (Attribute::Class, EntryClass::Object.to_value()),
248        (Attribute::Class, EntryClass::Account.to_value()),
249        (Attribute::Class, EntryClass::Person.to_value()),
250        (Attribute::Name, Value::new_iname("testperson2")),
251        (Attribute::DisplayName, Value::new_utf8s("Test Person 2")),
252        (
253            Attribute::Uuid,
254            Value::Uuid(super::uuids::UUID_TESTPERSON_2),
255        ),
256    ])
257});