1use derive_builder::Builder;
17use reqwest::Method;
18use std::borrow::Cow;
19
20use crate::api::custom_fields::CustomFieldEssentialsWithValue;
21use crate::api::groups::GroupEssentials;
22use crate::api::project_memberships::UserProjectMembership;
23use crate::api::{
24 CustomFieldFilter, DateTimeFilterPast, Endpoint, NoPagination, Pageable, QueryParams,
25 ReturnsJsonResponse,
26};
27use serde::Serialize;
28
29#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
32pub struct UserEssentials {
33 pub id: u64,
35 pub name: String,
37}
38
39#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
43pub struct User {
44 pub id: u64,
46 #[serde(default, skip_serializing_if = "Option::is_none")]
48 pub status: Option<UserStatus>,
49 pub login: String,
51 pub admin: bool,
53 pub firstname: String,
55 pub lastname: String,
57 #[serde(default, skip_serializing_if = "Option::is_none")]
59 pub mail: Option<String>,
60 #[serde(default, skip_serializing_if = "Option::is_none")]
62 pub api_key: Option<String>,
63 #[serde(default)]
65 pub twofa_scheme: Option<String>,
66 #[serde(default, skip_serializing_if = "Option::is_none")]
68 auth_source_id: Option<u64>,
69 #[serde(
71 serialize_with = "crate::api::serialize_rfc3339",
72 deserialize_with = "crate::api::deserialize_rfc3339"
73 )]
74 pub created_on: time::OffsetDateTime,
75 #[serde(
77 serialize_with = "crate::api::serialize_rfc3339",
78 deserialize_with = "crate::api::deserialize_rfc3339"
79 )]
80 pub updated_on: time::OffsetDateTime,
81 #[serde(
83 serialize_with = "crate::api::serialize_optional_rfc3339",
84 deserialize_with = "crate::api::deserialize_optional_rfc3339"
85 )]
86 pub passwd_changed_on: Option<time::OffsetDateTime>,
87 #[serde(
89 serialize_with = "crate::api::serialize_optional_rfc3339",
90 deserialize_with = "crate::api::deserialize_optional_rfc3339"
91 )]
92 pub last_login_on: Option<time::OffsetDateTime>,
93 #[serde(default, skip_serializing_if = "Option::is_none")]
95 pub custom_fields: Option<Vec<CustomFieldEssentialsWithValue>>,
96 #[serde(default, skip_serializing_if = "Option::is_none")]
98 pub groups: Option<Vec<GroupEssentials>>,
99 #[serde(default, skip_serializing_if = "Option::is_none")]
101 pub memberships: Option<Vec<UserProjectMembership>>,
102}
103
104#[derive(Debug, Clone, PartialEq, Eq)]
106pub enum UserStatus {
107 Active,
109 Registered,
111 Locked,
113}
114
115impl serde::Serialize for UserStatus {
116 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
117 where
118 S: serde::Serializer,
119 {
120 match self {
121 Self::Active => serializer.serialize_u64(1),
122 Self::Registered => serializer.serialize_u64(2),
123 Self::Locked => serializer.serialize_u64(3),
124 }
125 }
126}
127
128impl<'de> serde::Deserialize<'de> for UserStatus {
129 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
130 where
131 D: serde::Deserializer<'de>,
132 {
133 let status_code = u64::deserialize(deserializer)?;
134 match status_code {
135 1 => Ok(Self::Active),
136 2 => Ok(Self::Registered),
137 3 => Ok(Self::Locked),
138 _ => Err(serde::de::Error::custom(format!(
139 "unknown user status code: {status_code}"
140 ))),
141 }
142 }
143}
144
145#[derive(Debug, Clone)]
147pub enum UserStatusFilter {
148 Active,
150 Registered,
152 Locked,
154 Any,
156}
157
158impl std::fmt::Display for UserStatusFilter {
159 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
160 match self {
161 Self::Active => {
162 write!(f, "1")
163 }
164 Self::Registered => {
165 write!(f, "2")
166 }
167 Self::Locked => {
168 write!(f, "3")
169 }
170 Self::Any => {
171 write!(f, "*")
172 }
173 }
174 }
175}
176
177impl From<UserStatus> for UserStatusFilter {
178 fn from(value: UserStatus) -> Self {
179 match value {
180 UserStatus::Active => Self::Active,
181 UserStatus::Registered => Self::Registered,
182 UserStatus::Locked => Self::Locked,
183 }
184 }
185}
186
187#[derive(Debug, Clone, Builder)]
189#[builder(setter(strip_option))]
190pub struct ListUsers<'a> {
191 #[builder(default)]
193 status: Option<UserStatusFilter>,
194 #[builder(default)]
195 #[builder(setter(into))]
197 name: Option<Cow<'a, str>>,
198 #[builder(default)]
200 group_id: Option<u64>,
201 #[builder(default)]
203 auth_source_id: Option<u64>,
204 #[builder(default)]
206 #[builder(setter(into))]
207 twofa_scheme: Option<Cow<'a, str>>,
208 #[builder(default)]
210 admin: Option<bool>,
211 #[builder(default)]
213 created_on: Option<DateTimeFilterPast>,
214 #[builder(default)]
216 last_login_on: Option<DateTimeFilterPast>,
217 #[builder(default)]
219 #[builder(setter(into))]
220 login: Option<Cow<'a, str>>,
221 #[builder(default)]
223 #[builder(setter(into))]
224 firstname: Option<Cow<'a, str>>,
225 #[builder(default)]
227 #[builder(setter(into))]
228 lastname: Option<Cow<'a, str>>,
229 #[builder(default)]
231 #[builder(setter(into))]
232 mail: Option<Cow<'a, str>>,
233 #[builder(default)]
235 custom_field_filters: Option<Vec<CustomFieldFilter>>,
236}
237
238impl ReturnsJsonResponse for ListUsers<'_> {}
239impl Pageable for ListUsers<'_> {
240 fn response_wrapper_key(&self) -> String {
241 "users".to_string()
242 }
243}
244
245impl<'a> ListUsers<'a> {
246 #[must_use]
248 pub fn builder() -> ListUsersBuilder<'a> {
249 ListUsersBuilder::default()
250 }
251}
252
253impl Endpoint for ListUsers<'_> {
254 fn method(&self) -> Method {
255 Method::GET
256 }
257
258 fn endpoint(&self) -> Cow<'static, str> {
259 "users.json".into()
260 }
261
262 fn parameters(&self) -> QueryParams<'_> {
263 let mut params = QueryParams::default();
264 params.push_opt("status", self.status.as_ref().map(|s| s.to_string()));
265 params.push_opt("name", self.name.as_ref());
266 params.push_opt("group_id", self.group_id);
267 params.push_opt("auth_source_id", self.auth_source_id);
268 params.push_opt("twofa_scheme", self.twofa_scheme.as_ref());
269 params.push_opt("admin", self.admin);
270 params.push_opt(
271 "created_on",
272 self.created_on.as_ref().map(|s| s.to_string()),
273 );
274 params.push_opt(
275 "last_login_on",
276 self.last_login_on.as_ref().map(|s| s.to_string()),
277 );
278 params.push_opt("login", self.login.as_ref());
279 params.push_opt("firstname", self.firstname.as_ref());
280 params.push_opt("lastname", self.lastname.as_ref());
281 params.push_opt("mail", self.mail.as_ref());
282 if let Some(filters) = self.custom_field_filters.as_ref() {
283 for filter in filters {
284 params.push(format!("cf_{}", filter.id), filter.value.to_string());
285 }
286 }
287 params
288 }
289}
290
291#[derive(Debug, Clone)]
293pub enum UserInclude {
294 Memberships,
296 Groups,
298}
299
300impl std::fmt::Display for UserInclude {
301 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
302 match self {
303 Self::Memberships => {
304 write!(f, "memberships")
305 }
306 Self::Groups => {
307 write!(f, "groups")
308 }
309 }
310 }
311}
312
313#[derive(Debug, Clone, Builder)]
315#[builder(setter(strip_option))]
316pub struct GetUser {
317 #[builder(default)]
319 id: Option<u64>,
320 #[builder(default)]
322 include: Option<Vec<UserInclude>>,
323}
324
325impl ReturnsJsonResponse for GetUser {}
326impl NoPagination for GetUser {}
327
328impl GetUser {
329 #[must_use]
331 pub fn builder() -> GetUserBuilder {
332 GetUserBuilder::default()
333 }
334}
335
336impl Endpoint for GetUser {
337 fn method(&self) -> Method {
338 Method::GET
339 }
340
341 fn endpoint(&self) -> Cow<'static, str> {
342 match self.id {
343 Some(id) => format!("users/{id}.json").into(),
344 None => "users/current.json".into(),
345 }
346 }
347
348 fn parameters(&self) -> QueryParams<'_> {
349 let mut params = QueryParams::default();
350 params.push_opt("include", self.include.as_ref());
351 params
352 }
353}
354
355#[derive(Debug, Clone, Serialize)]
357#[serde(rename_all = "snake_case")]
358pub enum MailNotificationOptions {
359 All,
361 Selected,
363 OnlyMyEvents,
365 OnlyAssigned,
367 OnlyOwner,
369 OnlyMyWatches,
372 #[serde(rename = "none")]
374 NoMailNotifications,
375}
376
377#[serde_with::skip_serializing_none]
379#[derive(Debug, Clone, Builder, Serialize)]
380#[builder(setter(strip_option))]
381pub struct CreateUser<'a> {
382 #[builder(setter(into))]
384 login: Cow<'a, str>,
385 #[builder(setter(into), default)]
389 password: Option<Cow<'a, str>>,
390 #[builder(setter(into))]
392 firstname: Cow<'a, str>,
393 #[builder(setter(into))]
395 lastname: Cow<'a, str>,
396 #[builder(setter(into))]
398 mail: Cow<'a, str>,
399 #[builder(default)]
401 auth_source_id: Option<u64>,
402 #[builder(default)]
404 mail_notification: Option<MailNotificationOptions>,
405 #[builder(default)]
407 must_change_passwd: Option<bool>,
408 #[builder(default)]
410 generate_password: Option<bool>,
411 #[builder(default)]
413 #[serde(skip_serializing)]
414 send_information: Option<bool>,
415 #[builder(default)]
417 admin: Option<bool>,
418}
419
420impl ReturnsJsonResponse for CreateUser<'_> {}
421impl NoPagination for CreateUser<'_> {}
422
423impl<'a> CreateUser<'a> {
424 #[must_use]
426 pub fn builder() -> CreateUserBuilder<'a> {
427 CreateUserBuilder::default()
428 }
429}
430
431impl Endpoint for CreateUser<'_> {
432 fn method(&self) -> Method {
433 Method::POST
434 }
435
436 fn endpoint(&self) -> Cow<'static, str> {
437 "users.json".into()
438 }
439
440 fn body(&self) -> Result<Option<(&'static str, Vec<u8>)>, crate::Error> {
441 Ok(Some((
442 "application/json",
443 serde_json::to_vec(&UserWrapperWithSendInformation::<CreateUser> {
444 user: (*self).to_owned(),
445 send_information: self.send_information,
446 })?,
447 )))
448 }
449}
450
451#[serde_with::skip_serializing_none]
453#[derive(Debug, Clone, Builder, Serialize)]
454#[builder(setter(strip_option))]
455pub struct UpdateUser<'a> {
456 #[serde(skip_serializing)]
458 id: u64,
459 #[builder(setter(into))]
461 login: Cow<'a, str>,
462 #[builder(setter(into), default)]
466 password: Option<Cow<'a, str>>,
467 #[builder(default, setter(into))]
469 firstname: Option<Cow<'a, str>>,
470 #[builder(default, setter(into))]
472 lastname: Option<Cow<'a, str>>,
473 #[builder(default, setter(into))]
475 mail: Option<Cow<'a, str>>,
476 #[builder(default)]
478 auth_source_id: Option<u64>,
479 #[builder(default)]
481 mail_notification: Option<MailNotificationOptions>,
482 #[builder(default)]
484 must_change_passwd: Option<bool>,
485 #[builder(default)]
487 generate_password: Option<bool>,
488 #[builder(default)]
490 #[serde(skip_serializing)]
491 send_information: Option<bool>,
492 #[builder(default)]
494 admin: Option<bool>,
495}
496
497impl<'a> UpdateUser<'a> {
498 #[must_use]
500 pub fn builder() -> UpdateUserBuilder<'a> {
501 UpdateUserBuilder::default()
502 }
503}
504
505impl Endpoint for UpdateUser<'_> {
506 fn method(&self) -> Method {
507 Method::PUT
508 }
509
510 fn endpoint(&self) -> Cow<'static, str> {
511 format!("users/{}.json", self.id).into()
512 }
513
514 fn body(&self) -> Result<Option<(&'static str, Vec<u8>)>, crate::Error> {
515 Ok(Some((
516 "application/json",
517 serde_json::to_vec(&UserWrapperWithSendInformation::<UpdateUser> {
518 user: (*self).to_owned(),
519 send_information: self.send_information,
520 })?,
521 )))
522 }
523}
524
525#[derive(Debug, Clone, Builder)]
527#[builder(setter(strip_option))]
528pub struct DeleteUser {
529 id: u64,
531}
532
533impl DeleteUser {
534 #[must_use]
536 pub fn builder() -> DeleteUserBuilder {
537 DeleteUserBuilder::default()
538 }
539}
540
541impl Endpoint for DeleteUser {
542 fn method(&self) -> Method {
543 Method::DELETE
544 }
545
546 fn endpoint(&self) -> Cow<'static, str> {
547 format!("users/{}.json", self.id).into()
548 }
549}
550
551#[derive(Debug, Clone, PartialEq, Eq, Serialize, serde::Deserialize)]
553pub struct UsersWrapper<T> {
554 pub users: Vec<T>,
556}
557
558#[derive(Debug, Clone, PartialEq, Eq, Serialize, serde::Deserialize)]
561pub struct UserWrapper<T> {
562 pub user: T,
564}
565
566#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
570pub struct UserWrapperWithSendInformation<T> {
571 pub user: T,
573 #[serde(default, skip_serializing_if = "Option::is_none")]
575 pub send_information: Option<bool>,
576}
577
578#[cfg(test)]
579pub(crate) mod test {
580 use crate::api::{
581 ResponsePage, groups::test::GROUP_LOCK, project_memberships::test::PROJECT_MEMBERSHIP_LOCK,
582 };
583
584 use super::*;
585 use pretty_assertions::assert_eq;
586 use std::error::Error;
587 use tokio::sync::RwLock;
588 use tracing_test::traced_test;
589
590 pub static USER_LOCK: RwLock<()> = RwLock::const_new(());
593
594 #[traced_test]
595 #[test]
596 fn test_list_users_first_page() -> Result<(), Box<dyn Error>> {
597 let _r_user = USER_LOCK.blocking_read();
598 crate::api::test_helpers::setup()?;
599 let redmine = crate::api::Redmine::from_env(
600 reqwest::blocking::Client::builder()
601 .tls_backend_rustls()
602 .build()?,
603 )?;
604 let endpoint = ListUsers::builder().build()?;
605 redmine.json_response_body_page::<_, User>(&endpoint, 0, 25)?;
606 Ok(())
607 }
608
609 #[traced_test]
610 #[test]
611 fn test_list_users_all_pages() -> Result<(), Box<dyn Error>> {
612 let _r_user = USER_LOCK.blocking_read();
613 crate::api::test_helpers::setup()?;
614 let redmine = crate::api::Redmine::from_env(
615 reqwest::blocking::Client::builder()
616 .tls_backend_rustls()
617 .build()?,
618 )?;
619 let endpoint = ListUsers::builder().build()?;
620 redmine.json_response_body_all_pages::<_, User>(&endpoint)?;
621 Ok(())
622 }
623
624 #[traced_test]
625 #[test]
626 fn test_get_user() -> Result<(), Box<dyn Error>> {
627 let _r_user = USER_LOCK.blocking_read();
628 crate::api::test_helpers::setup()?;
629 let redmine = crate::api::Redmine::from_env(
630 reqwest::blocking::Client::builder()
631 .tls_backend_rustls()
632 .build()?,
633 )?;
634 let endpoint = GetUser::builder().id(1).build()?;
635 redmine.json_response_body::<_, UserWrapper<User>>(&endpoint)?;
636 Ok(())
637 }
638
639 #[function_name::named]
640 #[traced_test]
641 #[test]
642 fn test_create_user() -> Result<(), Box<dyn Error>> {
643 let _w_user = USER_LOCK.blocking_write();
644 let name = format!("unittest_{}", function_name!());
645 crate::api::test_helpers::setup()?;
646 let redmine = crate::api::Redmine::from_env(
647 reqwest::blocking::Client::builder()
648 .tls_backend_rustls()
649 .build()?,
650 )?;
651 let list_endpoint = ListUsers::builder().name(name.clone()).build()?;
652 let users: Vec<User> = redmine.json_response_body_all_pages(&list_endpoint)?;
653 for user in users {
654 let delete_endpoint = DeleteUser::builder().id(user.id).build()?;
655 redmine.ignore_response_body::<_>(&delete_endpoint)?;
656 }
657 let create_endpoint = CreateUser::builder()
658 .login(name.clone())
659 .firstname("Unit")
660 .lastname("Test")
661 .mail(format!("unit-test_{name}@example.org"))
662 .build()?;
663 let UserWrapper { user } =
664 redmine.json_response_body::<_, UserWrapper<User>>(&create_endpoint)?;
665 let delete_endpoint = DeleteUser::builder().id(user.id).build()?;
666 redmine.ignore_response_body::<_>(&delete_endpoint)?;
667 Ok(())
668 }
669
670 #[function_name::named]
737 #[traced_test]
738 #[test]
739 fn test_update_user() -> Result<(), Box<dyn Error>> {
740 let _w_user = USER_LOCK.blocking_write();
741 let name = format!("unittest_{}", function_name!());
742 crate::api::test_helpers::setup()?;
743 let redmine = crate::api::Redmine::from_env(
744 reqwest::blocking::Client::builder()
745 .tls_backend_rustls()
746 .build()?,
747 )?;
748 let list_endpoint = ListUsers::builder().name(name.clone()).build()?;
749 let users: Vec<User> = redmine.json_response_body_all_pages(&list_endpoint)?;
750 for user in users {
751 let delete_endpoint = DeleteUser::builder().id(user.id).build()?;
752 redmine.ignore_response_body::<_>(&delete_endpoint)?;
753 }
754 let create_endpoint = CreateUser::builder()
755 .login(name.clone())
756 .firstname("Unit")
757 .lastname("Test")
758 .mail(format!("unit-test_{name}@example.org"))
759 .build()?;
760 let UserWrapper { user } =
761 redmine.json_response_body::<_, UserWrapper<User>>(&create_endpoint)?;
762 let update_endpoint = super::UpdateUser::builder()
763 .id(user.id)
764 .login(format!("new_{name}"))
765 .build()?;
766 redmine.ignore_response_body::<_>(&update_endpoint)?;
767 let delete_endpoint = DeleteUser::builder().id(user.id).build()?;
768 redmine.ignore_response_body::<_>(&delete_endpoint)?;
769 Ok(())
770 }
771
772 #[traced_test]
777 #[test]
778 fn test_completeness_user_type_first_page() -> Result<(), Box<dyn Error>> {
779 let _r_user = USER_LOCK.blocking_read();
780 crate::api::test_helpers::setup()?;
781 let redmine = crate::api::Redmine::from_env(
782 reqwest::blocking::Client::builder()
783 .tls_backend_rustls()
784 .build()?,
785 )?;
786 let endpoint = ListUsers::builder().build()?;
787 let ResponsePage {
788 values,
789 total_count: _,
790 offset: _,
791 limit: _,
792 } = redmine.json_response_body_page::<_, serde_json::Value>(&endpoint, 0, 100)?;
793 for value in values {
794 let o: User = serde_json::from_value(value.clone())?;
795 let reserialized = serde_json::to_value(o)?;
796 assert_eq!(value, reserialized);
797 }
798 Ok(())
799 }
800
801 #[traced_test]
809 #[test]
810 fn test_completeness_user_type_all_pages_all_user_details() -> Result<(), Box<dyn Error>> {
811 let _r_user = USER_LOCK.blocking_read();
812 let _r_groups = GROUP_LOCK.blocking_read();
813 let _r_project_memberships = PROJECT_MEMBERSHIP_LOCK.blocking_read();
814 crate::api::test_helpers::setup()?;
815 let redmine = crate::api::Redmine::from_env(
816 reqwest::blocking::Client::builder()
817 .tls_backend_rustls()
818 .build()?,
819 )?;
820 let endpoint = ListUsers::builder().build()?;
821 let users = redmine.json_response_body_all_pages::<_, User>(&endpoint)?;
822 for user in users {
823 let get_endpoint = GetUser::builder()
824 .id(user.id)
825 .include(vec![UserInclude::Memberships, UserInclude::Groups])
826 .build()?;
827 let UserWrapper { user: value } =
828 redmine.json_response_body::<_, UserWrapper<serde_json::Value>>(&get_endpoint)?;
829 let o: User = serde_json::from_value(value.clone())?;
830 let reserialized = serde_json::to_value(o)?;
831 assert_eq!(value, reserialized);
832 }
833 Ok(())
834 }
835}