use std::collections::{BTreeMap, HashSet};
use jmap_chat_types::{Space, SpaceInvite};
use jmap_types::{Id, JmapError, State, UTCDate};
use serde_json::{Value, json};
use crate::ChatBackend;
use crate::helpers::resolved_create;
use crate::helpers::{PropType, mistyped_create_props};
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, reject_server_set, server_fail_from_backend,
server_fail_value_from_backend,
};
use jmap_server::{SetError, SetErrorType};
pub async fn handle_invite_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 (fetched, mut not_found) = backend
.get_objects::<SpaceInvite>(caller, &account_id, ids_slice, None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let mut list = Vec::with_capacity(fetched.len());
for invite in fetched {
if backend
.may_get_space_invite(caller, &account_id, &invite)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
list.push(invite);
} else if ids_slice.is_some() {
not_found.push(invite.id);
}
}
let state = backend
.get_state::<SpaceInvite>(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_invite_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::<SpaceInvite>(
caller,
&account_id,
jmap_server::ChangesParams::new(&since_state).max_changes(max_changes),
)
.await
.map_err(jmap_server::changes_error_from_backend)?;
let changed: Vec<Id> = result
.created
.iter()
.chain(&result.updated)
.cloned()
.collect();
let mut visible: HashSet<Id> = HashSet::with_capacity(changed.len());
if !changed.is_empty() {
let (invites, _) = backend
.get_objects::<SpaceInvite>(caller, &account_id, Some(&changed), None)
.await
.map_err(|e| server_fail_from_backend(&e))?;
for invite in invites {
if backend
.may_get_space_invite(caller, &account_id, &invite)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
visible.insert(invite.id);
}
}
}
let visible_ids = |ids: &[Id]| -> Vec<Value> {
ids.iter()
.filter(|id| visible.contains(*id))
.map(|id| Value::from(id.as_ref()))
.collect()
};
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": visible_ids(&result.created),
"updated": visible_ids(&result.updated),
"destroyed": result.destroyed.iter().map(|id| id.as_ref()).collect::<Vec<_>>(),
})))
}
pub async fn handle_invite_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::<SpaceInvite>(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 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()) {
for (create_id, obj_val) in create_map {
let resolved =
match resolved_create(obj_val, &["spaceId", "defaultChannelId"], 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::<SpaceInvite>)
{
not_created.insert(create_id.clone(), serde_json::Value::from(&err));
continue;
}
if let Some(err) = mistyped_create_props(
obj_val,
&[
("defaultChannelId", PropType::Str),
("expiresAt", PropType::Str),
("maxUses", PropType::UnsignedInt),
],
) {
not_created.insert(create_id.clone(), err);
continue;
}
let space_id = match obj_val
.get("spaceId")
.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": ["spaceId"] }),
);
continue;
}
};
match backend
.get_objects::<Space>(
caller,
&account_id,
Some(std::slice::from_ref(&space_id)),
None,
)
.await
{
Ok((spaces, _)) if spaces.first().is_some_and(|s| s.closed_at.is_some()) => {
not_created.insert(
create_id.clone(),
json!({ "type": "forbidden", "description": "the Space is closed" }),
);
continue;
}
Ok(_) => {}
Err(e) => {
not_created.insert(create_id.clone(), server_fail_value_from_backend(&e));
continue;
}
}
let default_channel_id: Option<Id> =
match obj_val.get("defaultChannelId").and_then(|v| v.as_str()) {
Some(s) => match jmap_server::parse_wire_id(s, "defaultChannelId") {
Ok(id) => Some(id),
Err(err) => {
not_created.insert(create_id.clone(), serde_json::Value::from(&*err));
continue;
}
},
None => None,
};
let expires_at: Option<UTCDate> =
if let Some(s) = obj_val.get("expiresAt").and_then(|v| v.as_str()) {
let Ok(d) = UTCDate::new_validated(s) else {
not_created.insert(
create_id.clone(),
json!({
"type": "invalidProperties",
"properties": ["expiresAt"],
}),
);
continue;
};
Some(d)
} else {
None
};
let max_uses: Option<u64> = obj_val.get("maxUses").and_then(|v| v.as_u64());
if max_uses == Some(0) {
not_created.insert(
create_id.clone(),
json!({ "type": "invalidProperties", "properties": ["maxUses"] }),
);
continue;
}
let now_str = now_utc_string();
let now: UTCDate = UTCDate::from(now_str.as_ref());
let code = match backend.generate_invite_code(caller, &account_id).await {
Ok(code) => code,
Err(e) => {
not_created.insert(create_id.clone(), server_fail_value_from_backend(&e));
continue;
}
};
if let Some(err) = invite_denied(backend, caller, &account_id, &space_id, None).await {
not_created.insert(create_id.clone(), err);
continue;
}
let invite = |id: &Id| {
SpaceInvite::new(
id.clone(),
code,
space_id,
account_id.clone(),
0,
now,
default_channel_id,
expires_at,
max_uses,
)
};
match backend
.create_object::<SpaceInvite, _>(caller, &account_id, create_id, invite)
.await
{
Ok((_server_id, created_obj)) => {
mutated = true;
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, _) in update_map {
not_updated.insert(
id_str,
serde_json::Value::from(&SetError::new(SetErrorType::Forbidden)),
);
}
}
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;
}
};
if let Some(err) = stored_invite_denied(backend, caller, &account_id, &id).await {
not_destroyed.insert(id_str.to_owned(), err);
continue;
}
match backend
.destroy_object::<SpaceInvite>(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, SpaceInvite>(
backend,
caller,
&account_id,
old_state,
mutated,
SetAccumulators {
created,
updated,
destroyed: destroyed_list,
not_created,
not_updated,
not_destroyed,
},
)
.await
}
async fn invite_denied<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
space_id: &Id,
created_by: Option<&Id>,
) -> Option<Value> {
match backend
.may_set_space_invite(caller, account_id, space_id, created_by)
.await
{
Ok(Ok(())) => None,
Ok(Err(set_err)) => Some(serde_json::Value::from(&set_err)),
Err(e) => Some(server_fail_value_from_backend(&e)),
}
}
async fn stored_invite_denied<B: ChatBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
id: &Id,
) -> Option<Value> {
match backend
.get_objects::<SpaceInvite>(caller, account_id, Some(std::slice::from_ref(id)), None)
.await
{
Ok((invites, _)) => match invites.first() {
Some(invite) => {
invite_denied(
backend,
caller,
account_id,
&invite.space_id,
Some(&invite.created_by),
)
.await
}
None => None,
},
Err(e) => Some(server_fail_value_from_backend(&e)),
}
}