//! 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. 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, } 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", } } } /// 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, } 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, } } pub fn view(self) -> Value { json!({ "natal": self.natal, "synastry": self.synastry, "forecast": self.forecast, "question": self.question }) } } pub async fn balance(conn: &mut PgConnection, user_id: Uuid) -> Result { let (natal, synastry, forecast, person, question): (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 \ FROM credit_ledger WHERE user_id = $1", ) .bind(user_id) .fetch_one(conn) .await?; Ok(Balance { natal, synastry, forecast, person, question }) } /// 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(()) }