213 lines
7.7 KiB
Rust
213 lines
7.7 KiB
Rust
//! 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<Value>,
|
||
|
|
pub error: Option<String>,
|
||
|
|
pub credits_charged: i32,
|
||
|
|
pub attempts: i32,
|
||
|
|
pub created_at: OffsetDateTime,
|
||
|
|
pub completed_at: Option<OffsetDateTime>,
|
||
|
|
}
|
||
|
|
|
||
|
|
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<Value> = 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<Value> {
|
||
|
|
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<String>, Option<String>, Option<String>), ApiError> {
|
||
|
|
let chart: Option<Value> = 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<Json<Value>> {
|
||
|
|
let rows: Vec<ReadingRow> = 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::<Vec<_>>(), "left": left })))
|
||
|
|
}
|
||
|
|
|
||
|
|
pub async fn get_one(State(state): St, auth: AuthUser, WithRejection(Path(id), _): IdPath) -> ApiResult<Json<Value>> {
|
||
|
|
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<String>,
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Draws the cards and queues the reading (one `tarot` unit).
|
||
|
|
pub async fn create(
|
||
|
|
State(state): St,
|
||
|
|
auth: AuthUser,
|
||
|
|
WithRejection(Json(req), _): Body<NewReading>,
|
||
|
|
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||
|
|
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())))
|
||
|
|
}
|