1use derive_builder::Builder;
8use reqwest::Method;
9use serde::Serialize;
10use std::borrow::Cow;
11
12use crate::api::issues::RoleFilter;
13use crate::api::projects::ProjectEssentials;
14use crate::api::roles::RoleEssentials;
15use crate::api::trackers::TrackerEssentials;
16use crate::api::versions::VersionStatusFilter;
17use crate::api::{Endpoint, NoPagination, ReturnsJsonResponse};
18
19#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
22#[serde(rename_all = "snake_case")]
23pub enum CustomizedType {
24 Issue,
26 TimeEntry,
28 Project,
30 Version,
32 User,
34 Group,
36 Activity,
38 IssuePriority,
40 DocumentCategory,
42}
43
44#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
46#[serde(rename_all = "snake_case")]
47pub enum FieldFormat {
48 User,
50 Version,
52 String,
54 Text,
56 Link,
58 Int,
60 Float,
62 Date,
64 List,
66 Bool,
68 Enumeration,
70 Attachment,
72 Progressbar,
74}
75
76#[derive(Debug, Clone, PartialEq, Eq)]
78pub enum EditTagStyle {
79 DropDown,
81 CheckBox,
83 Radio,
85}
86
87impl serde::Serialize for EditTagStyle {
88 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
89 where
90 S: serde::Serializer,
91 {
92 match *self {
93 Self::DropDown => serializer.serialize_str(""),
94 Self::CheckBox => serializer.serialize_str("check_box"),
95 Self::Radio => serializer.serialize_str("radio"),
96 }
97 }
98}
99
100impl<'de> serde::Deserialize<'de> for EditTagStyle {
101 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
102 where
103 D: serde::Deserializer<'de>,
104 {
105 let s = String::deserialize(deserializer)?;
106 match s.as_str() {
107 "" => Ok(Self::DropDown),
108 "check_box" => Ok(Self::CheckBox),
109 "radio" => Ok(Self::Radio),
110 _ => Err(serde::de::Error::unknown_variant(
111 &s,
112 &["", "check_box", "radio"],
113 )),
114 }
115 }
116}
117
118#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
123#[serde(rename_all = "snake_case")]
124pub enum DefaultValueMode {
125 FixedDate,
127 DateOffset,
130}
131
132#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
134#[serde(rename_all = "snake_case")]
135pub struct PossibleValue {
136 pub label: String,
138 pub value: String,
140}
141
142#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
146#[expect(
147 clippy::struct_excessive_bools,
148 reason = "field set mirrors the Redmine REST representation"
149)]
150pub struct CustomFieldDefinition {
151 pub id: u64,
153 pub name: String,
155 pub description: Option<String>,
157 pub editable: bool,
159 pub customized_type: CustomizedType,
161 pub field_format: FieldFormat,
163 pub regexp: Option<String>,
165 pub min_length: Option<usize>,
167 pub max_length: Option<usize>,
169 pub is_required: Option<bool>,
171 pub is_filter: Option<bool>,
173 pub searchable: bool,
175 pub multiple: bool,
177 pub default_value: Option<String>,
183 #[serde(default, skip_serializing_if = "Option::is_none")]
186 pub default_value_mode: Option<DefaultValueMode>,
187 pub visible: bool,
189 #[serde(default, skip_serializing_if = "Option::is_none")]
191 pub roles: Option<Vec<RoleEssentials>>,
192 #[serde(skip_serializing_if = "Option::is_none")]
194 pub possible_values: Option<Vec<PossibleValue>>,
195 #[serde(default, skip_serializing_if = "Option::is_none")]
197 pub trackers: Option<Vec<TrackerEssentials>>,
198 #[serde(skip_serializing_if = "Option::is_none")]
200 pub projects: Option<Vec<ProjectEssentials>>,
201 #[serde(default, skip_serializing_if = "Option::is_none")]
203 pub is_for_all: Option<bool>,
204 #[serde(default, skip_serializing_if = "Option::is_none")]
206 pub position: Option<u64>,
207 #[serde(default, skip_serializing_if = "Option::is_none")]
209 pub url_pattern: Option<String>,
210 #[serde(default, skip_serializing_if = "Option::is_none")]
212 pub text_formatting: Option<String>,
213 #[serde(default, skip_serializing_if = "Option::is_none")]
215 pub edit_tag_style: Option<EditTagStyle>,
216 #[serde(default, skip_serializing_if = "Option::is_none")]
218 pub user_role: Option<RoleFilter>,
219 #[serde(default, skip_serializing_if = "Option::is_none")]
221 pub version_status: Option<VersionStatusFilter>,
222 #[serde(default, skip_serializing_if = "Option::is_none")]
224 pub extensions_allowed: Option<String>,
225 #[serde(default, skip_serializing_if = "Option::is_none")]
227 pub full_width_layout: Option<bool>,
228 #[serde(default, skip_serializing_if = "Option::is_none")]
230 pub thousands_delimiter: Option<bool>,
231 #[serde(default, skip_serializing_if = "Option::is_none")]
233 pub ratio_interval: Option<f32>,
234}
235
236#[derive(Debug, Clone, PartialEq, Eq)]
239pub struct CustomFieldEssentialsWithValue {
240 pub id: u64,
242 pub name: String,
244 pub multiple: Option<bool>,
246 pub value: Option<Vec<String>>,
248}
249
250#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
252pub struct CustomFieldName {
253 pub id: u64,
255 pub name: String,
257}
258
259impl serde::Serialize for CustomFieldEssentialsWithValue {
260 #[expect(
261 clippy::arithmetic_side_effects,
262 reason = "field count is bounded by the four optional fields below"
263 )]
264 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
265 where
266 S: serde::Serializer,
267 {
268 use serde::ser::SerializeStruct as _;
269 let mut len = 2;
270 if self.multiple.is_some() {
271 len += 1;
272 };
273 if self.value.is_some() {
274 len += 1;
275 }
276 let mut state = serializer.serialize_struct("CustomFieldEssentialsWithValue", len)?;
277 state.serialize_field("id", &self.id)?;
278 state.serialize_field("name", &self.name)?;
279 if let Some(ref multiple) = self.multiple {
280 state.serialize_field("multiple", &multiple)?;
281 if let Some(ref value) = self.value {
282 state.serialize_field("value", &value)?;
283 } else {
284 let s: Option<Vec<String>> = None;
285 state.serialize_field("value", &s)?;
286 }
287 } else if let Some(ref value) = self.value {
288 match value.as_slice() {
289 [] => {
290 let s: Option<String> = None;
291 state.serialize_field("value", &s)?;
292 }
293 [s] => {
294 state.serialize_field("value", &s)?;
295 }
296 values => {
297 return Err(serde::ser::Error::custom(format!(
298 "CustomFieldEssentialsWithValue multiple was set to false but value contained more than one value: {values:?}"
299 )));
300 }
301 }
302 } else {
303 let s: Option<String> = None;
304 state.serialize_field("value", &s)?;
305 }
306 state.end()
307 }
308}
309
310impl<'de> serde::Deserialize<'de> for CustomFieldEssentialsWithValue {
311 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
312 where
313 D: serde::Deserializer<'de>,
314 {
315 #[derive(serde::Deserialize)]
317 #[serde(field_identifier, rename_all = "lowercase")]
318 enum Field {
319 Id,
321 Name,
323 Multiple,
325 Value,
327 }
328
329 struct CustomFieldVisitor;
331
332 impl<'de> serde::de::Visitor<'de> for CustomFieldVisitor {
333 type Value = CustomFieldEssentialsWithValue;
334
335 fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
336 formatter.write_str("struct CustomFieldEssentialsWithValue")
337 }
338
339 fn visit_map<V>(self, mut map: V) -> Result<CustomFieldEssentialsWithValue, V::Error>
340 where
341 V: serde::de::MapAccess<'de>,
342 {
343 let mut id = None;
344 let mut name = None;
345 let mut multiple = None;
346 let mut string_value: Option<String> = None;
347 let mut vec_string_value: Option<Vec<String>> = None;
348 while let Some(key) = map.next_key()? {
349 match key {
350 Field::Id => {
351 if id.is_some() {
352 return Err(serde::de::Error::duplicate_field("id"));
353 }
354 id = Some(map.next_value()?);
355 }
356 Field::Name => {
357 if name.is_some() {
358 return Err(serde::de::Error::duplicate_field("name"));
359 }
360 name = Some(map.next_value()?);
361 }
362 Field::Multiple => {
363 if multiple.is_some() {
364 return Err(serde::de::Error::duplicate_field("multiple"));
365 }
366 multiple = Some(map.next_value()?);
367 }
368 Field::Value => {
369 if string_value.is_some() {
370 return Err(serde::de::Error::duplicate_field("value"));
371 }
372 if vec_string_value.is_some() {
373 return Err(serde::de::Error::duplicate_field("value"));
374 }
375 if multiple == Some(true) {
376 vec_string_value = Some(map.next_value()?);
377 } else {
378 string_value = map.next_value()?;
379 }
380 }
381 }
382 }
383 let id = id.ok_or_else(|| serde::de::Error::missing_field("id"))?;
384 let name = name.ok_or_else(|| serde::de::Error::missing_field("name"))?;
385 match (multiple, string_value, vec_string_value) {
386 (None, None, None) => Ok(CustomFieldEssentialsWithValue {
387 id,
388 name,
389 multiple: None,
390 value: None,
391 }),
392 (None, Some(s), None) => Ok(CustomFieldEssentialsWithValue {
393 id,
394 name,
395 multiple: None,
396 value: Some(vec![s]),
397 }),
398 (Some(true), None, Some(v)) => Ok(CustomFieldEssentialsWithValue {
399 id,
400 name,
401 multiple: Some(true),
402 value: Some(v),
403 }),
404 _ => Err(serde::de::Error::custom(
405 "invalid combination of multiple and value",
406 )),
407 }
408 }
409 }
410
411 const FIELDS: &[&str] = &["id", "name", "multiple", "value"];
413 deserializer.deserialize_struct(
414 "CustomFieldEssentialsWithValue",
415 FIELDS,
416 CustomFieldVisitor,
417 )
418 }
419}
420
421#[derive(Debug, Clone, Builder)]
423#[builder(setter(strip_option))]
424#[expect(
425 clippy::empty_structs_with_brackets,
426 reason = "derive_builder requires named-field syntax"
427)]
428pub struct ListCustomFields {}
429
430impl ReturnsJsonResponse for ListCustomFields {}
431impl NoPagination for ListCustomFields {}
432
433impl ListCustomFields {
434 #[must_use]
436 pub fn builder() -> ListCustomFieldsBuilder {
437 ListCustomFieldsBuilder::default()
438 }
439}
440
441impl Endpoint for ListCustomFields {
442 fn method(&self) -> Method {
443 Method::GET
444 }
445
446 fn endpoint(&self) -> Cow<'static, str> {
447 "custom_fields.json".into()
448 }
449}
450
451#[derive(Debug, Clone, Serialize, serde::Deserialize)]
453pub struct CustomField<'a> {
454 pub id: u64,
456 pub name: Option<Cow<'a, str>>,
458 pub value: Cow<'a, str>,
460}
461
462#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
464pub struct CustomFieldsWrapper<T> {
465 pub custom_fields: Vec<T>,
467}
468
469#[cfg(test)]
470mod test {
471 use super::*;
472 use pretty_assertions::assert_eq;
473 use std::error::Error;
474 use tracing_test::traced_test;
475
476 #[traced_test]
477 #[test]
478 fn test_list_custom_fields_no_pagination() -> Result<(), Box<dyn Error>> {
479 crate::api::test_helpers::setup()?;
480 let redmine = crate::api::Redmine::from_env(
481 reqwest::blocking::Client::builder()
482 .tls_backend_rustls()
483 .build()?,
484 )?;
485 let endpoint = ListCustomFields::builder().build()?;
486 redmine.json_response_body::<_, CustomFieldsWrapper<CustomFieldDefinition>>(&endpoint)?;
487 Ok(())
488 }
489
490 #[traced_test]
495 #[test]
496 fn test_completeness_custom_fields_type() -> Result<(), Box<dyn Error>> {
497 crate::api::test_helpers::setup()?;
498 let redmine = crate::api::Redmine::from_env(
499 reqwest::blocking::Client::builder()
500 .tls_backend_rustls()
501 .build()?,
502 )?;
503 let endpoint = ListCustomFields::builder().build()?;
504 let CustomFieldsWrapper {
505 custom_fields: values,
506 } = redmine.json_response_body::<_, CustomFieldsWrapper<serde_json::Value>>(&endpoint)?;
507 for value in values {
508 let o: CustomFieldDefinition = serde_json::from_value(value.clone())?;
509 let reserialized = serde_json::to_value(o)?;
510 assert_eq!(value, reserialized);
511 }
512 Ok(())
513 }
514}