Questions about an analysis or forecast, answered by the model that wrote it
CI / test (push) Successful in 1m5s
CI / build (push) Successful in 4m56s
CI / deploy (push) Skipped

- 3 questions in every package, +5 questions add-on (1 000 Ft); question units, refund on failure
- The answer sees the chart data, the analysis and earlier questions; at most 250 words
- Editable question prompt (Promptok → Kérdés-válasz); admins regenerate answers
- Package texts and FAQ updated

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
This commit is contained in:
feco
2026-11-18 18:44:20 +00:00
co-authored by Claude Opus 5.5
parent 22292f533b
commit 182d71fe65
33 changed files with 1233 additions and 59 deletions
+32 -6
View File
@@ -1,7 +1,8 @@
//! Analysis units: a detailed natal analysis uses one `natal` unit, a
//! synastry analysis one `synastry` unit, a yearly forecast one `forecast`
//! unit. Units come from purchases or an admin; a failed analysis gives its
//! unit back (the worker does that).
//! 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};
@@ -19,6 +20,8 @@ pub enum Unit {
Forecast,
/// A slot for adding a person (see [`crate::persons`]).
Person,
/// A question about a finished analysis (see `routes::questions`).
Question,
}
impl Unit {
@@ -28,6 +31,7 @@ impl Unit {
Unit::Synastry => "synastry",
Unit::Forecast => "forecast",
Unit::Person => "person",
Unit::Question => "question",
}
}
}
@@ -40,6 +44,7 @@ pub struct Balance {
pub forecast: i64,
/// Bought person slots (not the slots left; see [`crate::persons::slots`]).
pub person: i64,
pub question: i64,
}
impl Balance {
@@ -49,26 +54,28 @@ impl Balance {
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 })
json!({ "natal": self.natal, "synastry": self.synastry, "forecast": self.forecast, "question": self.question })
}
}
pub async fn balance(conn: &mut PgConnection, user_id: Uuid) -> Result<Balance, ApiError> {
let (natal, synastry, forecast, person): (i64, i64, i64, i64) = sqlx::query_as(
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 = '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 })
Ok(Balance { natal, synastry, forecast, person, question })
}
/// Spends one unit inside the caller's transaction. The user row is locked
@@ -90,3 +97,22 @@ pub async fn spend(tx: &mut PgConnection, user_id: Uuid, unit: Unit, analysis_id
.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(())
}
+30 -1
View File
@@ -19,6 +19,9 @@ const SYNASTRY_PRICE: i64 = 2_500;
/// A yearly forecast bought alone costs more than one in a package.
const FORECAST_PRICE: i64 = 2_500;
const PERSON_PRICE: i64 = 300; // 1 500 Ft for five
/// Questions every package of the main ladder comes with (not counted in the
/// "bought one by one" price: they are a bonus).
const QUESTIONS_INCLUDED: i64 = 3;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Tier {
@@ -40,11 +43,13 @@ pub struct Package {
pub synastry: i64,
pub forecast: i64,
pub persons: i64,
/// Questions about the user's analyses and forecasts.
pub questions: i64,
/// Badge on the card ("Legnépszerűbb").
pub badge: Option<&'static str>,
}
pub const CATALOG: [Package; 6] = [
pub const CATALOG: [Package; 7] = [
Package {
id: "single",
name: "Egy elemzés",
@@ -55,6 +60,7 @@ pub const CATALOG: [Package; 6] = [
synastry: 0,
forecast: 0,
persons: 0,
questions: QUESTIONS_INCLUDED,
badge: None,
},
Package {
@@ -67,6 +73,7 @@ pub const CATALOG: [Package; 6] = [
synastry: 1,
forecast: 2,
persons: 1,
questions: QUESTIONS_INCLUDED,
badge: None,
},
Package {
@@ -79,6 +86,7 @@ pub const CATALOG: [Package; 6] = [
synastry: 5,
forecast: 6,
persons: 5,
questions: QUESTIONS_INCLUDED,
badge: Some("Legnépszerűbb"),
},
Package {
@@ -91,6 +99,7 @@ pub const CATALOG: [Package; 6] = [
synastry: 1,
forecast: 0,
persons: 0,
questions: 0,
badge: None,
},
Package {
@@ -103,6 +112,7 @@ pub const CATALOG: [Package; 6] = [
synastry: 0,
forecast: 1,
persons: 0,
questions: 0,
badge: None,
},
Package {
@@ -115,6 +125,20 @@ pub const CATALOG: [Package; 6] = [
synastry: 0,
forecast: 0,
persons: 5,
questions: 0,
badge: None,
},
Package {
id: "addon_questions",
name: "+5 kérdés",
tagline: "Öt újabb kérdés az elemzéseidről és előrejelzéseidről.",
tier: Tier::Addon,
price_huf: 1_000,
natal: 0,
synastry: 0,
forecast: 0,
persons: 0,
questions: 5,
badge: None,
},
];
@@ -146,6 +170,7 @@ impl Package {
"synastry": self.synastry,
"forecast": self.forecast,
"persons": self.persons,
"questions": self.questions,
"badge": self.badge,
"list_price_huf": list,
"savings_percent": savings,
@@ -202,6 +227,7 @@ pub async fn grant(
(Unit::Synastry, package.synastry),
(Unit::Forecast, package.forecast),
(Unit::Person, package.persons),
(Unit::Question, package.questions),
];
for (unit, n) in contents {
if n == 0 {
@@ -254,5 +280,8 @@ mod tests {
assert!(find("single").unwrap().view()["savings_percent"].is_null());
assert!(find("unlimited").is_none());
assert!(CATALOG.iter().all(|p| find(p.id).is_some()));
// Every package of the ladder comes with questions; more can be bought.
assert!(CATALOG.iter().filter(|p| p.tier == Tier::Main).all(|p| p.questions == QUESTIONS_INCLUDED));
assert_eq!(find("addon_questions").unwrap().questions, 5);
}
}
+1
View File
@@ -158,6 +158,7 @@ pub async fn export(State(state): St, auth: AuthUser) -> ApiResult<impl IntoResp
"invites": rows("SELECT json_build_object('id', id, 'chart_id', inviter_chart_id, 'message', message, 'created_at', created_at, 'expires_at', expires_at, 'accepted_at', accepted_at) FROM synastry_invites WHERE inviter_id = $1").await?,
"forecasts": rows("SELECT json_build_object('id', f.id, 'chart_id', f.chart_id, 'year', f.year, 'location', f.location, 'result', f.result, 'created_at', f.created_at) FROM forecasts f JOIN charts c ON c.id = f.chart_id WHERE c.owner_id = $1").await?,
"analyses": rows("SELECT json_build_object('id', a.id, 'kind', a.kind, 'chart_id', a.chart_id, 'synastry_id', a.synastry_id, 'forecast_id', a.forecast_id, 'language', a.language, 'status', a.status, 'content', a.content, 'created_at', a.created_at) FROM analyses a WHERE a.requested_by = $1 OR a.chart_id IN (SELECT id FROM charts WHERE owner_id = $1)").await?,
"questions": rows("SELECT json_build_object('id', q.id, 'analysis_id', q.analysis_id, 'question', q.question, 'status', q.status, 'answer', q.answer, 'created_at', q.created_at) FROM questions q WHERE q.asked_by = $1").await?,
"credit_ledger": rows("SELECT json_build_object('unit', unit, 'delta', delta, 'reason', reason, 'note', note, 'created_at', created_at) FROM credit_ledger WHERE user_id = $1 ORDER BY created_at").await?,
"shares": rows("SELECT json_build_object('slug', slug, 'kind', kind, 'title', title, 'show_birth_data', show_birth_data, 'view_count', view_count, 'created_at', created_at, 'revoked_at', revoked_at) FROM shares WHERE owner_id = $1").await?,
});
+19 -5
View File
@@ -33,14 +33,27 @@ pub async fn list_users(
let limit = query.limit.unwrap_or(50).clamp(1, 200);
let offset = query.offset.unwrap_or(0).max(0);
let pattern = query.q.as_deref().map(|q| format!("%{}%", q.trim().replace(['%', '_'], "")));
type Row =
(Uuid, String, Option<String>, Vec<String>, bool, OffsetDateTime, Option<OffsetDateTime>, i64, i64, i64, i64);
type Row = (
Uuid,
String,
Option<String>,
Vec<String>,
bool,
OffsetDateTime,
Option<OffsetDateTime>,
i64,
i64,
i64,
i64,
i64,
);
let rows: Vec<Row> = sqlx::query_as(
"SELECT u.id, u.email, u.display_name, u.roles, u.email_verified_at IS NOT NULL, u.created_at, u.last_login_at, \
(SELECT count(*) FROM charts c WHERE c.owner_id = u.id), \
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'natal'), \
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'synastry'), \
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'forecast') \
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'forecast'), \
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'question') \
FROM users u \
WHERE $1::text IS NULL OR u.email ILIKE $1 OR u.display_name ILIKE $1 \
ORDER BY u.created_at DESC LIMIT $2 OFFSET $3",
@@ -52,11 +65,12 @@ pub async fn list_users(
.await?;
let users: Vec<Value> = rows
.into_iter()
.map(|(id, email, name, roles, verified, created, last_login, charts, natal, synastry, forecast)| {
.map(|(id, email, name, roles, verified, created, last_login, charts, natal, synastry, forecast, question)| {
json!({
"id": id, "email": email, "display_name": name, "roles": roles, "email_verified": verified,
"created_at": rfc3339(created), "last_login_at": rfc3339_opt(last_login),
"charts": charts, "analyses_left": {"natal": natal, "synastry": synastry, "forecast": forecast},
"charts": charts,
"analyses_left": {"natal": natal, "synastry": synastry, "forecast": forecast, "question": question},
})
})
.collect();
+1
View File
@@ -370,6 +370,7 @@ pub async fn regenerate(
}
let kind = Kind::parse(&row.kind).ok_or_else(|| ApiError::Internal(format!("unknown kind {}", row.kind)))?;
let hash: Option<String> = match kind {
Kind::Question => None,
Kind::Natal | Kind::Summary => {
sqlx::query_scalar("SELECT chart_hash FROM charts WHERE id = $1")
.bind(row.chart_id)
+4
View File
@@ -15,6 +15,7 @@ mod invitations;
mod models;
mod payments;
mod prompts;
mod questions;
mod recalculate;
mod shares;
mod synastries;
@@ -90,6 +91,8 @@ pub fn router(state: Arc<AppState>) -> Router {
.route("/v1/invites/accept", post(synastries::accept_invite))
// analyses
.route("/v1/analyses/{id}", get(analyses::get_one))
.route("/v1/analyses/{id}/questions", get(questions::list).post(questions::ask))
.route("/v1/questions/{id}", get(questions::get_one))
// sharing
.route("/v1/shares", get(shares::list).post(shares::create))
.route("/v1/shares/{id}", delete(shares::revoke))
@@ -117,6 +120,7 @@ pub fn router(state: Arc<AppState>) -> Router {
.route("/v1/admin/models/catalog", get(models::catalog))
.route("/v1/admin/models/{kind}", axum::routing::put(models::save))
.route("/v1/admin/analyses/{id}/regenerate", post(analyses::regenerate))
.route("/v1/admin/questions/{id}/regenerate", post(questions::regenerate))
.layer(cors(&state.config.cors_allowed_origins))
.layer(
TraceLayer::new_for_http()
+1 -1
View File
@@ -57,7 +57,7 @@ async fn entry(state: &AppState, kind: Kind) -> Result<Value, sqlx::Error> {
pub async fn list(State(state): St, _admin: AdminUser) -> ApiResult<Json<Value>> {
let mut functions = Vec::new();
for kind in Kind::ALL {
for kind in Kind::ANALYSES {
functions.push(entry(&state, kind).await?);
}
Ok(Json(json!({ "functions": functions })))
+1
View File
@@ -55,6 +55,7 @@ pub async fn mock(
(None, Some(Unit::Synastry)) => "addon_synastry",
(None, Some(Unit::Forecast)) => "addon_forecast",
(None, Some(Unit::Person)) => "addon_persons",
(None, Some(Unit::Question)) => "addon_questions",
_ => return Err(ApiError::BadRequest("give either package or unit".into())),
};
let package = packages::find(id).ok_or(ApiError::NotFound("package"))?;
+6 -1
View File
@@ -27,7 +27,7 @@ use crate::error::{ApiError, ApiResult};
use crate::views::{rfc3339, rfc3339_opt};
/// The kinds whose prompt the admin page edits.
const EDITABLE: [Kind; 4] = [Kind::Summary, Kind::Natal, Kind::Synastry, Kind::Forecast];
const EDITABLE: [Kind; 5] = [Kind::Summary, Kind::Natal, Kind::Synastry, Kind::Forecast, Kind::Question];
const MAX_CHARS: usize = 50_000;
const HISTORY: i64 = 20;
/// Test runs of one admin waiting or being written at the same time.
@@ -228,6 +228,11 @@ pub async fn start_preview(
),
(Kind::Synastry, ..) => return Err(ApiError::BadRequest("a synastry analysis needs synastry_id".into())),
(Kind::Forecast, ..) => return Err(ApiError::BadRequest("a forecast analysis needs forecast_id".into())),
(Kind::Question, ..) => {
return Err(ApiError::BadRequest(
"the question prompt cannot be tried here; ask a question on one of your analyses".into(),
));
}
_ => return Err(ApiError::BadRequest("this analysis needs chart_id".into())),
};
let found: Option<(Uuid,)> = sqlx::query_as(query).bind(id).bind(admin.id()).fetch_optional(&state.db).await?;
+204
View File
@@ -0,0 +1,204 @@
//! Questions about a finished detailed analysis: a natal chart analysis or a
//! yearly forecast. Each question uses a `question` unit (admins ask for
//! free). The worker answers with the model that wrote the analysis, seeing
//! the chart data, the analysis and the earlier questions about it.
use analysis_prompt::{Kind, QUESTION_MAX_CHARS};
use axum::Json;
use axum::extract::{Path, State};
use axum::http::StatusCode;
use axum_extra::extract::WithRejection;
use db::Role;
use serde::Deserialize;
use serde_json::{Value, json};
use sqlx::PgPool;
use time::OffsetDateTime;
use uuid::Uuid;
use super::analyses::{can_see, find_analysis};
use super::{Body, IdPath, St};
use crate::auth::{AdminUser, AuthUser};
use crate::credits;
use crate::error::{ApiError, ApiResult};
use crate::views::{rfc3339, rfc3339_opt};
/// The analyses that can be asked about.
const ASKABLE: [&str; 2] = ["natal", "forecast"];
/// A safety cap per analysis.
const MAX_PER_ANALYSIS: i64 = 100;
/// A question as users see it (the model is left out on purpose).
#[derive(Debug, sqlx::FromRow)]
pub struct QuestionRow {
pub id: Uuid,
pub analysis_id: Uuid,
pub question: String,
pub status: String,
pub answer: Option<String>,
pub error: Option<String>,
pub credits_charged: i32,
pub created_at: OffsetDateTime,
pub completed_at: Option<OffsetDateTime>,
}
const QUESTION_COLUMNS: &str =
"id, analysis_id, question, status, answer, error, credits_charged, created_at, completed_at";
impl QuestionRow {
pub fn view(&self) -> Value {
json!({
"id": self.id,
"analysis_id": self.analysis_id,
"question": self.question,
"status": self.status,
"answer": self.answer,
"error": self.error,
"credits_charged": self.credits_charged,
"created_at": rfc3339(self.created_at),
"completed_at": rfc3339_opt(self.completed_at),
})
}
}
async fn find_question(db: &PgPool, id: Uuid) -> Result<Option<QuestionRow>, sqlx::Error> {
sqlx::query_as(&format!("SELECT {QUESTION_COLUMNS} FROM questions WHERE id = $1")).bind(id).fetch_optional(db).await
}
/// The model of the analysis (questions are answered by the same model) and
/// the prompt version of the question prompt in force.
async fn model_and_version(
state: &crate::AppState,
analysis_id: Uuid,
language: &str,
) -> Result<(String, String), sqlx::Error> {
let model: String =
sqlx::query_scalar("SELECT model FROM analyses WHERE id = $1").bind(analysis_id).fetch_one(&state.db).await?;
let base = &state.config.prompt_version;
let version = match super::prompts::current_revision(&state.db, Kind::Question.as_str(), language).await? {
Some(id) => format!("{base}-r{id}"),
None => base.clone(),
};
Ok((model, version))
}
pub async fn list(State(state): St, auth: AuthUser, WithRejection(Path(id), _): IdPath) -> ApiResult<Json<Value>> {
let analysis = find_analysis(&state.db, id).await?.ok_or(ApiError::NotFound("analysis"))?;
if !can_see(&state.db, &analysis, auth.id()).await? {
return Err(ApiError::NotFound("analysis"));
}
let rows: Vec<QuestionRow> =
sqlx::query_as(&format!("SELECT {QUESTION_COLUMNS} FROM questions WHERE analysis_id = $1 ORDER BY created_at"))
.bind(id)
.fetch_all(&state.db)
.await?;
Ok(Json(json!({ "questions": rows.iter().map(QuestionRow::view).collect::<Vec<_>>() })))
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AskQuestion {
question: String,
}
pub async fn ask(
State(state): St,
auth: AuthUser,
WithRejection(Path(id), _): IdPath,
WithRejection(Json(req), _): Body<AskQuestion>,
) -> ApiResult<(StatusCode, Json<Value>)> {
let analysis = find_analysis(&state.db, id).await?.ok_or(ApiError::NotFound("analysis"))?;
if !can_see(&state.db, &analysis, auth.id()).await? {
return Err(ApiError::NotFound("analysis"));
}
if !ASKABLE.contains(&analysis.kind.as_str()) {
return Err(ApiError::BadRequest("questions can be asked about a natal analysis or a forecast".into()));
}
if analysis.status != "done" {
return Err(ApiError::conflict("analysis_not_ready", "Az elemzés még nem készült el."));
}
let question = req.question.trim().replace("\r\n", "\n");
let length = question.chars().count();
if !(3..=QUESTION_MAX_CHARS).contains(&length) {
return Err(ApiError::BadRequest(format!("the question must be 3 to {QUESTION_MAX_CHARS} characters long")));
}
let (open, total): (i64, i64) = sqlx::query_as(
"SELECT count(*) FILTER (WHERE status IN ('pending', 'running')), count(*) FROM questions WHERE analysis_id = $1",
)
.bind(id)
.fetch_one(&state.db)
.await?;
if open > 0 {
return Err(ApiError::conflict(
"question_in_progress",
"Az előző kérdésedre még készül a válasz. Várd meg, és utána kérdezz újra.",
));
}
if total >= MAX_PER_ANALYSIS {
return Err(ApiError::conflict(
"question_limit_reached",
"Ehhez az elemzéshez már nem lehet több kérdést feltenni.",
));
}
let admin = auth.user.has_role(Role::Admin);
let (model, prompt_version) = model_and_version(&state, id, &analysis.language).await?;
let question_id = Uuid::now_v7();
let mut tx = state.db.begin().await?;
let row: QuestionRow = sqlx::query_as(&format!(
"INSERT INTO questions (id, analysis_id, asked_by, question, language, model, prompt_version, credits_charged) \
VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING {QUESTION_COLUMNS}"
))
.bind(question_id)
.bind(id)
.bind(auth.id())
.bind(&question)
.bind(&analysis.language)
.bind(&model)
.bind(&prompt_version)
.bind(i32::from(!admin))
.fetch_one(&mut *tx)
.await?;
if !admin {
credits::spend_question(&mut tx, auth.id(), question_id).await?;
}
tx.commit().await?;
Ok((StatusCode::ACCEPTED, Json(row.view())))
}
pub async fn get_one(State(state): St, auth: AuthUser, WithRejection(Path(id), _): IdPath) -> ApiResult<Json<Value>> {
let row = find_question(&state.db, id).await?.ok_or(ApiError::NotFound("question"))?;
let analysis = find_analysis(&state.db, row.analysis_id).await?.ok_or(ApiError::NotFound("question"))?;
if !can_see(&state.db, &analysis, auth.id()).await? {
return Err(ApiError::NotFound("question"));
}
Ok(Json(row.view()))
}
/// Admin: answers a question again in place, with the current question prompt
/// and the analysis's model. Nobody is charged.
pub async fn regenerate(
State(state): St,
_admin: AdminUser,
WithRejection(Path(id), _): IdPath,
) -> ApiResult<Json<Value>> {
let row = find_question(&state.db, id).await?.ok_or(ApiError::NotFound("question"))?;
let language: String =
sqlx::query_scalar("SELECT language FROM questions WHERE id = $1").bind(id).fetch_one(&state.db).await?;
let (model, prompt_version) = model_and_version(&state, row.analysis_id, &language).await?;
let mut tx = state.db.begin().await?;
let row: QuestionRow = sqlx::query_as(&format!(
"UPDATE questions SET status = 'pending', answer = NULL, error = NULL, model_used = NULL, input_tokens = NULL, \
output_tokens = NULL, cost_usd = NULL, attempts = 0, next_attempt_at = now(), started_at = NULL, \
completed_at = NULL, model = $2, prompt_version = $3 \
WHERE id = $1 AND status IN ('done', 'failed') RETURNING {QUESTION_COLUMNS}"
))
.bind(id)
.bind(&model)
.bind(&prompt_version)
.fetch_optional(&mut *tx)
.await?
.ok_or_else(|| ApiError::conflict("question_in_progress", "Erre a kérdésre éppen készül a válasz."))?;
sqlx::query("SELECT pg_notify('analyses', '')").execute(&mut *tx).await?;
tx.commit().await?;
Ok(Json(row.view()))
}
+103 -14
View File
@@ -259,7 +259,7 @@ async fn register_login_verify_logout(pool: PgPool) {
let r = app.get("/v1/me", Some(&token)).await;
assert_eq!(r.status, StatusCode::OK);
assert_eq!(r.body["providers"], json!(["password"]));
assert_eq!(r.body["analyses_left"], json!({"natal": 0, "synastry": 0, "forecast": 0}));
assert_eq!(r.body["analyses_left"], json!({"natal": 0, "synastry": 0, "forecast": 0, "question": 0}));
// e-mail verification through the queued e-mail's link
let url = app.outbox_url("anna@example.com", "verify_email").await;
@@ -382,12 +382,12 @@ async fn roles_and_admin_guard(pool: PgPool) {
let r = app.post(&format!("/v1/admin/users/{anna}/credits"), Some(&admin), grant("natal", 5)).await;
assert_eq!(
(r.status, &r.body["analyses_left"]),
(StatusCode::CREATED, &json!({"natal": 5, "synastry": 0, "forecast": 0}))
(StatusCode::CREATED, &json!({"natal": 5, "synastry": 0, "forecast": 0, "question": 0}))
);
let r = app.post(&format!("/v1/admin/users/{anna}/credits"), Some(&admin), grant("chat", 5)).await;
assert_eq!(r.status, StatusCode::BAD_REQUEST);
let credits = app.get("/v1/credits", Some(&user)).await.body;
assert_eq!(credits["balance"], json!({"natal": 5, "synastry": 0, "forecast": 0}));
assert_eq!(credits["balance"], json!({"natal": 5, "synastry": 0, "forecast": 0, "question": 0}));
assert_eq!((credits["ledger"][0]["unit"].as_str(), &credits["ledger"][0]["delta"]), (Some("natal"), &json!(5)));
}
@@ -558,7 +558,7 @@ async fn analyses_spend_units_and_reuse_results(pool: PgPool) {
assert_eq!(model, "anthropic/claude-test");
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 1, "synastry": 0, "forecast": 0})
json!({"natal": 1, "synastry": 0, "forecast": 0, "question": 0})
);
// same request again: the same analysis, no charge
@@ -568,7 +568,7 @@ async fn analyses_spend_units_and_reuse_results(pool: PgPool) {
assert_eq!(r.status, StatusCode::ACCEPTED);
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 0, "synastry": 0, "forecast": 0})
json!({"natal": 0, "synastry": 0, "forecast": 0, "question": 0})
);
let r = app.post(&uri, Some(&anna), json!({"model": "anthropic/claude-other"})).await;
assert_eq!(r.status, StatusCode::BAD_REQUEST); // no model choice
@@ -759,7 +759,7 @@ async fn synastry_analyses_use_synastry_units(pool: PgPool) {
assert_eq!((r.status, r.body["kind"].as_str()), (StatusCode::ACCEPTED, Some("synastry")));
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 1, "synastry": 0, "forecast": 0})
json!({"natal": 1, "synastry": 0, "forecast": 0, "question": 0})
);
}
@@ -846,7 +846,7 @@ async fn admins_get_free_analyses_and_mock_payments_add_units(pool: PgPool) {
let r = app.post("/v1/payments/mock", Some(&anna), json!({"unit": "natal"})).await;
assert_eq!(
(r.status, &r.body["analyses_left"]),
(StatusCode::OK, &json!({"natal": 1, "synastry": 0, "forecast": 0})),
(StatusCode::OK, &json!({"natal": 1, "synastry": 0, "forecast": 0, "question": 3})),
"{}",
r.body
);
@@ -855,7 +855,7 @@ async fn admins_get_free_analyses_and_mock_payments_add_units(pool: PgPool) {
assert_eq!((r.status, &r.body["credits_charged"]), (StatusCode::ACCEPTED, &json!(1)), "{}", r.body);
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 0, "synastry": 0, "forecast": 0})
json!({"natal": 0, "synastry": 0, "forecast": 0, "question": 3})
);
// without MOCK_PAYMENTS there is no such payment
@@ -947,7 +947,8 @@ async fn admins_edit_analysis_prompts(pool: PgPool) {
let prompts = r.body["prompts"].as_array().unwrap();
let keys: Vec<String> =
prompts.iter().map(|p| format!("{}/{}", p["kind"], p["language"]).replace('"', "")).collect();
let expected = ["summary", "natal", "synastry", "forecast"].map(|k| [format!("{k}/hu"), format!("{k}/en")]);
let expected =
["summary", "natal", "synastry", "forecast", "question"].map(|k| [format!("{k}/hu"), format!("{k}/en")]);
assert_eq!(keys, expected.concat());
let natal = &prompts[2];
assert_eq!((&natal["custom"], &natal["system"]), (&json!(false), &natal["default"]));
@@ -1143,7 +1144,10 @@ async fn packages_grant_units(pool: PgPool) {
// the catalog is public
let r = app.get("/v1/packages", None).await;
let ids: Vec<&str> = r.body["packages"].as_array().unwrap().iter().map(|p| p["id"].as_str().unwrap()).collect();
assert_eq!(ids, ["single", "couple", "family", "addon_synastry", "addon_forecast", "addon_persons"]);
assert_eq!(
ids,
["single", "couple", "family", "addon_synastry", "addon_forecast", "addon_persons", "addon_questions"]
);
assert_eq!(
(&r.body["packages"][2]["badge"], &r.body["packages"][2]["per_analysis_huf"]),
(&json!("Legnépszerűbb"), &json!(647))
@@ -1155,7 +1159,7 @@ async fn packages_grant_units(pool: PgPool) {
let r = grant_package(&app, &admin, &anna_id, "family").await;
assert_eq!(
(r.status, &r.body["analyses_left"]),
(StatusCode::CREATED, &json!({"natal": 6, "synastry": 5, "forecast": 6})),
(StatusCode::CREATED, &json!({"natal": 6, "synastry": 5, "forecast": 6, "question": 3})),
"{}",
r.body
);
@@ -1170,7 +1174,7 @@ async fn packages_grant_units(pool: PgPool) {
// a (mock) purchase adds to it and records the price
let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "couple"})).await;
assert_eq!(r.body["analyses_left"], json!({"natal": 8, "synastry": 6, "forecast": 8}), "{}", r.body);
assert_eq!(r.body["analyses_left"], json!({"natal": 8, "synastry": 6, "forecast": 8, "question": 6}), "{}", r.body);
let (price,): (i32,) =
sqlx::query_as("SELECT price_huf FROM package_orders WHERE package = 'couple'").fetch_one(&pool).await.unwrap();
assert_eq!(price, 6000);
@@ -1411,14 +1415,14 @@ async fn forecasts_are_free_their_analysis_uses_a_forecast_unit(pool: PgPool) {
(StatusCode::PAYMENT_REQUIRED, Some("insufficient_credits"))
);
let r = app.post("/v1/payments/mock", Some(&anna), json!({"unit": "forecast"})).await;
assert_eq!(r.body["analyses_left"], json!({"natal": 1, "synastry": 0, "forecast": 1}), "{}", r.body);
assert_eq!(r.body["analyses_left"], json!({"natal": 1, "synastry": 0, "forecast": 1, "question": 0}), "{}", r.body);
let r = app.call("POST", &analyses, Some(&anna), None).await;
assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body);
assert_eq!((r.body["kind"].as_str(), r.body["forecast_id"].as_str()), (Some("forecast"), Some(id.as_str())));
let analysis = r.body["id"].as_str().unwrap().to_string();
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 1, "synastry": 0, "forecast": 0})
json!({"natal": 1, "synastry": 0, "forecast": 0, "question": 0})
);
assert_eq!(app.call("POST", &analyses, Some(&anna), None).await.status, StatusCode::OK); // the same one, no charge
assert_eq!(app.get(&analyses, Some(&anna)).await.body["analyses"].as_array().unwrap().len(), 1);
@@ -1548,3 +1552,88 @@ async fn admins_choose_the_model_of_each_function(pool: PgPool) {
let r = app.get(&format!("/v1/charts/{chart_id}/analyses"), Some(&admin)).await;
assert_eq!(r.body["analyses"].as_array().unwrap().iter().filter(|a| a["kind"] == "natal").count(), 1);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn questions_about_an_analysis_use_question_units(pool: PgPool) {
let app = TestApp::new(pool.clone()).await;
let anna = app.register("anna@example.com", "Anna").await;
let bob = app.register("bob@example.com", "Bob").await;
let chart = app.chart(&anna, "Saját", true, "1990-03-15").await;
let chart_id = chart["id"].as_str().unwrap();
// a package comes with three questions
let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "single"})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
let left = || async { app.get("/v1/me", Some(&anna)).await.body["analyses_left"]["question"].clone() };
assert_eq!(left().await, json!(3));
let r = app.post(&format!("/v1/charts/{chart_id}/analyses"), Some(&anna), json!({})).await;
let analysis = r.body["id"].as_str().unwrap().to_string();
let uri = format!("/v1/analyses/{analysis}/questions");
let ask = |who: &str, q: &str| {
let (app, uri, who, body) = (&app, &uri, who.to_string(), json!({ "question": q }));
async move { app.post(uri, Some(&who), body).await }
};
let r = ask(&anna, "Mi az erősségem?").await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("analysis_not_ready")));
sqlx::query("UPDATE analyses SET status = 'done', content = '{\"title\": \"Cím\"}'").execute(&pool).await.unwrap();
assert_eq!(ask(&bob, "Mi az erősségem?").await.status, StatusCode::NOT_FOUND);
assert_eq!(ask(&anna, "?").await.status, StatusCode::BAD_REQUEST);
assert_eq!(ask(&anna, &"x".repeat(601)).await.status, StatusCode::BAD_REQUEST);
let r = ask(&anna, " Mi az erősségem? ").await;
assert_eq!((r.status, r.body["status"].as_str()), (StatusCode::ACCEPTED, Some("pending")), "{}", r.body);
assert_eq!(r.body["question"], "Mi az erősségem?");
assert!(r.body.get("model").is_none(), "the model is a secret");
assert_eq!(left().await, json!(2));
let question = r.body["id"].as_str().unwrap().to_string();
// the same model as the analysis answers
let (q_model, a_model): (String, String) = sqlx::query_as(
"SELECT q.model, a.model FROM questions q JOIN analyses a ON a.id = q.analysis_id WHERE q.id = $1::uuid",
)
.bind(&question)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(q_model, a_model);
// one at a time
let r = ask(&anna, "És a munkában?").await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("question_in_progress")));
sqlx::query("UPDATE questions SET status = 'done', answer = 'A kitartásod.'").execute(&pool).await.unwrap();
assert_eq!(app.get(&format!("/v1/questions/{question}"), Some(&anna)).await.body["answer"], "A kitartásod.");
assert_eq!(app.get(&format!("/v1/questions/{question}"), Some(&bob)).await.status, StatusCode::NOT_FOUND);
assert_eq!(ask(&anna, "És a munkában?").await.status, StatusCode::ACCEPTED);
sqlx::query("UPDATE questions SET status = 'done', answer = 'Válasz.'").execute(&pool).await.unwrap();
assert_eq!(ask(&anna, "És a pénz?").await.status, StatusCode::ACCEPTED);
sqlx::query("UPDATE questions SET status = 'done', answer = 'Válasz.'").execute(&pool).await.unwrap();
let r = ask(&anna, "És a szerelem?").await;
assert_eq!(
(r.status, r.body["error"]["code"].as_str()),
(StatusCode::PAYMENT_REQUIRED, Some("insufficient_credits"))
);
let list = app.get(&uri, Some(&anna)).await.body;
assert_eq!(list["questions"].as_array().unwrap().len(), 3);
assert_eq!(list["questions"][0]["question"], "Mi az erősségem?");
// more can be bought; the summary cannot be asked about
let r = app.post("/v1/payments/mock", Some(&anna), json!({"unit": "question"})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
assert_eq!(left().await, json!(5));
let summary: String =
sqlx::query_scalar("SELECT id::text FROM analyses WHERE kind = 'summary'").fetch_one(&pool).await.unwrap();
sqlx::query("UPDATE analyses SET status = 'done', content = '{}' WHERE kind = 'summary'")
.execute(&pool)
.await
.unwrap();
let r = app.post(&format!("/v1/analyses/{summary}/questions"), Some(&anna), json!({"question": "Miért?"})).await;
assert_eq!(r.status, StatusCode::BAD_REQUEST);
// admins regenerate an answer in place
let admin = app.register("admin@example.com", "Admin").await;
let r = app.post(&format!("/v1/admin/questions/{question}/regenerate"), Some(&admin), json!({})).await;
assert_eq!(
(r.status, r.body["status"].as_str(), &r.body["answer"]),
(StatusCode::OK, Some("pending"), &Value::Null)
);
assert_eq!(left().await, json!(5), "regenerating charges nobody");
}