use jmap_scene_types::{SceneRegion, SceneRegionBroadcast, SceneRegionEvent};
use jmap_types::{Id, JmapError};
use serde_json::{Map, Value, json};
use crate::SceneBackend;
use crate::helpers::{extract_account_id, fetch_one, forbidden, invalid, not_found};
use jmap_server::{
HandlerOutput, SetError, SetErrorType, server_fail_from_backend, server_fail_value_from_backend,
};
pub async fn handle_scene_region_broadcast<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());
}
let cap = backend
.scene_capability(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
if !cap.supports_region_broadcast {
return Err(JmapError::unknown_method());
}
let Some(Value::Object(events)) = args.remove("events") else {
return Err(JmapError::invalid_arguments(
"events must be an Id[SceneRegionBroadcast] map",
));
};
if events.len() as u64 > backend.max_objects_in_set(caller, &account_id) {
let mut err = JmapError::request_too_large();
err.description = Some("maxObjectsInSet".into());
return Err(err);
}
let mut accepted = Vec::new();
let mut not_accepted = Map::new();
for (client_id, raw) in events {
match broadcast(backend, caller, &account_id, raw).await {
Ok(()) => accepted.push(Value::String(client_id)),
Err(e) => {
not_accepted.insert(client_id, e);
}
}
}
Ok(HandlerOutput::new(json!({
"accountId": account_id.as_ref(),
"accepted": if accepted.is_empty() { Value::Null } else { Value::Array(accepted) },
"notAccepted": if not_accepted.is_empty() { Value::Null } else { Value::Object(not_accepted) },
})))
}
async fn broadcast<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
raw: Value,
) -> Result<(), Value> {
let submitted = parse(raw)?;
let fail = |e: B::Error| server_fail_value_from_backend(&e);
let region: SceneRegion = fetch_one(backend, caller, account_id, &submitted.region_id)
.await?
.ok_or_else(not_found)?;
if !backend
.may_access_region(caller, account_id, ®ion.id)
.await
.map_err(fail)?
{
return Err(not_found());
}
if !backend
.may_update_region(caller, account_id, ®ion)
.await
.map_err(fail)?
{
return Err(forbidden(
"only the region owner or an admin may broadcast to this region",
));
}
let mut event = SceneRegionEvent::new(account_id.clone(), region.id, submitted.event);
event.data = submitted.data;
if !backend
.accept_region_event(caller, account_id, &event)
.await
.map_err(fail)?
{
return Err(serde_json::Value::from(
&SetError::new(SetErrorType::RateLimit)
.with_description("The region event rate was exceeded."),
));
}
Ok(())
}
fn parse(raw: Value) -> Result<SceneRegionBroadcast, Value> {
let Value::Object(m) = &raw else {
return Err(invalid(&[], "A SceneRegionBroadcast must be an object."));
};
let bad: Vec<&str> = [
("regionId", m.get("regionId").is_some_and(Value::is_string)),
(
"event",
m.get("event")
.and_then(Value::as_str)
.is_some_and(|e| !e.is_empty()),
),
(
"data",
m.get("data").is_none_or(|d| d.is_null() || d.is_object()),
),
]
.into_iter()
.filter_map(|(k, ok)| (!ok).then_some(k))
.collect();
if !bad.is_empty() {
return Err(invalid(
&bad,
"A property is missing or has the wrong type.",
));
}
serde_json::from_value(raw).map_err(|_| invalid(&[], "Malformed SceneRegionBroadcast."))
}