1use crate::{
2 api::{self, auth::userpass::requests::LoginRequest, AuthInfo},
3 client::Client,
4 error::ClientError,
5};
6
7pub async fn login(
11 client: &impl Client,
12 mount: &str,
13 username: &str,
14 password: &str,
15) -> Result<AuthInfo, ClientError> {
16 let endpoint = LoginRequest::builder()
17 .mount(mount)
18 .username(username)
19 .password(password)
20 .build()
21 .unwrap();
22 api::auth(client, endpoint).await
23}
24
25pub mod user {
26 use crate::{
27 api::{
28 self,
29 auth::userpass::{
30 requests::{
31 CreateUserRequest, CreateUserRequestBuilder, DeleteUserRequest,
32 ListUsersRequest, ReadUserRequest, UpdatePasswordRequest,
33 UpdatePoliciesRequest,
34 },
35 responses::{ListUsersResponse, ReadUserResponse},
36 },
37 },
38 client::Client,
39 error::ClientError,
40 };
41
42 pub async fn delete(
46 client: &impl Client,
47 mount: &str,
48 username: &str,
49 ) -> Result<(), ClientError> {
50 let endpoint = DeleteUserRequest::builder()
51 .mount(mount)
52 .username(username)
53 .build()
54 .unwrap();
55 api::exec_with_empty(client, endpoint).await
56 }
57
58 pub async fn list(client: &impl Client, mount: &str) -> Result<ListUsersResponse, ClientError> {
62 let endpoint = ListUsersRequest::builder().mount(mount).build().unwrap();
63 api::exec_with_result(client, endpoint).await
64 }
65
66 pub async fn read(
70 client: &impl Client,
71 mount: &str,
72 username: &str,
73 ) -> Result<ReadUserResponse, ClientError> {
74 let endpoint = ReadUserRequest::builder()
75 .mount(mount)
76 .username(username)
77 .build()
78 .unwrap();
79 api::exec_with_result(client, endpoint).await
80 }
81
82 pub async fn set(
86 client: &impl Client,
87 mount: &str,
88 username: &str,
89 password: &str,
90 opts: Option<&mut CreateUserRequestBuilder>,
91 ) -> Result<(), ClientError> {
92 let mut t = CreateUserRequest::builder();
93 let endpoint = opts
94 .unwrap_or(&mut t)
95 .mount(mount)
96 .username(username)
97 .password(password)
98 .build()
99 .unwrap();
100 api::exec_with_empty(client, endpoint).await
101 }
102
103 pub async fn update_password(
107 client: &impl Client,
108 mount: &str,
109 username: &str,
110 password: &str,
111 ) -> Result<(), ClientError> {
112 let endpoint = UpdatePasswordRequest::builder()
113 .mount(mount)
114 .username(username)
115 .password(password)
116 .build()
117 .unwrap();
118 api::exec_with_empty(client, endpoint).await
119 }
120
121 pub async fn update_policies(
125 client: &impl Client,
126 mount: &str,
127 username: &str,
128 policies: &str,
129 ) -> Result<(), ClientError> {
130 let endpoint = UpdatePoliciesRequest::builder()
131 .mount(mount)
132 .username(username)
133 .policies(policies)
134 .build()
135 .unwrap();
136 api::exec_with_empty(client, endpoint).await
137 }
138}