Yearly forecast: solar return, transits, progressions, profection, eclipses
- astro-engine: forecast module (solar return moment, slow-planet transits
with exact dates and periods, natal house ingresses, secondary
progressions, annual profection, eclipses via Swiss Ephemeris)
- horoscope-api: POST /v1/forecast, solar return chart cast for the place
of the birthday
- backend: forecasts table, /v1/charts/{id}/forecasts, /v1/forecasts/{id}
and its analyses using a new 'forecast' unit; current year of life open,
the next one 30 days before the birthday
- packages: Páros and Család include forecasts (6 000 / 11 000 Ft),
+1 éves előrejelzés add-on 2 500 Ft; Egy elemzés unchanged
- worker and prompt: forecast kind with five sections and forecast rules
(trends, no event predictions); no birth data, place or exact age sent
- frontend: /kepletek/{id}/elorejelzes with the solar return wheel, the
keys of the year, a monthly timeline, transit list and detailed forecast
- data export: forecasts added, model name removed
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
This commit is contained in:
@@ -1,6 +1,7 @@
|
||||
//! Analysis units: a detailed natal analysis uses one `natal` unit, a
|
||||
//! synastry analysis one `synastry` unit. Units come from purchases or an
|
||||
//! admin; a failed analysis gives its unit back (the worker does that).
|
||||
//! 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).
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
@@ -14,6 +15,8 @@ use crate::error::ApiError;
|
||||
pub enum Unit {
|
||||
Natal,
|
||||
Synastry,
|
||||
/// A yearly forecast (see `routes::forecasts`).
|
||||
Forecast,
|
||||
/// A slot for adding a person (see [`crate::persons`]).
|
||||
Person,
|
||||
}
|
||||
@@ -23,6 +26,7 @@ impl Unit {
|
||||
match self {
|
||||
Unit::Natal => "natal",
|
||||
Unit::Synastry => "synastry",
|
||||
Unit::Forecast => "forecast",
|
||||
Unit::Person => "person",
|
||||
}
|
||||
}
|
||||
@@ -33,6 +37,7 @@ impl Unit {
|
||||
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,
|
||||
}
|
||||
@@ -42,26 +47,28 @@ impl Balance {
|
||||
match unit {
|
||||
Unit::Natal => self.natal,
|
||||
Unit::Synastry => self.synastry,
|
||||
Unit::Forecast => self.forecast,
|
||||
Unit::Person => self.person,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn view(self) -> Value {
|
||||
json!({ "natal": self.natal, "synastry": self.synastry })
|
||||
json!({ "natal": self.natal, "synastry": self.synastry, "forecast": self.forecast })
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn balance(conn: &mut PgConnection, user_id: Uuid) -> Result<Balance, ApiError> {
|
||||
let (natal, synastry, person): (i64, i64, i64) = sqlx::query_as(
|
||||
let (natal, synastry, forecast, person): (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 \
|
||||
FROM credit_ledger WHERE user_id = $1",
|
||||
)
|
||||
.bind(user_id)
|
||||
.fetch_one(conn)
|
||||
.await?;
|
||||
Ok(Balance { natal, synastry, person })
|
||||
Ok(Balance { natal, synastry, forecast, person })
|
||||
}
|
||||
|
||||
/// Spends one unit inside the caller's transaction. The user row is locked
|
||||
|
||||
@@ -16,6 +16,8 @@ use crate::error::ApiError;
|
||||
/// List prices of the single items, for showing what a package saves.
|
||||
const NATAL_PRICE: i64 = 2_000;
|
||||
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
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
@@ -36,12 +38,13 @@ pub struct Package {
|
||||
pub price_huf: i64,
|
||||
pub natal: i64,
|
||||
pub synastry: i64,
|
||||
pub forecast: i64,
|
||||
pub persons: i64,
|
||||
/// Badge on the card ("Legnépszerűbb").
|
||||
pub badge: Option<&'static str>,
|
||||
}
|
||||
|
||||
pub const CATALOG: [Package; 5] = [
|
||||
pub const CATALOG: [Package; 6] = [
|
||||
Package {
|
||||
id: "single",
|
||||
name: "Egy elemzés",
|
||||
@@ -50,28 +53,31 @@ pub const CATALOG: [Package; 5] = [
|
||||
price_huf: 2_000,
|
||||
natal: 1,
|
||||
synastry: 0,
|
||||
forecast: 0,
|
||||
persons: 0,
|
||||
badge: None,
|
||||
},
|
||||
Package {
|
||||
id: "couple",
|
||||
name: "Páros",
|
||||
tagline: "Te és ő: mindkettőtök képlete és a kapcsolati elemzés.",
|
||||
tagline: "Te és ő: mindkettőtök képlete, éves előrejelzése és a kapcsolati elemzés.",
|
||||
tier: Tier::Main,
|
||||
price_huf: 4_500,
|
||||
price_huf: 6_000,
|
||||
natal: 2,
|
||||
synastry: 1,
|
||||
forecast: 2,
|
||||
persons: 1,
|
||||
badge: None,
|
||||
},
|
||||
Package {
|
||||
id: "family",
|
||||
name: "Család",
|
||||
tagline: "Az egész család: öt személy, mindenki képlete, és öt kapcsolat.",
|
||||
tagline: "Az egész család: öt személy, mindenki képlete és éves előrejelzése, és öt kapcsolat.",
|
||||
tier: Tier::Main,
|
||||
price_huf: 8_000,
|
||||
price_huf: 11_000,
|
||||
natal: 6,
|
||||
synastry: 5,
|
||||
forecast: 6,
|
||||
persons: 5,
|
||||
badge: Some("Legnépszerűbb"),
|
||||
},
|
||||
@@ -83,6 +89,19 @@ pub const CATALOG: [Package; 5] = [
|
||||
price_huf: 2_500,
|
||||
natal: 0,
|
||||
synastry: 1,
|
||||
forecast: 0,
|
||||
persons: 0,
|
||||
badge: None,
|
||||
},
|
||||
Package {
|
||||
id: "addon_forecast",
|
||||
name: "+1 éves előrejelzés",
|
||||
tagline: "Egy év születésnaptól születésnapig: szolár, tranzitok, progresszió.",
|
||||
tier: Tier::Addon,
|
||||
price_huf: FORECAST_PRICE,
|
||||
natal: 0,
|
||||
synastry: 0,
|
||||
forecast: 1,
|
||||
persons: 0,
|
||||
badge: None,
|
||||
},
|
||||
@@ -94,6 +113,7 @@ pub const CATALOG: [Package; 5] = [
|
||||
price_huf: 1_500,
|
||||
natal: 0,
|
||||
synastry: 0,
|
||||
forecast: 0,
|
||||
persons: 5,
|
||||
badge: None,
|
||||
},
|
||||
@@ -106,11 +126,14 @@ pub fn find(id: &str) -> Option<&'static Package> {
|
||||
impl Package {
|
||||
/// What the contents would cost one by one.
|
||||
fn list_price(&self) -> i64 {
|
||||
self.natal * NATAL_PRICE + self.synastry * SYNASTRY_PRICE + self.persons * PERSON_PRICE
|
||||
self.natal * NATAL_PRICE
|
||||
+ self.synastry * SYNASTRY_PRICE
|
||||
+ self.forecast * FORECAST_PRICE
|
||||
+ self.persons * PERSON_PRICE
|
||||
}
|
||||
|
||||
pub fn view(&self) -> Value {
|
||||
let analyses = self.natal + self.synastry;
|
||||
let analyses = self.natal + self.synastry + self.forecast;
|
||||
let list = self.list_price();
|
||||
let savings = (list > self.price_huf).then(|| ((list - self.price_huf) * 100 + list / 2) / list);
|
||||
json!({
|
||||
@@ -121,6 +144,7 @@ impl Package {
|
||||
"price_huf": self.price_huf,
|
||||
"natal": self.natal,
|
||||
"synastry": self.synastry,
|
||||
"forecast": self.forecast,
|
||||
"persons": self.persons,
|
||||
"badge": self.badge,
|
||||
"list_price_huf": list,
|
||||
@@ -173,8 +197,13 @@ pub async fn grant(
|
||||
.bind(created_by)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
for (unit, n) in [(Unit::Natal, package.natal), (Unit::Synastry, package.synastry), (Unit::Person, package.persons)]
|
||||
{
|
||||
let contents = [
|
||||
(Unit::Natal, package.natal),
|
||||
(Unit::Synastry, package.synastry),
|
||||
(Unit::Forecast, package.forecast),
|
||||
(Unit::Person, package.persons),
|
||||
];
|
||||
for (unit, n) in contents {
|
||||
if n == 0 {
|
||||
continue;
|
||||
}
|
||||
@@ -218,8 +247,10 @@ mod tests {
|
||||
fn bigger_packages_are_cheaper_per_analysis() {
|
||||
let per = |id: &str| find(id).unwrap().view()["per_analysis_huf"].as_i64().unwrap();
|
||||
assert!(per("single") > per("couple") && per("couple") > per("family"));
|
||||
assert_eq!(find("family").unwrap().view()["savings_percent"], 69);
|
||||
assert_eq!(find("couple").unwrap().view()["savings_percent"], 34);
|
||||
assert_eq!(find("family").unwrap().view()["savings_percent"], 73);
|
||||
assert_eq!(find("couple").unwrap().view()["savings_percent"], 49);
|
||||
// Alone a forecast costs more than a natal analysis.
|
||||
assert!(find("addon_forecast").unwrap().price_huf > find("single").unwrap().price_huf);
|
||||
assert!(find("single").unwrap().view()["savings_percent"].is_null());
|
||||
assert!(find("unlimited").is_none());
|
||||
assert!(CATALOG.iter().all(|p| find(p.id).is_some()));
|
||||
|
||||
@@ -156,7 +156,8 @@ pub async fn export(State(state): St, auth: AuthUser) -> ApiResult<impl IntoResp
|
||||
"charts": rows("SELECT json_build_object('id', id, 'label', label, 'is_primary', is_primary, 'birth_data', birth_data, 'result', result, 'created_at', created_at) FROM charts WHERE owner_id = $1").await?,
|
||||
"synastries": rows("SELECT json_build_object('id', s.id, 'owner_id', s.owner_id, 'chart1_id', s.chart1_id, 'chart2_id', s.chart2_id, 'result', s.result, 'created_at', s.created_at) FROM synastries s JOIN charts c1 ON c1.id = s.chart1_id JOIN charts c2 ON c2.id = s.chart2_id WHERE s.owner_id = $1 OR c1.owner_id = $1 OR c2.owner_id = $1").await?,
|
||||
"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?,
|
||||
"analyses": rows("SELECT json_build_object('id', a.id, 'kind', a.kind, 'chart_id', a.chart_id, 'synastry_id', a.synastry_id, 'language', a.language, 'model', a.model, '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?,
|
||||
"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?,
|
||||
"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?,
|
||||
});
|
||||
|
||||
@@ -33,12 +33,14 @@ 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);
|
||||
type Row =
|
||||
(Uuid, String, Option<String>, Vec<String>, bool, OffsetDateTime, Option<OffsetDateTime>, 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 = 'synastry'), \
|
||||
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'forecast') \
|
||||
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",
|
||||
@@ -50,11 +52,11 @@ 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)| {
|
||||
.map(|(id, email, name, roles, verified, created, last_login, charts, natal, synastry, forecast)| {
|
||||
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},
|
||||
"charts": charts, "analyses_left": {"natal": natal, "synastry": synastry, "forecast": forecast},
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
//! Text analyses (LLM) of charts and synastries.
|
||||
//!
|
||||
//! A request creates a `pending` analysis and spends one unit of its kind
|
||||
//! (`natal` or `synastry`, see [`credits`]; admins pay nothing); the worker
|
||||
//! (`natal`, `synastry` or `forecast`, see [`credits`]; admins pay nothing); the worker
|
||||
//! writes the text later. A finished analysis with the same cache key (same
|
||||
//! chart or synastry hash, prompt version, model and language) is copied
|
||||
//! instead, free of charge, so the same chart is never paid for twice.
|
||||
@@ -22,6 +22,7 @@ use uuid::Uuid;
|
||||
|
||||
use super::auth::validate_locale;
|
||||
use super::charts::{ChartRow, find_chart, owned_chart};
|
||||
use super::forecasts::{find_forecast, owned_forecast};
|
||||
use super::synastries::{load_synastry, visible_synastry};
|
||||
use super::{IdPath, St};
|
||||
use crate::AppState;
|
||||
@@ -38,6 +39,7 @@ pub struct AnalysisRow {
|
||||
pub kind: String,
|
||||
pub chart_id: Option<Uuid>,
|
||||
pub synastry_id: Option<Uuid>,
|
||||
pub forecast_id: Option<Uuid>,
|
||||
pub language: String,
|
||||
pub prompt_version: String,
|
||||
pub status: String,
|
||||
@@ -48,7 +50,8 @@ pub struct AnalysisRow {
|
||||
pub completed_at: Option<OffsetDateTime>,
|
||||
}
|
||||
|
||||
const ANALYSIS_COLUMNS: &str = "id, kind, chart_id, synastry_id, language, prompt_version, status, content, error, \
|
||||
const ANALYSIS_COLUMNS: &str = "id, kind, chart_id, synastry_id, forecast_id, language, prompt_version, status, \
|
||||
content, error, \
|
||||
credits_charged, created_at, completed_at";
|
||||
|
||||
impl AnalysisRow {
|
||||
@@ -58,6 +61,7 @@ impl AnalysisRow {
|
||||
"kind": self.kind,
|
||||
"chart_id": self.chart_id,
|
||||
"synastry_id": self.synastry_id,
|
||||
"forecast_id": self.forecast_id,
|
||||
"language": self.language,
|
||||
"prompt_version": self.prompt_version,
|
||||
"status": self.status,
|
||||
@@ -77,8 +81,8 @@ pub async fn find_analysis(db: &PgPool, id: Uuid) -> Result<Option<AnalysisRow>,
|
||||
.await?)
|
||||
}
|
||||
|
||||
/// Whether `user` may read the analysis: the chart's owner, or a member of
|
||||
/// the synastry.
|
||||
/// Whether `user` may read the analysis: the owner of the chart (or of the
|
||||
/// forecast's chart), or a member of the synastry.
|
||||
pub async fn can_see(db: &PgPool, analysis: &AnalysisRow, user: Uuid) -> Result<bool, ApiError> {
|
||||
if let Some(chart_id) = analysis.chart_id {
|
||||
return Ok(find_chart(db, chart_id).await?.is_some_and(|c| c.owner_id == user));
|
||||
@@ -86,6 +90,11 @@ pub async fn can_see(db: &PgPool, analysis: &AnalysisRow, user: Uuid) -> Result<
|
||||
if let Some(synastry_id) = analysis.synastry_id {
|
||||
return Ok(load_synastry(db, synastry_id).await?.is_some_and(|s| s.is_member(user)));
|
||||
}
|
||||
if let Some(forecast_id) = analysis.forecast_id
|
||||
&& let Some(forecast) = find_forecast(db, forecast_id).await?
|
||||
{
|
||||
return Ok(find_chart(db, forecast.chart_id).await?.is_some_and(|c| c.owner_id == user));
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
@@ -108,6 +117,7 @@ enum Target {
|
||||
Natal { chart_id: Uuid, hash: String },
|
||||
Summary { chart_id: Uuid, hash: String },
|
||||
Synastry { synastry_id: Uuid, hash: String },
|
||||
Forecast { forecast_id: Uuid, hash: String },
|
||||
}
|
||||
|
||||
async fn request(
|
||||
@@ -122,6 +132,7 @@ async fn request(
|
||||
let unit = match target {
|
||||
_ if admin => None,
|
||||
Target::Synastry { .. } => Some(Unit::Synastry),
|
||||
Target::Forecast { .. } => Some(Unit::Forecast),
|
||||
_ => Some(Unit::Natal),
|
||||
};
|
||||
let model = state.config.analysis_model.clone();
|
||||
@@ -140,10 +151,11 @@ async fn queue(
|
||||
model: &str,
|
||||
unit: Option<Unit>,
|
||||
) -> Result<(StatusCode, AnalysisRow), ApiError> {
|
||||
let (kind, hash, chart_id, synastry_id) = match target {
|
||||
Target::Natal { chart_id, hash } => ("natal", hash, Some(*chart_id), None),
|
||||
Target::Summary { chart_id, hash } => ("summary", hash, Some(*chart_id), None),
|
||||
Target::Synastry { synastry_id, hash } => ("synastry", hash, None, Some(*synastry_id)),
|
||||
let (kind, hash, chart_id, synastry_id, forecast_id) = match target {
|
||||
Target::Natal { chart_id, hash } => ("natal", hash, Some(*chart_id), None, None),
|
||||
Target::Summary { chart_id, hash } => ("summary", hash, Some(*chart_id), None, None),
|
||||
Target::Synastry { synastry_id, hash } => ("synastry", hash, None, Some(*synastry_id), None),
|
||||
Target::Forecast { forecast_id, hash } => ("forecast", hash, None, None, Some(*forecast_id)),
|
||||
};
|
||||
// The cache key leaves out the admin-edited prompt revision, so a chart keeps
|
||||
// its analysis when the prompt changes; copying from another chart needs the same revision.
|
||||
@@ -157,12 +169,13 @@ async fn queue(
|
||||
// Already requested for this chart/synastry: return it.
|
||||
let existing: Option<AnalysisRow> = sqlx::query_as(&format!(
|
||||
"SELECT {ANALYSIS_COLUMNS} FROM analyses \
|
||||
WHERE (chart_id = $1 OR synastry_id = $2) AND cache_key = $3 AND status <> 'failed' \
|
||||
WHERE (chart_id = $1 OR synastry_id = $2 OR forecast_id = $4) AND cache_key = $3 AND status <> 'failed' \
|
||||
ORDER BY created_at DESC LIMIT 1"
|
||||
))
|
||||
.bind(chart_id)
|
||||
.bind(synastry_id)
|
||||
.bind(&cache_key)
|
||||
.bind(forecast_id)
|
||||
.fetch_optional(&state.db)
|
||||
.await?;
|
||||
if let Some(row) = existing {
|
||||
@@ -171,8 +184,9 @@ async fn queue(
|
||||
|
||||
let insert = format!(
|
||||
"INSERT INTO analyses (id, kind, chart_id, synastry_id, requested_by, language, model, prompt_version, \
|
||||
cache_key, status, content, input_tokens, output_tokens, credits_charged, completed_at) \
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15) RETURNING {ANALYSIS_COLUMNS}"
|
||||
cache_key, status, content, input_tokens, output_tokens, credits_charged, completed_at, \
|
||||
forecast_id) \
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16) RETURNING {ANALYSIS_COLUMNS}"
|
||||
);
|
||||
let id = Uuid::now_v7();
|
||||
|
||||
@@ -202,6 +216,7 @@ async fn queue(
|
||||
.bind(output_tokens)
|
||||
.bind(0)
|
||||
.bind(OffsetDateTime::now_utc())
|
||||
.bind(forecast_id)
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
return Ok((StatusCode::CREATED, row));
|
||||
@@ -225,6 +240,7 @@ async fn queue(
|
||||
.bind(None::<i32>)
|
||||
.bind(i32::from(unit.is_some()))
|
||||
.bind(None::<OffsetDateTime>)
|
||||
.bind(forecast_id)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
if let Some(unit) = unit {
|
||||
@@ -309,3 +325,23 @@ pub async fn get_one(State(state): St, auth: AuthUser, WithRejection(Path(id), _
|
||||
}
|
||||
Ok(Json(analysis.view()))
|
||||
}
|
||||
|
||||
pub async fn list_for_forecast(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
owned_forecast(&state.db, id, auth.id()).await?;
|
||||
list_where(&state.db, "forecast_id", id).await
|
||||
}
|
||||
|
||||
pub async fn request_for_forecast(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
body: Bytes,
|
||||
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||||
let (forecast, _) = owned_forecast(&state.db, id, auth.id()).await?;
|
||||
let req = optional_body(&body)?;
|
||||
request(&state, &auth, Target::Forecast { forecast_id: forecast.id, hash: forecast.forecast_hash }, req).await
|
||||
}
|
||||
|
||||
@@ -0,0 +1,303 @@
|
||||
//! Yearly forecasts of a chart: one year of life from a solar return
|
||||
//! (birthday) to the next, calculated by the horoscope service for where the
|
||||
//! person is on the birthday. The calculation (solar return chart, transit
|
||||
//! timeline, progressions, profection, eclipses) is free; its detailed text
|
||||
//! analysis uses a `forecast` unit (see [`super::analyses`]).
|
||||
//!
|
||||
//! Users can calculate the year of life they are in, and the next one from
|
||||
//! [`NEXT_YEAR_DAYS`] days before the birthday; admins any year.
|
||||
|
||||
use axum::Json;
|
||||
use axum::extract::State;
|
||||
use axum::http::StatusCode;
|
||||
use axum_extra::extract::WithRejection;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
use sqlx::PgPool;
|
||||
use time::{Date, Month, OffsetDateTime};
|
||||
use uuid::Uuid;
|
||||
|
||||
use super::charts::{ChartRow, find_chart, owned_chart};
|
||||
use super::{Body, IdPath, St};
|
||||
use crate::auth::AuthUser;
|
||||
use crate::error::{ApiError, ApiResult};
|
||||
use crate::views::{rfc3339, sha256_hex};
|
||||
use db::Role;
|
||||
|
||||
/// The next year of life can be calculated this many days before the birthday.
|
||||
pub const NEXT_YEAR_DAYS: i64 = 30;
|
||||
/// At most this many forecasts (years and places) per chart.
|
||||
const MAX_PER_CHART: i64 = 20;
|
||||
|
||||
#[derive(Debug, Clone, sqlx::FromRow)]
|
||||
pub struct ForecastRow {
|
||||
pub id: Uuid,
|
||||
pub chart_id: Uuid,
|
||||
pub year: i32,
|
||||
pub location: Option<Value>,
|
||||
pub result: Value,
|
||||
pub forecast_hash: String,
|
||||
pub created_at: OffsetDateTime,
|
||||
}
|
||||
|
||||
const FORECAST_COLUMNS: &str = "id, chart_id, year, location, result, forecast_hash, created_at";
|
||||
|
||||
impl ForecastRow {
|
||||
/// Where the year is reckoned, for lists: the place name or the coordinates.
|
||||
fn place(&self) -> Value {
|
||||
let sr = &self.result["solar_return"]["location"];
|
||||
let loc = &self.result["location"];
|
||||
sr.pointer("/place/name").or(loc.get("place")).cloned().unwrap_or(Value::Null)
|
||||
}
|
||||
|
||||
pub fn summary_view(&self) -> Value {
|
||||
let f = &self.result["forecast"];
|
||||
json!({
|
||||
"id": self.id,
|
||||
"chart_id": self.chart_id,
|
||||
"year": self.year,
|
||||
"start": f["start"],
|
||||
"end": f["end"],
|
||||
"place": self.place(),
|
||||
"birth_place": self.location.is_none(),
|
||||
"created_at": rfc3339(self.created_at),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn view(&self) -> Value {
|
||||
let mut v = self.summary_view();
|
||||
v["location"] = self.location.clone().unwrap_or(Value::Null);
|
||||
v["result"] = self.result.clone();
|
||||
v
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn find_forecast(db: &PgPool, id: Uuid) -> Result<Option<ForecastRow>, ApiError> {
|
||||
Ok(sqlx::query_as(&format!("SELECT {FORECAST_COLUMNS} FROM forecasts WHERE id = $1"))
|
||||
.bind(id)
|
||||
.fetch_optional(db)
|
||||
.await?)
|
||||
}
|
||||
|
||||
/// A forecast of a chart of `owner`; 404 otherwise.
|
||||
pub async fn owned_forecast(db: &PgPool, id: Uuid, owner: Uuid) -> Result<(ForecastRow, ChartRow), ApiError> {
|
||||
let forecast = find_forecast(db, id).await?.ok_or(ApiError::NotFound("forecast"))?;
|
||||
let chart = find_chart(db, forecast.chart_id).await?.filter(|c| c.owner_id == owner);
|
||||
chart.map(|c| (forecast, c)).ok_or(ApiError::NotFound("forecast"))
|
||||
}
|
||||
|
||||
/// The Gregorian birth date of a calculated chart.
|
||||
fn birth_date(chart: &ChartRow) -> Option<Date> {
|
||||
let text = chart.result.pointer("/time/date")?.as_str()?;
|
||||
let mut parts = text.split('-').map(str::parse::<i32>);
|
||||
let (y, m, d) = (parts.next()?.ok()?, parts.next()?.ok()?, parts.next()?.ok()?);
|
||||
Date::from_calendar_date(y, Month::try_from(m as u8).ok()?, d as u8).ok()
|
||||
}
|
||||
|
||||
/// The birthday in a year (29 February is the 28th in common years).
|
||||
fn birthday(birth: Date, year: i32) -> Option<Date> {
|
||||
Date::from_calendar_date(year, birth.month(), birth.day())
|
||||
.or_else(|_| Date::from_calendar_date(year, birth.month(), birth.day() - 1))
|
||||
.ok()
|
||||
}
|
||||
|
||||
/// The years (of the solar return starting them) a user can calculate on
|
||||
/// `today`: the current year of life, and the next one close to the birthday.
|
||||
pub fn open_years(birth: Date, today: Date) -> Vec<i32> {
|
||||
let Some(this) = birthday(birth, today.year()) else { return Vec::new() };
|
||||
let current = if today >= this { today.year() } else { today.year() - 1 };
|
||||
let mut years = Vec::new();
|
||||
if current > birth.year() {
|
||||
years.push(current);
|
||||
}
|
||||
if birthday(birth, current + 1).is_some_and(|next| (next - today).whole_days() <= NEXT_YEAR_DAYS) {
|
||||
years.push(current + 1);
|
||||
}
|
||||
years
|
||||
}
|
||||
|
||||
/// Where the person is on the birthday, as the horoscope service takes it.
|
||||
#[derive(Debug, Clone, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Location {
|
||||
country: String,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
place: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
region: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
geonames_id: Option<u64>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
latitude: Option<f64>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
longitude: Option<f64>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Default)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct CreateForecast {
|
||||
/// Defaults to the current year of life.
|
||||
year: Option<i32>,
|
||||
/// Defaults to the birth place.
|
||||
location: Option<Location>,
|
||||
}
|
||||
|
||||
fn is_admin(auth: &AuthUser) -> bool {
|
||||
auth.user.has_role(Role::Admin)
|
||||
}
|
||||
|
||||
/// The years open to this user for a chart (admins: also every earlier one is allowed on request).
|
||||
fn years_for(chart: &ChartRow) -> Vec<i32> {
|
||||
birth_date(chart).map(|b| open_years(b, OffsetDateTime::now_utc().date())).unwrap_or_default()
|
||||
}
|
||||
|
||||
fn current_forecasts_query() -> String {
|
||||
format!(
|
||||
"SELECT {FORECAST_COLUMNS} FROM forecasts WHERE chart_id = $1 AND chart_hash = $2 ORDER BY year DESC, created_at"
|
||||
)
|
||||
}
|
||||
|
||||
/// The forecasts of a chart (for its current birth data) and the years that can be calculated.
|
||||
pub async fn list_for_chart(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(axum::extract::Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let chart = owned_chart(&state.db, id, auth.id()).await?;
|
||||
let rows: Vec<ForecastRow> =
|
||||
sqlx::query_as(¤t_forecasts_query()).bind(chart.id).bind(&chart.chart_hash).fetch_all(&state.db).await?;
|
||||
Ok(Json(json!({
|
||||
"years": years_for(&chart),
|
||||
"birth_place": chart.result.pointer("/location/place/name"),
|
||||
"time_known": chart.result.pointer("/time/time_known"),
|
||||
"forecasts": rows.iter().map(ForecastRow::summary_view).collect::<Vec<_>>(),
|
||||
})))
|
||||
}
|
||||
|
||||
/// Calculates a year (or returns it when already calculated). 201 or 200.
|
||||
pub async fn create(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(axum::extract::Path(id), _): IdPath,
|
||||
WithRejection(Json(req), _): Body<CreateForecast>,
|
||||
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||||
let chart = owned_chart(&state.db, id, auth.id()).await?;
|
||||
let open = years_for(&chart);
|
||||
let year = match req.year {
|
||||
Some(y) if open.contains(&y) || is_admin(&auth) => y,
|
||||
Some(_) => {
|
||||
return Err(ApiError::Refused {
|
||||
code: "forecast_year_closed",
|
||||
message: "Az aktuális évre, és a születésnap előtti 30 napban a következőre kérhetsz előrejelzést."
|
||||
.into(),
|
||||
});
|
||||
}
|
||||
None => *open.first().ok_or(ApiError::Refused {
|
||||
code: "forecast_year_closed",
|
||||
message: "Az első születésnap előtt még nincs éves előrejelzés.".into(),
|
||||
})?,
|
||||
};
|
||||
let location = req.location.map(|l| serde_json::to_value(l).expect("serializable"));
|
||||
let location_key = location.as_ref().map_or_else(|| "birth".to_string(), |l| sha256_hex(&l.to_string()));
|
||||
|
||||
let existing: Option<ForecastRow> = sqlx::query_as(&format!(
|
||||
"SELECT {FORECAST_COLUMNS} FROM forecasts \
|
||||
WHERE chart_id = $1 AND chart_hash = $2 AND year = $3 AND location_key = $4"
|
||||
))
|
||||
.bind(chart.id)
|
||||
.bind(&chart.chart_hash)
|
||||
.bind(year)
|
||||
.bind(&location_key)
|
||||
.fetch_optional(&state.db)
|
||||
.await?;
|
||||
if let Some(row) = existing {
|
||||
return Ok((StatusCode::OK, Json(row.view())));
|
||||
}
|
||||
let (count,): (i64,) = sqlx::query_as("SELECT count(*) FROM forecasts WHERE chart_id = $1")
|
||||
.bind(chart.id)
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
if count >= MAX_PER_CHART && !is_admin(&auth) {
|
||||
return Err(ApiError::conflict(
|
||||
"forecast_limit_reached",
|
||||
format!("at most {MAX_PER_CHART} forecasts can be saved for a chart"),
|
||||
));
|
||||
}
|
||||
|
||||
let mut request = json!({ "birth": chart.birth_data, "year": year });
|
||||
if let Some(l) = &location {
|
||||
request["location"] = l.clone();
|
||||
}
|
||||
let mut result = state.horoscope.forecast(&request).await?;
|
||||
if let Some(obj) = result.as_object_mut() {
|
||||
obj.remove("meta");
|
||||
}
|
||||
let forecast_hash = forecast_hash(&chart.chart_hash, year, &location_key, &result);
|
||||
let row: ForecastRow = sqlx::query_as(&format!(
|
||||
"INSERT INTO forecasts (id, chart_id, chart_hash, year, location, location_key, result, forecast_hash, created_by) \
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) \
|
||||
ON CONFLICT (chart_id, chart_hash, year, location_key) DO UPDATE SET chart_id = EXCLUDED.chart_id \
|
||||
RETURNING {FORECAST_COLUMNS}"
|
||||
))
|
||||
.bind(Uuid::now_v7())
|
||||
.bind(chart.id)
|
||||
.bind(&chart.chart_hash)
|
||||
.bind(year)
|
||||
.bind(&location)
|
||||
.bind(&location_key)
|
||||
.bind(&result)
|
||||
.bind(&forecast_hash)
|
||||
.bind(auth.id())
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
Ok((StatusCode::CREATED, Json(row.view())))
|
||||
}
|
||||
|
||||
/// Identifies a forecast independently of how the place was entered: the
|
||||
/// chart, the year and the resolved place and time zone of the solar return.
|
||||
fn forecast_hash(chart_hash: &str, year: i32, location_key: &str, result: &Value) -> String {
|
||||
let sr = &result["solar_return"];
|
||||
let place = if sr.is_object() {
|
||||
format!(
|
||||
"{:.4}|{:.4}|{}",
|
||||
sr["location"]["latitude"].as_f64().unwrap_or_default(),
|
||||
sr["location"]["longitude"].as_f64().unwrap_or_default(),
|
||||
sr["timezone"].as_str().unwrap_or_default()
|
||||
)
|
||||
} else {
|
||||
location_key.to_string()
|
||||
};
|
||||
sha256_hex(&format!("forecast|{chart_hash}|{year}|{place}"))
|
||||
}
|
||||
|
||||
pub async fn get_one(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(axum::extract::Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let (forecast, _) = owned_forecast(&state.db, id, auth.id()).await?;
|
||||
Ok(Json(forecast.view()))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn date(y: i32, m: u8, d: u8) -> Date {
|
||||
Date::from_calendar_date(y, Month::try_from(m).unwrap(), d).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn years_open_around_the_birthday() {
|
||||
let birth = date(1990, 3, 15);
|
||||
assert_eq!(open_years(birth, date(2026, 11, 18)), vec![2026]);
|
||||
assert_eq!(open_years(birth, date(2027, 3, 1)), vec![2026, 2027]);
|
||||
assert_eq!(open_years(birth, date(2027, 3, 15)), vec![2027]);
|
||||
assert_eq!(open_years(birth, date(2027, 2, 12)), vec![2026]);
|
||||
// Before the first birthday: only the first year, close to it.
|
||||
assert!(open_years(birth, date(1990, 6, 1)).is_empty());
|
||||
assert_eq!(open_years(birth, date(1991, 3, 1)), vec![1991]);
|
||||
// 29 February
|
||||
assert_eq!(open_years(date(1992, 2, 29), date(2027, 2, 28)), vec![2027]);
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@ mod admin;
|
||||
mod analyses;
|
||||
mod auth;
|
||||
mod charts;
|
||||
mod forecasts;
|
||||
mod invitations;
|
||||
mod payments;
|
||||
mod prompts;
|
||||
@@ -73,6 +74,9 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/charts/{id}", get(charts::get_one).patch(charts::update).delete(charts::remove))
|
||||
.route("/v1/charts/{id}/analyses", get(analyses::list_for_chart).post(analyses::request_for_chart))
|
||||
.route("/v1/charts/{id}/summary", post(analyses::summary_for_chart))
|
||||
.route("/v1/charts/{id}/forecasts", get(forecasts::list_for_chart).post(forecasts::create))
|
||||
.route("/v1/forecasts/{id}", get(forecasts::get_one))
|
||||
.route("/v1/forecasts/{id}/analyses", get(analyses::list_for_forecast).post(analyses::request_for_forecast))
|
||||
// synastries and invitations
|
||||
.route("/v1/synastries", get(synastries::list).post(synastries::create))
|
||||
.route("/v1/synastries/{id}", get(synastries::get_one).delete(synastries::remove))
|
||||
|
||||
@@ -53,6 +53,7 @@ pub async fn mock(
|
||||
(Some(id), None) => id,
|
||||
(None, Some(Unit::Natal)) => "single",
|
||||
(None, Some(Unit::Synastry)) => "addon_synastry",
|
||||
(None, Some(Unit::Forecast)) => "addon_forecast",
|
||||
(None, Some(Unit::Person)) => "addon_persons",
|
||||
_ => return Err(ApiError::BadRequest("give either package or unit".into())),
|
||||
};
|
||||
|
||||
+118
-14
@@ -39,7 +39,7 @@ async fn fake_natal(Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
|
||||
Json(json!({
|
||||
"input": body,
|
||||
"location": {"country": {"name": "Hungary"}, "place": {"name": body["place"]}, "latitude": 47.0, "longitude": 19.0},
|
||||
"time": {"local": format!("{date}T{}:00", time.unwrap_or("12:00")), "utc": format!("{date}T11:00:00Z"), "time_known": time.is_some()},
|
||||
"time": {"date": date, "local": format!("{date}T{}:00", time.unwrap_or("12:00")), "utc": format!("{date}T11:00:00Z"), "time_known": time.is_some()},
|
||||
"astronomy": {"julian_day_ut": 2451545.0},
|
||||
"settings": body.get("options").cloned().unwrap_or(json!({"house_system": "placidus"})),
|
||||
"points": [{"id": "sun", "sign": "cancer", "longitude": 90.4}, {"id": "moon", "sign": "pisces", "longitude": 338.2}],
|
||||
@@ -72,6 +72,24 @@ async fn fake_synastry(Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
|
||||
)
|
||||
}
|
||||
|
||||
async fn fake_forecast(Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
|
||||
let year = body["year"].as_i64().unwrap_or(2026);
|
||||
let loc = body.get("location").cloned().unwrap_or(json!({"country": "HU", "place": body["birth"]["place"]}));
|
||||
(
|
||||
StatusCode::OK,
|
||||
Json(json!({
|
||||
"year": year,
|
||||
"solar_return": {
|
||||
"location": {"place": {"name": loc["place"]}, "latitude": 47.0, "longitude": 19.0},
|
||||
"timezone": "Europe/Budapest", "points": [], "input": {"date": format!("{year}-03-15")}
|
||||
},
|
||||
"location": loc,
|
||||
"forecast": {"start": format!("{year}-03-15"), "end": format!("{}-03-15", year + 1), "transits": []},
|
||||
"meta": {}
|
||||
})),
|
||||
)
|
||||
}
|
||||
|
||||
async fn fake_jwks() -> Json<Value> {
|
||||
Json(
|
||||
json!({"keys": [{"kid": "test-key", "kty": "RSA", "alg": "RS256", "use": "sig", "n": GOOGLE_KEY_N.trim(), "e": "AQAB"}]}),
|
||||
@@ -82,6 +100,7 @@ async fn fake_services() -> String {
|
||||
let app = Router::new()
|
||||
.route("/v1/natal", post(fake_natal))
|
||||
.route("/v1/synastry", post(fake_synastry))
|
||||
.route("/v1/forecast", post(fake_forecast))
|
||||
.route("/jwks", get(fake_jwks));
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let addr = listener.local_addr().unwrap();
|
||||
@@ -222,7 +241,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}));
|
||||
assert_eq!(r.body["analyses_left"], json!({"natal": 0, "synastry": 0, "forecast": 0}));
|
||||
|
||||
// e-mail verification through the queued e-mail's link
|
||||
let url = app.outbox_url("anna@example.com", "verify_email").await;
|
||||
@@ -343,11 +362,14 @@ async fn roles_and_admin_guard(pool: PgPool) {
|
||||
|
||||
let grant = |unit: &str, delta: i32| json!({"unit": unit, "delta": delta, "note": "bonus"});
|
||||
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})));
|
||||
assert_eq!(
|
||||
(r.status, &r.body["analyses_left"]),
|
||||
(StatusCode::CREATED, &json!({"natal": 5, "synastry": 0, "forecast": 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}));
|
||||
assert_eq!(credits["balance"], json!({"natal": 5, "synastry": 0, "forecast": 0}));
|
||||
assert_eq!((credits["ledger"][0]["unit"].as_str(), &credits["ledger"][0]["delta"]), (Some("natal"), &json!(5)));
|
||||
}
|
||||
|
||||
@@ -516,14 +538,20 @@ async fn analyses_spend_units_and_reuse_results(pool: PgPool) {
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(model, "anthropic/claude-test");
|
||||
assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 1, "synastry": 0}));
|
||||
assert_eq!(
|
||||
app.get("/v1/credits", Some(&anna)).await.body["balance"],
|
||||
json!({"natal": 1, "synastry": 0, "forecast": 0})
|
||||
);
|
||||
|
||||
// same request again: the same analysis, no charge
|
||||
let r = app.call("POST", &uri, Some(&anna), None).await;
|
||||
assert_eq!((r.status, r.body["id"].as_str()), (StatusCode::OK, Some(first.as_str())));
|
||||
let r = app.post(&uri, Some(&anna), json!({"language": "en"})).await;
|
||||
assert_eq!(r.status, StatusCode::ACCEPTED);
|
||||
assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 0, "synastry": 0}));
|
||||
assert_eq!(
|
||||
app.get("/v1/credits", Some(&anna)).await.body["balance"],
|
||||
json!({"natal": 0, "synastry": 0, "forecast": 0})
|
||||
);
|
||||
let r = app.post(&uri, Some(&anna), json!({"model": "anthropic/claude-other"})).await;
|
||||
assert_eq!(r.status, StatusCode::BAD_REQUEST); // no model choice
|
||||
|
||||
@@ -711,7 +739,10 @@ async fn synastry_analyses_use_synastry_units(pool: PgPool) {
|
||||
grant_units(&app, &anna, "synastry", 1).await;
|
||||
let r = app.call("POST", &uri, Some(&anna), None).await;
|
||||
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}));
|
||||
assert_eq!(
|
||||
app.get("/v1/credits", Some(&anna)).await.body["balance"],
|
||||
json!({"natal": 1, "synastry": 0, "forecast": 0})
|
||||
);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
@@ -797,14 +828,17 @@ 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})),
|
||||
(StatusCode::OK, &json!({"natal": 1, "synastry": 0, "forecast": 0})),
|
||||
"{}",
|
||||
r.body
|
||||
);
|
||||
let r =
|
||||
app.call("POST", &format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap()), Some(&anna), None).await;
|
||||
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}));
|
||||
assert_eq!(
|
||||
app.get("/v1/credits", Some(&anna)).await.body["balance"],
|
||||
json!({"natal": 0, "synastry": 0, "forecast": 0})
|
||||
);
|
||||
|
||||
// without MOCK_PAYMENTS there is no such payment
|
||||
let app = TestApp::with_config(app.pool.clone(), |c| c.mock_payments = false).await;
|
||||
@@ -1064,10 +1098,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_persons"]);
|
||||
assert_eq!(ids, ["single", "couple", "family", "addon_synastry", "addon_forecast", "addon_persons"]);
|
||||
assert_eq!(
|
||||
(&r.body["packages"][2]["badge"], &r.body["packages"][2]["per_analysis_huf"]),
|
||||
(&json!("Legnépszerűbb"), &json!(727))
|
||||
(&json!("Legnépszerűbb"), &json!(647))
|
||||
);
|
||||
|
||||
// an admin gives a package as a gift
|
||||
@@ -1076,7 +1110,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})),
|
||||
(StatusCode::CREATED, &json!({"natal": 6, "synastry": 5, "forecast": 6})),
|
||||
"{}",
|
||||
r.body
|
||||
);
|
||||
@@ -1091,10 +1125,10 @@ 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}), "{}", r.body);
|
||||
assert_eq!(r.body["analyses_left"], json!({"natal": 8, "synastry": 6, "forecast": 8}), "{}", 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, 4500);
|
||||
assert_eq!(price, 6000);
|
||||
// the header shows the latest main package; a top-up does not change it
|
||||
app.post("/v1/payments/mock", Some(&anna), json!({"package": "addon_persons"})).await;
|
||||
assert_eq!(app.get("/v1/me", Some(&anna)).await.body["package"]["name"], "Páros");
|
||||
@@ -1288,3 +1322,73 @@ async fn invitation_only_signup(pool: PgPool) {
|
||||
assert!(r.body["html"].as_str().unwrap().contains("Szia!") && r.body["text"].as_str().unwrap().contains("> Szia!"));
|
||||
assert_eq!(app.outbox_url("admin@example.com", "invitation").await, "https://sorsfonalak.test/meghivo/minta");
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn forecasts_are_free_their_analysis_uses_a_forecast_unit(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();
|
||||
let uri = format!("/v1/charts/{chart_id}/forecasts");
|
||||
|
||||
// the year of life the user is in can be calculated (free, stored once)
|
||||
let list = app.get(&uri, Some(&anna)).await.body;
|
||||
let year = list["years"][0].as_i64().expect("an open year");
|
||||
assert_eq!(list["forecasts"], json!([]));
|
||||
let r = app.post(&uri, Some(&anna), json!({})).await;
|
||||
assert_eq!((r.status, &r.body["year"]), (StatusCode::CREATED, &json!(year)), "{}", r.body);
|
||||
assert_eq!(r.body["start"], format!("{year}-03-15"));
|
||||
assert!(r.body["result"].get("meta").is_none());
|
||||
let id = r.body["id"].as_str().unwrap().to_string();
|
||||
let again = app.post(&uri, Some(&anna), json!({"year": year})).await;
|
||||
assert_eq!((again.status, again.body["id"].as_str()), (StatusCode::OK, Some(id.as_str())));
|
||||
// another place on the birthday is another forecast
|
||||
let away = app
|
||||
.post(&uri, Some(&anna), json!({"location": {"country": "JP", "geonames_id": 1850147, "place": "Tokió"}}))
|
||||
.await;
|
||||
assert_eq!((away.status, &away.body["place"]), (StatusCode::CREATED, &json!("Tokió")));
|
||||
assert_eq!(app.get(&uri, Some(&anna)).await.body["forecasts"].as_array().unwrap().len(), 2);
|
||||
// far years are closed to users; others cannot see it
|
||||
let r = app.post(&uri, Some(&anna), json!({"year": 2000})).await;
|
||||
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::FORBIDDEN, Some("forecast_year_closed")));
|
||||
assert_eq!(app.post(&uri, Some(&anna), json!({"year": year, "oops": 1})).await.status, StatusCode::BAD_REQUEST);
|
||||
assert_eq!(app.get(&format!("/v1/forecasts/{id}"), Some(&bob)).await.status, StatusCode::NOT_FOUND);
|
||||
assert_eq!(app.get(&uri, Some(&bob)).await.status, StatusCode::NOT_FOUND);
|
||||
assert_eq!(app.get(&format!("/v1/forecasts/{id}"), Some(&anna)).await.body["year"], json!(year));
|
||||
|
||||
// the detailed text uses a forecast unit, not a natal one
|
||||
let analyses = format!("/v1/forecasts/{id}/analyses");
|
||||
grant_units(&app, &anna, "natal", 1).await;
|
||||
let r = app.call("POST", &analyses, Some(&anna), None).await;
|
||||
assert_eq!(
|
||||
(r.status, r.body["error"]["code"].as_str()),
|
||||
(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);
|
||||
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})
|
||||
);
|
||||
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);
|
||||
assert_eq!(app.get(&format!("/v1/analyses/{analysis}"), Some(&anna)).await.status, StatusCode::OK);
|
||||
assert_eq!(app.get(&format!("/v1/analyses/{analysis}"), Some(&bob)).await.status, StatusCode::NOT_FOUND);
|
||||
assert_eq!(app.call("POST", &analyses, Some(&bob), None).await.status, StatusCode::NOT_FOUND);
|
||||
// the natal analyses of the chart do not list it
|
||||
let natal = app.get(&format!("/v1/charts/{chart_id}/analyses"), Some(&anna)).await.body;
|
||||
assert!(natal["analyses"].as_array().unwrap().iter().all(|a| a["kind"] != "forecast"));
|
||||
|
||||
// deleting the chart deletes its forecasts
|
||||
assert_eq!(
|
||||
app.call("DELETE", &format!("/v1/charts/{chart_id}"), Some(&anna), None).await.status,
|
||||
StatusCode::NO_CONTENT
|
||||
);
|
||||
let (n,): (i64,) = sqlx::query_as("SELECT count(*) FROM forecasts").fetch_one(&pool).await.unwrap();
|
||||
assert_eq!(n, 0);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user