use derive_builder::Builder;
use reqwest::Method;
use std::borrow::Cow;
use crate::api::custom_fields::CustomField;
use crate::api::custom_fields::CustomFieldEssentialsWithValue;
use crate::api::project_memberships::GroupProjectMembership;
use crate::api::users::UserEssentials;
use crate::api::{Endpoint, NoPagination, QueryParams, ReturnsJsonResponse};
use serde::Serialize;
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct GroupEssentials {
pub id: u64,
pub name: String,
}
impl From<Group> for GroupEssentials {
fn from(v: Group) -> Self {
Self {
id: v.id,
name: v.name,
}
}
}
impl From<&Group> for GroupEssentials {
fn from(v: &Group) -> Self {
Self {
id: v.id,
name: v.name.to_owned(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, serde::Deserialize)]
pub struct Group {
pub id: u64,
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub users: Option<Vec<UserEssentials>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub memberships: Option<Vec<GroupProjectMembership>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub custom_fields: Option<Vec<CustomFieldEssentialsWithValue>>,
}
#[derive(Debug, Clone, Builder)]
#[builder(setter(strip_option))]
pub struct ListGroups {
#[builder(default)]
builtin: Option<bool>,
}
impl ReturnsJsonResponse for ListGroups {}
impl NoPagination for ListGroups {}
impl ListGroups {
#[must_use]
pub fn builder() -> ListGroupsBuilder {
ListGroupsBuilder::default()
}
}
impl Endpoint for ListGroups {
fn method(&self) -> Method {
Method::GET
}
fn endpoint(&self) -> Cow<'static, str> {
"groups.json".into()
}
fn parameters(&self) -> QueryParams<'_> {
let mut params = QueryParams::default();
params.push_opt("builtin", self.builtin);
params
}
}
#[derive(Debug, Clone)]
pub enum GroupInclude {
Users,
Memberships,
}
impl std::fmt::Display for GroupInclude {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Users => {
write!(f, "users")
}
Self::Memberships => {
write!(f, "memberships")
}
}
}
}
#[derive(Debug, Clone, Builder)]
#[builder(setter(strip_option))]
pub struct GetGroup {
id: u64,
#[builder(default)]
include: Option<Vec<GroupInclude>>,
}
impl ReturnsJsonResponse for GetGroup {}
impl NoPagination for GetGroup {}
impl GetGroup {
#[must_use]
pub fn builder() -> GetGroupBuilder {
GetGroupBuilder::default()
}
}
impl Endpoint for GetGroup {
fn method(&self) -> Method {
Method::GET
}
fn endpoint(&self) -> Cow<'static, str> {
format!("groups/{}.json", self.id).into()
}
fn parameters(&self) -> QueryParams<'_> {
let mut params = QueryParams::default();
params.push_opt("include", self.include.as_ref());
params
}
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Clone, Builder, Serialize)]
#[builder(setter(strip_option))]
pub struct CreateGroup<'a> {
#[builder(setter(into))]
name: Cow<'a, str>,
#[builder(default)]
twofa_required: Option<bool>,
#[builder(default)]
user_ids: Option<Vec<u64>>,
#[builder(default)]
custom_fields: Option<Vec<CustomField<'a>>>,
}
impl ReturnsJsonResponse for CreateGroup<'_> {}
impl NoPagination for CreateGroup<'_> {}
impl<'a> CreateGroup<'a> {
#[must_use]
pub fn builder() -> CreateGroupBuilder<'a> {
CreateGroupBuilder::default()
}
}
impl Endpoint for CreateGroup<'_> {
fn method(&self) -> Method {
Method::POST
}
fn endpoint(&self) -> Cow<'static, str> {
"groups.json".into()
}
fn body(&self) -> Result<Option<(&'static str, Vec<u8>)>, crate::Error> {
Ok(Some((
"application/json",
serde_json::to_vec(&GroupWrapper::<CreateGroup> {
group: (*self).to_owned(),
})?,
)))
}
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Clone, Builder, Serialize)]
#[builder(setter(strip_option))]
pub struct UpdateGroup<'a> {
#[serde(skip_serializing)]
id: u64,
#[builder(setter(into))]
name: Cow<'a, str>,
#[builder(default)]
twofa_required: Option<bool>,
#[builder(default)]
user_ids: Option<Vec<u64>>,
#[builder(default)]
custom_fields: Option<Vec<CustomField<'a>>>,
}
impl<'a> UpdateGroup<'a> {
#[must_use]
pub fn builder() -> UpdateGroupBuilder<'a> {
UpdateGroupBuilder::default()
}
}
impl Endpoint for UpdateGroup<'_> {
fn method(&self) -> Method {
Method::PUT
}
fn endpoint(&self) -> Cow<'static, str> {
format!("groups/{}.json", self.id).into()
}
fn body(&self) -> Result<Option<(&'static str, Vec<u8>)>, crate::Error> {
Ok(Some((
"application/json",
serde_json::to_vec(&GroupWrapper::<UpdateGroup> {
group: (*self).to_owned(),
})?,
)))
}
}
#[derive(Debug, Clone, Builder)]
#[builder(setter(strip_option))]
pub struct DeleteGroup {
id: u64,
}
impl DeleteGroup {
#[must_use]
pub fn builder() -> DeleteGroupBuilder {
DeleteGroupBuilder::default()
}
}
impl Endpoint for DeleteGroup {
fn method(&self) -> Method {
Method::DELETE
}
fn endpoint(&self) -> Cow<'static, str> {
format!("groups/{}.json", self.id).into()
}
}
#[derive(Debug, Clone, Builder, Serialize)]
#[builder(setter(strip_option))]
pub struct AddUserToGroup {
#[serde(skip_serializing)]
group_id: u64,
user_id: u64,
}
impl AddUserToGroup {
#[must_use]
pub fn builder() -> AddUserToGroupBuilder {
AddUserToGroupBuilder::default()
}
}
impl Endpoint for AddUserToGroup {
fn method(&self) -> Method {
Method::POST
}
fn endpoint(&self) -> Cow<'static, str> {
format!("groups/{}/users.json", self.group_id).into()
}
fn body(&self) -> Result<Option<(&'static str, Vec<u8>)>, crate::Error> {
Ok(Some(("application/json", serde_json::to_vec(self)?)))
}
}
#[derive(Debug, Clone, Builder)]
#[builder(setter(strip_option))]
pub struct RemoveUserFromGroup {
group_id: u64,
user_id: u64,
}
impl RemoveUserFromGroup {
#[must_use]
pub fn builder() -> RemoveUserFromGroupBuilder {
RemoveUserFromGroupBuilder::default()
}
}
impl Endpoint for RemoveUserFromGroup {
fn method(&self) -> Method {
Method::DELETE
}
fn endpoint(&self) -> Cow<'static, str> {
format!("groups/{}/users/{}.json", self.group_id, self.user_id).into()
}
}
#[derive(Debug, Clone, Builder, Serialize)]
#[builder(setter(strip_option))]
pub struct RemoveUsersFromGroup {
#[serde(skip_serializing)]
group_id: u64,
user_ids: Vec<u64>,
}
impl RemoveUsersFromGroup {
#[must_use]
pub fn builder() -> RemoveUsersFromGroupBuilder {
RemoveUsersFromGroupBuilder::default()
}
}
impl Endpoint for RemoveUsersFromGroup {
fn method(&self) -> Method {
Method::DELETE
}
fn endpoint(&self) -> Cow<'static, str> {
format!("groups/{}/users.json", self.group_id).into()
}
fn body(&self) -> Result<Option<(&'static str, Vec<u8>)>, crate::Error> {
Ok(Some(("application/json", serde_json::to_vec(self)?)))
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, serde::Deserialize)]
pub struct GroupsWrapper<T> {
pub groups: Vec<T>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, serde::Deserialize)]
pub struct GroupWrapper<T> {
pub group: T,
}
#[cfg(test)]
pub(crate) mod test {
use super::*;
use crate::api::project_memberships::test::PROJECT_MEMBERSHIP_LOCK;
use crate::api::test_helpers::{RedmineVersion, current_user_id, redmine_version, with_group};
use crate::api::users::test::USER_LOCK;
use pretty_assertions::assert_eq;
use std::error::Error;
use tokio::sync::RwLock;
use tracing::trace;
use tracing_test::traced_test;
pub static GROUP_LOCK: RwLock<()> = RwLock::const_new(());
#[traced_test]
#[test]
fn test_list_groups_no_pagination() -> Result<(), Box<dyn Error>> {
let _r_groups = GROUP_LOCK.blocking_read();
crate::api::test_helpers::setup()?;
let redmine = crate::api::Redmine::from_env(
reqwest::blocking::Client::builder()
.tls_backend_rustls()
.build()?,
)?;
let endpoint = ListGroups::builder().build()?;
redmine.json_response_body::<_, GroupsWrapper<Group>>(&endpoint)?;
Ok(())
}
#[function_name::named]
#[traced_test]
#[test]
fn test_get_group() -> Result<(), Box<dyn Error>> {
let name = format!("unittest_{}", function_name!());
with_group(&name, |redmine, id, name| {
let endpoint = GetGroup::builder().id(id).build()?;
let GroupWrapper { group } =
redmine.json_response_body::<_, GroupWrapper<Group>>(&endpoint)?;
assert_eq!(group.name, name);
Ok(())
})?;
Ok(())
}
#[function_name::named]
#[traced_test]
#[test]
fn test_create_group() -> Result<(), Box<dyn Error>> {
let name = format!("unittest_{}", function_name!());
with_group(&name, |_, _, _| Ok(()))?;
Ok(())
}
#[function_name::named]
#[traced_test]
#[test]
fn test_update_group() -> Result<(), Box<dyn Error>> {
let name = format!("unittest_{}", function_name!());
with_group(&name, |redmine, id, _name| {
let update_endpoint = super::UpdateGroup::builder()
.id(id)
.name("unittest_rename_test")
.build()?;
redmine.ignore_response_body::<_>(&update_endpoint)?;
Ok(())
})?;
Ok(())
}
fn group_user_ids(
redmine: &crate::api::Redmine,
group_id: u64,
) -> Result<Vec<u64>, Box<dyn Error>> {
let endpoint = GetGroup::builder()
.id(group_id)
.include(vec![GroupInclude::Users])
.build()?;
let GroupWrapper { group } =
redmine.json_response_body::<_, GroupWrapper<Group>>(&endpoint)?;
Ok(group
.users
.unwrap_or_default()
.into_iter()
.map(|u| u.id)
.collect())
}
fn with_current_user_in_group<F>(name: &str, f: F) -> Result<(), Box<dyn Error>>
where
F: FnOnce(&crate::api::Redmine, u64, u64) -> Result<(), Box<dyn Error>>,
{
with_group(name, |redmine, group_id, _name| {
let user_id = current_user_id(redmine)?;
let add_endpoint = AddUserToGroup::builder()
.group_id(group_id)
.user_id(user_id)
.build()?;
redmine.ignore_response_body::<_>(&add_endpoint)?;
assert_eq!(group_user_ids(redmine, group_id)?, vec![user_id]);
f(redmine, group_id, user_id)
})
}
fn has_remove_users_from_group_route(group_id: u64) -> Result<bool, Box<dyn Error>> {
let url = std::env::var("REDMINE_URL")?;
let api_key = std::env::var("REDMINE_API_KEY")?;
let response = reqwest::blocking::Client::builder()
.tls_backend_rustls()
.build()?
.delete(format!(
"{}/groups/{group_id}/users.json",
url.trim_end_matches('/')
))
.header("X-Redmine-API-Key", api_key)
.send()?;
let content_type = response
.headers()
.get(reqwest::header::CONTENT_TYPE)
.and_then(|v| v.to_str().ok())
.unwrap_or_default()
.to_owned();
trace!(status = %response.status(), %content_type, "RemoveUsersFromGroup probe");
Ok(response.status() == reqwest::StatusCode::NOT_FOUND
&& content_type.starts_with("application/json"))
}
#[function_name::named]
#[traced_test]
#[test]
fn test_add_and_remove_user_from_group() -> Result<(), Box<dyn Error>> {
let name = format!("unittest_{}", function_name!());
with_current_user_in_group(&name, |redmine, group_id, user_id| {
let remove_endpoint = RemoveUserFromGroup::builder()
.group_id(group_id)
.user_id(user_id)
.build()?;
redmine.ignore_response_body::<_>(&remove_endpoint)?;
assert_eq!(group_user_ids(redmine, group_id)?, Vec::<u64>::new());
Ok(())
})
}
#[function_name::named]
#[traced_test]
#[test]
fn test_add_and_remove_users_from_group() -> Result<(), Box<dyn Error>> {
let version = redmine_version()?;
let name = format!("unittest_{}", function_name!());
with_group(&name, |redmine, group_id, _name| {
let has_route = has_remove_users_from_group_route(group_id)?;
if version < RedmineVersion::new(7, 0, 0) {
assert!(
!has_route,
"REDMINE_VERSION is {version} but the Redmine instance has the \
RemoveUsersFromGroup endpoint added in Redmine 7.0, \
is REDMINE_VERSION correct?"
);
return Ok(());
}
assert!(
has_route,
"REDMINE_VERSION is {version} but the Redmine instance does not have the \
RemoveUsersFromGroup endpoint added in Redmine 7.0, \
is REDMINE_VERSION correct?"
);
let user_id = current_user_id(redmine)?;
let add_endpoint = AddUserToGroup::builder()
.group_id(group_id)
.user_id(user_id)
.build()?;
redmine.ignore_response_body::<_>(&add_endpoint)?;
assert_eq!(group_user_ids(redmine, group_id)?, vec![user_id]);
let remove_endpoint = RemoveUsersFromGroup::builder()
.group_id(group_id)
.user_ids(vec![user_id])
.build()?;
redmine.ignore_response_body::<_>(&remove_endpoint)?;
assert_eq!(group_user_ids(redmine, group_id)?, Vec::<u64>::new());
Ok(())
})
}
#[traced_test]
#[test]
fn test_completeness_group_type() -> Result<(), Box<dyn Error>> {
let _r_groups = GROUP_LOCK.blocking_read();
crate::api::test_helpers::setup()?;
let redmine = crate::api::Redmine::from_env(
reqwest::blocking::Client::builder()
.tls_backend_rustls()
.build()?,
)?;
let endpoint = ListGroups::builder().build()?;
let GroupsWrapper { groups: values } =
redmine.json_response_body::<_, GroupsWrapper<serde_json::Value>>(&endpoint)?;
for value in values {
let o: Group = serde_json::from_value(value.clone())?;
let reserialized = serde_json::to_value(o)?;
assert_eq!(value, reserialized);
}
Ok(())
}
#[traced_test]
#[test]
fn test_completeness_group_type_all_group_details() -> Result<(), Box<dyn Error>> {
let _r_user = USER_LOCK.blocking_read();
let _r_groups = GROUP_LOCK.blocking_read();
let _r_project_memberships = PROJECT_MEMBERSHIP_LOCK.blocking_read();
crate::api::test_helpers::setup()?;
let redmine = crate::api::Redmine::from_env(
reqwest::blocking::Client::builder()
.tls_backend_rustls()
.build()?,
)?;
let endpoint = ListGroups::builder().build()?;
let GroupsWrapper { groups } =
redmine.json_response_body::<_, GroupsWrapper<Group>>(&endpoint)?;
for group in groups {
let get_endpoint = GetGroup::builder()
.id(group.id)
.include(vec![GroupInclude::Users, GroupInclude::Memberships])
.build()?;
let GroupWrapper { group: value } =
redmine.json_response_body::<_, GroupWrapper<serde_json::Value>>(&get_endpoint)?;
let o: Group = serde_json::from_value(value.clone())?;
let reserialized = serde_json::to_value(o)?;
assert_eq!(value, reserialized);
}
Ok(())
}
}