use std::collections::BTreeMap;
use jmap_chat_types::ReadPosition;
use jmap_types::{Id, JmapError, PatchObject, State};
use serde_json::{Value, json};
use crate::ChatBackend;
use crate::chat::record_unread_count_changes;
use crate::helpers::check_read_only_patch;
use crate::helpers::resolve_refs;
use crate::helpers::{
SetAccumulators, enforce_max_objects_in_get, enforce_max_objects_in_set, extract_account_id,
finalize_set_response, not_found_json, now_utc_string, serialize_value,
};
use jmap_server::{HandlerOutput, backend_set_error_value, server_fail_from_backend};
use jmap_server::{SetError, SetErrorType};
pub async fn handle_position_get<B: ChatBackend>(
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_get(&args, backend.max_objects_in_get(caller, &account_id))?;
let ids: Option<Vec<Id>> = match args.remove("ids") {
None | Some(Value::Null) => None,
Some(v) => Some(
serde_json::from_value(v)
.map_err(|_| JmapError::invalid_arguments("ids must be an Id array"))?,
),
};
let ids_slice = ids.as_deref();
let (list, not_found) = backend
.get_objects::<ReadPosition>(caller, &account_id, ids_slice, None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let state = backend
.get_state::<ReadPosition>(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let list_json: Vec<Value> = list
.iter()
.map(serialize_value)
.collect::<Result<Vec<_>, _>>()?;
Ok(HandlerOutput::new(json!({
"accountId": account_id.as_ref(),
"state": state.as_ref(),
"list": list_json,
"notFound": not_found_json(¬_found),
})))
}
pub async fn handle_position_changes<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
let (account_id, 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());
}
let since_state: State = match args.get("sinceState").and_then(|v| v.as_str()) {
Some(s) => State::from(s),
None => return Err(JmapError::invalid_arguments("sinceState is required")),
};
let max_changes = jmap_server::parse_max_changes(args.get("maxChanges"))?;
let result = backend
.get_changes::<ReadPosition>(
caller,
&account_id,
jmap_server::ChangesParams::new(&since_state).max_changes(max_changes),
)
.await
.map_err(jmap_server::changes_error_from_backend)?;
Ok(HandlerOutput::new(json!({
"accountId": account_id.as_ref(),
"oldState": since_state.as_ref(),
"newState": result.new_state.as_ref(),
"hasMoreChanges": result.has_more_changes,
"updatedProperties": Value::Null,
"created": result.created.iter().map(|id| id.as_ref()).collect::<Vec<_>>(),
"updated": result.updated.iter().map(|id| id.as_ref()).collect::<Vec<_>>(),
"destroyed": result.destroyed.iter().map(|id| id.as_ref()).collect::<Vec<_>>(),
})))
}
pub async fn handle_position_set<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
created_ids: &BTreeMap<Id, Id>,
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::<ReadPosition>(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,
created_ids,
};
let mut acc = SetAccumulators::default();
set_create(&args, &mut acc);
let mutated = set_update(&ctx, &mut args, &mut acc).await?;
set_destroy(&args, &mut acc)?;
finalize_set_response::<B, ReadPosition>(backend, caller, &account_id, old_state, mutated, acc)
.await
}
struct SetCtx<'a, B: ChatBackend> {
backend: &'a B,
caller: &'a B::CallerCtx,
account_id: &'a Id,
created_ids: &'a BTreeMap<Id, Id>,
}
fn set_create(args: &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(), forbidden_server_managed());
}
}
}
async fn set_update<B: ChatBackend>(
ctx: &SetCtx<'_, B>,
args: &mut serde_json::Map<String, Value>,
acc: &mut SetAccumulators,
) -> Result<bool, JmapError> {
let mut mutated = false;
let mut updated_ids: Vec<Id> = Vec::new();
if let Some(Value::Object(update_map)) = args.remove("update") {
for (id_str, patch_val) in update_map {
if let Some(id) = update_one(ctx, id_str, patch_val, acc).await? {
mutated = true;
updated_ids.push(id);
}
}
}
if !updated_ids.is_empty()
&& let Ok((updated_positions, _)) = ctx
.backend
.get_objects::<ReadPosition>(ctx.caller, ctx.account_id, Some(&updated_ids), None)
.await
{
let chat_ids = updated_positions.into_iter().map(|p| p.chat_id).collect();
record_unread_count_changes(ctx.backend, ctx.caller, ctx.account_id, chat_ids).await;
}
Ok(mutated)
}
async fn update_one<B: ChatBackend>(
ctx: &SetCtx<'_, B>,
id_str: String,
mut patch_val: Value,
acc: &mut SetAccumulators,
) -> Result<Option<Id>, JmapError> {
let id = match jmap_server::parse_wire_id(&id_str, "id") {
Ok(id) => id,
Err(err) => {
acc.not_updated
.insert(id_str, serde_json::Value::from(&*err));
return Ok(None);
}
};
if let Err(err) = resolve_refs(&mut patch_val, &["lastReadMessageId"], ctx.created_ids) {
acc.not_updated
.insert(id_str, serde_json::Value::from(&*err));
return Ok(None);
}
match check_read_only_patch::<_, ReadPosition>(
ctx.backend,
ctx.caller,
ctx.account_id,
&id,
&mut patch_val,
)
.await
{
Ok(false) => {}
Ok(true) => {
acc.updated.insert(id_str, Value::Null);
return Ok(None);
}
Err(err) => {
acc.not_updated.insert(id_str, err);
return Ok(None);
}
}
if patch_val
.get("lastReadMessageId")
.is_some_and(|v| !v.is_string() && !v.is_null())
{
acc.not_updated.insert(
id_str,
json!({ "type": "invalidProperties", "properties": ["lastReadMessageId"] }),
);
return Ok(None);
}
let mut patch = match serde_json::from_value::<PatchObject>(patch_val) {
Ok(p) => p,
Err(e) => {
acc.not_updated.insert(
id_str,
json!({ "type": "invalidPatch", "description": e.to_string() }),
);
return Ok(None);
}
};
patch.as_map_mut().insert(
"lastReadAt".to_owned(),
Value::String(now_utc_string().into_inner()),
);
match ctx
.backend
.update_object::<ReadPosition>(ctx.caller, ctx.account_id, &id, patch)
.await
{
Ok(Some(obj)) => {
acc.updated
.insert(id_str, jmap_server::serialize_value(&obj)?);
Ok(Some(id))
}
Ok(None) => {
acc.updated.insert(id_str, Value::Null);
Ok(Some(id))
}
Err(e) => {
acc.not_updated.insert(id_str, backend_set_error_value(e));
Ok(None)
}
}
}
fn set_destroy(
args: &serde_json::Map<String, Value>,
acc: &mut SetAccumulators,
) -> Result<(), JmapError> {
if let Some(destroy_arr) = args.get("destroy").and_then(|v| v.as_array()) {
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 {
acc.not_destroyed
.insert(id_str.to_owned(), forbidden_server_managed());
}
}
Ok(())
}
fn forbidden_server_managed() -> Value {
serde_json::Value::from(
&SetError::new(SetErrorType::Forbidden)
.with_description("ReadPosition records are managed by the server"),
)
}