use jmap_types::{GetObject, Id, JmapError, JmapObject, State, UTCDate};
use serde_json::{Map, Value, json};
use jmap_scene_types::{SceneAvatar, SceneObject, SceneRegion};
use crate::SceneBackend;
use jmap_server::{
HandlerOutput, enforce_max_objects_in_get, not_found_json, optional_arg, serialize_value,
server_fail_from_backend, server_fail_value_from_backend,
};
use jmap_server::{SetError, SetErrorType};
pub(crate) use jmap_server::{enforce_max_objects_in_set, extract_account_id};
pub(crate) fn numbers(v: &Value, n: usize) -> Option<Vec<f64>> {
let a = v.as_array().filter(|a| a.len() == n)?;
a.iter().map(Value::as_f64).collect()
}
const ORIENTATION_EPSILON: f64 = 1e-3;
pub(crate) fn finite3(v: &Value) -> bool {
numbers(v, 3).is_some_and(|n| n.iter().all(|c| c.is_finite()))
}
fn magnitude(v: &Value) -> Option<f64> {
numbers(v, 4).map(|q| q.iter().map(|c| c * c).sum::<f64>().sqrt())
}
pub(crate) fn orientation_ok(v: &Value) -> bool {
magnitude(v).is_some_and(|n| (n - 1.0).abs() <= ORIENTATION_EPSILON)
}
pub(crate) fn normalized_quaternion(m: &Map<String, Value>, key: &str) -> Option<Value> {
let v = m.get(key)?;
let n = magnitude(v)?;
if n == 1.0 {
return None;
}
let q: Vec<f64> = numbers(v, 4)?.iter().map(|c| c / n).collect();
Some(json!(q))
}
pub(crate) fn check_region_filter(
filter: &Value,
condition: &dyn Fn(&Value) -> Result<(), JmapError>,
) -> Result<(), JmapError> {
if let Some(conditions) = filter.get("conditions") {
return match conditions.as_array() {
Some(c) if !c.is_empty() => {
c.iter().try_for_each(|f| check_region_filter(f, condition))
}
_ => Err(JmapError::invalid_arguments(
"filter.regionId is required in every condition",
)),
};
}
if filter.get("regionId").is_none_or(Value::is_null) {
return Err(JmapError::invalid_arguments("filter.regionId is required"));
}
if let Some(r) = filter
.pointer("/withinRadius/radius")
.and_then(Value::as_f64)
&& r <= 0.0
{
return Err(JmapError::invalid_arguments(
"filter withinRadius.radius must be positive",
));
}
if let Some(b) = filter.get("withinBounds") {
let corner = |k| b.get(k).and_then(|c| numbers(c, 3));
if let (Some(min), Some(max)) = (corner("min"), corner("max"))
&& min.iter().zip(&max).any(|(lo, hi)| hi < lo)
{
return Err(JmapError::invalid_arguments(
"filter withinBounds.max must be >= withinBounds.min on every axis",
));
}
}
condition(filter)
}
pub(crate) fn resolve_ref(
raw: &str,
property: &str,
created_ids: &std::collections::BTreeMap<jmap_types::Id, jmap_types::Id>,
) -> Result<jmap_types::Id, Box<jmap_server::SetError>> {
jmap_server::resolve_creation_ref(raw, created_ids).ok_or_else(|| {
Box::new(
jmap_server::SetError::new(jmap_server::SetErrorType::InvalidProperties)
.with_properties([property])
.with_description(
"creation id reference matches no record created earlier in this request",
),
)
})
}
pub(crate) fn resolve_refs(
obj: &mut serde_json::Value,
props: &[&str],
created_ids: &std::collections::BTreeMap<jmap_types::Id, jmap_types::Id>,
) -> Result<(), Box<jmap_server::SetError>> {
let Some(m) = obj.as_object_mut() else {
return Ok(());
};
for p in props {
if let Some(serde_json::Value::String(raw)) = m.get_mut(*p) {
*raw = resolve_ref(raw, p, created_ids)?.as_ref().to_owned();
}
}
Ok(())
}
pub(crate) fn parents_first(
creates: serde_json::Map<String, serde_json::Value>,
property: &str,
) -> Vec<(String, serde_json::Value)> {
let keys: std::collections::BTreeSet<String> = creates.keys().cloned().collect();
let mut pending: Vec<(String, serde_json::Value)> = creates.into_iter().collect();
let mut ordered: Vec<(String, serde_json::Value)> = Vec::with_capacity(pending.len());
loop {
let before = pending.len();
let (waiting, ready): (Vec<_>, Vec<_>) = std::mem::take(&mut pending)
.into_iter()
.partition(|(create_id, props)| {
props
.get(property)
.and_then(serde_json::Value::as_str)
.and_then(|p| p.strip_prefix('#'))
.is_some_and(|parent| {
parent != create_id.as_str()
&& keys.contains(parent)
&& !ordered.iter().any(|(done, _)| done.as_str() == parent)
})
});
ordered.extend(ready);
pending = waiting;
if pending.is_empty() || pending.len() == before {
ordered.extend(pending);
return ordered;
}
}
}
pub(crate) fn invalid(properties: &[&str], description: &str) -> Value {
let err = SetError::new(SetErrorType::InvalidProperties).with_description(description);
serde_json::Value::from(&if properties.is_empty() {
err
} else {
err.with_properties(properties.iter().copied())
})
}
pub(crate) fn forbidden(description: &str) -> Value {
serde_json::Value::from(&SetError::new(SetErrorType::Forbidden).with_description(description))
}
pub(crate) fn not_found() -> Value {
serde_json::Value::from(&SetError::new(SetErrorType::NotFound))
}
pub(crate) fn over_quota(description: &str) -> Value {
serde_json::Value::from(&SetError::new(SetErrorType::OverQuota).with_description(description))
}
pub(crate) async fn fetch_one<O: GetObject + Send + Sync, B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
id: &Id,
) -> Result<Option<O>, Value> {
backend
.get_objects::<O>(caller, account_id, Some(std::slice::from_ref(id)), None)
.await
.map(|(found, _)| found.into_iter().next())
.map_err(|e| server_fail_value_from_backend(&e))
}
pub(crate) trait Visible: GetObject + Send + Sync {
fn id(&self) -> &Id;
fn region(&self) -> &Id;
fn visible<B: SceneBackend>(
&self,
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
) -> impl std::future::Future<Output = Result<bool, B::Error>> + Send;
fn redact<B: SceneBackend>(
self,
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
) -> impl std::future::Future<Output = Result<Self, B::Error>> + Send {
let _ = (backend, caller, account_id);
async { Ok(self) }
}
}
impl Visible for SceneRegion {
fn id(&self) -> &Id {
&self.id
}
fn region(&self) -> &Id {
&self.id
}
async fn visible<B: SceneBackend>(
&self,
_backend: &B,
_caller: &B::CallerCtx,
_account_id: &Id,
) -> Result<bool, B::Error> {
Ok(true)
}
async fn redact<B: SceneBackend>(
mut self,
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
) -> Result<Self, B::Error> {
if !self.invited_user_ids.is_empty()
&& !backend.may_update_region(caller, account_id, &self).await?
{
self.invited_user_ids.clear();
}
Ok(self)
}
}
impl Visible for SceneObject {
fn id(&self) -> &Id {
&self.id
}
fn region(&self) -> &Id {
&self.region_id
}
fn visible<B: SceneBackend>(
&self,
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
) -> impl std::future::Future<Output = Result<bool, B::Error>> + Send {
backend.is_object_visible(caller, account_id, self)
}
}
impl Visible for SceneAvatar {
fn id(&self) -> &Id {
&self.id
}
fn region(&self) -> &Id {
&self.region_id
}
async fn visible<B: SceneBackend>(
&self,
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
) -> Result<bool, B::Error> {
Ok(!backend.is_user_blocked(caller, &self.user_id).await?
&& backend
.may_see_region_avatars(caller, account_id, &self.region_id)
.await?)
}
}
pub(crate) async fn is_visible<O: Visible, B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
o: &O,
) -> Result<bool, B::Error> {
Ok(backend
.may_access_region(caller, account_id, o.region())
.await?
&& o.visible(backend, caller, account_id).await?)
}
pub(crate) async fn handle_get_visible<O: Visible, B: SceneBackend>(
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>> = optional_arg(&mut args, "ids", || {
JmapError::invalid_arguments("ids must be an Id array")
})?;
let properties: Option<Vec<String>> = optional_arg(&mut args, "properties", || {
JmapError::invalid_arguments("properties must be a string array")
})?;
let (fetched, _) = backend
.get_objects::<O>(caller, &account_id, ids.as_deref(), properties.as_deref())
.await
.map_err(|e| server_fail_from_backend(&e))?;
let mut list = Vec::with_capacity(fetched.len());
for o in fetched {
if is_visible(backend, caller, &account_id, &o)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
list.push(
o.redact(backend, caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?,
);
}
}
let not_found: Vec<Id> = ids
.unwrap_or_default()
.into_iter()
.filter(|id| !list.iter().any(|o| o.id() == id))
.collect();
let state = backend
.get_state::<O>(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
Ok(HandlerOutput::new(json!({
"accountId": account_id.as_ref(),
"state": state.as_ref(),
"list": serialize_value(&list)?,
"notFound": not_found_json(¬_found),
})))
}
pub(crate) fn utc_key(d: &UTCDate) -> &str {
let s: &str = d.as_ref();
s.get(..19).unwrap_or(s)
}
pub(crate) fn default_sort(args: &mut Map<String, Value>, default: Value) {
let unsorted = match args.get("sort") {
None | Some(Value::Null) => true,
Some(Value::Array(a)) => a.is_empty(),
Some(_) => false,
};
if unsorted {
args.insert("sort".to_owned(), default);
}
}
pub(crate) fn reject_unsupported_sort<C: serde::de::DeserializeOwned + KnownSort>(
sort: Option<&Value>,
) -> Result<(), JmapError> {
if let Some(Value::Array(comparators)) = sort {
for c in comparators {
if !<C as serde::Deserialize>::deserialize(c).is_ok_and(|c| c.known()) {
return Err(JmapError::unsupported_sort());
}
}
}
Ok(())
}
pub(crate) trait KnownSort {
fn known(&self) -> bool;
}
macro_rules! known_sort {
($($cmp:ty => $prop:path),+ $(,)?) => {$(
impl KnownSort for $cmp {
fn known(&self) -> bool {
!matches!(self.property, $prop(_))
}
}
)+};
}
known_sort!(
jmap_scene_types::SceneAssetComparator => jmap_scene_types::SceneAssetSortProperty::Other,
jmap_scene_types::SceneRegionComparator => jmap_scene_types::SceneRegionSortProperty::Other,
jmap_scene_types::SceneObjectComparator => jmap_scene_types::SceneObjectSortProperty::Other,
jmap_scene_types::SceneAvatarComparator => jmap_scene_types::SceneAvatarSortProperty::Other,
);
#[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: SceneBackend,
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) },
})))
}