//! Tarot readings. The server shuffles and draws the cards (so nobody can //! draw again for free until a card they like comes), stores them with the //! question as a `tarot` analysis and spends one `tarot` unit; the worker //! writes the reading with the model of the detailed analyses. A failed //! reading gives its unit back. use analysis_prompt::tarot::{self, Spread}; use analysis_prompt::{Kind, TAROT_QUESTION_MAX_CHARS}; use axum::Json; use axum::extract::{Path, State}; use axum::http::StatusCode; use axum_extra::extract::WithRejection; use rand::seq::SliceRandom; use rand::{Rng, rng}; use serde::Deserialize; use serde_json::{Value, json}; use time::OffsetDateTime; use uuid::Uuid; use super::{Body, IdPath, St}; use crate::auth::AuthUser; use crate::credits::{self, Unit}; use crate::error::{ApiError, ApiResult}; use crate::views::{rfc3339, rfc3339_opt}; /// How often a card comes up reversed. const REVERSED_SHARE: f64 = 0.28; /// The readings listed on the page, newest first. const LIST_LIMIT: i64 = 100; #[derive(Debug, sqlx::FromRow)] pub struct ReadingRow { pub id: Uuid, pub status: String, pub tarot: Value, pub content: Option, pub error: Option, pub credits_charged: i32, pub attempts: i32, pub created_at: OffsetDateTime, pub completed_at: Option, } const COLUMNS: &str = "id, status, tarot, content, error, credits_charged, attempts, created_at, completed_at"; impl ReadingRow { /// The reading as users see it: the cards with their positions (the model /// and the reader's signs are left out). pub fn view(&self) -> Value { let spread = tarot::spread(self.tarot["spread"].as_str().unwrap_or_default()); let positions = spread.map(|s| s.positions).unwrap_or_default(); let cards: Vec = self.tarot["cards"] .as_array() .into_iter() .flatten() .enumerate() .map(|(i, c)| { let position = positions.get(i); json!({ "card": c["card"], "reversed": c["reversed"], "position": position.map(|p| p.title), "about": position.map(|p| p.about), }) }) .collect(); json!({ "id": self.id, "status": self.status, "spread": self.tarot["spread"], "spread_name": spread.map(|s| s.name), "question": self.tarot["question"], "cards": cards, "content": self.content, "error": self.error, "credits_charged": self.credits_charged, "attempts": self.attempts, "created_at": rfc3339(self.created_at), "completed_at": rfc3339_opt(self.completed_at), }) } } /// Shuffles the deck and draws one card per position. fn draw(spread: &Spread) -> Vec { let mut rng = rng(); let mut ids: Vec<&str> = tarot::deck().iter().map(|c| c.id.as_str()).collect(); ids.shuffle(&mut rng); ids.into_iter() .take(spread.positions.len()) .map(|id| json!({ "card": id, "reversed": rng.random_bool(REVERSED_SHARE) })) .collect() } /// The Sun, Moon and Ascendant signs of the user's own chart (the Ascendant /// only with a known birth time). async fn big_three( state: &crate::AppState, user: Uuid, ) -> Result<(Option, Option, Option), ApiError> { let chart: Option = sqlx::query_scalar( "SELECT result FROM charts WHERE owner_id = $1 AND kind = 'own' ORDER BY is_primary DESC, created_at LIMIT 1", ) .bind(user) .fetch_optional(&state.db) .await?; let Some(chart) = chart else { return Ok((None, None, None)) }; let sign_of = |id: &str| { chart["points"] .as_array() .into_iter() .flatten() .find(|p| p["id"] == id) .and_then(|p| p["sign"].as_str()) .map(str::to_string) }; let time_known = chart["time"]["time_known"].as_bool().unwrap_or(false); let ascendant = chart["angles"]["ascendant"]["sign"].as_str().filter(|_| time_known).map(str::to_string); Ok((sign_of("sun"), sign_of("moon"), ascendant)) } pub async fn list(State(state): St, auth: AuthUser) -> ApiResult> { let rows: Vec = sqlx::query_as(&format!( "SELECT {COLUMNS} FROM analyses WHERE kind = 'tarot' AND requested_by = $1 ORDER BY created_at DESC LIMIT $2" )) .bind(auth.id()) .bind(LIST_LIMIT) .fetch_all(&state.db) .await?; let left = credits::balance(&mut *state.db.acquire().await?, auth.id()).await?.tarot; Ok(Json(json!({ "readings": rows.iter().map(ReadingRow::view).collect::>(), "left": left }))) } pub async fn get_one(State(state): St, auth: AuthUser, WithRejection(Path(id), _): IdPath) -> ApiResult> { let row: ReadingRow = sqlx::query_as(&format!( "SELECT {COLUMNS} FROM analyses WHERE id = $1 AND kind = 'tarot' AND requested_by = $2" )) .bind(id) .bind(auth.id()) .fetch_optional(&state.db) .await? .ok_or(ApiError::NotFound("reading"))?; Ok(Json(row.view())) } #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct NewReading { spread: String, question: Option, } /// Draws the cards and queues the reading (one `tarot` unit). pub async fn create( State(state): St, auth: AuthUser, WithRejection(Json(req), _): Body, ) -> ApiResult<(StatusCode, Json)> { let spread = tarot::spread(&req.spread).ok_or_else(|| ApiError::BadRequest("unknown spread".into()))?; let question = req.question.map(|q| q.trim().replace("\r\n", "\n")).filter(|q| !q.is_empty()); if question.as_ref().is_some_and(|q| q.chars().count() > TAROT_QUESTION_MAX_CHARS) { return Err(ApiError::BadRequest(format!( "the question is at most {TAROT_QUESTION_MAX_CHARS} characters long" ))); } let open: bool = sqlx::query_scalar( "SELECT EXISTS (SELECT 1 FROM analyses WHERE kind = 'tarot' AND requested_by = $1 \ AND status IN ('pending', 'running'))", ) .bind(auth.id()) .fetch_one(&state.db) .await?; if open { return Err(ApiError::conflict( "tarot_in_progress", "Az előző jóslásod még készül. Várd meg, és utána húzz újra.", )); } let (sun, moon, ascendant) = big_three(&state, auth.id()).await?; let reading = json!({ "spread": spread.id, "question": question, "cards": draw(spread), "sun": sun, "moon": moon, "ascendant": ascendant, }); // The model of the detailed analyses writes the readings too. let (model, fallback) = crate::models::models_for(&state, Kind::Natal).await?; let language = super::auth::validate_locale(&state, Some(&auth.user.locale))?; let id = Uuid::now_v7(); let mut tx = state.db.begin().await?; let row: ReadingRow = sqlx::query_as(&format!( "INSERT INTO analyses (id, kind, requested_by, language, model, prompt_version, cache_key, status, \ credits_charged, fallback_model, tarot) \ VALUES ($1, 'tarot', $2, $3, $4, $5, $6, 'pending', 1, $7, $8) RETURNING {COLUMNS}" )) .bind(id) .bind(auth.id()) .bind(&language) .bind(&model) .bind(&state.config.prompt_version) .bind(format!("tarot|{id}")) .bind(&fallback) .bind(&reading) .fetch_one(&mut *tx) .await?; credits::spend(&mut tx, auth.id(), Unit::Tarot, id).await?; tx.commit().await?; tracing::info!(user = %auth.id(), %id, spread = spread.id, "tarot reading queued"); Ok((StatusCode::ACCEPTED, Json(row.view()))) }