use std::collections::{BTreeMap, HashMap, HashSet};
use jmap_chat_types::ChatComparator;
use jmap_chat_types::SPEC_CHAT_MEMBER_ROLES;
use jmap_chat_types::{Chat, ChatKind, ChatMember, ChatMemberRole, Message, ReadPosition};
use jmap_types::{Id, JmapError, PatchObject, UTCDate};
use serde::Deserialize;
use serde_json::{Value, json};
use crate::ChatBackend;
use crate::helpers::{PropType, check_metadata_entry, create_metadata, mistyped_create_props};
use crate::helpers::{
SetAccumulators, default_sort, enforce_max_objects_in_set, extract_account_id,
finalize_set_response, now_utc_string, reject_unsupported_sort,
};
use crate::helpers::{resolve_entry_refs, resolve_refs, resolved_create, strip_read_only_patch};
use crate::outbound::{GroupUpdateAction, OutboundEvent};
use jmap_server::{
HandlerOutput, backend_set_error_value, is_client_updatable, reject_server_set,
server_fail_from_backend, server_fail_value_from_backend,
};
use jmap_server::{SetError, SetErrorType};
const MEMBER_PATCH_KEYS: &[&str] = &["addMembers", "removeMembers", "updateMemberRoles"];
const SHARED_GROUP_KEYS: &[&str] = &["name", "description", "avatarBlobId", "pinnedMessageIds"];
const GROUP_ADMIN_KEYS: &[&str] = &["name", "description", "avatarBlobId"];
const KIND_SCOPED_CREATE_PROPS: &[(&str, ChatKind)] = &[
("contactId", ChatKind::Direct),
("name", ChatKind::Group),
("description", ChatKind::Group),
("avatarBlobId", ChatKind::Group),
("spaceId", ChatKind::Channel),
];
pub(crate) fn is_chat_admin(chat: &Chat, account_id: &Id) -> bool {
chat.members
.iter()
.flatten()
.any(|m| m.id == *account_id && m.role == ChatMemberRole::Admin)
}
#[derive(Deserialize)]
struct MemberRoleEntry {
id: Id,
role: Option<ChatMemberRole>,
}
fn apply_member_patch_keys(
chat: &Chat,
owner_id: &Id,
patch: &serde_json::Map<String, Value>,
max_members: u32,
) -> Result<(Vec<ChatMember>, bool), Box<SetError>> {
fn parse<T: serde::de::DeserializeOwned>(
patch: &serde_json::Map<String, Value>,
key: &str,
) -> Result<Option<T>, Box<SetError>> {
patch
.get(key)
.map(|v| serde_json::from_value(v.clone()))
.transpose()
.map_err(|_| {
Box::new(SetError::new(SetErrorType::InvalidProperties).with_properties([key]))
})
}
let valid_role = |role: &ChatMemberRole| SPEC_CHAT_MEMBER_ROLES.contains(&role.as_str());
let invalid =
|key: &str| Box::new(SetError::new(SetErrorType::InvalidProperties).with_properties([key]));
let forbidden =
|desc: &str| Box::new(SetError::new(SetErrorType::Forbidden).with_description(desc));
let add: Option<Vec<MemberRoleEntry>> = parse(patch, "addMembers")?;
let remove: Option<Vec<Id>> = parse(patch, "removeMembers")?;
let update: Option<Vec<MemberRoleEntry>> = parse(patch, "updateMemberRoles")?;
if add
.iter()
.flatten()
.any(|e| e.role.as_ref().is_some_and(|r| !valid_role(r)))
{
return Err(invalid("addMembers"));
}
if update
.iter()
.flatten()
.any(|e| !e.role.as_ref().is_some_and(valid_role))
{
return Err(invalid("updateMemberRoles"));
}
if chat.kind != ChatKind::Group {
return Err(forbidden("member patch keys apply to group chats only"));
}
let is_admin = is_chat_admin(chat, owner_id);
let mut members = chat.members.clone().unwrap_or_default();
let self_leave = add.is_none()
&& update.is_none()
&& remove.as_deref() == Some(std::slice::from_ref(owner_id));
if !is_admin && !self_leave {
return Err(forbidden("only group chat admins may change members"));
}
if let Some(add) = &add {
let now = UTCDate::from(now_utc_string().as_ref());
for entry in add {
if members.iter().all(|m| m.id != entry.id) {
let role = entry.role.clone().unwrap_or(ChatMemberRole::Member);
let mut m = ChatMember::new(entry.id.clone(), role, now.clone());
m.invited_by = Some(owner_id.clone());
members.push(m);
}
}
if members.len() > max_members as usize {
return Err(Box::new(
SetError::new(SetErrorType::OverQuota)
.with_description("group chat member limit exceeded"),
));
}
}
if let Some(remove) = &remove {
members.retain(|m| !remove.contains(&m.id));
}
if let Some(update) = &update {
for entry in update {
let member = members
.iter_mut()
.find(|m| m.id == entry.id)
.ok_or_else(|| invalid("updateMemberRoles"))?;
member.role = entry.role.clone().expect("role checked above");
}
if !members.is_empty() && members.iter().all(|m| m.role != ChatMemberRole::Admin) {
return Err(forbidden("the last admin may not demote themselves"));
}
}
let closes = is_admin
&& members.iter().all(|m| m.id != *owner_id)
&& !members.is_empty()
&& members.iter().all(|m| m.role != ChatMemberRole::Admin);
Ok((members, closes))
}
async fn banned_among<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
chat_id: &Id,
user_ids: &[&Id],
) -> Result<bool, B::Error> {
let (bans, _) = backend
.get_objects::<jmap_chat_types::ChatBan>(caller, account_id, None, None)
.await?;
let now = UTCDate::from(now_utc_string().as_ref());
Ok(bans.iter().any(|b| {
b.chat_id == *chat_id
&& user_ids.contains(&&b.user_id)
&& crate::chat_ban::chat_ban_is_active(b, &now)
}))
}
fn other_member_ids<'a>(
members: impl IntoIterator<Item = &'a ChatMember>,
owner_id: &Id,
) -> Vec<Id> {
members
.into_iter()
.filter(|m| m.id != *owner_id)
.map(|m| m.id.clone())
.collect()
}
fn group_update_events(
chat_id: &Id,
owner_id: &Id,
before: &[ChatMember],
after: Option<&[ChatMember]>,
closes: bool,
metadata_changed: bool,
) -> Vec<OutboundEvent> {
let after = after.unwrap_or(before);
let find = |list: &[ChatMember], id: &Id| list.iter().find(|m| m.id == *id).cloned();
let everyone = other_member_ids(after, owner_id);
let mut actions = Vec::new();
if metadata_changed {
actions.push((GroupUpdateAction::UpdateMetadata, everyone.clone()));
}
let added: Vec<ChatMember> = after
.iter()
.filter(|m| find(before, &m.id).is_none())
.cloned()
.collect();
if !added.is_empty() {
actions.push((GroupUpdateAction::AddMembers { added }, everyone.clone()));
}
let removed_ids = other_member_ids(
before.iter().filter(|m| find(after, &m.id).is_none()),
owner_id,
);
if !removed_ids.is_empty() {
let mut recipients = everyone.clone();
recipients.extend(removed_ids.iter().cloned());
actions.push((GroupUpdateAction::RemoveMembers { removed_ids }, recipients));
}
let updated: Vec<ChatMember> = after
.iter()
.filter(|m| find(before, &m.id).is_some_and(|old| old.role != m.role))
.cloned()
.collect();
if !updated.is_empty() {
actions.push((GroupUpdateAction::UpdateRoles { updated }, everyone.clone()));
}
if find(before, owner_id).is_some() && find(after, owner_id).is_none() {
let action = if closes {
GroupUpdateAction::Close
} else {
GroupUpdateAction::Leave
};
actions.push((action, everyone));
}
actions
.into_iter()
.map(|(action, recipients)| OutboundEvent::GroupUpdate {
chat_id: chat_id.clone(),
action,
recipients,
})
.collect()
}
pub async fn handle_chat_get<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
let mut out =
jmap_server::handle_get_with_metadata::<Chat, B>(backend, caller, args, using).await?;
fill_unread_counts(backend, caller, &mut out.primary).await?;
Ok(out)
}
async fn fill_unread_counts<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
response: &mut Value,
) -> Result<(), JmapError> {
if backend.maintains_unread_count() {
return Ok(());
}
let account_id = Id::from(response["accountId"].as_str().unwrap_or_default());
let Some(list) = response["list"].as_array_mut() else {
return Ok(());
};
if !list.iter().any(|c| c.get("unreadCount").is_some()) {
return Ok(());
}
let (messages, positions) = messages_and_positions(backend, caller, &account_id).await?;
for chat in list.iter_mut() {
let Some(chat) = chat.as_object_mut() else {
continue;
};
if !chat.contains_key("unreadCount") {
continue;
}
let Some(chat_id) = chat.get("id").and_then(Value::as_str) else {
continue;
};
let unread = unread_count(&messages, &positions, &account_id, chat_id);
chat.insert("unreadCount".to_owned(), Value::from(unread));
}
Ok(())
}
async fn messages_and_positions<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
) -> Result<(Vec<Message>, Vec<ReadPosition>), JmapError> {
let (messages, _) = backend
.get_objects::<Message>(caller, account_id, None, None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let (positions, _) = backend
.get_objects::<ReadPosition>(caller, account_id, None, None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
Ok((messages, positions))
}
pub(crate) fn unread_count(
messages: &[Message],
positions: &[ReadPosition],
account_id: &Id,
chat_id: &str,
) -> u64 {
let last_read = positions
.iter()
.find(|p| p.chat_id.as_ref() == chat_id)
.and_then(|p| p.last_read_message_id.as_ref());
messages
.iter()
.filter(|m| m.chat_id.as_ref() == chat_id && m.sender_id != *account_id)
.filter(|m| last_read.is_none_or(|l| m.id.as_ref() > l.as_ref()))
.count() as u64
}
pub(crate) async fn record_unread_count_changes<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
mut chat_ids: Vec<Id>,
) {
if chat_ids.is_empty() || backend.maintains_unread_count() {
return;
}
let Ok((messages, positions)) = messages_and_positions(backend, caller, account_id).await
else {
return;
};
chat_ids.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));
chat_ids.dedup();
for chat_id in chat_ids {
let unread = unread_count(&messages, &positions, account_id, chat_id.as_ref());
let mut patch = PatchObject::new();
patch
.as_map_mut()
.insert("unreadCount".to_owned(), Value::from(unread));
let _ = backend
.update_object::<Chat>(caller, account_id, &chat_id, patch)
.await;
}
}
pub async fn handle_chat_changes<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_changes::<Chat, B>(backend, caller, args, using).await
}
pub async fn handle_chat_query<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
mut args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
jmap_server::reject_metadata_filter_arg(
&args,
jmap_chat_types::ChatFilterCondition::has_metadata_condition,
using,
)?;
if let Value::Object(map) = &mut args {
default_sort(
map,
json!([{ "property": "lastMessageAt", "isAscending": false }]),
);
}
reject_unsupported_sort::<ChatComparator>(args.get("sort"))?;
jmap_server::handle_query::<Chat, B>(backend, caller, args).await
}
pub async fn handle_chat_query_changes<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
mut args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
jmap_server::reject_metadata_filter_arg(
&args,
jmap_chat_types::ChatFilterCondition::has_metadata_condition,
using,
)?;
if let Value::Object(map) = &mut args {
default_sort(
map,
json!([{ "property": "lastMessageAt", "isAscending": false }]),
);
}
reject_unsupported_sort::<ChatComparator>(args.get("sort"))?;
jmap_server::handle_query_changes::<Chat, B>(backend, caller, args).await
}
const CHAT_ID_PROPERTIES: &[&str] = &[
"contactId",
"memberIds",
"pinnedMessageIds",
"removeMembers",
KICK_MEMBERS_KEY,
];
const KICK_MEMBERS_KEY: &str = "kickMembers";
fn take_kick_members(
patch: &mut serde_json::Map<String, Value>,
) -> Result<Option<Vec<Id>>, Box<SetError>> {
let Some(value) = patch.remove(KICK_MEMBERS_KEY) else {
return Ok(None);
};
let invalid = || {
Box::new(SetError::new(SetErrorType::InvalidProperties).with_properties([KICK_MEMBERS_KEY]))
};
let Value::Array(items) = value else {
return Err(invalid());
};
let ids = items
.iter()
.map(|v| {
v.as_str()
.and_then(|s| jmap_server::parse_wire_id(s, KICK_MEMBERS_KEY).ok())
.ok_or_else(invalid)
})
.collect::<Result<Vec<Id>, _>>()?;
Ok((!ids.is_empty()).then_some(ids))
}
const CHAT_ENTRY_ID_PROPERTIES: &[(&str, &str, &str)] = &[
("addMembers", "id", "addMembers"),
("updateMemberRoles", "id", "updateMemberRoles"),
];
pub async fn handle_chat_set<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
created_ids: &BTreeMap<Id, Id>,
mut args: Value,
using: &[String],
) -> Result<HandlerOutput, JmapError> {
jmap_server::resolve_blob_refs(&mut args, &["avatarBlobId"], 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::<Chat>(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(create_map) = args.get("create").and_then(|v| v.as_object()) {
let has_direct_create = create_map.values().any(|v| {
v.get("kind")
.and_then(|k| k.as_str())
.is_some_and(|s| s.eq_ignore_ascii_case("direct"))
});
let (existing_chats, mut known_direct_contact_ids): (Vec<Chat>, HashSet<String>) =
if has_direct_create {
let (chats, _) = backend
.get_objects::<Chat>(caller, &account_id, None, None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let known = chats
.iter()
.filter(|c| c.kind == ChatKind::Direct)
.filter_map(|c| c.contact_id.as_ref().map(|id| id.as_ref().to_owned()))
.collect();
(chats, known)
} else {
(Vec::new(), HashSet::new())
};
let mut batch_direct_ids: HashMap<String, Id> = HashMap::new();
for (create_id, obj_val) in create_map {
let resolved = match resolved_create(obj_val, CHAT_ID_PROPERTIES, 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(err)) = obj_val
.as_object()
.map(|o| check_metadata_entry(o, true, using))
{
not_created.insert(create_id.clone(), serde_json::Value::from(&*err));
continue;
}
let (metadata, private_metadata) = match create_metadata(obj_val) {
Ok(maps) => maps,
Err(err) => {
not_created.insert(create_id.clone(), err);
continue;
}
};
if let Some(err) = mistyped_create_props(
obj_val,
&[
("contactId", PropType::Str),
("name", PropType::Str),
("description", PropType::Str),
("avatarBlobId", PropType::Str),
("messageExpirySeconds", PropType::UnsignedInt),
("spaceId", PropType::Str),
("muted", PropType::Bool),
("receiveTypingIndicators", PropType::Bool),
],
) {
not_created.insert(create_id.clone(), err);
continue;
}
let Some(kind_str) = obj_val
.get("kind")
.and_then(|v| v.as_str())
.map(str::to_owned)
else {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["kind"] }),
);
continue;
};
let kind = match serde_json::from_value::<ChatKind>(Value::String(kind_str)) {
Ok(k) if !matches!(k, ChatKind::Other(_)) => k,
_ => {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["kind"] }),
);
continue;
}
};
if kind != ChatKind::Channel {
let foreign: Vec<&str> = KIND_SCOPED_CREATE_PROPS
.iter()
.filter(|(prop, scope)| {
*scope != kind && obj_val.get(*prop).is_some_and(|v| !v.is_null())
})
.map(|(prop, _)| *prop)
.collect();
if !foreign.is_empty() {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": foreign }),
);
continue;
}
if let Some(err) = obj_val.as_object().and_then(reject_server_set::<Chat>) {
not_created.insert(create_id.clone(), serde_json::Value::from(&err));
continue;
}
}
let direct_contact_id_str: Option<String> = match &kind {
ChatKind::Direct => {
let Some(contact_id_str) = obj_val
.get("contactId")
.and_then(|v| v.as_str())
.map(str::to_owned)
else {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["contactId"] }),
);
continue;
};
if let Some(dup) = existing_chats.iter().find(|c| {
c.kind == ChatKind::Direct
&& c.contact_id.as_ref().map(|id| id.as_ref())
== Some(contact_id_str.as_str())
}) {
not_created.insert(
create_id.clone(),
serde_json::Value::from(
SetError::new(SetErrorType::AlreadyExists)
.with_existing_id(dup.id.clone()),
),
);
continue;
}
if known_direct_contact_ids.contains(&contact_id_str) {
let canonical_id = if let Some(c) = existing_chats.iter().find(|c| {
c.kind == ChatKind::Direct
&& c.contact_id.as_ref().map(|id| id.as_ref())
== Some(contact_id_str.as_str())
}) {
c.id.clone()
} else if let Some(id) = batch_direct_ids.get(&contact_id_str) {
id.clone()
} else {
not_created.insert(
create_id.clone(),
json!({
"type": "serverFail",
"description": "direct chat for contact not found after concurrent operation; retry"
}),
);
continue;
};
not_created.insert(
create_id.clone(),
jmap_server::serialize_value(
SetError::new(SetErrorType::AlreadyExists)
.with_existing_id(canonical_id),
)?,
);
continue;
}
Some(contact_id_str)
}
ChatKind::Channel => {
not_created.insert(create_id.clone(), json!({ "type": "forbidden" }));
continue;
}
_ => None,
};
let member_ids: Option<Vec<Id>> = if kind == ChatKind::Group {
match obj_val.get("memberIds") {
None => Some(Vec::new()),
Some(v) => match serde_json::from_value::<Vec<String>>(v.clone()) {
Ok(ids) => {
match ids
.iter()
.map(|s| jmap_server::parse_wire_id(s, "memberIds"))
.collect::<Result<Vec<Id>, _>>()
{
Ok(ids) => Some(ids),
Err(err) => {
not_created
.insert(create_id.clone(), serde_json::Value::from(&*err));
continue;
}
}
}
Err(_) => {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["memberIds"] }),
);
continue;
}
},
}
} else {
None
};
let now_str = now_utc_string();
let now: UTCDate = UTCDate::from(now_str.as_ref());
let members: Option<Vec<ChatMember>> = member_ids.map(|ids| {
let creator: Id = account_id.clone();
let mut members = vec![ChatMember::new(
creator.clone(),
ChatMemberRole::Admin,
now.clone(),
)];
for id in ids {
if members.iter().all(|m| m.id != id) {
let mut m = ChatMember::new(id, ChatMemberRole::Member, now.clone());
m.invited_by = Some(creator.clone());
members.push(m);
}
}
members
});
let max_members = backend.limits(caller, &account_id).max_group_chat_members;
if members
.as_ref()
.is_some_and(|m| m.len() > max_members as usize)
{
not_created.insert(
create_id.clone(),
json!({
"type": "overQuota",
"description": "group chat member limit exceeded",
}),
);
continue;
}
let contact_id: Option<Id> = match obj_val.get("contactId").and_then(|v| v.as_str()) {
Some(s) => match jmap_server::parse_wire_id(s, "contactId") {
Ok(id) => Some(id),
Err(err) => {
not_created.insert(create_id.clone(), serde_json::Value::from(&*err));
continue;
}
},
None => None,
};
let name: Option<String> = obj_val
.get("name")
.and_then(|v| v.as_str())
.map(str::to_owned);
let description: Option<String> = obj_val
.get("description")
.and_then(|v| v.as_str())
.map(str::to_owned);
let muted: bool = obj_val
.get("muted")
.and_then(|v| v.as_bool())
.unwrap_or(false);
let receive_typing_indicators: bool = obj_val
.get("receiveTypingIndicators")
.and_then(|v| v.as_bool())
.unwrap_or(true);
let avatar_blob_id = match obj_val.get("avatarBlobId").and_then(Value::as_str) {
Some(s) => match jmap_server::parse_wire_id(s, "avatarBlobId") {
Ok(id) => Some(id),
Err(err) => {
not_created.insert(create_id.clone(), serde_json::Value::from(&*err));
continue;
}
},
None => None,
};
let message_expiry_seconds =
obj_val.get("messageExpirySeconds").and_then(Value::as_u64);
let build = |id: &Id| {
let mut chat = Chat::new(
id.clone(),
kind,
now,
0,
vec![],
muted,
receive_typing_indicators,
);
chat.contact_id = contact_id;
chat.name = name;
chat.description = description;
chat.avatar_blob_id = avatar_blob_id;
chat.message_expiry_seconds = message_expiry_seconds;
chat.members = members;
chat.metadata = metadata;
chat.private_metadata = private_metadata;
chat
};
match backend
.create_object::<Chat, _>(caller, &account_id, create_id, build)
.await
{
Ok((new_id, created_obj)) => {
mutated = true;
if let Some(contact_id_str) = direct_contact_id_str.as_deref() {
let current_chats = match backend
.get_objects::<Chat>(caller, &account_id, None, None)
.await
{
Ok((chats, _)) => chats,
Err(read_err) => {
let value = match backend
.destroy_object::<Chat>(caller, &account_id, &new_id)
.await
{
Ok(()) => server_fail_value_from_backend(&read_err),
Err(e) => server_fail_value_from_backend(&e),
};
not_created.insert(create_id.clone(), value);
continue;
}
};
let duplicates: Vec<&Chat> = current_chats
.iter()
.filter(|c| {
c.kind == ChatKind::Direct
&& c.contact_id.as_ref().map(|id| id.as_ref())
== Some(contact_id_str)
})
.collect();
if duplicates.len() > 1 {
let canonical_id: Id = duplicates
.iter()
.map(|c| c.id.as_ref())
.min()
.map(Id::from)
.unwrap_or_else(|| new_id.clone());
if new_id != canonical_id {
if let Err(e) = backend
.destroy_object::<Chat>(caller, &account_id, &new_id)
.await
{
not_created.insert(
create_id.clone(),
server_fail_value_from_backend(&e),
);
continue;
}
not_created.insert(
create_id.clone(),
serde_json::to_value(
SetError::new(SetErrorType::AlreadyExists)
.with_existing_id(canonical_id),
)
.unwrap_or_else(|e| server_fail_value_from_backend(&e)),
);
continue;
}
}
known_direct_contact_ids.insert(contact_id_str.to_owned());
batch_direct_ids.insert(contact_id_str.to_owned(), new_id.clone());
}
if created_obj.kind == ChatKind::Group {
let event = OutboundEvent::GroupUpdate {
chat_id: new_id.clone(),
action: GroupUpdateAction::Create,
recipients: other_member_ids(
created_obj.members.iter().flatten(),
&account_id,
),
};
backend.on_outbound_event(caller, &account_id, &event).await;
}
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;
}
};
if let Err(err) = resolve_refs(&mut patch_val, CHAT_ID_PROPERTIES, created_ids)
.and_then(|()| {
resolve_entry_refs(&mut patch_val, CHAT_ENTRY_ID_PROPERTIES, created_ids)
})
{
not_updated.insert(id_str, serde_json::Value::from(&*err));
continue;
}
if let Some(Err(err)) = patch_val
.as_object()
.map(|o| check_metadata_entry(o, false, using))
{
not_updated.insert(id_str, serde_json::Value::from(&*err));
continue;
}
if let Some(Err(e)) = patch_val.as_object().map(jmap_server::check_patch_paths) {
not_updated.insert(
id_str,
json!({ "type": "invalidPatch", "description": e.to_string() }),
);
continue;
}
let mut 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;
}
};
let stored = match backend
.get_objects::<Chat>(caller, &account_id, Some(std::slice::from_ref(&id)), None)
.await
{
Ok((chats, _)) => chats.into_iter().next(),
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
};
let Some(chat) = &stored else {
not_updated.insert(id_str, Value::from(&SetError::new(SetErrorType::NotFound)));
continue;
};
let computed;
let chat = if patch.as_map().contains_key("unreadCount")
&& !backend.maintains_unread_count()
{
let (messages, positions) =
match messages_and_positions(backend, caller, &account_id).await {
Ok(v) => v,
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
};
let mut c = chat.clone();
c.unread_count = unread_count(&messages, &positions, &account_id, c.id.as_ref());
computed = c;
&computed
} else {
chat
};
let mut shape_err = strip_read_only_patch::<Chat>(patch.as_map_mut(), chat).err();
let defined = |k: &str| {
let top = k.split('/').next().unwrap_or(k);
is_client_updatable::<Chat>(top)
|| MEMBER_PATCH_KEYS.contains(&top)
|| k == KICK_MEMBERS_KEY
};
let bad_props: Vec<&str> = patch
.as_map()
.keys()
.map(String::as_str)
.filter(|k| !defined(k))
.collect();
if shape_err.is_none() && !bad_props.is_empty() {
shape_err = Some(json!({ "type": "invalidProperties", "properties": bad_props }));
}
let patch_keys: Vec<&str> = patch
.as_map()
.keys()
.map(String::as_str)
.filter(|k| defined(k))
.collect();
match backend
.may_update_chat(caller, &account_id, chat, &patch_keys)
.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;
}
}
let kick = match take_kick_members(patch.as_map_mut()) {
Ok(kick) => kick,
Err(err) => {
not_updated.insert(id_str, serde_json::Value::from(&*err));
continue;
}
};
let mut group_before: Option<Vec<ChatMember>> = None;
let mut member_change: Option<(Vec<ChatMember>, bool)> = None;
let touches_closed_keys = patch.as_map().keys().any(|k| {
let top = k.split('/').next().unwrap_or(k);
MEMBER_PATCH_KEYS.contains(&top) || SHARED_GROUP_KEYS.contains(&top)
});
if touches_closed_keys {
if chat.closed_at.is_some() {
not_updated.insert(
id_str,
json!({ "type": "forbidden", "description": "the group is closed" }),
);
continue;
}
let touches_admin_keys = patch
.as_map()
.keys()
.any(|k| GROUP_ADMIN_KEYS.contains(&k.split('/').next().unwrap_or(k)));
if touches_admin_keys
&& !(chat.kind == ChatKind::Group && is_chat_admin(chat, &account_id))
{
not_updated.insert(
id_str,
json!({
"type": "forbidden",
"description": "only group chat admins may update name, description and avatarBlobId",
}),
);
continue;
}
if chat.kind == ChatKind::Group {
group_before = Some(chat.members.clone().unwrap_or_default());
}
}
if patch.is_empty() && kick.is_none() {
updated.insert(id_str, Value::Null);
continue;
}
if MEMBER_PATCH_KEYS
.iter()
.any(|k| patch.as_map().contains_key(*k))
{
let max_members = backend.limits(caller, &account_id).max_group_chat_members;
match apply_member_patch_keys(chat, &account_id, patch.as_map(), max_members) {
Ok((members, closes)) => {
member_change = Some((members.clone(), closes));
let map = patch.as_map_mut();
for key in MEMBER_PATCH_KEYS {
map.remove(*key);
}
map.insert("members".to_owned(), jmap_server::serialize_value(members)?);
if closes {
map.insert("closedAt".to_owned(), json!(now_utc_string()));
}
}
Err(set_err) => {
not_updated.insert(id_str, serde_json::Value::from(&*set_err));
continue;
}
}
}
if let Some((members, _)) = &member_change {
let added: Vec<&Id> = members
.iter()
.filter(|m| chat.members.iter().flatten().all(|old| old.id != m.id))
.map(|m| &m.id)
.collect();
if !added.is_empty() {
match banned_among(backend, caller, &account_id, &id, &added).await {
Ok(false) => {}
Ok(true) => {
not_updated.insert(
id_str,
json!({
"type": "forbidden",
"description": "addMembers names a user banned from this chat",
}),
);
continue;
}
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
}
}
}
let touches_pins = patch
.as_map()
.keys()
.any(|k| k == "pinnedMessageIds" || k.starts_with("pinnedMessageIds/"));
if touches_pins {
match backend
.may_set_pinned_messages(caller, &account_id, &id)
.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;
}
}
}
if let Some(err) = shape_err.take() {
not_updated.insert(id_str, err);
continue;
}
if let Some(Value::Array(new_pins)) = patch.as_map().get("pinnedMessageIds") {
let pins = match new_pins
.iter()
.filter_map(Value::as_str)
.map(|s| jmap_server::parse_wire_id(s, "pinnedMessageIds"))
.collect::<Result<Vec<Id>, _>>()
{
Ok(pins) => pins,
Err(err) => {
not_updated.insert(id_str, serde_json::Value::from(&*err));
continue;
}
};
let added: Vec<Id> = pins
.into_iter()
.filter(|pin| !chat.pinned_message_ids.contains(pin))
.collect();
if !added.is_empty() {
match backend
.validate_pinned_message_ids(caller, &account_id, &id, &added)
.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;
}
}
}
}
if let Some(user_ids) = &kick {
match backend
.kick_chat_members(caller, &account_id, chat, user_ids)
.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;
}
}
if patch.is_empty() {
updated.insert(id_str, Value::Null);
continue;
}
}
let metadata_changed = patch
.as_map()
.keys()
.any(|k| GROUP_ADMIN_KEYS.contains(&k.split('/').next().unwrap_or(k)));
let outcome = backend
.update_object::<Chat>(caller, &account_id, &id, patch)
.await;
if let (Ok(_), Some(before)) = (&outcome, &group_before) {
let (after, closes) = match &member_change {
Some((members, closes)) => (Some(members.as_slice()), *closes),
None => (None, false),
};
for event in
group_update_events(&id, &account_id, before, after, closes, metadata_changed)
{
backend.on_outbound_event(caller, &account_id, &event).await;
}
}
match outcome {
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<_, _>>()?;
let mut ids: Vec<Id> = Vec::new();
for raw in id_strs {
match jmap_server::parse_wire_id(raw, "id") {
Ok(id) => ids.push(id),
Err(err) => {
not_destroyed.insert(raw.to_owned(), serde_json::Value::from(&*err));
}
}
}
let channel_ids: HashSet<Id> = if ids.is_empty() {
HashSet::new()
} else {
match backend
.get_objects::<Chat>(caller, &account_id, Some(&ids), None)
.await
{
Ok((chats, _)) => chats
.into_iter()
.filter(|c| c.kind == ChatKind::Channel)
.map(|c| c.id)
.collect(),
Err(e) => {
let err = server_fail_value_from_backend(&e);
for id in ids.drain(..) {
not_destroyed.insert(id.as_ref().to_owned(), err.clone());
}
HashSet::new()
}
}
};
for id in ids {
let id_str = id.as_ref();
if channel_ids.contains(&id) {
not_destroyed.insert(
id_str.to_owned(),
json!({
"type": "forbidden",
"description": "channel Chats are removed via Space/set removeChannels",
}),
);
continue;
}
match backend
.destroy_object::<Chat>(caller, &account_id, &id)
.await
{
Ok(()) => {
mutated = true;
destroyed_list.push(Value::String(id_str.to_owned()));
backend.on_chat_destroyed(caller, &account_id, &id).await;
}
Err(e) => {
not_destroyed.insert(id_str.to_owned(), backend_set_error_value(e));
}
}
}
}
finalize_set_response::<B, Chat>(
backend,
caller,
&account_id,
old_state,
mutated,
SetAccumulators {
created,
updated,
destroyed: destroyed_list,
not_created,
not_updated,
not_destroyed,
},
)
.await
}
pub async fn handle_chat_typing<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 chat_id: Id = match args.get("chatId").and_then(|v| v.as_str()) {
Some(s) => Id::new_validated(s)
.map_err(|e| JmapError::invalid_arguments(format!("chatId: {e}")))?,
None => return Err(JmapError::invalid_arguments("chatId is required")),
};
let typing: bool = match args.get("typing") {
Some(Value::Bool(b)) => *b,
None => return Err(JmapError::invalid_arguments("typing is required")),
Some(_) => return Err(JmapError::invalid_arguments("typing must be a boolean")),
};
let (found, _not_found) = backend
.get_objects::<Chat>(
caller,
&account_id,
Some(std::slice::from_ref(&chat_id)),
None,
)
.await
.map_err(|e| server_fail_from_backend(&e))?;
found
.into_iter()
.next()
.filter(|c| {
c.kind != ChatKind::Group || c.members.iter().flatten().any(|m| m.id == account_id)
})
.ok_or_else(|| {
JmapError::invalid_arguments("chatId is not a Chat the account participates in")
})?;
backend
.on_outbound_event(
caller,
&account_id,
&OutboundEvent::Typing { chat_id, typing },
)
.await;
Ok(HandlerOutput::new(json!({
"accountId": account_id.as_ref(),
})))
}