use jmap_types::{SetError, SetErrorType};
use serde_json::{Map, Value};
pub const DEFAULT_WORKFLOW_STATUSES: &[&str] = &[
"completed",
"failed",
"in-process",
"needs-action",
"cancelled",
"pending",
];
pub const PROGRESS_VALUES: &[&str] = &[
"needs-action",
"in-process",
"completed",
"failed",
"cancelled",
];
fn invalid(property: &str, description: &str) -> Box<SetError> {
Box::new(
SetError::new(SetErrorType::InvalidProperties)
.with_properties([property])
.with_description(description),
)
}
#[derive(Debug, Clone, Copy)]
pub enum WorkflowWrite<'a> {
Create,
Update {
before: &'a Map<String, Value>,
written: &'a [String],
},
}
pub fn apply_workflow_status(
task: &mut Map<String, Value>,
write: WorkflowWrite<'_>,
list_statuses: Option<&[String]>,
now: &str,
) -> Result<bool, Box<SetError>> {
let wrote_progress_updated = match write {
WorkflowWrite::Create => task_has(task, "progressUpdated"),
WorkflowWrite::Update { written, .. } => written.iter().any(|w| w == "progressUpdated"),
};
let (sets_status, sets_progress, moves) = match write {
WorkflowWrite::Create => (true, task_has(task, "progress"), false),
WorkflowWrite::Update { before, written } => (
written.iter().any(|w| w == "workflowStatus"),
written.iter().any(|w| w == "progress"),
before.get("taskListId") != task.get("taskListId"),
),
};
let Some(status) = task
.get("workflowStatus")
.and_then(Value::as_str)
.map(str::to_owned)
else {
return Ok(false);
};
if sets_status || moves {
let allowed = match list_statuses {
Some(list) => list.contains(&status),
None => DEFAULT_WORKFLOW_STATUSES.contains(&status.as_str()),
};
if !allowed {
return Err(invalid(
"workflowStatus",
"workflowStatus is not one of the task list's workflowStatuses",
));
}
}
if !sets_status && !sets_progress {
return Ok(false);
}
let mirrored = PROGRESS_VALUES
.contains(&status.as_str())
.then(|| Value::String(status.clone()));
let given = task.get("progress").filter(|v| !v.is_null()).cloned();
if sets_progress && given != mirrored {
return Err(invalid(
"progress",
"progress must match workflowStatus: the workflowStatus when it is a progress value, otherwise null",
));
}
let previous = match write {
WorkflowWrite::Create => None,
WorkflowWrite::Update { before, .. } => before.get("progress").filter(|v| !v.is_null()),
};
let mut changed = given != mirrored;
match &mirrored {
Some(v) => {
task.insert("progress".to_owned(), v.clone());
}
None => {
task.remove("progress");
}
}
if previous != mirrored.as_ref() && !wrote_progress_updated {
task.insert("progressUpdated".to_owned(), Value::String(now.to_owned()));
changed = true;
}
Ok(changed)
}
fn task_has(task: &Map<String, Value>, k: &str) -> bool {
task.get(k).is_some_and(|v| !v.is_null())
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
const NOW: &str = "2026-11-19T12:00:00Z";
fn map(v: Value) -> Map<String, Value> {
v.as_object().cloned().unwrap()
}
#[test]
fn a_progress_value_mirrors() {
let mut t = map(json!({ "taskListId": "L", "workflowStatus": "completed" }));
assert!(apply_workflow_status(&mut t, WorkflowWrite::Create, None, NOW).unwrap());
assert_eq!(t["progress"], "completed");
assert_eq!(t["progressUpdated"], NOW);
}
#[test]
fn pending_leaves_progress_null() {
let mut t = map(json!({ "taskListId": "L", "workflowStatus": "pending" }));
assert!(!apply_workflow_status(&mut t, WorkflowWrite::Create, None, NOW).unwrap());
assert!(t.get("progress").is_none());
}
#[test]
fn matching_progress_is_accepted() {
let mut t = map(json!({ "workflowStatus": "in-process", "progress": "in-process" }));
apply_workflow_status(&mut t, WorkflowWrite::Create, None, NOW).unwrap();
}
#[test]
fn an_unrelated_update_skips_the_list_check() {
let before = map(json!({ "taskListId": "L", "workflowStatus": "in-review" }));
let mut t = map(json!({ "taskListId": "L", "workflowStatus": "in-review", "title": "x" }));
let written = vec!["title".to_owned()];
let w = WorkflowWrite::Update {
before: &before,
written: &written,
};
assert!(!apply_workflow_status(&mut t, w, Some(&[]), NOW).unwrap());
}
}