kanidm_cli/group/
mod.rs

1use crate::common::OpType;
2use crate::{handle_client_error, GroupOpt, GroupPosix, OutputMode};
3use kanidm_proto::constants::ATTR_GIDNUMBER;
4
5mod account_policy;
6
7impl GroupOpt {
8    pub fn debug(&self) -> bool {
9        match self {
10            GroupOpt::List(copt) | GroupOpt::Search { copt, .. } => copt.debug,
11            GroupOpt::Get(gcopt) => gcopt.copt.debug,
12            GroupOpt::SetEntryManagedBy { copt, .. } | GroupOpt::Create { copt, .. } => copt.debug,
13            GroupOpt::Delete(gcopt) => gcopt.copt.debug,
14            GroupOpt::ListMembers(gcopt) => gcopt.copt.debug,
15            GroupOpt::AddMembers(gcopt) => gcopt.copt.debug,
16            GroupOpt::RemoveMembers(gcopt) => gcopt.copt.debug,
17            GroupOpt::SetMembers(gcopt) => gcopt.copt.debug,
18            GroupOpt::PurgeMembers(gcopt) => gcopt.copt.debug,
19            GroupOpt::Rename { copt, .. } | GroupOpt::SetMail { copt, .. } => copt.debug,
20            GroupOpt::Posix { commands } => match commands {
21                GroupPosix::Show(gcopt) => gcopt.copt.debug,
22                GroupPosix::Set(gcopt) => gcopt.copt.debug,
23                GroupPosix::ResetGidnumber { copt, .. } => copt.debug,
24            },
25            GroupOpt::AccountPolicy { commands } => commands.debug(),
26        }
27    }
28
29    pub async fn exec(&self) {
30        match self {
31            GroupOpt::List(copt) => {
32                let client = copt.to_client(OpType::Read).await;
33                match client.idm_group_list().await {
34                    Ok(r) => match copt.output_mode {
35                        OutputMode::Json => {
36                            let r_attrs: Vec<_> = r.iter().map(|entry| &entry.attrs).collect();
37                            println!(
38                                "{}",
39                                serde_json::to_string(&r_attrs).expect("Failed to serialise json")
40                            );
41                        }
42                        OutputMode::Text => r.iter().for_each(|ent| println!("{}", ent)),
43                    },
44                    Err(e) => handle_client_error(e, copt.output_mode),
45                }
46            }
47            GroupOpt::Search { copt, name } => {
48                let client = copt.to_client(OpType::Read).await;
49                match client.idm_group_search(name).await {
50                    Ok(r) => match copt.output_mode {
51                        OutputMode::Json => {
52                            let r_attrs: Vec<_> = r.iter().map(|entry| &entry.attrs).collect();
53                            println!(
54                                "{}",
55                                serde_json::to_string(&r_attrs).expect("Failed to serialise json")
56                            );
57                        }
58                        OutputMode::Text => r.iter().for_each(|ent| println!("{}", ent)),
59                    },
60                    Err(e) => handle_client_error(e, copt.output_mode),
61                }
62            }
63            GroupOpt::Get(gcopt) => {
64                let client = gcopt.copt.to_client(OpType::Read).await;
65                // idm_group_get
66                match client.idm_group_get(gcopt.name.as_str()).await {
67                    Ok(Some(e)) => match gcopt.copt.output_mode {
68                        OutputMode::Json => {
69                            println!(
70                                "{}",
71                                serde_json::to_string(&e.attrs).expect("Failed to serialise json")
72                            );
73                        }
74                        OutputMode::Text => println!("{}", e),
75                    },
76                    Ok(None) => warn!("No matching group '{}'", gcopt.name.as_str()),
77                    Err(e) => handle_client_error(e, gcopt.copt.output_mode),
78                }
79            }
80            GroupOpt::Create {
81                copt,
82                name,
83                entry_managed_by,
84            } => {
85                let client = copt.to_client(OpType::Write).await;
86                match client
87                    .idm_group_create(name.as_str(), entry_managed_by.as_deref())
88                    .await
89                {
90                    Err(err) => {
91                        error!("Error -> {:?}", err)
92                    }
93                    Ok(_) => println!("Successfully created group '{}'", name.as_str()),
94                }
95            }
96            GroupOpt::Delete(gcopt) => {
97                let client = gcopt.copt.to_client(OpType::Write).await;
98                match client.idm_group_delete(gcopt.name.as_str()).await {
99                    Err(e) => handle_client_error(e, gcopt.copt.output_mode),
100                    Ok(_) => println!("Successfully deleted group {}", gcopt.name.as_str()),
101                }
102            }
103            GroupOpt::PurgeMembers(gcopt) => {
104                let client = gcopt.copt.to_client(OpType::Write).await;
105                match client.idm_group_purge_members(gcopt.name.as_str()).await {
106                    Err(e) => handle_client_error(e, gcopt.copt.output_mode),
107                    Ok(_) => println!(
108                        "Successfully purged members of group {}",
109                        gcopt.name.as_str()
110                    ),
111                }
112            }
113            GroupOpt::ListMembers(gcopt) => {
114                let client = gcopt.copt.to_client(OpType::Read).await;
115                match client.idm_group_get_members(gcopt.name.as_str()).await {
116                    Ok(Some(groups)) => groups.iter().for_each(|m| println!("{:?}", m)),
117                    Ok(None) => warn!("No members in group {}", gcopt.name.as_str()),
118                    Err(e) => handle_client_error(e, gcopt.copt.output_mode),
119                }
120            }
121            GroupOpt::AddMembers(gcopt) => {
122                let client = gcopt.copt.to_client(OpType::Write).await;
123                let new_members: Vec<&str> = gcopt.members.iter().map(String::as_str).collect();
124
125                match client
126                    .idm_group_add_members(gcopt.name.as_str(), &new_members)
127                    .await
128                {
129                    Err(e) => handle_client_error(e, gcopt.copt.output_mode),
130                    Ok(_) => println!(
131                        "Successfully added {:?} to group \"{}\"",
132                        &new_members,
133                        gcopt.name.as_str()
134                    ),
135                }
136            }
137
138            GroupOpt::RemoveMembers(gcopt) => {
139                let client = gcopt.copt.to_client(OpType::Write).await;
140                let remove_members: Vec<&str> = gcopt.members.iter().map(String::as_str).collect();
141
142                match client
143                    .idm_group_remove_members(gcopt.name.as_str(), &remove_members)
144                    .await
145                {
146                    Err(e) => {
147                        error!("Failed to remove members!");
148                        handle_client_error(e, gcopt.copt.output_mode)
149                    }
150                    Ok(_) => println!("Successfully removed members from {}", gcopt.name.as_str()),
151                }
152            }
153            GroupOpt::SetMembers(gcopt) => {
154                let client = gcopt.copt.to_client(OpType::Write).await;
155                let new_members: Vec<&str> = gcopt.members.iter().map(String::as_str).collect();
156
157                match client
158                    .idm_group_set_members(gcopt.name.as_str(), &new_members)
159                    .await
160                {
161                    Err(e) => handle_client_error(e, gcopt.copt.output_mode),
162                    Ok(_) => println!("Successfully set members for group {}", gcopt.name.as_str()),
163                }
164            }
165            GroupOpt::SetMail { copt, name, mail } => {
166                let client = copt.to_client(OpType::Write).await;
167
168                let result = if mail.is_empty() {
169                    client.idm_group_purge_mail(name.as_str()).await
170                } else {
171                    client
172                        .idm_group_set_mail(name.as_str(), mail.as_slice())
173                        .await
174                };
175
176                match result {
177                    Err(e) => handle_client_error(e, copt.output_mode),
178                    Ok(_) => println!("Successfully set mail for group {}", name.as_str()),
179                }
180            }
181            GroupOpt::Rename {
182                copt,
183                name,
184                new_name,
185            } => {
186                let client = copt.to_client(OpType::Write).await;
187
188                let result = client.group_rename(name.as_str(), new_name.as_str()).await;
189
190                match result {
191                    Err(e) => handle_client_error(e, copt.output_mode),
192                    Ok(_) => println!("Successfully renamed group {} to {}", name, new_name),
193                }
194            }
195            GroupOpt::SetEntryManagedBy {
196                name,
197                entry_managed_by,
198                copt,
199            } => {
200                let client = copt.to_client(OpType::Write).await;
201
202                match client
203                    .idm_group_set_entry_managed_by(name, entry_managed_by)
204                    .await
205                {
206                    Err(e) => handle_client_error(e, copt.output_mode),
207                    Ok(_) => println!(
208                        "Successfully set entry manager to '{}' for group '{}'",
209                        entry_managed_by, name
210                    ),
211                }
212            }
213            GroupOpt::Posix { commands } => match commands {
214                GroupPosix::Show(gcopt) => {
215                    let client = gcopt.copt.to_client(OpType::Read).await;
216                    match client.idm_group_unix_token_get(gcopt.name.as_str()).await {
217                        Ok(token) => println!("{}", token),
218                        Err(e) => handle_client_error(e, gcopt.copt.output_mode),
219                    }
220                }
221                GroupPosix::Set(gcopt) => {
222                    let client = gcopt.copt.to_client(OpType::Write).await;
223                    match client
224                        .idm_group_unix_extend(gcopt.name.as_str(), gcopt.gidnumber)
225                        .await
226                    {
227                        Err(e) => handle_client_error(e, gcopt.copt.output_mode),
228                        Ok(_) => println!(
229                            "Success adding POSIX configuration for group {}",
230                            gcopt.name.as_str()
231                        ),
232                    }
233                }
234                GroupPosix::ResetGidnumber { copt, group_id } => {
235                    let client = copt.to_client(OpType::Write).await;
236                    if let Err(e) = client
237                        .idm_group_purge_attr(group_id.as_str(), ATTR_GIDNUMBER)
238                        .await
239                    {
240                        handle_client_error(e, copt.output_mode)
241                    }
242                }
243            },
244            GroupOpt::AccountPolicy { commands } => commands.exec().await,
245        } // end match
246    }
247}
kanidm_cli/group/mod.rs

kanidm_cli/group/
mod.rs
