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
128 lines
4.5 KiB
Rust
128 lines
4.5 KiB
Rust
//! Analysis units: a detailed natal analysis uses one `natal` unit, a
|
|
//! synastry analysis one `synastry` unit, a yearly forecast one `forecast`
|
|
//! unit, a question about an analysis one `question` unit, a tarot reading one
|
|
//! `tarot` unit. Units come from purchases or an admin; a failed analysis or
|
|
//! answer gives its unit back (the worker does that).
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::{Value, json};
|
|
use sqlx::PgConnection;
|
|
use uuid::Uuid;
|
|
|
|
use crate::error::ApiError;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(rename_all = "lowercase")]
|
|
pub enum Unit {
|
|
Natal,
|
|
Synastry,
|
|
/// A yearly forecast (see `routes::forecasts`).
|
|
Forecast,
|
|
/// A slot for adding a person (see [`crate::persons`]).
|
|
Person,
|
|
/// A question about a finished analysis (see `routes::questions`).
|
|
Question,
|
|
/// A tarot reading (see `routes::tarot`).
|
|
Tarot,
|
|
}
|
|
|
|
impl Unit {
|
|
pub fn as_str(self) -> &'static str {
|
|
match self {
|
|
Unit::Natal => "natal",
|
|
Unit::Synastry => "synastry",
|
|
Unit::Forecast => "forecast",
|
|
Unit::Person => "person",
|
|
Unit::Question => "question",
|
|
Unit::Tarot => "tarot",
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Units left per kind.
|
|
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
|
|
pub struct Balance {
|
|
pub natal: i64,
|
|
pub synastry: i64,
|
|
pub forecast: i64,
|
|
/// Bought person slots (not the slots left; see [`crate::persons::slots`]).
|
|
pub person: i64,
|
|
pub question: i64,
|
|
pub tarot: i64,
|
|
}
|
|
|
|
impl Balance {
|
|
pub fn of(self, unit: Unit) -> i64 {
|
|
match unit {
|
|
Unit::Natal => self.natal,
|
|
Unit::Synastry => self.synastry,
|
|
Unit::Forecast => self.forecast,
|
|
Unit::Person => self.person,
|
|
Unit::Question => self.question,
|
|
Unit::Tarot => self.tarot,
|
|
}
|
|
}
|
|
|
|
pub fn view(self) -> Value {
|
|
json!({
|
|
"natal": self.natal, "synastry": self.synastry, "forecast": self.forecast, "question": self.question,
|
|
"tarot": self.tarot,
|
|
})
|
|
}
|
|
}
|
|
|
|
pub async fn balance(conn: &mut PgConnection, user_id: Uuid) -> Result<Balance, ApiError> {
|
|
let (natal, synastry, forecast, person, question, tarot): (i64, i64, i64, i64, i64, i64) = sqlx::query_as(
|
|
"SELECT COALESCE(SUM(delta) FILTER (WHERE unit = 'natal'), 0)::bigint, \
|
|
COALESCE(SUM(delta) FILTER (WHERE unit = 'synastry'), 0)::bigint, \
|
|
COALESCE(SUM(delta) FILTER (WHERE unit = 'forecast'), 0)::bigint, \
|
|
COALESCE(SUM(delta) FILTER (WHERE unit = 'person' AND reason <> 'person'), 0)::bigint, \
|
|
COALESCE(SUM(delta) FILTER (WHERE unit = 'question'), 0)::bigint, \
|
|
COALESCE(SUM(delta) FILTER (WHERE unit = 'tarot'), 0)::bigint \
|
|
FROM credit_ledger WHERE user_id = $1",
|
|
)
|
|
.bind(user_id)
|
|
.fetch_one(conn)
|
|
.await?;
|
|
Ok(Balance { natal, synastry, forecast, person, question, tarot })
|
|
}
|
|
|
|
/// Spends one unit inside the caller's transaction. The user row is locked
|
|
/// so concurrent requests cannot overspend.
|
|
pub async fn spend(tx: &mut PgConnection, user_id: Uuid, unit: Unit, analysis_id: Uuid) -> Result<(), ApiError> {
|
|
sqlx::query("SELECT id FROM users WHERE id = $1 FOR UPDATE").bind(user_id).execute(&mut *tx).await?;
|
|
let left = balance(tx, user_id).await?.of(unit);
|
|
if left < 1 {
|
|
return Err(ApiError::InsufficientCredits { unit: unit.as_str(), balance: left });
|
|
}
|
|
sqlx::query(
|
|
"INSERT INTO credit_ledger (id, user_id, unit, delta, reason, analysis_id) VALUES ($1, $2, $3, -1, 'analysis', $4)",
|
|
)
|
|
.bind(Uuid::now_v7())
|
|
.bind(user_id)
|
|
.bind(unit.as_str())
|
|
.bind(analysis_id)
|
|
.execute(tx)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Spends one `question` unit for a question, inside the caller's transaction.
|
|
pub async fn spend_question(tx: &mut PgConnection, user_id: Uuid, question_id: Uuid) -> Result<(), ApiError> {
|
|
sqlx::query("SELECT id FROM users WHERE id = $1 FOR UPDATE").bind(user_id).execute(&mut *tx).await?;
|
|
let left = balance(tx, user_id).await?.question;
|
|
if left < 1 {
|
|
return Err(ApiError::InsufficientCredits { unit: Unit::Question.as_str(), balance: left });
|
|
}
|
|
sqlx::query(
|
|
"INSERT INTO credit_ledger (id, user_id, unit, delta, reason, question_id) \
|
|
VALUES ($1, $2, 'question', -1, 'question', $3)",
|
|
)
|
|
.bind(Uuid::now_v7())
|
|
.bind(user_id)
|
|
.bind(question_id)
|
|
.execute(tx)
|
|
.await?;
|
|
Ok(())
|
|
}
|