use crate::caller::Caller;
use crate::events::{Building, NotesEvent};
use crate::seam::{Held, Seam};
use crate::slot::{FillOf, Hand};
use crate::store::{now_ms, NotesStore};
use crate::streams::{failed, reached};
use crate::vocab::BuildStep;
use serde_json::{Map, Value};
use std::sync::Arc;
fn hand(user: &Caller) -> Hand {
Hand { name: user.name(), principal: user.principal().to_string() }
}
pub(crate) async fn slot(store: Arc<NotesStore>, seam: Seam, user: Caller, id: String) -> NotesEvent {
if let Err(ev) = reached(&store, &seam, &user, &id, "notes.slot").await {
return ev;
}
match store.slot(&id).await {
Ok(slot) => NotesEvent::Slot { slot },
Err(e) => failed(e),
}
}
async fn checked(seam: &Seam, component: String, version: String, props: Option<Map<String, Value>>, say: Option<String>) -> Result<FillOf, NotesEvent> {
let version = held(seam, &component, &version).await?;
Ok(FillOf { component, version, props, say })
}
pub(crate) async fn held(seam: &Seam, component: &str, version: &str) -> Result<String, NotesEvent> {
match seam.component(version, component).await {
Ok(Held::Holds(version)) => Ok(version),
Ok(Held::NoComponent(whole)) => Err(NotesEvent::Refused { reason: "unknown_component".into(), message: format!("version {whole} holds no component {component} (nothing was written)") }),
Ok(Held::NoVersion) => Err(NotesEvent::Refused { reason: "unknown_version".into(), message: format!("the ui service keeps no version {version}, so none holds {component} (nothing was written)") }),
Err(message) => Err(NotesEvent::Error { message }),
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) async fn fill(store: Arc<NotesStore>, seam: Seam, user: Caller, id: String, component: String, version: String, props: Option<Map<String, Value>>, say: Option<String>) -> NotesEvent {
if let Err(ev) = reached(&store, &seam, &user, &id, "notes.fill").await {
return ev;
}
let fill = match checked(&seam, component, version, props, say).await {
Ok(f) => f,
Err(ev) => return ev,
};
match store.fill(&id, fill, hand(&user)).await {
Ok(slot) => NotesEvent::Filled { slot },
Err(e) => failed(e),
}
}
pub(crate) async fn empty(store: Arc<NotesStore>, seam: Seam, user: Caller, id: String) -> NotesEvent {
if let Err(ev) = reached(&store, &seam, &user, &id, "notes.empty").await {
return ev;
}
match store.empty(&id, hand(&user)).await {
Ok(slot) => NotesEvent::Emptied { slot },
Err(e) => failed(e),
}
}
pub(crate) async fn props(store: Arc<NotesStore>, seam: Seam, user: Caller, id: String, patch: Map<String, Value>) -> NotesEvent {
if let Err(ev) = reached(&store, &seam, &user, &id, "notes.props").await {
return ev;
}
match store.props(&id, patch, hand(&user)).await {
Ok(slot) => NotesEvent::Props { slot },
Err(e) => failed(e),
}
}
pub(crate) async fn building(store: Arc<NotesStore>, seam: Seam, user: Caller, id: String, component: String, step: Option<BuildStep>, say: Option<String>, failed_: bool) -> NotesEvent {
if let Err(ev) = reached(&store, &seam, &user, &id, "notes.building").await {
return ev;
}
let at = now_ms();
let b = Building { component, step, say, failed: failed_, by: user.name(), principal: user.principal().to_string(), started: at, at };
match store.building(&id, b).await {
Ok(slot) => NotesEvent::Building { slot },
Err(e) => failed(e),
}
}