Tarot readings: AI-written, drawn on the server, sold as units
A new Kártyajóslás page: choose a spread (1, 3 or 5 cards), ask a question, pick the cards from the fanned deck and watch them turn over; the reading is written by the detailed-analysis model from the cards, their positions and base meanings, the question and the reader's Sun, Moon and Ascendant. The server shuffles and draws, so nobody can draw again for free. A reading is a 'tarot' analysis (worker, retries, fallback, refunds and admin regeneration as for analyses), uses one 'tarot' unit, and survives recalculations; deleting the account deletes it. Packages carry 2/5/10 readings, the new +5 kártyajóslás addon costs 1 000 Ft. The card artwork comes from the tarot design studio (celestial astrolabe style); the deck JSON is shared by the frontend and the prompt. A public example is at /kartyajoslas/pelda. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
This commit is contained in:
@@ -0,0 +1,212 @@
|
||||
//! 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())))
|
||||
}
|
||||
Reference in New Issue
Block a user