putting a pin in it

Updated README.md for Maddy

i

README.md

@@ -374,6 +374,7 @@ folder for help with:
 - [Kasm](example_configs/kasm.md)
 - [KeyCloak](example_configs/keycloak.md)
 - [LibreNMS](example_configs/librenms.md)
+- [Maddy](example_configs/maddy.md)
 - [Mastodon](example_configs/mastodon.env.example)
 - [Matrix](example_configs/matrix_synapse.yml)
 - [Mealie](example_configs/mealie.md)

app/queries/get_group_details.graphql

@@ -8,5 +8,21 @@ query GetGroupDetails($id: Int!) {
       id
       displayName
     }
+    attributes {
+      name
+      value
+    }
+  }
+  schema {
+     groupSchema {
+      attributes {
+        name
+        attributeType
+        isList
+        isVisible
+        isEditable
+        isHardcoded
+      }
+    }
   }
 }

app/src/components/group_attributes_form.rs

@@ -0,0 +1,83 @@
+use std::ops::Deref;
+
+use crate::{
+    components::{
+        group_details::Attribute,
+        router::{AppRoute, Link},
+    },
+    infra::common_component::{CommonComponent, CommonComponentParts},
+};
+use anyhow::{bail, Error, Result};
+use gloo_console::log;
+use graphql_client::GraphQLQuery;
+use yew::prelude::*;
+
+#[derive(Properties, PartialEq)]
+pub struct AttributeInputProps {
+    pub attribute: Attribute,
+    pub on_changed: Callback<(String, Vec<String>)>,
+}
+
+#[function_component(SingleAttributeInput)]
+fn single_attribute_input(props: &AttributeInputProps) -> Html {
+    let attribute = props.attribute.clone();
+    let on_changed = props.on_changed.clone();
+    let on_input = Callback::from(move |e: InputEvent| on_changed.emit((attribute.name.clone(), vec![e.data().unwrap_or_default()])));
+    html!{
+        <div class="row mb-3">
+            <label for={props.attribute.name.clone()}
+                class="form-label col-4 col-form-label">
+                {props.attribute.name.clone()}
+                {":"}
+            </label>
+            <div class="col-8">
+                <input id={props.attribute.name.clone()} name={props.attribute.name.clone()} type="text" class="form-control" oninput={on_input} />
+            </div>
+        </div>
+    }
+}
+
+#[function_component(ListAttributeInput)]
+fn list_attribute_input(props: &AttributeInputProps) -> Html {
+    html!{}
+}
+
+#[function_component(AttributeInput)]
+fn attribute_input(props: &AttributeInputProps) -> Html {
+    if props.attribute.is_list {
+        html!{
+            <ListAttributeInput 
+                attribute={props.attribute.clone()} 
+                on_changed={props.on_changed.clone()} />
+        }
+    } else {
+        html!{
+            <SingleAttributeInput 
+                attribute={props.attribute.clone()} 
+                on_changed={props.on_changed.clone()} />
+        }
+    }
+}
+
+#[derive(Properties, PartialEq)]
+pub struct Props {
+    pub attributes: Vec<Attribute>,
+}
+
+#[function_component(GroupAttributesForm)]
+pub fn group_attributes_form(Props{ attributes }: &Props) -> Html {
+    let attributes = use_state(|| attributes.clone());
+    let on_changed = {
+        let attributes = attributes.clone();
+        Callback::from(move |(name, value): (String, Vec<String>)| {
+            let mut new_attributes = attributes.deref().clone();
+            new_attributes.iter_mut().filter(|attribute| attribute.name == name).for_each(|attribute| attribute.value = value.clone());
+            attributes.set(new_attributes.clone());
+            log!("New attributes:");
+            new_attributes.iter().for_each(|attribute| log!("Name: {attribute.name}, Value: {attribute.value}"));
+        })
+    };
+    html!{
+        {for attributes.iter().map(|attribute| html!{<AttributeInput attribute={attribute.clone()} on_changed={on_changed.clone()} />})}
+    }
+}

app/src/components/group_details.rs

@@ -2,6 +2,7 @@ use crate::{
     components::{
         add_group_member::{self, AddGroupMemberComponent},
         remove_user_from_group::RemoveUserFromGroupComponent,
+        group_attributes_form::GroupAttributesForm,
         router::{AppRoute, Link},
     },
     infra::common_component::{CommonComponent, CommonComponentParts},
@@ -22,12 +23,22 @@ pub struct GetGroupDetails;
 pub type Group = get_group_details::GetGroupDetailsGroup;
 pub type User = get_group_details::GetGroupDetailsGroupUsers;
 pub type AddGroupMemberUser = add_group_member::User;
+pub type AttributeSchema = get_group_details::GetGroupDetailsSchemaGroupSchemaAttributes;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Attribute {
+  pub name: String,
+  pub value: Vec<String>,
+  pub attribute_type: String,
+  pub is_list: bool,
+}
 
 pub struct GroupDetails {
     common: CommonComponentParts<Self>,
     /// The group info. If none, the error is in `error`. If `error` is None, then we haven't
     /// received the server response yet.
     group: Option<Group>,
+    attributes: Vec<Attribute>,
 }
 
 /// State machine describing the possible transitions of the component state.
@@ -185,7 +196,22 @@ impl CommonComponent<GroupDetails> for GroupDetails {
     fn handle_msg(&mut self, _: &Context<Self>, msg: <Self as Component>::Message) -> Result<bool> {
         match msg {
             Msg::GroupDetailsResponse(response) => match response {
-                Ok(group) => self.group = Some(group.group),
+                Ok(response) => {
+                  let group = response.group;
+                  self.group = Some(group.clone());
+                  let set_attributes = group.attributes.clone();
+                  let mut attribute_schema = response.schema.group_schema.attributes;
+                  attribute_schema.retain(|schema| !schema.is_hardcoded);
+                  let attributes = attribute_schema.into_iter().map(|schema| {
+                    Attribute {
+                      name: schema.name.clone(),
+                      value: set_attributes.iter().find(|attribute_value| attribute_value.name == schema.name).unwrap().value.clone(),
+                      attribute_type: format!("{:?}",schema.attribute_type),
+                      is_list: schema.is_list,
+                    }
+                  }).collect();
+                  self.attributes = attributes;
+                },
                 Err(e) => {
                     self.group = None;
                     bail!("Error getting user details: {}", e);
@@ -222,6 +248,7 @@ impl Component for GroupDetails {
         let mut table = Self {
             common: CommonComponentParts::<Self>::create(),
             group: None,
+            attributes: Vec::default(),
         };
         table.get_group_details(ctx);
         table
@@ -239,6 +266,7 @@ impl Component for GroupDetails {
                 html! {
                     <div>
                       {self.view_details(u)}
+                      <GroupAttributesForm attributes={self.attributes.clone()} />
                       {self.view_user_list(ctx, u)}
                       {self.view_add_user_button(ctx, u)}
                       {self.view_messages(error)}

app/src/components/mod.rs

@@ -6,6 +6,7 @@ pub mod create_group;
 pub mod create_user;
 pub mod delete_group;
 pub mod delete_user;
+pub mod group_attributes_form;
 pub mod group_details;
 pub mod group_table;
 pub mod login;

example_configs/maddy.md

@@ -0,0 +1,83 @@
+# Configuration for Maddy Mail Server
+
+Documentation for maddy LDAP can be found [here](https://maddy.email/reference/auth/ldap/).  
+Maddy will automatically create an imap-acct if a new user connects via LDAP.  
+Replace `dc=example,dc=com` with your LLDAP configured domain.
+
+
+## Simple Setup
+Depending on the mail client(s) the simple setup can work for you. However, if this does not work for you, follow the instructions in the `Advanced Setup` section.
+
+### DN Template
+You only have to specify the dn template:
+```
+dn_template "cn={username},ou=people,dc=example,dc=com"
+```
+
+### Config Example with Docker
+Example maddy configuration with LLDAP running in docker.  
+You can replace `local_authdb` with another name if you want to use multiple auth backends.  
+If you only want to use one storage backend make sure to disable `auth.pass_table local_authdb` in your config if it is still active.
+```
+auth.ldap local_authdb {
+    urls ldap://lldap:3890
+
+    dn_template "cn={username},ou=people,dc=example,dc=com"
+
+    starttls off
+    debug off
+    connect_timeout 1m
+}
+```
+
+
+## Advanced Setup
+If the simple setup does not work for you, you can use a proper lookup.
+
+### Bind Credentials
+If you have a service account in LLDAP with restricted rights (e.g. `lldap_strict_readonly`), replace `admin` with your LLDAP service account.  
+Replace `admin_password` with the password of either the admin or service account.  
+```
+bind plain "cn=admin,ou=people,dc=example,dc=com" "admin_password"
+```
+If you do not want to use plain auth check the [maddy LDAP page](https://maddy.email/reference/auth/ldap/) for other options.
+
+### Base DN
+```
+base_dn "dc=example,dc=com"
+```
+
+### Filter
+Depending on the mail client, maddy receives and sends either the username or the full E-Mail address as username (even if the username is not an E-Mail).  
+For the username use:
+```
+filter "(&(objectClass=person)(uid={username}))"
+```
+For mapping the username (as E-Mail):
+```
+filter "(&(objectClass=person)(mail={username}))"
+```
+For allowing both, username and username as E-Mail use:
+```
+filter "(&(|(uid={username})(mail={username}))(objectClass=person))"
+```
+
+### Config Example with Docker
+Example maddy configuration with LLDAP running in docker.  
+You can replace `local_authdb` with another name if you want to use multiple auth backends.  
+If you only want to use one storage backend make sure to disable `auth.pass_table local_authdb` in your config if it is still active.
+```
+auth.ldap local_authdb {
+    urls ldap://lldap:3890
+
+    bind plain "cn=admin,ou=people,dc=example,dc=com" "admin_password"
+    base_dn "dc=example,dc=com"
+    filter "(&(|(uid={username})(mail={username}))(objectClass=person))"
+
+    starttls off
+    debug off
+    connect_timeout 1m
+}
+```
+
+

server/src/domain/types.rs

@@ -11,7 +11,6 @@ use sea_orm::{
 use serde::{Deserialize, Serialize};
 use strum::{EnumString, IntoStaticStr};
 
-use super::handler::AttributeSchema;
 pub use super::model::UserColumn;
 pub use lldap_auth::types::UserId;
 
@@ -534,38 +533,6 @@ pub struct UserAndGroups {
     pub groups: Option<Vec<GroupDetails>>,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct AttributeValueAndSchema {
-    pub value: AttributeValue,
-    pub schema: AttributeSchema,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct UserAndSchema {
-    pub user: User,
-    pub schema: Vec<AttributeSchema>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct GroupAndSchema {
-    pub group: Group,
-    pub schema: Vec<AttributeSchema>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct GroupDetailsAndSchema {
-    pub group: GroupDetails,
-    pub schema: Vec<AttributeSchema>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct UserAndGroupsAndSchema {
-    pub user: User,
-    pub user_schema: Vec<AttributeSchema>,
-    pub group: Option<Vec<GroupDetails>>,
-    pub group_schema: Vec<AttributeSchema>,
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

server/src/infra/graphql/query.rs

@@ -25,14 +25,9 @@ type DomainRequestFilter = crate::domain::handler::UserRequestFilter;
 type DomainUser = crate::domain::types::User;
 type DomainGroup = crate::domain::types::Group;
 type DomainUserAndGroups = crate::domain::types::UserAndGroups;
-type DomainUserAndSchema = crate::domain::types::UserAndSchema;
-type DomainGroupAndSchema = crate::domain::types::GroupAndSchema;
-type DomainGroupDetailsAndSchema = crate::domain::types::GroupDetailsAndSchema;
-type DomainUserAndGroupsAndSchema = crate::domain::types::UserAndGroupsAndSchema;
 type DomainAttributeList = crate::domain::handler::AttributeList;
 type DomainAttributeSchema = crate::domain::handler::AttributeSchema;
 type DomainAttributeValue = crate::domain::types::AttributeValue;
-type DomainAttributeValueAndSchema = crate::domain::types::AttributeValueAndSchema;
 
 #[derive(PartialEq, Eq, Debug, GraphQLInputObject)]
 /// A filter for requests, specifying a boolean expression based on field constraints. Only one of
@@ -148,15 +143,11 @@ impl<Handler: BackendHandler> Query<Handler> {
                 &span,
                 "Unauthorized access to user data",
             ))?;
-        let user = handler
+        Ok(handler
             .get_user_details(&user_id)
             .instrument(span)
-            .await?;
+            .await
-        let schema = self.get_schema(context, span).await?;
+            .map(Into::into)?)
-        return Ok(DomainUserAndSchema {
-            user,
-            schema: schema.get_schema().user_attributes.attributes,
-        }.into())
     }
 
     async fn users(
@@ -246,7 +237,6 @@ impl<Handler: BackendHandler> Query<Handler> {
 /// Represents a single user.
 pub struct User<Handler: BackendHandler> {
     user: DomainUser,
-    schema: Vec<DomainAttributeSchema>,
     _phantom: std::marker::PhantomData<Box<Handler>>,
 }
 
@@ -255,7 +245,6 @@ impl<Handler: BackendHandler> Default for User<Handler> {
     fn default() -> Self {
         Self {
             user: DomainUser::default(),
-            schema: Vec::default(),
             _phantom: std::marker::PhantomData,
         }
     }
@@ -343,21 +332,19 @@ impl<Handler: BackendHandler> User<Handler> {
     }
 }
 
-impl<Handler: BackendHandler> From<DomainUserAndSchema> for User<Handler> {
+impl<Handler: BackendHandler> From<DomainUser> for User<Handler> {
-    fn from(user: DomainUserAndSchema) -> Self {
+    fn from(user: DomainUser) -> Self {
         Self {
-            user: user.user,
+            user,
-            schema: user.schema,
             _phantom: std::marker::PhantomData,
         }
     }
 }
 
-impl<Handler: BackendHandler> From<DomainUserAndGroupsAndSchema> for User<Handler> {
+impl<Handler: BackendHandler> From<DomainUserAndGroups> for User<Handler> {
-    fn from(user: DomainUserAndGroupsAndSchema) -> Self {
+    fn from(user: DomainUserAndGroups) -> Self {
         Self {
             user: user.user,
-            schema: user.user_schema,
             _phantom: std::marker::PhantomData,
         }
     }
@@ -371,7 +358,6 @@ pub struct Group<Handler: BackendHandler> {
     creation_date: chrono::NaiveDateTime,
     uuid: String,
     attributes: Vec<DomainAttributeValue>,
-    schema: Vec<DomainAttributeSchema>,
     members: Option<Vec<String>>,
     _phantom: std::marker::PhantomData<Box<Handler>>,
 }
@@ -423,31 +409,29 @@ impl<Handler: BackendHandler> Group<Handler> {
     }
 }
 
-impl<Handler: BackendHandler> From<DomainGroupDetailsAndSchema> for Group<Handler> {
+impl<Handler: BackendHandler> From<GroupDetails> for Group<Handler> {
-    fn from(group_details: DomainGroupDetailsAndSchema) -> Self {
+    fn from(group_details: GroupDetails) -> Self {
         Self {
-            group_id: group_details.group.group_id.0,
+            group_id: group_details.group_id.0,
-            display_name: group_details.group.display_name.to_string(),
+            display_name: group_details.display_name.to_string(),
-            creation_date: group_details.group.creation_date,
+            creation_date: group_details.creation_date,
-            uuid: group_details.group.uuid.into_string(),
+            uuid: group_details.uuid.into_string(),
-            attributes: group_details.group.attributes,
+            attributes: group_details.attributes,
             members: None,
-            schema: group_details.schema,
             _phantom: std::marker::PhantomData,
         }
     }
 }
 
-impl<Handler: BackendHandler> From<DomainGroupAndSchema> for Group<Handler> {
+impl<Handler: BackendHandler> From<DomainGroup> for Group<Handler> {
-    fn from(group: DomainGroupAndSchema) -> Self {
+    fn from(group: DomainGroup) -> Self {
         Self {
-            group_id: group.group.id.0,
+            group_id: group.id.0,
-            display_name: group.group.display_name.to_string(),
+            display_name: group.display_name.to_string(),
-            creation_date: group.group.creation_date,
+            creation_date: group.creation_date,
-            uuid: group.group.uuid.into_string(),
+            uuid: group.uuid.into_string(),
-            attributes: group.group.attributes,
+            attributes: group.attributes,
-            members: Some(group.group.users.into_iter().map(UserId::into_string).collect()),
+            members: Some(group.users.into_iter().map(UserId::into_string).collect()),
-            schema: group.schema,
             _phantom: std::marker::PhantomData,
         }
     }
@@ -545,7 +529,6 @@ impl<Handler: BackendHandler> From<PublicSchema> for Schema<Handler> {
 #[derive(PartialEq, Eq, Debug, Serialize, Deserialize)]
 pub struct AttributeValue<Handler: BackendHandler, Extractor> {
     attribute: DomainAttributeValue,
-    schema: DomainAttributeSchema,
     _phantom: std::marker::PhantomData<Box<Handler>>,
     _phantom_extractor: std::marker::PhantomData<Extractor>,
 }
@@ -618,13 +601,12 @@ pub fn serialize_attribute(
         .ok_or_else(|| FieldError::from(anyhow::anyhow!("Unknown attribute: {}", &attribute.name)))
 }
 
-impl<Handler: BackendHandler, Extractor> From<DomainAttributeValueAndSchema>
+impl<Handler: BackendHandler, Extractor> From<DomainAttributeValue>
     for AttributeValue<Handler, Extractor>
 {
-    fn from(value: DomainAttributeValueAndSchema) -> Self {
+    fn from(value: DomainAttributeValue) -> Self {
         Self {
-            attribute: value.value,
+            attribute: value,
-            schema: value.schema,
             _phantom: std::marker::PhantomData,
             _phantom_extractor: std::marker::PhantomData,
         }