use std::collections::BTreeMap;
use jmap_chat_types::CustomEmoji;
use jmap_chat_types::{CustomEmojiComparator, CustomEmojiFilter};
use jmap_types::{Id, JmapError, PatchObject, State, UTCDate};
use serde_json::{Value, json};
use crate::helpers::check_read_only_patch;
use crate::helpers::resolved_create;
use crate::helpers::{PropType, mistyped_create_props};
use crate::helpers::{
SetAccumulators, default_sort, enforce_max_objects_in_get, enforce_max_objects_in_set,
extract_account_id, finalize_set_response, not_found_json, now_utc_string, optional_arg,
reject_unsupported_sort, serialize_value,
};
use crate::{ChatBackend, ChatLimits, EmojiSetOp};
use jmap_server::{
HandlerOutput, QueryParams, backend_set_error_value, bool_arg, filter_arg, is_client_updatable,
query_anchor_args, reject_server_set, server_fail_from_backend, server_fail_value_from_backend,
};
pub async fn handle_emoji_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::<CustomEmoji>(caller, &account_id, ids_slice, None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let state = backend
.get_state::<CustomEmoji>(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_emoji_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::<CustomEmoji>(
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_emoji_query<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());
}
let calculate_total: bool = bool_arg(&args, "calculateTotal", false);
let limit: Option<u64> = match args.remove("limit") {
None | Some(Value::Null) => None,
Some(v) => match v.as_u64() {
Some(n) => Some(n),
None => {
return Err(JmapError::invalid_arguments(format!(
"limit: expected a non-negative integer, got {}",
jmap_server::json_type_name(&v)
)));
}
},
};
let position: i64 = match args.remove("position") {
None | Some(Value::Null) => 0,
Some(v) => v.as_i64().ok_or_else(|| {
JmapError::invalid_arguments(format!(
"position: expected an integer, got {}",
jmap_server::json_type_name(&v)
))
})?,
};
let (anchor, anchor_offset) = query_anchor_args(&args)?;
default_sort(&mut args, json!([{ "property": "name" }]));
reject_unsupported_sort::<CustomEmojiComparator>(args.get("sort"))?;
let filter: Option<CustomEmojiFilter> = filter_arg(&mut args)?;
let sort: Option<Vec<CustomEmojiComparator>> = optional_arg(&mut args, "sort", || {
JmapError::invalid_arguments("sort must be an array")
})?;
let result = backend
.query_objects::<CustomEmoji>(
caller,
&account_id,
QueryParams::new()
.filter(filter.as_ref())
.sort(sort.as_deref())
.limit(limit)
.position(position)
.anchor(anchor.as_ref())
.anchor_offset(anchor_offset),
)
.await
.map_err(JmapError::from)?;
let mut resp = json!({
"accountId": account_id.as_ref(),
"queryState": result.query_state.as_ref(),
"canCalculateChanges": result.can_calculate_changes,
"position": result.position,
"ids": result.ids.iter().map(|id| id.as_ref()).collect::<Vec<_>>(),
});
if calculate_total && let Some(t) = result.total {
resp["total"] = json!(t);
}
Ok(HandlerOutput::new(resp))
}
pub async fn handle_emoji_query_changes<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
mut args: Value,
) -> Result<HandlerOutput, JmapError> {
if let Value::Object(map) = &mut args {
default_sort(map, json!([{ "property": "name" }]));
}
reject_unsupported_sort::<CustomEmojiComparator>(args.get("sort"))?;
jmap_server::handle_query_changes::<CustomEmoji, B>(backend, caller, args).await
}
pub async fn handle_emoji_set<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
created_ids: &BTreeMap<Id, Id>,
mut args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::resolve_blob_refs(&mut args, &["blobId"], created_ids);
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::<CustomEmoji>(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;
let limits = backend.limits(caller, &account_id);
if let Some(create_map) = args.get("create").and_then(|v| v.as_object()) {
let mut space_counts = emoji_space_counts(backend, caller, &account_id, &limits, &args)
.await
.map_err(|e| server_fail_from_backend(&e))?;
for (create_id, obj_val) in create_map {
let resolved = match resolved_create(obj_val, &["spaceId"], created_ids) {
Ok(v) => v,
Err(err) => {
not_created.insert(create_id.clone(), serde_json::Value::from(&*err));
continue;
}
};
let obj_val = &resolved;
if let Some(err) = obj_val
.as_object()
.and_then(reject_server_set::<CustomEmoji>)
{
not_created.insert(create_id.clone(), serde_json::Value::from(&err));
continue;
}
if let Some(err) = mistyped_create_props(obj_val, &[("spaceId", PropType::Str)]) {
not_created.insert(create_id.clone(), err);
continue;
}
let name = match obj_val.get("name").and_then(|v| v.as_str()) {
Some(s) if !s.is_empty() => s.to_owned(),
_ => {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["name"] }),
);
continue;
}
};
if !name
.chars()
.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_' || c == '-')
{
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["name"] }),
);
continue;
}
if name.len() > 64 {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["name"] }),
);
continue;
}
let blob_id = match obj_val
.get("blobId")
.and_then(|v| v.as_str())
.and_then(|s| Id::new_validated(s).ok())
{
Some(id) => id,
_ => {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["blobId"] }),
);
continue;
}
};
let space_id: Option<Id> = match obj_val.get("spaceId").and_then(|v| v.as_str()) {
Some(s) => match jmap_server::parse_wire_id(s, "spaceId") {
Ok(id) => Some(id),
Err(err) => {
not_created.insert(create_id.clone(), serde_json::Value::from(&*err));
continue;
}
},
None => None,
};
let now_str = now_utc_string();
let now: UTCDate = UTCDate::from(now_str.as_ref());
match backend
.may_set_custom_emoji(caller, &account_id, space_id.as_ref(), EmojiSetOp::Create)
.await
{
Ok(Ok(())) => {}
Ok(Err(set_err)) => {
not_created.insert(create_id.clone(), serde_json::Value::from(&set_err));
continue;
}
Err(e) => {
not_created.insert(create_id.clone(), server_fail_value_from_backend(&e));
continue;
}
}
if let (Some(space), Some(max)) = (&space_id, limits.max_custom_emoji_per_space)
&& space_counts.get(space).copied().unwrap_or(0) >= u64::from(max)
{
not_created.insert(create_id.clone(), over_quota(TOO_MANY_EMOJI));
continue;
}
if let Some(err) =
emoji_blob_too_large(backend, caller, &account_id, &limits, &blob_id).await
{
not_created.insert(create_id.clone(), err);
continue;
}
let emoji = |id: &Id| {
let mut emoji =
CustomEmoji::new(id.clone(), name, blob_id, account_id.clone(), now);
emoji.space_id = space_id;
emoji
};
match backend
.create_object::<CustomEmoji, _>(caller, &account_id, create_id, emoji)
.await
{
Ok((_server_id, created_obj)) => {
mutated = true;
if let Some(space) = &created_obj.space_id {
*space_counts.entry(space.clone()).or_default() += 1;
}
created.insert(
create_id.clone(),
jmap_server::serialize_value(&created_obj)?,
);
}
Err(e) => {
not_created.insert(create_id.clone(), backend_set_error_value(e));
}
}
}
}
jmap_server::resolve_set_id_refs(&mut args, created_ids, &created);
if let Some(Value::Object(update_map)) = args.remove("update") {
for (id_str, mut 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 (found, _not_found) = match backend
.get_objects::<CustomEmoji>(
caller,
&account_id,
Some(std::slice::from_ref(&id)),
None,
)
.await
{
Ok(result) => result,
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
};
if let Some(emoji) = found.first() {
match backend
.may_set_custom_emoji(
caller,
&account_id,
emoji.space_id.as_ref(),
EmojiSetOp::Update,
)
.await
{
Ok(Ok(())) => {}
Ok(Err(set_err)) => {
not_updated.insert(id_str, serde_json::Value::from(&set_err));
continue;
}
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
}
}
match check_read_only_patch::<_, CustomEmoji>(
backend,
caller,
&account_id,
&id,
&mut patch_val,
)
.await
{
Ok(false) => {}
Ok(true) => {
updated.insert(id_str, Value::Null);
continue;
}
Err(err) => {
not_updated.insert(id_str, err);
continue;
}
}
let Value::Object(mut patch_map) = patch_val else {
not_updated.insert(
id_str,
json!({ "type": "invalidPatch", "description": "patch must be a JSON object" }),
);
continue;
};
patch_map.retain(|field, _| is_client_updatable::<CustomEmoji>(field));
let clean_patch = patch_map;
if clean_patch.is_empty() {
not_updated.insert(
id_str,
json!({ "type": "invalidPatch", "description": "no updatable fields in patch" }),
);
continue;
}
if let Some(blob_id) = clean_patch
.get("blobId")
.and_then(Value::as_str)
.and_then(|s| Id::new_validated(s).ok())
&& let Some(err) =
emoji_blob_too_large(backend, caller, &account_id, &limits, &blob_id).await
{
not_updated.insert(id_str, err);
continue;
}
match backend
.update_object::<CustomEmoji>(
caller,
&account_id,
&id,
PatchObject::from_map(clean_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(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 {
let id = match jmap_server::parse_wire_id(id_str, "id") {
Ok(id) => id,
Err(err) => {
not_destroyed.insert(id_str.to_owned(), serde_json::Value::from(&*err));
continue;
}
};
let (found, _not_found) = match backend
.get_objects::<CustomEmoji>(
caller,
&account_id,
Some(std::slice::from_ref(&id)),
None,
)
.await
{
Ok(result) => result,
Err(e) => {
not_destroyed.insert(id_str.to_owned(), server_fail_value_from_backend(&e));
continue;
}
};
if let Some(emoji) = found.first() {
match backend
.may_set_custom_emoji(
caller,
&account_id,
emoji.space_id.as_ref(),
EmojiSetOp::Destroy,
)
.await
{
Ok(Ok(())) => {}
Ok(Err(set_err)) => {
not_destroyed.insert(id_str.to_owned(), serde_json::Value::from(&set_err));
continue;
}
Err(e) => {
not_destroyed.insert(id_str.to_owned(), server_fail_value_from_backend(&e));
continue;
}
}
}
match backend
.destroy_object::<CustomEmoji>(caller, &account_id, &id)
.await
{
Ok(()) => {
mutated = true;
destroyed_list.push(Value::String(id_str.to_owned()));
}
Err(e) => {
not_destroyed.insert(id_str.to_owned(), backend_set_error_value(e));
}
}
}
}
finalize_set_response::<B, CustomEmoji>(
backend,
caller,
&account_id,
old_state,
mutated,
SetAccumulators {
created,
updated,
destroyed: destroyed_list,
not_created,
not_updated,
not_destroyed,
},
)
.await
}
pub(crate) const TOO_MANY_EMOJI: &str = "too many custom emoji in this Space";
pub(crate) const EMOJI_TOO_LARGE: &str = "custom emoji image too large";
fn over_quota(description: &str) -> Value {
json!({ "type": "overQuota", "description": description })
}
async fn emoji_space_counts<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
limits: &ChatLimits,
args: &serde_json::Map<String, Value>,
) -> Result<BTreeMap<Id, u64>, B::Error> {
let mut counts = BTreeMap::new();
if limits.max_custom_emoji_per_space.is_none() {
return Ok(counts);
}
let (stored, _) = backend
.get_objects::<CustomEmoji>(caller, account_id, None, None)
.await?;
let destroyed: Vec<&str> = args
.get("destroy")
.and_then(Value::as_array)
.map(|ids| ids.iter().filter_map(Value::as_str).collect())
.unwrap_or_default();
for emoji in stored {
if let Some(space) = emoji.space_id
&& !destroyed.contains(&emoji.id.as_ref())
{
*counts.entry(space).or_default() += 1;
}
}
Ok(counts)
}
async fn emoji_blob_too_large<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
limits: &ChatLimits,
blob_id: &Id,
) -> Option<Value> {
let max = limits.max_custom_emoji_bytes?;
match backend.attachment_blob(caller, account_id, blob_id).await {
Ok(Ok(Some(blob))) if blob.size > max => Some(over_quota(EMOJI_TOO_LARGE)),
Ok(Ok(_)) => None,
Ok(Err(_)) => Some(json!({ "type": "invalidProperties", "properties": ["blobId"] })),
Err(e) => Some(server_fail_value_from_backend(&e)),
}
}