use jmap_tasks_types::{Task, TaskFilterCondition, TaskList};
use jmap_types::{Filter, Id, JmapError, PatchObject};
use serde_json::{Value, json};
use crate::TasksBackend;
use crate::helpers::{
SetAccumulators, check_map_key_ids, check_metadata_entry, enforce_max_objects_in_set,
extract_account_id, finalize_set_response,
};
use jmap_server::{
HandlerOutput, QueryParams, backend_set_error_value, bool_arg, reject_read_only_patch,
reject_server_set, server_fail_from_backend, server_fail_value_from_backend,
};
pub async fn handle_task_list_get<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_get_with_metadata::<TaskList, B>(backend, caller, args, using).await
}
pub async fn handle_task_list_changes<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_changes::<TaskList, B>(backend, caller, args, using).await
}
pub async fn handle_task_list_set<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
let (account_id, mut args) = extract_account_id(args)?;
if !backend
.account_exists(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
return Err(JmapError::account_not_found());
}
enforce_max_objects_in_set(&args, backend.max_objects_in_set(caller, &account_id))?;
let on_destroy_remove_tasks = bool_arg(&args, "onDestroyRemoveTasks", false);
let old_state = backend
.get_state::<TaskList>(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
if let Some(if_in_state) = args.get("ifInState").and_then(|v| v.as_str())
&& if_in_state != old_state.as_ref()
{
return Err(JmapError::state_mismatch());
}
let mut created = serde_json::Map::new();
let mut not_created = serde_json::Map::new();
let mut updated = serde_json::Map::new();
let mut not_updated = serde_json::Map::new();
let mut destroyed_list: Vec<Value> = Vec::new();
let mut not_destroyed = serde_json::Map::new();
let mut mutated = false;
if let Some(Value::Object(create_map)) = args.remove("create") {
for (create_id, obj_val) in create_map {
if let Some(err) = obj_val.as_object().and_then(reject_server_set::<TaskList>) {
not_created.insert(create_id, serde_json::Value::from(&err));
continue;
}
if let Some(Err(err)) = obj_val
.as_object()
.map(|o| check_metadata_entry(o, true, using))
{
not_created.insert(create_id, serde_json::Value::from(&*err));
continue;
}
if let Some(Err(err)) = obj_val
.as_object()
.map(|o| check_map_key_ids(o, "shareWith"))
{
not_created.insert(create_id, serde_json::Value::from(&*err));
continue;
}
let obj_with_id = match obj_val {
Value::Object(mut m) => {
m.insert("id".to_owned(), jmap_server::CREATE_ID_PLACEHOLDER.into());
m.entry("isSubscribed").or_insert(Value::Bool(true));
m.insert(
"myRights".to_owned(),
json!({
"mayReadItems": true,
"mayWriteAll": true,
"mayWriteOwn": true,
"mayUpdatePrivate": true,
"mayRSVP": true,
"mayAdmin": true,
"mayDelete": true,
}),
);
Value::Object(m)
}
other => other,
};
if !obj_with_id.is_object() {
not_created.insert(
create_id,
json!({
"type": "invalidProperties",
"description": "a create entry must be an object",
}),
);
continue;
}
if obj_with_id.get("name").is_none() {
not_created.insert(
create_id,
json!({
"type": "invalidProperties",
"properties": ["name"],
"description": "name is required on create",
}),
);
continue;
}
let mut task_list: TaskList = match serde_path_to_error::deserialize(obj_with_id) {
Ok(tl) => tl,
Err(e) => {
let mut err =
json!({ "type": "invalidProperties", "description": e.to_string() });
if let Some(serde_path_to_error::Segment::Map { key }) = e.path().iter().next()
{
err["properties"] = json!([key]);
}
not_created.insert(create_id, err);
continue;
}
};
let build = move |id: &Id| {
task_list.id = id.clone();
task_list
};
match backend
.create_object::<TaskList, _>(caller, &account_id, &create_id, build)
.await
{
Ok((_new_id, created_obj)) => {
mutated = true;
created.insert(create_id, jmap_server::serialize_value(&created_obj)?);
}
Err(e) => {
not_created.insert(create_id, backend_set_error_value(e));
}
}
}
}
if let Some(Value::Object(update_map)) = args.remove("update") {
for (id_str, patch_val) in update_map {
let id = match jmap_server::parse_wire_id(&id_str, "id") {
Ok(id) => id,
Err(err) => {
not_updated.insert(id_str, serde_json::Value::from(&*err));
continue;
}
};
let patch = match serde_json::from_value::<PatchObject>(patch_val) {
Ok(p) => p,
Err(e) => {
not_updated.insert(
id_str,
json!({ "type": "invalidPatch", "description": e.to_string() }),
);
continue;
}
};
if let Some(err) = reject_read_only_patch::<TaskList>(patch.as_map(), None) {
not_updated.insert(id_str, serde_json::Value::from(&err));
continue;
}
if let Err(err) = check_metadata_entry(patch.as_map(), false, using) {
not_updated.insert(id_str, serde_json::Value::from(&*err));
continue;
}
if let Err(err) = check_map_key_ids(patch.as_map(), "shareWith") {
not_updated.insert(id_str, serde_json::Value::from(&*err));
continue;
}
match backend
.update_object::<TaskList>(caller, &account_id, &id, patch)
.await
{
Ok(Some(obj)) => {
mutated = true;
updated.insert(id_str, jmap_server::serialize_value(&obj)?);
}
Ok(None) => {
mutated = true;
updated.insert(id_str, Value::Null);
}
Err(e) => {
not_updated.insert(id_str, backend_set_error_value(e));
}
}
}
}
if let Some(Value::Array(destroy_arr)) = args.remove("destroy") {
let id_strs: Vec<&str> = destroy_arr
.iter()
.map(|v| {
v.as_str().ok_or_else(|| {
JmapError::invalid_arguments(format!(
"destroy: every element must be a string Id; got {}",
jmap_server::json_type_name(v)
))
})
})
.collect::<Result<_, _>>()?;
for id_str in id_strs {
let id_str = id_str.to_owned();
let id = match jmap_server::parse_wire_id(&id_str, "id") {
Ok(id) => id,
Err(err) => {
not_destroyed.insert(id_str, serde_json::Value::from(&*err));
continue;
}
};
if !on_destroy_remove_tasks {
match backend.task_list_has_tasks(caller, &account_id, &id).await {
Ok(true) => {
not_destroyed.insert(id_str, json!({ "type": "taskListHasTask" }));
continue;
}
Ok(false) => {
}
Err(e) => {
not_destroyed.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
}
}
if on_destroy_remove_tasks
&& let Err(value) = destroy_task_list_tasks(backend, caller, &account_id, &id).await
{
not_destroyed.insert(id_str, value);
continue;
}
match backend
.destroy_object::<TaskList>(caller, &account_id, &id)
.await
{
Ok(()) => {
mutated = true;
destroyed_list.push(Value::String(id_str));
}
Err(e) => {
not_destroyed.insert(id_str, backend_set_error_value(e));
}
}
}
}
finalize_set_response::<B, TaskList>(
backend,
caller,
&account_id,
old_state,
mutated,
SetAccumulators {
created,
updated,
destroyed: destroyed_list,
not_created,
not_updated,
not_destroyed,
},
)
.await
}
async fn destroy_task_list_tasks<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
task_list_id: &Id,
) -> Result<(), Value> {
let mut condition = TaskFilterCondition::default();
condition.task_list_id = Some(task_list_id.clone());
let filter = Filter::Condition(condition);
let ids = backend
.query_objects::<Task>(caller, account_id, QueryParams::new().filter(Some(&filter)))
.await
.map_err(|e| server_fail_value_from_backend(&e))?
.ids;
if ids.is_empty() {
return Ok(());
}
let (tasks, _not_found): (Vec<Task>, _) = backend
.get_objects::<Task>(caller, account_id, Some(&ids), None)
.await
.map_err(|e| server_fail_value_from_backend(&e))?;
for task in tasks {
if task.task_list_id.as_ref() != Some(task_list_id) {
continue;
}
let Some(task_id) = task.id.as_ref() else {
return Err(server_fail_value_from_backend(&"missing task id"));
};
backend
.destroy_object::<Task>(caller, account_id, task_id)
.await
.map_err(backend_set_error_value)?;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
use crate::test_support::MockBackend;
#[tokio::test]
async fn get_unknown_account_returns_account_not_found() {
let backend = MockBackend::new();
let args = json!({ "accountId": "unknown", "ids": null });
let result = handle_task_list_get(&backend, &(), args, &[]).await;
let err = result.expect_err("must return error for unknown account");
assert_eq!(err.error_type.to_string(), "accountNotFound");
}
#[tokio::test]
async fn set_destroy_with_tasks_returns_task_list_has_task() {
let mut backend = MockBackend::new_with_account("acc1");
backend.add_task_list_with_task("acc1", "list1");
let args = json!({
"accountId": "acc1",
"destroy": ["list1"],
"onDestroyRemoveTasks": false
});
let HandlerOutput { primary: resp, .. } = handle_task_list_set(&backend, &(), args, &[])
.await
.expect("must not return top-level error");
assert_eq!(
resp["notDestroyed"]["list1"]["type"], "taskListHasTask",
"must return taskListHasTask: {resp}"
);
assert!(
resp["destroyed"].is_null(),
"destroyed must be null: {resp}"
);
}
#[tokio::test]
async fn set_destroy_with_on_destroy_remove_tasks_true_succeeds() {
let mut backend = MockBackend::new_with_account("acc1");
backend.add_task_list_with_task("acc1", "list1");
let args = json!({
"accountId": "acc1",
"destroy": ["list1"],
"onDestroyRemoveTasks": true
});
let HandlerOutput { primary: resp, .. } = handle_task_list_set(&backend, &(), args, &[])
.await
.expect("must not return top-level error");
let destroyed = resp["destroyed"].as_array();
assert!(
destroyed.is_some(),
"destroyed array must be present: {resp}"
);
}
#[tokio::test]
async fn set_empty_returns_valid_response() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({ "accountId": "acc1", "destroy": [] });
let HandlerOutput { primary: resp, .. } = handle_task_list_set(&backend, &(), args, &[])
.await
.expect("must not return top-level error");
assert_eq!(resp["accountId"], "acc1");
assert!(resp["destroyed"].is_null());
}
#[tokio::test]
async fn set_create_typed_parse_failure_names_property() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"create": {
"missingName": {},
"nullName": { "name": null },
"badSortOrder": { "name": "l", "sortOrder": "x" }
}
});
let HandlerOutput { primary: resp, .. } = handle_task_list_set(&backend, &(), args, &[])
.await
.expect("must not return top-level error");
assert!(resp["created"].is_null(), "nothing may be created: {resp}");
for (cid, prop) in [
("missingName", "name"),
("nullName", "name"),
("badSortOrder", "sortOrder"),
] {
let err = &resp["notCreated"][cid];
assert_eq!(err["type"], "invalidProperties", "{cid}: {resp}");
assert_eq!(err["properties"], json!([prop]), "{cid}: {resp}");
}
}
#[tokio::test]
async fn set_create_non_object_entry_names_no_property() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"create": { "str": "x", "arr": ["x"], "nul": null, "num": 5 }
});
let HandlerOutput { primary: resp, .. } = handle_task_list_set(&backend, &(), args, &[])
.await
.expect("must not return top-level error");
assert!(resp["created"].is_null(), "nothing may be created: {resp}");
for cid in ["str", "arr", "nul", "num"] {
let err = &resp["notCreated"][cid];
assert_eq!(err["type"], "invalidProperties", "{cid}: {resp}");
assert!(err.get("properties").is_none(), "{cid}: {resp}");
}
}
}