use std::collections::HashSet;
use jmap_types::{Id, JmapError, JmapObject, State};
use serde_json::{json, Map, Value};
use crate::backend::ChatBackend;
use jmap_server::{server_fail_from_backend, HandlerOutput};
pub(crate) use jmap_server::{
enforce_max_objects_in_get, enforce_max_objects_in_set, extract_account_id, not_found_json,
now_utc_string, optional_arg, serialize_value,
};
pub(crate) const PLACEHOLDER_ID: &str = "placeholder";
#[derive(Clone, Copy)]
pub(crate) enum PropType {
Str,
Bool,
UnsignedInt,
Array,
}
const MAX_UNSIGNED_INT: u64 = (1 << 53) - 1;
pub(crate) fn mistyped_create_props(obj: &Value, props: &[(&str, PropType)]) -> Option<Value> {
let bad: Vec<&str> = props
.iter()
.filter(|(key, ty)| match obj.get(*key) {
None | Some(Value::Null) => false,
Some(v) => !match ty {
PropType::Str => v.is_string(),
PropType::Bool => v.is_boolean(),
PropType::UnsignedInt => v.as_u64().is_some_and(|n| n <= MAX_UNSIGNED_INT),
PropType::Array => v.is_array(),
},
})
.map(|(key, _)| *key)
.collect();
(!bad.is_empty()).then(|| json!({ "type": "invalidProperties", "properties": bad }))
}
pub(crate) fn reject_unsupported_sort<C: serde::de::DeserializeOwned>(
sort: Option<&Value>,
) -> Result<(), JmapError> {
if let Some(Value::Array(comparators)) = sort {
for c in comparators {
<C as serde::Deserialize>::deserialize(c).map_err(|_| JmapError::unsupported_sort())?;
}
}
Ok(())
}
#[derive(Debug, Default)]
pub(crate) struct SetAccumulators {
pub created: Map<String, Value>,
pub updated: Map<String, Value>,
pub destroyed: Vec<Value>,
pub not_created: Map<String, Value>,
pub not_updated: Map<String, Value>,
pub not_destroyed: Map<String, Value>,
}
pub(crate) async fn finalize_set_response<B, O>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
old_state: State,
mutated: bool,
acc: SetAccumulators,
) -> Result<HandlerOutput, JmapError>
where
B: ChatBackend,
O: JmapObject + Send + Sync,
{
let new_state = if mutated {
backend
.get_state::<O>(caller, account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
} else {
old_state.clone()
};
let SetAccumulators {
created,
updated,
destroyed,
not_created,
not_updated,
not_destroyed,
} = acc;
Ok(HandlerOutput::new(json!({
"accountId": account_id.as_ref(),
"oldState": old_state.as_ref(),
"newState": new_state.as_ref(),
"created": if created.is_empty() { Value::Null } else { Value::Object(created) },
"updated": if updated.is_empty() { Value::Null } else { Value::Object(updated) },
"destroyed": if destroyed.is_empty() { Value::Null } else { Value::Array(destroyed) },
"notCreated": if not_created.is_empty() { Value::Null } else { Value::Object(not_created) },
"notUpdated": if not_updated.is_empty() { Value::Null } else { Value::Object(not_updated) },
"notDestroyed": if not_destroyed.is_empty() { Value::Null } else { Value::Object(not_destroyed) },
})))
}
pub(crate) fn filter_properties(
obj: &serde_json::Value,
prop_set: &HashSet<&str>,
) -> serde_json::Value {
match obj {
serde_json::Value::Object(map) => {
let filtered: serde_json::Map<String, serde_json::Value> = map
.iter()
.filter(|(k, _)| prop_set.contains(k.as_str()))
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
serde_json::Value::Object(filtered)
}
_ => obj.clone(),
}
}
pub(crate) fn iso8601_before(a: &jmap_types::UTCDate, b: &jmap_types::UTCDate) -> bool {
let a_str: &str = a.as_ref();
let b_str: &str = b.as_ref();
let a_sec = &a_str[..a_str.len().min(19)];
let b_sec = &b_str[..b_str.len().min(19)];
a_sec < b_sec
}
pub(crate) fn set_error_value(e: &crate::backend::SetError) -> serde_json::Value {
serde_json::to_value(e).expect("derive(Serialize) on plain data is infallible")
}
pub(crate) fn count_add_ops(ops: &[crate::backend::SpacePatchOp]) -> (u32, u32, u32, u32) {
let mut add_roles: u32 = 0;
let mut add_members: u32 = 0;
let mut add_channels: u32 = 0;
let mut add_categories: u32 = 0;
for op in ops {
match op {
crate::backend::SpacePatchOp::AddRole(_) => add_roles = add_roles.saturating_add(1),
crate::backend::SpacePatchOp::AddMember(_) => {
add_members = add_members.saturating_add(1);
}
crate::backend::SpacePatchOp::AddChannel(_) => {
add_channels = add_channels.saturating_add(1);
}
crate::backend::SpacePatchOp::AddCategory(_) => {
add_categories = add_categories.saturating_add(1);
}
_ => {}
}
}
(add_roles, add_members, add_channels, add_categories)
}