use jmap_tasks_types::{TaskNotification, TaskNotificationComparator};
use jmap_types::{Id, JmapError};
use serde_json::Value;
use crate::TasksBackend;
use crate::helpers::{
SetAccumulators, enforce_max_objects_in_set, extract_account_id, finalize_set_response,
reject_unsupported_sort,
};
use jmap_server::{HandlerOutput, backend_set_error_value, server_fail_from_backend};
use jmap_server::{SetError, SetErrorType};
pub async fn handle_task_notification_get<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_get::<TaskNotification, B>(backend, caller, args).await
}
pub async fn handle_task_notification_changes<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_changes::<TaskNotification, B>(backend, caller, args, &[]).await
}
pub async fn handle_task_notification_set<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> 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 old_state = backend
.get_state::<TaskNotification>(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 ctx = SetCtx {
backend,
caller,
account_id: &account_id,
};
let mut acc = SetAccumulators::default();
set_create(&mut args, &mut acc);
set_update(&mut args, &mut acc);
let mutated = set_destroy(&ctx, &mut args, &mut acc).await?;
finalize_set_response::<B, TaskNotification>(
backend,
caller,
&account_id,
old_state,
mutated,
acc,
)
.await
}
struct SetCtx<'a, B: TasksBackend> {
backend: &'a B,
caller: &'a B::CallerCtx,
account_id: &'a Id,
}
fn set_create(args: &mut serde_json::Map<String, Value>, acc: &mut SetAccumulators) {
if let Some(create_map) = args.get("create").and_then(|v| v.as_object()) {
for create_id in create_map.keys() {
acc.not_created.insert(
create_id.clone(),
serde_json::Value::from(&SetError::new(SetErrorType::Forbidden)),
);
}
}
}
fn set_update(args: &mut serde_json::Map<String, Value>, acc: &mut SetAccumulators) {
if let Some(update_map) = args.get("update").and_then(|v| v.as_object()) {
for id_str in update_map.keys() {
acc.not_updated.insert(
id_str.clone(),
serde_json::Value::from(&SetError::new(SetErrorType::Forbidden)),
);
}
}
}
async fn set_destroy<B: TasksBackend>(
ctx: &SetCtx<'_, B>,
args: &mut serde_json::Map<String, Value>,
acc: &mut SetAccumulators,
) -> Result<bool, JmapError> {
let mut mutated = false;
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) => {
acc.not_destroyed
.insert(id_str, serde_json::Value::from(&*err));
continue;
}
};
match ctx
.backend
.destroy_object::<TaskNotification>(ctx.caller, ctx.account_id, &id)
.await
{
Ok(()) => {
mutated = true;
acc.destroyed.push(Value::String(id_str));
}
Err(e) => {
acc.not_destroyed.insert(id_str, backend_set_error_value(e));
}
}
}
}
Ok(mutated)
}
pub async fn handle_task_notification_query<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
reject_unsupported_sort::<TaskNotificationComparator>(args.get("sort"))?;
jmap_server::handle_query::<TaskNotification, B>(backend, caller, args).await
}
pub async fn handle_task_notification_query_changes<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
reject_unsupported_sort::<TaskNotificationComparator>(args.get("sort"))?;
jmap_server::handle_query_changes::<TaskNotification, B>(backend, caller, args).await
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
use crate::test_support::MockBackend;
#[tokio::test]
async fn query_unlisted_sort_property_returns_unsupported_sort() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({ "accountId": "acc1", "sort": [{ "property": "taskId" }] });
let err = handle_task_notification_query(&backend, &(), args)
.await
.expect_err("unlisted sort property must be rejected");
assert_eq!(err.error_type.to_string(), "unsupportedSort");
}
#[tokio::test]
async fn query_changes_unlisted_sort_property_returns_unsupported_sort() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"sinceQueryState": "0",
"sort": [{ "property": "created" }, { "property": "taskId" }]
});
let err = handle_task_notification_query_changes(&backend, &(), args)
.await
.expect_err("unlisted sort property must be rejected");
assert_eq!(err.error_type.to_string(), "unsupportedSort");
}
#[tokio::test]
async fn query_listed_sort_property_is_accepted() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({ "accountId": "acc1", "sort": [{ "property": "created" }] });
handle_task_notification_query(&backend, &(), args)
.await
.expect("listed sort property must not be rejected");
}
#[tokio::test]
async fn set_create_returns_forbidden_not_created() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"create": {
"c1": {
"id": "ignored",
"created": "2024-01-01T00:00:00Z",
"changedBy": { "@type": "Person", "name": "Alice" },
"type": "created",
"taskId": "t1"
}
}
});
let HandlerOutput { primary: resp, .. } = handle_task_notification_set(&backend, &(), args)
.await
.expect("must not return top-level error");
let not_created = &resp["notCreated"];
assert!(
not_created.is_object(),
"notCreated must be present for create attempts: {resp}"
);
assert_eq!(
not_created["c1"]["type"], "forbidden",
"c1 create must be forbidden: {resp}"
);
assert!(
resp["created"].is_null(),
"created must be null when all creates are forbidden: {resp}"
);
}
#[tokio::test]
async fn set_update_returns_forbidden_not_updated() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"update": {
"notif1": { "comment": "new comment" }
}
});
let HandlerOutput { primary: resp, .. } = handle_task_notification_set(&backend, &(), args)
.await
.expect("must not return top-level error");
let not_updated = &resp["notUpdated"];
assert!(
not_updated.is_object(),
"notUpdated must be present for update attempts: {resp}"
);
assert_eq!(not_updated["notif1"]["type"], "forbidden");
}
#[tokio::test]
async fn set_destroy_nonexistent_returns_not_found() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"destroy": ["doesnotexist"]
});
let HandlerOutput { primary: resp, .. } = handle_task_notification_set(&backend, &(), args)
.await
.expect("must not return top-level error");
let not_destroyed = &resp["notDestroyed"];
assert!(
not_destroyed.is_object(),
"notDestroyed must be present: {resp}"
);
assert_eq!(
not_destroyed["doesnotexist"]["type"], "notFound",
"missing id must produce notFound: {resp}"
);
}
#[tokio::test]
async fn set_destroy_existing_notification_succeeds() {
let mut backend = MockBackend::new_with_account("acc1");
backend.add_notification("acc1", "notif1");
let args = json!({
"accountId": "acc1",
"destroy": ["notif1"]
});
let HandlerOutput { primary: resp, .. } = handle_task_notification_set(&backend, &(), args)
.await
.expect("must not return top-level error");
let destroyed = resp["destroyed"]
.as_array()
.expect("destroyed must be array");
assert_eq!(destroyed.len(), 1);
assert_eq!(destroyed[0], "notif1");
}
}