use std::collections::BTreeMap;
use jmap_scene_types::SceneRegionComparator;
use jmap_scene_types::{GeoAnchor, SceneRegion};
use jmap_types::{Id, JmapError, PatchObject};
use serde_json::{Map, Value, json};
use crate::helpers::resolve_refs;
use crate::helpers::{
SetAccumulators, default_sort, enforce_max_objects_in_set, extract_account_id, fetch_one,
finalize_set_response, forbidden, handle_get_visible, invalid, normalized_quaternion,
not_found, numbers, orientation_ok, reject_unsupported_sort,
};
use crate::{BindingProperty, BindingTarget, SceneBackend};
use jmap_server::{
HandlerOutput, SetError, SetErrorType, apply_patch_object, backend_set_error_value,
now_utc_string, reject_read_only_patch, reject_server_set, server_fail_from_backend,
server_fail_value_from_backend,
};
pub(crate) const JMAP_CHAT_URI: &str = "urn:ietf:params:jmap:chat";
const JMAP_VTC_URI: &str = "urn:ietf:params:jmap:vtc";
const BINDINGS: &[(BindingProperty, &str)] = &[
(BindingProperty::ChatId, JMAP_CHAT_URI),
(BindingProperty::SpaceId, JMAP_CHAT_URI),
(BindingProperty::ChannelId, JMAP_CHAT_URI),
(BindingProperty::ActiveCallId, JMAP_VTC_URI),
];
const ACCESS_POLICIES: &[&str] = &["public", "invite", "space"];
pub async fn handle_scene_region_get<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
handle_get_visible::<SceneRegion, B>(backend, caller, args).await
}
pub async fn handle_scene_region_changes<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_changes::<SceneRegion, B>(backend, caller, args, &[]).await
}
pub async fn handle_scene_region_query<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_query::<SceneRegion, B>(backend, caller, prepare_query(args)?).await
}
pub async fn handle_scene_region_query_changes<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_query_changes::<SceneRegion, B>(backend, caller, prepare_query(args)?).await
}
fn prepare_query(mut args: Value) -> Result<Value, JmapError> {
if let Value::Object(map) = &mut args {
default_sort(
map,
json!([{ "property": "createdAt", "isAscending": false }]),
);
}
reject_unsupported_sort::<SceneRegionComparator>(args.get("sort"))?;
if let Some(filter) = args.get("filter") {
check_access_policy_filter(filter)?;
}
Ok(args)
}
fn check_access_policy_filter(filter: &Value) -> Result<(), JmapError> {
if let Some(Value::Array(conditions)) = filter.get("conditions") {
return conditions.iter().try_for_each(check_access_policy_filter);
}
match filter.get("accessPolicy") {
Some(v) if !v.as_str().is_some_and(|p| ACCESS_POLICIES.contains(&p)) => {
Err(JmapError::invalid_arguments(format!(
"filter accessPolicy must be \"public\", \"invite\" or \"space\"; got {}",
jmap_server::json_type_name(v)
)))
}
_ => Ok(()),
}
}
const REGION_ID_PROPERTIES: &[&str] = &["chatId", "spaceId", "channelId", "activeCallId"];
pub async fn handle_scene_region_set<B: SceneBackend>(
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::<SceneRegion>(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
if let Some(if_in_state) = args.get("ifInState").and_then(Value::as_str)
&& if_in_state != old_state.as_ref()
{
return Err(JmapError::state_mismatch());
}
let mut acc = SetAccumulators::default();
let mut mutated = false;
if let Some(Value::Object(create_map)) = args.remove("create") {
for (create_id, mut obj) in create_map {
if let Err(err) = resolve_refs(&mut obj, REGION_ID_PROPERTIES, created_ids) {
acc.not_created
.insert(create_id, serde_json::Value::from(&*err));
continue;
}
match create_region(backend, caller, &account_id, &create_id, obj).await {
Ok(created) => {
mutated = true;
acc.created.insert(create_id, created);
}
Err(e) => {
acc.not_created.insert(create_id, e);
}
}
}
}
if let Some(Value::Object(update_map)) = args.remove("update") {
for (id_str, mut patch) in update_map {
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));
continue;
}
};
if let Err(err) = resolve_refs(&mut patch, REGION_ID_PROPERTIES, created_ids) {
acc.not_updated
.insert(id_str, serde_json::Value::from(&*err));
continue;
}
match update_region(backend, caller, &account_id, &id, patch).await {
Ok(echo) => {
mutated = true;
acc.updated.insert(id_str, echo);
}
Err(e) => {
acc.not_updated.insert(id_str, e);
}
}
}
}
if let Some(Value::Array(destroy_arr)) = args.remove("destroy") {
let ids: Vec<&str> = destroy_arr
.iter()
.map(|v| v.as_str().ok_or(v))
.collect::<Result<_, _>>()
.map_err(|bad| {
JmapError::invalid_arguments(format!(
"destroy: every element must be a string Id; got {}",
jmap_server::json_type_name(bad)
))
})?;
for id_str in ids {
let id = match jmap_server::parse_wire_id(id_str, "id") {
Ok(id) => id,
Err(err) => {
acc.not_destroyed
.insert(id_str.to_owned(), serde_json::Value::from(&*err));
continue;
}
};
match destroy_region(backend, caller, &account_id, &id).await {
Ok(()) => {
mutated = true;
acc.destroyed.push(Value::String(id_str.to_owned()));
}
Err(e) => {
acc.not_destroyed.insert(id_str.to_owned(), e);
}
}
}
}
finalize_set_response::<B, SceneRegion>(backend, caller, &account_id, old_state, mutated, acc)
.await
}
fn bounds_ok(v: &Value) -> bool {
match (
v.get("min").and_then(|m| numbers(m, 3)),
v.get("max").and_then(|m| numbers(m, 3)),
) {
(Some(min), Some(max)) => min.iter().zip(&max).all(|(lo, hi)| lo <= hi),
_ => false,
}
}
fn malformed(m: &Map<String, Value>) -> Vec<&'static str> {
let mut bad = Vec::new();
let mut check = |key: &'static str, ok: bool| {
if !ok {
bad.push(key);
}
};
let optional = |key: &str, ok: fn(&Value) -> bool| m.get(key).is_none_or(ok);
check(
"name",
m.get("name")
.and_then(Value::as_str)
.is_some_and(|s| !s.is_empty()),
);
check("bounds", m.get("bounds").is_some_and(bounds_ok));
for key in [
"description",
"simulationUri",
"inputUri",
"viewHint",
"chatId",
"spaceId",
"channelId",
"activeCallId",
] {
check(key, optional(key, |v| v.is_null() || v.is_string()));
}
for key in ["environment", "worldState"] {
check(key, optional(key, |v| v.is_null() || v.is_object()));
}
check(
"geoAnchor",
optional("geoAnchor", |v| {
v.is_null() || serde_json::from_value::<GeoAnchor>(v.clone()).is_ok()
}),
);
check(
"spawnPosition",
optional("spawnPosition", |v| numbers(v, 3).is_some()),
);
check(
"spawnOrientation",
optional("spawnOrientation", orientation_ok),
);
check(
"accessPolicy",
optional("accessPolicy", |v| {
v.as_str().is_some_and(|p| ACCESS_POLICIES.contains(&p))
}),
);
check(
"invitedUserIds",
optional("invitedUserIds", |v| {
v.as_array().is_some_and(|a| a.iter().all(Value::is_string))
}),
);
bad
}
fn capability_errors<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
m: &Map<String, Value>,
touched: &impl Fn(&str) -> bool,
) -> Vec<&'static str> {
let has = |uri| backend.has_capability(caller, account_id, uri);
let mut bad: Vec<&'static str> = BINDINGS
.iter()
.map(|(p, uri)| (p.as_str(), uri))
.filter(|(key, uri)| touched(key) && m.get(*key).is_some_and(|v| !v.is_null()) && !has(uri))
.map(|(key, _)| key)
.collect();
if m.get("accessPolicy").and_then(Value::as_str) == Some("space") {
if !has(JMAP_CHAT_URI) {
bad.push("accessPolicy");
} else if m.get("spaceId").is_none_or(Value::is_null) {
bad.push("spaceId");
}
}
bad
}
async fn check_bindings<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
m: &Map<String, Value>,
touched: &impl Fn(&str) -> bool,
) -> Result<(), Value> {
for (property, _) in BINDINGS.iter().filter(|(p, _)| touched(p.as_str())) {
let key = property.as_str();
let Some(id) = m.get(key).and_then(Value::as_str) else {
continue;
};
let target = backend
.region_binding(
caller,
account_id,
*property,
&Id::new_validated(id).map_err(|e| invalid(&[key], &e.to_string()))?,
)
.await
.map_err(|e| server_fail_value_from_backend(&e))?;
match (target, property) {
(BindingTarget::Inaccessible, BindingProperty::ActiveCallId) => {
return Err(forbidden(
"the caller is not a participant in or moderator of the VTCCall",
));
}
(BindingTarget::Missing | BindingTarget::Inaccessible, _) => {
return Err(invalid(
&[key],
"the referenced object does not exist, is not accessible, or is an ended call",
));
}
_ => {}
}
}
if (touched("channelId") || touched("spaceId"))
&& let (Some(channel), Some(space)) = (
m.get("channelId").and_then(Value::as_str),
m.get("spaceId").and_then(Value::as_str),
)
{
let in_space = backend
.channel_in_space(
caller,
account_id,
&Id::new_validated(channel).map_err(|e| invalid(&["channelId"], &e.to_string()))?,
&Id::new_validated(space).map_err(|e| invalid(&["spaceId"], &e.to_string()))?,
)
.await
.map_err(|e| server_fail_value_from_backend(&e))?;
if !in_space {
return Err(invalid(
&["channelId"],
"channelId is not a channel of the Space named by spaceId",
));
}
}
Ok(())
}
async fn validate<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
m: &Map<String, Value>,
touched: &impl Fn(&str) -> bool,
) -> Result<(), Value> {
let mut bad = malformed(m);
if bad.is_empty() {
bad = capability_errors(backend, caller, account_id, m, touched);
}
if !bad.is_empty() {
bad.sort_unstable();
bad.dedup();
return Err(invalid(
&bad,
"name and bounds are required, bounds.min <= bounds.max, spawnOrientation a unit \
quaternion, accessPolicy public, invite or space (space needs \
urn:ietf:params:jmap:chat and spaceId), bindings need their companion capability",
));
}
check_bindings(backend, caller, account_id, m, touched).await
}
async fn create_region<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
create_id: &str,
obj: Value,
) -> Result<Value, Value> {
let Value::Object(mut m) = obj else {
return Err(invalid(&[], "a SceneRegion create must be a JSON object"));
};
let cap = backend
.scene_capability(caller, account_id)
.await
.map_err(|e| server_fail_value_from_backend(&e))?;
if !cap.may_create_region {
return Err(forbidden("mayCreateRegion is false"));
}
if let Some(e) = reject_server_set::<SceneRegion>(&m) {
return Err(serde_json::Value::from(
&e.with_description("these properties are set by the server"),
));
}
if m.contains_key("activeCallId") {
return Err(invalid(
&["activeCallId"],
"activeCallId cannot be set on create",
));
}
validate(backend, caller, account_id, &m, &|_| true).await?;
let owner_id = backend
.caller_user_id(caller, account_id)
.await
.map_err(|e| server_fail_value_from_backend(&e))?;
for (property, uri) in BINDINGS {
if backend.has_capability(caller, account_id, uri) {
m.entry(property.as_str()).or_insert(Value::Null);
}
}
let normalized = normalized_quaternion(&m, "spawnOrientation");
if let Some(q) = &normalized {
m.insert("spawnOrientation".to_owned(), q.clone());
}
let now = now_utc_string();
m.insert("id".to_owned(), json!(jmap_server::CREATE_ID_PLACEHOLDER));
m.insert("accountId".to_owned(), json!(account_id));
m.insert("ownerId".to_owned(), json!(owner_id));
m.insert("activeAvatarCount".to_owned(), json!(0));
m.insert("createdAt".to_owned(), json!(now));
m.insert("updatedAt".to_owned(), json!(now));
let mut region: SceneRegion = serde_json::from_value(Value::Object(m))
.map_err(|e| invalid(&[], &format!("invalid SceneRegion: {e}")))?;
let (id, stored) = backend
.create_object(caller, account_id, create_id, move |id: &Id| {
region.id = id.clone();
region
})
.await
.map_err(backend_set_error_value)?;
let mut created = json!({
"id": id,
"accountId": stored.account_id,
"ownerId": stored.owner_id,
"activeAvatarCount": stored.active_avatar_count,
"createdAt": stored.created_at,
"updatedAt": stored.updated_at,
});
if normalized.is_some() {
created["spawnOrientation"] = json!(stored.spawn_orientation);
}
Ok(created)
}
async fn update_region<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
id: &Id,
patch: Value,
) -> Result<Value, Value> {
let mut patch: PatchObject = serde_json::from_value(patch).map_err(|e| {
serde_json::Value::from(
&SetError::new(SetErrorType::InvalidPatch).with_description(e.to_string()),
)
})?;
let region = fetch_accessible(backend, caller, account_id, id).await?;
if !backend
.may_update_region(caller, account_id, ®ion)
.await
.map_err(|e| server_fail_value_from_backend(&e))?
{
return Err(forbidden(
"only the region owner or an admin may modify this region",
));
}
let top = |k: &str| k.split('/').next().unwrap_or(k).to_owned();
let patched: Vec<String> = patch.as_map().keys().map(|k| top(k)).collect();
let Value::Object(mut result) = jmap_server::serialize_value(®ion)
.map_err(|e| jmap_server::server_fail_value_from_backend(&e))?
else {
unreachable!("a SceneRegion serializes as a JSON object")
};
if let Some(e) = reject_read_only_patch::<SceneRegion>(patch.as_map(), Some(&result)) {
return Err(serde_json::Value::from(
&e.with_description("these properties are set by the server"),
));
}
apply_patch_object(&mut result, patch.as_map()).map_err(|e| {
serde_json::Value::from(
&SetError::new(SetErrorType::InvalidPatch).with_description(e.to_string()),
)
})?;
let touched = |k: &str| patched.iter().any(|p| p == k);
validate(backend, caller, account_id, &result, &touched).await?;
let now = now_utc_string();
let mut echo = Map::new();
echo.insert("updatedAt".to_owned(), json!(now));
let map = patch.as_map_mut();
if touched("spawnOrientation")
&& let Some(q) = normalized_quaternion(&result, "spawnOrientation")
{
map.retain(|k, _| top(k) != "spawnOrientation");
map.insert("spawnOrientation".to_owned(), q.clone());
echo.insert("spawnOrientation".to_owned(), q);
}
map.insert("updatedAt".to_owned(), json!(now));
match backend
.update_object::<SceneRegion>(caller, account_id, id, patch)
.await
.map_err(backend_set_error_value)?
{
Some(region) => Ok(jmap_server::serialize_value(region)
.map_err(|e| jmap_server::server_fail_value_from_backend(&e))?),
None => Ok(Value::Object(echo)),
}
}
async fn fetch_accessible<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
id: &Id,
) -> Result<SceneRegion, Value> {
let region: SceneRegion = fetch_one(backend, caller, account_id, id)
.await?
.ok_or_else(not_found)?;
if backend
.may_access_region(caller, account_id, ®ion.id)
.await
.map_err(|e| server_fail_value_from_backend(&e))?
{
Ok(region)
} else {
Err(not_found())
}
}
async fn destroy_region<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
id: &Id,
) -> Result<(), Value> {
let region = fetch_accessible(backend, caller, account_id, id).await?;
if !backend
.may_destroy_region(caller, account_id, ®ion)
.await
.map_err(|e| server_fail_value_from_backend(&e))?
{
return Err(forbidden(
"only the region owner or an admin may destroy this region",
));
}
backend
.destroy_object::<SceneRegion>(caller, account_id, id)
.await
.map_err(backend_set_error_value)
}