Yearly forecast: solar return, transits, progressions, profection, eclipses
CI / test (push) Successful in 56s
CI / build (push) Successful in 4m41s
CI / deploy (push) Skipped

- 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:
feco
2026-11-18 08:19:13 +00:00
co-authored by Claude Opus 5.5
parent 829c33e52f
commit f1bd34c394
42 changed files with 4764 additions and 85 deletions
+12 -5
View File
@@ -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
+42 -11
View File
@@ -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()));
+2 -1
View File
@@ -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?,
});
+6 -4
View File
@@ -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();
+47 -11
View File
@@ -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
}
+303
View File
@@ -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(&current_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]);
}
}
+4
View File
@@ -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))
+1
View File
@@ -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
View File
@@ -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);
}
@@ -8,9 +8,12 @@ import { ROLE_LABELS, formatDate } from "@/lib/astro";
import type { AdminUser, Package, Role } from "@/lib/types";
const EDITABLE_ROLES: Role[] = ["user", "creator", "admin"];
const UNITS: { value: "natal" | "synastry"; label: string }[] = [
type UnitKind = "natal" | "synastry" | "forecast";
const UNITS: { value: UnitKind; label: string }[] = [
{ value: "natal", label: "képlet" },
{ value: "synastry", label: "szinasztria" },
{ value: "forecast", label: "előrejelzés" },
];
export function AdminUsers({ selfId }: { selfId: string }) {
@@ -102,7 +105,7 @@ function UserRow({
const [status, setStatus] = useState<{ ok: boolean; text: string } | null>(null);
const [busy, setBusy] = useState(false);
const [delta, setDelta] = useState("");
const [unit, setUnit] = useState<"natal" | "synastry">("natal");
const [unit, setUnit] = useState<UnitKind>("natal");
async function toggleRole(role: Role, on: boolean) {
const roles = on ? [...user.roles, role] : user.roles.filter((r) => r !== role);
@@ -175,6 +178,8 @@ function UserRow({
képlet {user.analyses_left.natal}
<br />
szinasztria {user.analyses_left.synastry}
<br />
előrejelzés {user.analyses_left.forecast ?? 0}
</span>
<label className="sr-only" htmlFor={`unit-${user.id}`}>
Elemzés fajtája
@@ -184,7 +189,7 @@ function UserRow({
className="inp"
style={{ width: 118, minHeight: 36 }}
value={unit}
onChange={(e) => setUnit(e.target.value as "natal" | "synastry")}
onChange={(e) => setUnit(e.target.value as UnitKind)}
>
{UNITS.map((u) => (
<option key={u.value} value={u.value}>
@@ -16,6 +16,10 @@ const FAQ: [string, string][] = [
"Mi a különbség a képletelemzés és a kapcsolati elemzés között?",
"A képletelemzés egy ember születési képletét írja le hat fejezetben. A kapcsolati elemzés két képletet vet össze: mi vonz, hol súrlódtok, és mit ad a kapcsolat.",
],
[
"Mi az éves előrejelzés?",
"Egy év születésnaptól születésnapig. A szolár képletből (a Nap visszatérése a születési helyére), a lassú bolygók tranzitjaiból, a progresszióból, az év urából és a fogyatkozásokból áll össze, öt fejezetben és negyedévenkénti idővonallal. A számított idővonal ingyenes, a részletes szöveg egy előrejelzést használ.",
],
[
"Mire kell a személyhely?",
"A saját képleted mellé felvett emberekhez (társ, gyerek, barát). Egy személy felvétele egy helyet használ; a képlete és a rövid összefoglalója ingyenes, a részletes elemzés külön jár.",
@@ -49,6 +53,7 @@ export default async function PackagesPage() {
<span className="eyebrow">Most</span>
<p>
<strong>{left.natal}</strong> képletelemzés · <strong>{left.synastry}</strong> kapcsolati elemzés ·{" "}
<strong>{left.forecast}</strong> éves előrejelzés ·{" "}
{slots.unlimited ? (
"korlátlan személy"
) : (
+27
View File
@@ -583,3 +583,30 @@ a.pair-row:hover strong { color: var(--gold); }
.ai-note h2 { font-size: 24px; }
.ai-note p { margin: 0; max-width: 72ch; line-height: 1.65; }
.ai-line { margin: 0; color: var(--ink-2); line-height: 1.6; padding-left: 12px; border-left: 2px solid var(--gold); max-width: 64ch; }
/* Yearly forecast: timeline and transit list */
.timeline { display: flex; flex-direction: column; gap: 18px; }
.timeline-month h3 { font-size: 20px; margin: 0 0 8px; text-transform: capitalize; }
.timeline-month ol, .transit-list { margin: 0; padding: 0; list-style: none; display: flex; flex-direction: column; gap: 6px; }
.timeline-item {
display: grid; grid-template-columns: 64px 56px 1fr; gap: 10px; align-items: baseline;
padding: 8px 12px; border-left: 3px solid var(--line); border-radius: 4px; background: rgba(255, 255, 255, 0.02);
}
.timeline-date { color: var(--muted); font-variant-numeric: tabular-nums; white-space: nowrap; }
.timeline-glyph { font-size: 17px; color: var(--gold); white-space: nowrap; }
.timeline-text { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
.timeline-item.tone-tense, .transit-list .tone-tense { border-left-color: var(--tense); }
.timeline-item.tone-harmonic, .transit-list .tone-harmonic { border-left-color: var(--harmonic); }
.timeline-item.tone-neutral, .transit-list .tone-neutral { border-left-color: var(--gold); }
.transit-list li {
display: grid; grid-template-columns: 72px 1fr; gap: 10px; align-items: baseline;
padding: 8px 12px; border-left: 3px solid var(--line); border-radius: 4px;
}
.transit-list li > span:last-child { display: flex; flex-direction: column; gap: 2px; }
.transit-list .sym { font-size: 17px; color: var(--gold); white-space: nowrap; }
.transit-list .pill { align-self: flex-start; font-size: 12px; padding: 1px 8px; border: 1px solid var(--gold); border-radius: 999px; color: var(--gold); }
.plain-list { margin: 8px 0 12px; padding-left: 18px; display: flex; flex-direction: column; gap: 4px; }
@media (max-width: 560px) {
.timeline-item { grid-template-columns: 52px 1fr; }
.timeline-glyph { display: none; }
}
@@ -0,0 +1,127 @@
"use client";
import { useRouter } from "next/navigation";
import { useState } from "react";
import { CountrySelect, PlaceSearch } from "@/app/profil/BirthForm";
import { api, errorText } from "@/lib/api";
import type { ForecastDetail, Place } from "@/lib/types";
/**
* Calculates a year: which year (when two are open) and where the person is
* on the birthday (the solar return chart is cast for that place).
*/
export function ForecastStart({
chartId,
years,
birthPlace,
timeKnown,
compact = false,
}: {
chartId: string;
years: number[];
birthPlace: string | null;
timeKnown: boolean;
compact?: boolean;
}) {
const router = useRouter();
const [year, setYear] = useState(years[0]);
const [elsewhere, setElsewhere] = useState(false);
const [country, setCountry] = useState("HU");
const [place, setPlace] = useState<Place | null>(null);
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
async function submit(e: React.FormEvent) {
e.preventDefault();
if (elsewhere && !place) return setError("Válaszd ki a települést a listából.");
setBusy(true);
setError(null);
try {
const body: Record<string, unknown> = { year };
if (elsewhere && place) body.location = { country, geonames_id: place.geonames_id, place: place.name };
const f = await api<ForecastDetail>(`/charts/${chartId}/forecasts`, { body });
router.push(`/kepletek/${chartId}/elorejelzes?f=${f.id}`);
router.refresh();
} catch (err) {
setError(errorText(err));
setBusy(false);
}
}
return (
<form className={compact ? "field" : "card field"} onSubmit={submit} style={{ gap: 14 }}>
{!compact && (
<>
<span className="eyebrow">Éves előrejelzés</span>
<h2>Mit hoz az éved?</h2>
<p className="muted">
Egy év születésnaptól születésnapig. Az év képlete a szolár: az a pillanat, amikor a Nap visszatér a
születéskori helyére. Ehhez jönnek a lassú bolygók tranzitjai pontos dátumokkal, a progresszív Hold, az év ura
és a fogyatkozások. A számítás és az idővonal ingyenes.
</p>
</>
)}
{years.length > 1 && (
<fieldset className="field" style={{ border: 0, padding: 0, margin: 0 }}>
<legend className="label" style={{ marginBottom: 8 }}>
Melyik év?
</legend>
{years.map((y) => (
<label key={y} className="check">
<input type="radio" name="year" checked={year === y} onChange={() => setYear(y)} />
{y === years[0] ? `A mostani év (${y}-es születésnaptól)` : `A következő év (${y}-es születésnaptól)`}
</label>
))}
</fieldset>
)}
{timeKnown && (
<fieldset className="field" style={{ border: 0, padding: 0, margin: 0 }}>
<legend className="label" style={{ marginBottom: 8 }}>
Hol vagy a születésnapodon?
</legend>
<label className="check">
<input type="radio" name="where" checked={!elsewhere} onChange={() => setElsewhere(false)} />
A születési helyemen{birthPlace ? ` (${birthPlace})` : ""}
</label>
<label className="check">
<input type="radio" name="where" checked={elsewhere} onChange={() => setElsewhere(true)} />
Máshol (lakóhely, nyaralás)
</label>
<span className="hint">
A szolár képlet házai attól függnek, hol tartózkodsz a születésnapod pillanatában. Ha nem tudod, add meg
a lakóhelyed.
</span>
</fieldset>
)}
{timeKnown && elsewhere && (
<div className="grid-2">
<CountrySelect
value={country}
onChange={(c) => {
setCountry(c);
setPlace(null);
}}
/>
<PlaceSearch country={country} value={place} onChange={setPlace} />
</div>
)}
{!timeKnown && (
<p className="hint">
A születési idő ismeretlen, ezért szolár képlet és az év ura nem számolható; az előrejelzés a tranzitokra és a
progresszióra épül.
</p>
)}
{error && (
<p className="msg msg-error" role="alert">
{error}
</p>
)}
<div className="form-actions">
<button type="submit" className="btn btn-primary" disabled={busy}>
{busy ? "Számolás…" : compact ? "Kiszámítás" : "Előrejelzés kiszámítása"}
</button>
</div>
</form>
);
}
@@ -0,0 +1,150 @@
import type { Metadata } from "next";
import Link from "next/link";
import { notFound } from "next/navigation";
import { ChartWheel } from "@/components/ChartWheel";
import { DetailedAnalysis } from "@/components/DetailedAnalysis";
import { ForecastKeys, ForecastTimeline, ForecastTransits, longDay } from "@/components/ForecastViews";
import { Tabs } from "@/components/Tabs";
import { backendGet, requireMe } from "@/lib/server";
import type { Analysis, Chart, ForecastDetail, ForecastList, PublicConfig } from "@/lib/types";
import { ForecastStart } from "./ForecastStart";
export const metadata: Metadata = { title: "Éves előrejelzés" };
const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
/** One year of a chart: the solar return, the year's keys, the timeline and the detailed forecast. */
export default async function ForecastPage({
params,
searchParams,
}: {
params: Promise<{ id: string }>;
searchParams: Promise<{ f?: string }>;
}) {
const { id } = await params;
const { f } = await searchParams;
const me = await requireMe(`/kepletek/${id}/elorejelzes`);
if (!UUID.test(id)) notFound();
const [chart, list, config] = await Promise.all([
backendGet<Chart>(`/v1/charts/${id}`),
backendGet<ForecastList>(`/v1/charts/${id}/forecasts`),
backendGet<PublicConfig>("/v1/config"),
]);
if (!chart || !list) notFound();
const chosenId = f && UUID.test(f) ? f : (list.forecasts[0]?.id ?? null);
const [forecast, analyses] = chosenId
? await Promise.all([
backendGet<ForecastDetail>(`/v1/forecasts/${chosenId}`),
backendGet<{ analyses: Analysis[] }>(`/v1/forecasts/${chosenId}/analyses`),
])
: [null, null];
const detailed = (analyses?.analyses ?? []).find((a) => a.status !== "failed") ?? analyses?.analyses[0] ?? null;
const name = chart.is_primary ? "Az éved" : `${chart.label} éve`;
const sr = forecast?.result.solar_return ?? null;
const fc = forecast?.result.forecast;
const others = list.forecasts.filter((x) => x.id !== forecast?.id);
return (
<main className="page" style={{ maxWidth: 1180 }}>
<div className="page-head">
<p className="hint">
<Link href={`/kepletek/${chart.id}`}>← {chart.is_primary ? "Születési képletem" : chart.label}</Link>
</p>
<h1>{forecast ? `${name}: ${forecast.year}–${forecast.year + 1}` : "Éves előrejelzés"}</h1>
{forecast && fc && (
<p className="muted">
{longDay(fc.start)} – {longDay(fc.end)} · {forecast.place ?? "születési hely"}
</p>
)}
</div>
{!forecast && list.years.length > 0 && (
<ForecastStart
chartId={chart.id}
years={list.years}
birthPlace={list.birth_place}
timeKnown={list.time_known}
/>
)}
{!forecast && list.years.length === 0 && (
<p className="card muted">Az első születésnap előtt még nincs éves előrejelzés.</p>
)}
{forecast && fc && (
<>
<section className="chart-layout" aria-label="Szolár képlet">
{sr ? (
<div className="card chart-wheel-card">
<ChartWheel chart={sr} timeKnown title="Szolár képlet" />
<p className="hint">
Szolár képlet: {longDay(sr.local_time.slice(0, 10))} {sr.local_time.slice(11, 16)} helyi idő
szerint, {forecast.place}. A Nap ekkor ér vissza pontosan a születéskori helyére.
</p>
</div>
) : (
<div className="card">
<p className="muted">
Szolár képlet nincs, mert a születési idő ismeretlen: a Nap visszatérésének pillanata így akár fél napot
is tévedhet. Az előrejelzés a tranzitokra és a progresszióra épül.
</p>
</div>
)}
<div className="field chart-side">
<ForecastKeys forecast={fc} solarReturn={sr} />
{(list.years.length > 0 || others.length > 0) && (
<details className="card">
<summary>Másik év vagy helyszín</summary>
{others.length > 0 && (
<ul className="plain-list">
{others.map((o) => (
<li key={o.id}>
<Link href={`/kepletek/${chart.id}/elorejelzes?f=${o.id}`}>
{o.year}–{o.year + 1} · {o.place ?? "születési hely"}
</Link>
</li>
))}
</ul>
)}
{list.years.length > 0 && (
<ForecastStart
chartId={chart.id}
years={list.years}
birthPlace={list.birth_place}
timeKnown={list.time_known}
compact
/>
)}
</details>
)}
</div>
</section>
<section className="card chart-tabs" aria-label="Előrejelzés">
<Tabs
label="Előrejelzés részletei"
tabs={[
{
id: "elemzes",
label: "Előrejelzés",
content: (
<DetailedAnalysis
target={{ kind: "forecast", forecastId: forecast.id }}
initial={detailed}
left={me.analyses_left.forecast}
isAdmin={me.user.roles.includes("admin")}
canPay={config?.mock_payments ?? false}
/>
),
},
{ id: "idovonal", label: "Idővonal", content: <ForecastTimeline forecast={fc} /> },
{ id: "tranzitok", label: "Tranzitok", content: <ForecastTransits forecast={fc} /> },
]}
/>
</section>
</>
)}
</main>
);
}
@@ -118,6 +118,16 @@ export default async function ChartPage({ params }: { params: Promise<{ id: stri
)}
</div>
)}
<Link href={`/kepletek/${chart.id}/elorejelzes`} className="card persons-tile">
<span className="eyebrow">Éves előrejelzés</span>
<strong>{chart.is_primary ? "Mit hoz az éved?" : `Mit hoz ${chart.label} éve?`}</strong>
<span className="muted">
Szolár képlet, tranzitok pontos dátumokkal, progresszió: egy év születésnaptól születésnapig.
</span>
<span className="persons-tile-arrow" aria-hidden="true">
→
</span>
</Link>
{!chart.is_primary && own && (
<div className="card compare-tile">
<span className="eyebrow">Összevetés</span>
@@ -199,7 +199,7 @@ export function BirthForm({
);
}
function CountrySelect({ value, onChange }: { value: string; onChange: (iso2: string) => void }) {
export function CountrySelect({ value, onChange }: { value: string; onChange: (iso2: string) => void }) {
const [countries, setCountries] = useState<Country[]>([]);
useEffect(() => {
fetch("/api/geo/countries")
@@ -226,7 +226,7 @@ function CountrySelect({ value, onChange }: { value: string; onChange: (iso2: st
);
}
function PlaceSearch({
export function PlaceSearch({
country,
value,
onChange,
+1 -1
View File
@@ -46,7 +46,7 @@ export default async function ProfilePage() {
<dd>{me.providers.map((p) => PROVIDERS[p] ?? p).join(", ") || "–"}</dd>
<dt>Részletes elemzések</dt>
<dd>
{`${me.analyses_left.natal} képlet, ${me.analyses_left.synastry} kapcsolati`}{" "}
{`${me.analyses_left.natal} képlet, ${me.analyses_left.synastry} kapcsolati, ${me.analyses_left.forecast} előrejelzés`}{" "}
· <Link href="/csomagok">Csomagok</Link>
</dd>
<dt>Személyek</dt>
@@ -4,10 +4,18 @@ import { Paragraphs, Rich } from "./Rich";
const NATAL_ORDER = ["personality", "emotions", "mind", "love", "work", "growth"];
const SYNASTRY_ORDER = ["attraction", "communication", "emotional_bond", "friction", "long_term"];
const FORECAST_ORDER = ["theme", "love", "work", "growth", "timeline"];
const ORDER = { natal: NATAL_ORDER, synastry: SYNASTRY_ORDER, forecast: FORECAST_ORDER };
/** A finished detailed analysis (natal or synastry). */
export function AnalysisView({ content, kind = "natal" }: { content: AnalysisContent; kind?: "natal" | "synastry" }) {
const order = kind === "synastry" ? SYNASTRY_ORDER : NATAL_ORDER;
/** A finished detailed analysis (natal, synastry or yearly forecast). */
export function AnalysisView({
content,
kind = "natal",
}: {
content: AnalysisContent;
kind?: "natal" | "synastry" | "forecast";
}) {
const order = ORDER[kind];
const sections = order.map((key) => content.sections?.[key]).filter((s) => s !== undefined);
return (
<article className="analysis">
@@ -28,7 +36,7 @@ export function AnalysisView({ content, kind = "natal" }: { content: AnalysisCon
<div className="analysis-lists">
{content.strengths && content.strengths.length > 0 && (
<section>
<h3>Erősségek</h3>
<h3>{kind === "forecast" ? "Lehetőségek" : "Erősségek"}</h3>
<ul>
{content.strengths.map((t, i) => (
<li key={i}>
@@ -83,7 +83,15 @@ export function arcPath(r1: number, r2: number, from: number, to: number, start:
}
/** The natal chart as a wheel: zodiac, houses, planets and aspect lines. */
export function ChartWheel({ chart, timeKnown }: { chart: ChartResult; timeKnown: boolean }) {
export function ChartWheel({
chart,
timeKnown,
title = "Születési képlet",
}: {
chart: ChartResult;
timeKnown: boolean;
title?: string;
}) {
const angle = (key: string): Position | null => {
const a = chart.angles?.[key];
return typeof a === "object" && a !== null ? a : null;
@@ -128,7 +136,7 @@ export function ChartWheel({ chart, timeKnown }: { chart: ChartResult; timeKnown
role="img"
aria-labelledby="wheel-title wheel-desc"
>
<title id="wheel-title">Születési képlet</title>
<title id="wheel-title">{title}</title>
<desc id="wheel-desc">
{timeKnown && asc ? `Aszcendens ${signName(asc.sign)}. ` : "Születési idő nélkül, házak nélkül. "}
{description}
@@ -16,8 +16,11 @@ const MAX_POLLS = 120; // 10 minutes
type Step = "offer" | "confirm" | "pay";
/** What is analysed: a natal chart, or a comparison of two charts. */
export type AnalysisTarget = { kind: "natal"; chartId: string } | { kind: "synastry"; synastryId: string };
/** What is analysed: a natal chart, a comparison of two charts, or one year of a chart. */
export type AnalysisTarget =
| { kind: "natal"; chartId: string }
| { kind: "synastry"; synastryId: string }
| { kind: "forecast"; forecastId: string };
const TEXTS = {
natal: {
@@ -46,8 +49,32 @@ const TEXTS = {
unitName: "kapcsolati elemzés",
packages: ["addon_synastry", "couple", "family"],
},
forecast: {
eyebrow: "Éves előrejelzés",
title: "Az éved, fejezetekre bontva",
about:
"Kb. 1800 szó öt fejezetben: az év fő témája, kapcsolatok, munka és pénz, belső fejlődés, és negyedévenként az év menete " +
"a fontos dátumokkal. A végén lehetőségek, kihívások és útravaló. Trendekről és lehetőségekről szól, nem jósol meg biztos eseményeket.",
loadingTitle: "Készül az éves előrejelzésed",
loading:
"Most íródik az öt fejezet a szolár képlet, a tranzitok és a progresszió alapján. Ez általában 1–3 perc; nyugodtan elhagyhatod az oldalt, az előrejelzés elkészül és itt vár.",
item: "Részletes éves előrejelzés",
unitName: "előrejelzés",
packages: ["addon_forecast", "couple", "family"],
},
};
function targetPath(target: AnalysisTarget): string {
switch (target.kind) {
case "natal":
return `/charts/${target.chartId}`;
case "synastry":
return `/synastries/${target.synastryId}`;
case "forecast":
return `/forecasts/${target.forecastId}`;
}
}
/**
* The detailed analysis of a chart or a comparison. A saved one is shown at once; otherwise
* the offer: admins start it free, users with units confirm, others pay
@@ -76,7 +103,7 @@ export function DetailedAnalysis({
const [error, setError] = useState<string | null>(null);
const waiting = analysis?.status === "pending" || analysis?.status === "running";
const t = TEXTS[target.kind];
const path = target.kind === "natal" ? `/charts/${target.chartId}` : `/synastries/${target.synastryId}`;
const path = targetPath(target);
useEffect(() => {
if (!waiting || !analysis) return;
@@ -175,7 +202,7 @@ export function DetailedAnalysis({
) : (
<div className="form-actions">
<button type="button" className="btn btn-primary" onClick={() => setStep("confirm")}>
Részletes elemzés kérése
{target.kind === "forecast" ? "Részletes előrejelzés kérése" : "Részletes elemzés kérése"}
</button>
<span className="hint">
Még {left} {t.unitName}ed van.
@@ -198,7 +225,7 @@ export function DetailedAnalysis({
) : (
<div className="form-actions">
<button type="button" className="btn btn-primary" onClick={() => setStep("pay")}>
Részletes elemzés kérése
{target.kind === "forecast" ? "Részletes előrejelzés kérése" : "Részletes elemzés kérése"}
</button>
{target.kind === "natal" && (
<Link href="/pelda" className="btn btn-ghost">
@@ -0,0 +1,295 @@
import { ASPECTS, MOON_PHASES, POINTS, dms, orbText, pointName, signName } from "@/lib/astro";
import type { Forecast, ForecastContact, SolarReturn } from "@/lib/types";
/** Sign names with the "into" suffix: Kos → Kosba. */
const SIGN_INTO: Record<string, string> = {
aries: "Kosba",
taurus: "Bikába",
gemini: "Ikrekbe",
cancer: "Rákba",
leo: "Oroszlánba",
virgo: "Szűzbe",
libra: "Mérlegbe",
scorpio: "Skorpióba",
sagittarius: "Nyilasba",
capricorn: "Bakba",
aquarius: "Vízöntőbe",
pisces: "Halakba",
};
const ECLIPSE_TYPES: Record<string, string> = {
total: "Teljes",
annular: "Gyűrűs",
hybrid: "Hibrid",
partial: "Részleges",
penumbral: "Félárnyékos",
};
const utcDate = (iso: string) => {
const [y, m, d] = iso.split("-").map(Number);
return new Date(Date.UTC(y, m - 1, d));
};
/** `2026-08-20` → `aug. 20.` */
export function shortDay(iso: string): string {
return new Intl.DateTimeFormat("hu-HU", { month: "short", day: "numeric", timeZone: "UTC" }).format(utcDate(iso));
}
/** `2026-08-20` → `2026. aug. 20.` */
export function longDay(iso: string): string {
return new Intl.DateTimeFormat("hu-HU", { year: "numeric", month: "short", day: "numeric", timeZone: "UTC" }).format(
utcDate(iso),
);
}
function monthTitle(key: string): string {
return new Intl.DateTimeFormat("hu-HU", { year: "numeric", month: "long", timeZone: "UTC" }).format(
utcDate(`${key}-01`),
);
}
const glyph = (id: string) => POINTS[id]?.glyph ?? "";
type Tone = "tense" | "harmonic" | "neutral";
const toneOf = (c: ForecastContact): Tone =>
c.nature === "challenging" ? "tense" : c.nature === "harmonious" ? "harmonic" : "neutral";
function contactTitle(c: ForecastContact, progressed = false): string {
const planet = progressed ? `Progresszív ${pointName(c.planet)}` : pointName(c.planet);
return `${planet} ${ASPECTS[c.aspect]?.hu ?? c.aspect} – születési ${pointName(c.natal_point)}`;
}
function periodText(c: ForecastContact, date?: string): string | null {
const periods = c.periods ?? [];
const p = (date && periods.find((x) => x.start <= date && date <= x.end)) || periods[0];
if (!p) return null;
return p.start === p.end ? `hatás: ${longDay(p.start)}` : `hatás: ${longDay(p.start)} – ${longDay(p.end)}`;
}
interface Event {
date: string;
tone: Tone;
label: string;
title: string;
detail: string[];
}
/** Everything datable in the year, in time order. */
function events(f: Forecast): Event[] {
const out: Event[] = [];
const inYear = (d: string) => d >= f.start && d <= f.end;
for (const c of f.transits) {
const glyphs = `${glyph(c.planet)} ${ASPECTS[c.aspect]?.glyph ?? ""} ${glyph(c.natal_point)}`;
if (c.exact.length === 0) {
out.push({
date: c.peak,
tone: toneOf(c),
label: glyphs,
title: contactTitle(c),
detail: [`legközelebb ${orbText(c.min_orb)}`, periodText(c, c.peak) ?? ""].filter(Boolean),
});
}
c.exact.forEach((e, i) => {
const pass = c.exact.length > 1 ? `${i + 1}. pontos fényszög` : "pontos";
out.push({
date: e.date,
tone: toneOf(c),
label: glyphs,
title: contactTitle(c),
detail: [
e.retrograde ? `${pass}, retrográd mozgás közben` : pass,
periodText(c, e.date) ?? "",
c.house ? `a ${c.house}. házadban` : "",
].filter(Boolean),
});
});
}
for (const h of f.transit_houses) {
for (const i of h.ingresses) {
out.push({
date: i.date,
tone: "neutral",
label: glyph(h.planet),
title: `${pointName(h.planet)} a ${i.house}. házadba lép`,
detail: i.retrograde ? ["retrográd mozgással"] : [],
});
}
}
const p = f.progressions;
for (const c of p.contacts) {
for (const e of c.exact) {
out.push({
date: e.date,
tone: toneOf(c),
label: `${glyph(c.planet)}ᵖ`,
title: contactTitle(c, true),
detail: ["progresszió, pontos"],
});
}
}
for (const b of p.bodies) {
const name = `A progresszív ${pointName(b.planet)}`;
for (const s of b.sign_changes) {
out.push({ date: s.date, tone: "neutral", label: `${glyph(b.planet)}ᵖ`, title: `${name} ${SIGN_INTO[s.sign] ?? signName(s.sign)} lép`, detail: [] });
}
for (const h of b.house_changes) {
out.push({ date: h.date, tone: "neutral", label: `${glyph(b.planet)}ᵖ`, title: `${name} a ${h.house}. házadba lép`, detail: [] });
}
}
if (p.lunar_phase_change) {
out.push({
date: p.lunar_phase_change.date,
tone: "neutral",
label: "☽ᵖ",
title: `Progresszív holdfázis: ${MOON_PHASES[p.lunar_phase_change.phase] ?? p.lunar_phase_change.phase}`,
detail: [],
});
}
for (const e of f.eclipses) {
const what = `${ECLIPSE_TYPES[e.eclipse_type] ?? e.eclipse_type} ${e.kind === "solar" ? "napfogyatkozás" : "holdfogyatkozás"}`;
out.push({
date: e.date,
tone: e.contacts.length > 0 ? "tense" : "neutral",
label: e.kind === "solar" ? "☉●" : "☽●",
title: `${what}, ${signName(e.sign)} ${dms(e.degree_in_sign_dms).split("′")[0]}′`,
detail: [
e.house ? `a ${e.house}. házadban` : "",
...e.contacts.map(
(c) => `${ASPECTS[c.aspect]?.hu ?? c.aspect} a születési ${pointName(c.point)} pontoddal (${orbText(c.orb)})`,
),
].filter(Boolean),
});
}
return out.filter((e) => inYear(e.date)).sort((a, b) => a.date.localeCompare(b.date));
}
/** The year month by month: exact transits, ingresses, progressions, eclipses. */
export function ForecastTimeline({ forecast }: { forecast: Forecast }) {
const list = events(forecast);
const months = new Map<string, Event[]>();
for (const e of list) {
const key = e.date.slice(0, 7);
months.set(key, [...(months.get(key) ?? []), e]);
}
if (list.length === 0) return <p className="muted">Ebben az évben nincs pontos lassú bolygós fényszög.</p>;
return (
<div className="timeline">
<p className="hint">
A lassú bolygók (Jupiter–Plútó) fényszögei a születési képletedhez 1° hatásfokon belül, a progresszió és a
fogyatkozások. Egy tranzit a teljes hatásidő alatt érződik, a pontos napok körül a legerősebben.
</p>
{[...months.entries()].map(([key, items]) => (
<section key={key} className="timeline-month" aria-label={monthTitle(key)}>
<h3>{monthTitle(key)}</h3>
<ol>
{items.map((e, i) => (
<li key={i} className={`timeline-item tone-${e.tone}`}>
<span className="timeline-date">{shortDay(e.date)}</span>
<span className="timeline-glyph" aria-hidden="true">
{e.label}
</span>
<span className="timeline-text">
<strong>{e.title}</strong>
{e.detail.length > 0 && <span className="hint">{e.detail.join(" · ")}</span>}
</span>
</li>
))}
</ol>
</section>
))}
</div>
);
}
/** The main facts of the year at a glance. */
export function ForecastKeys({ forecast, solarReturn }: { forecast: Forecast; solarReturn: SolarReturn | null }) {
const sun = solarReturn?.points.find((p) => p.id === "sun");
const moon = solarReturn?.points.find((p) => p.id === "moon");
const asc = solarReturn?.angles?.ascendant;
const ascSign = typeof asc === "object" && asc !== null ? asc.sign : null;
const prof = forecast.profection;
const pmoon = forecast.progressions.bodies.find((b) => b.planet === "moon");
const exact = forecast.transits.filter((t) => t.exact.length > 0).length;
return (
<div className="card" style={{ gap: 12 }}>
<span className="eyebrow">Az év kulcsai</span>
<dl className="facts">
{ascSign && (
<>
<dt>Szolár Aszcendens</dt>
<dd>
{signName(ascSign)}
{solarReturn?.natal_house_of_ascendant ? `, a születési ${solarReturn.natal_house_of_ascendant}. házadban` : ""}
</dd>
</>
)}
{sun?.house && (
<>
<dt>Szolár Nap</dt>
<dd>a {sun.house}. házban: ez az év fő terepe</dd>
</>
)}
{moon?.house && (
<>
<dt>Szolár Hold</dt>
<dd>
{signName(moon.sign)}, a {moon.house}. házban
</dd>
</>
)}
{prof && (
<>
<dt>Az év ura</dt>
<dd>
{pointName(prof.lord)} ({prof.house}. ház, {signName(prof.sign)})
</dd>
</>
)}
{pmoon && (
<>
<dt>Progresszív Hold</dt>
<dd>
{signName(pmoon.sign)}
{pmoon.house ? `, ${pmoon.house}. ház` : ""} ·{" "}
{MOON_PHASES[forecast.progressions.lunar_phase] ?? forecast.progressions.lunar_phase}
{pmoon.approximate ? " (bizonytalan)" : ""}
</dd>
</>
)}
<dt>Tranzitok</dt>
<dd>
{exact} pontos lassú bolygós fényszög, {forecast.eclipses.length} fogyatkozás
</dd>
</dl>
</div>
);
}
/** All slow-planet transits of the year as a list. */
export function ForecastTransits({ forecast }: { forecast: Forecast }) {
if (forecast.transits.length === 0) return <p className="muted">Ebben az évben nincs lassú bolygós tranzit.</p>;
return (
<ul className="transit-list">
{forecast.transits.map((c, i) => (
<li key={i} className={`tone-${toneOf(c)}`}>
<span className="sym" aria-hidden="true">
{glyph(c.planet)} {ASPECTS[c.aspect]?.glyph} {glyph(c.natal_point)}
</span>
<span>
<strong>{contactTitle(c)}</strong>
{c.planet === c.natal_point && <span className="pill">életciklus</span>}
<span className="hint">
{c.exact.length > 0
? `pontos: ${c.exact.map((e) => longDay(e.date) + (e.retrograde ? " (R)" : "")).join(", ")}`
: `nem pontos az évben, legközelebb ${orbText(c.min_orb)}`}
{(c.periods ?? []).length > 0 &&
` · hatás: ${(c.periods ?? []).map((p) => `${longDay(p.start)} – ${longDay(p.end)}`).join("; ")}`}
{c.house ? ` · ${c.house}. ház` : ""}
</span>
</span>
</li>
))}
</ul>
);
}
@@ -14,6 +14,7 @@ export function contents(p: Package): string[] {
const lines: string[] = [];
if (p.natal) lines.push(`${p.natal} részletes képletelemzés`);
if (p.synastry) lines.push(`${p.synastry} kapcsolati elemzés`);
if (p.forecast) lines.push(`${p.forecast} éves előrejelzés`);
if (p.persons) lines.push(`${p.persons} személy felvétele`);
return lines;
}
+100 -1
View File
@@ -32,6 +32,7 @@ export interface Package {
price_huf: number;
natal: number;
synastry: number;
forecast: number;
persons: number;
badge: string | null;
list_price_huf: number;
@@ -58,6 +59,7 @@ export interface BirthChange {
export interface UnitBalance {
natal: number;
synastry: number;
forecast: number;
}
export interface PublicConfig {
@@ -204,7 +206,7 @@ export interface SynastryListItem {
export interface Analysis {
id: string;
kind: "natal" | "synastry" | "summary";
kind: "natal" | "synastry" | "summary" | "forecast";
status: "pending" | "running" | "done" | "failed";
model: string;
language: string;
@@ -338,3 +340,100 @@ export interface InvitationResult {
id?: string;
url?: string;
}
/** A calculated year in a list (`GET /v1/charts/{id}/forecasts`). */
export interface ForecastSummary {
id: string;
chart_id: string;
year: number;
/** First and last day, `YYYY-MM-DD`. */
start: string;
end: string;
place: string | null;
/** Reckoned at the birth place. */
birth_place: boolean;
created_at: string;
}
export interface ForecastList {
/** Years that can be calculated now. */
years: number[];
birth_place: string | null;
time_known: boolean;
forecasts: ForecastSummary[];
}
export interface ForecastExact {
date: string;
retrograde: boolean;
}
/** A transiting or progressed planet in aspect to a natal point. */
export interface ForecastContact {
planet: string;
natal_point: string;
aspect: string;
nature: "harmonious" | "challenging" | "neutral";
exact: ForecastExact[];
periods?: { start: string; end: string }[];
peak: string;
min_orb: number;
house?: number;
}
export interface HouseIngress {
house: number;
date: string;
retrograde: boolean;
}
export interface Forecast {
start: string;
end: string;
age: number;
profection: {
house: number;
sign: string;
lord: string;
lord_sign: string;
lord_house: number;
planets_in_sign: string[];
} | null;
transits: ForecastContact[];
transit_houses: { planet: string; house_at_start: number; ingresses: HouseIngress[] }[];
progressions: {
bodies: (Position & {
planet: string;
house: number | null;
retrograde: boolean;
approximate: boolean;
sign_changes: { sign: string; date: string }[];
house_changes: HouseIngress[];
})[];
lunar_phase: string;
lunar_phase_change: { phase: string; date: string } | null;
contacts: ForecastContact[];
};
eclipses: (Position & {
date: string;
kind: "solar" | "lunar";
eclipse_type: "total" | "annular" | "hybrid" | "partial" | "penumbral";
house: number | null;
contacts: { point: string; aspect: string; orb: number }[];
})[];
warnings?: string[];
}
export type SolarReturn = ChartResult & {
moment_utc: string;
local_time: string;
timezone: string;
utc_offset: string;
natal_house_of_ascendant: number | null;
};
/** One calculated year (`GET /v1/forecasts/{id}`). */
export interface ForecastDetail extends ForecastSummary {
location: { country: string; place?: string; geonames_id?: number } | null;
result: { year: number; solar_return: SolarReturn | null; forecast: Forecast };
}
+165
View File
@@ -0,0 +1,165 @@
//! `POST /v1/forecast`: one year of a natal chart, from the solar return in
//! the given year to the next one: the solar return chart (cast for where the
//! person is on the birthday), slow-planet transits, progressions, the annual
//! profection and eclipses.
use astro_engine::chart::house_of;
use astro_engine::{Forecast, calculate_forecast, solar_return};
use geo_tz::tz::format_offset;
use jiff::Timestamp;
use jiff::tz::Offset;
use serde::{Deserialize, Serialize};
use crate::AppState;
use crate::error::ApiError;
use crate::natal::{self, Meta, NatalRequest, NatalResult};
/// Where the person is on the birthday; the birth place when not given.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Location {
pub country: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub place: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub geonames_id: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub latitude: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub longitude: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub timezone: Option<String>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ForecastRequest {
/// Birth data as for `POST /v1/natal`.
pub birth: NatalRequest,
/// The year starts at the solar return (birthday) in this calendar year.
pub year: i32,
#[serde(default)]
pub location: Option<Location>,
}
#[derive(Debug, Serialize)]
pub struct SolarReturn {
/// The exact moment, RFC 3339 UTC.
pub moment_utc: String,
/// The same moment on the local clock of the place, `YYYY-MM-DDTHH:MM:SS`.
pub local_time: String,
pub timezone: String,
pub utc_offset: String,
/// Natal house the solar return Ascendant falls into.
pub natal_house_of_ascendant: Option<u8>,
/// The chart of the moment at the place.
#[serde(flatten)]
pub chart: NatalResult,
}
#[derive(Debug, Serialize)]
pub struct ForecastResponse {
pub year: i32,
/// `null` when the birth time is unknown: the moment may then be half a day off.
pub solar_return: Option<SolarReturn>,
/// Where the year is reckoned (dates are local to it).
pub location: Location,
pub forecast: Forecast,
pub meta: Meta,
}
fn bad(msg: impl Into<String>) -> ApiError {
ApiError::BadRequest(msg.into())
}
fn timestamp_of(jd: f64) -> Result<Timestamp, ApiError> {
let seconds = ((jd - 2_440_587.5) * 86_400.0).round() as i64;
Timestamp::from_second(seconds).map_err(|e| ApiError::Internal(e.to_string()))
}
pub fn calculate(state: &AppState, req: ForecastRequest) -> Result<ForecastResponse, ApiError> {
let birth = req.birth;
let options = birth.options;
let natal = natal::calculate(state, birth.clone()).map_err(|e| e.for_person("birth"))?;
let birth_year: i32 = natal.time.date[..4].parse().map_err(|_| ApiError::Internal("birth year".into()))?;
if req.year <= birth_year || req.year > birth_year + 120 || req.year > 2398 {
return Err(bad(format!("year must be after the birth year {birth_year} and at most 120 years later")));
}
let engine = state.engine.as_ref();
let calc = |e: astro_engine::EngineError| ApiError::Calculation(e.to_string());
let start = solar_return(engine, &natal.chart, req.year).map_err(calc)?;
let end = solar_return(engine, &natal.chart, req.year + 1).map_err(calc)?;
let location = req.location.unwrap_or_else(|| Location {
country: birth.country.clone(),
place: birth.place.clone(),
region: birth.region.clone(),
geonames_id: birth.geonames_id,
latitude: birth.latitude,
longitude: birth.longitude,
timezone: birth.timezone.clone(),
});
// The chart of the solar return moment at the place: given in UTC, so no
// local-time ambiguity can move it.
let ts = timestamp_of(start)?;
let utc = Offset::UTC.to_datetime(ts);
let probe = NatalRequest {
name: None,
date: utc.date().to_string(),
time: Some(utc.time().strftime("%H:%M:%S").to_string()),
calendar: natal::Calendar::Gregorian,
country: location.country.clone(),
place: location.place.clone(),
region: location.region.clone(),
geonames_id: location.geonames_id,
latitude: location.latitude,
longitude: location.longitude,
elevation: None,
timezone: None,
utc_offset: Some("+00:00".into()),
ambiguous_time: Default::default(),
options,
};
let mut chart = natal::calculate(state, probe).map_err(|e| e.for_person("location"))?;
chart.time.notes.clear();
let place = &chart.location;
let zone = state
.atlas
.choose_zone(
&place.country,
location.timezone.as_deref(),
place.place.as_ref(),
(place.latitude, place.longitude),
)?
.zone;
let tz = state.atlas.zones.get(&zone)?;
let offset = tz.to_offset(ts);
let local = tz.to_datetime(ts);
let forecast =
calculate_forecast(engine, &natal.chart, start, end, f64::from(offset.seconds()) / 3600.0).map_err(calc)?;
let solar_return = natal.time.time_known.then(|| {
let cusps = natal.chart.houses.as_ref().map(|h| {
let mut c = [0.0; 12];
for (x, cusp) in c.iter_mut().zip(&h.cusps) {
*x = cusp.position.longitude;
}
c
});
let asc = chart.chart.angles.as_ref().map(|a| a.ascendant.position.longitude);
SolarReturn {
moment_utc: ts.to_string(),
local_time: local.strftime("%Y-%m-%dT%H:%M:%S").to_string(),
timezone: zone.clone(),
utc_offset: format_offset(offset),
natal_house_of_ascendant: cusps.zip(asc).map(|(c, a)| house_of(a, &c)),
chart,
}
});
Ok(ForecastResponse { year: req.year, solar_return, location, forecast, meta: natal::meta(state) })
}
+1
View File
@@ -9,6 +9,7 @@
//! `horoscope-api healthcheck` performs a local health check (for Docker).
mod error;
mod forecast;
mod natal;
mod routes;
mod synastry;
+13
View File
@@ -14,6 +14,7 @@ use tracing::Level;
use crate::AppState;
use crate::error::ApiError;
use crate::forecast::{self, ForecastRequest, ForecastResponse};
use crate::natal::{self, NatalRequest, NatalResponse};
use crate::synastry::{self, SynastryRequest, SynastryResponse};
@@ -28,6 +29,7 @@ pub fn router(state: Arc<AppState>) -> Router {
.route("/v1/timezones", get(timezones))
.route("/v1/natal", post(natal_chart))
.route("/v1/synastry", post(synastry_chart))
.route("/v1/forecast", post(forecast_year))
.layer(cors())
.layer(
TraceLayer::new_for_http()
@@ -154,3 +156,14 @@ async fn synastry_chart(
.map_err(|e| ApiError::Internal(e.to_string()))??;
Ok(Json(response))
}
async fn forecast_year(
State(state): State<Arc<AppState>>,
body: Result<Json<ForecastRequest>, JsonRejection>,
) -> AppResult<ForecastResponse> {
let Json(request) = body?;
let response = tokio::task::spawn_blocking(move || forecast::calculate(&state, request))
.await
.map_err(|e| ApiError::Internal(e.to_string()))??;
Ok(Json(response))
}
+45
View File
@@ -273,3 +273,48 @@ async fn synastry_unknown_time_and_errors() {
let (status, _) = call("POST", "/v1/synastry", Some(json!({"person1": {"date": "1985-07-14"}}))).await;
assert_eq!(status, StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn forecast_year_with_solar_return() {
let birth = json!({"date": "1985-07-14", "time": "14:30", "country": "HU", "place": "Budapest"});
let (status, d) = call("POST", "/v1/forecast", Some(json!({"birth": birth, "year": 2026}))).await;
assert_eq!(status, StatusCode::OK, "{d}");
let sr = &d["solar_return"];
assert_eq!(sr["timezone"], "Europe/Budapest");
assert!(sr["local_time"].as_str().unwrap().starts_with("2026-07-14T"), "{sr}");
assert_eq!(sr["utc_offset"], "+02:00");
assert_eq!(sr["points"][0]["sign"], "cancer");
assert!(sr["natal_house_of_ascendant"].as_u64().is_some());
assert_eq!(sr["location"]["place"]["name"], "Budapest");
let f = &d["forecast"];
assert_eq!(f["start"], "2026-07-14");
assert_eq!(f["age"], 41);
assert_eq!(f["profection"]["lord"], "mars");
assert!(!f["transits"].as_array().unwrap().is_empty());
// Elsewhere on the birthday: same moment, other houses.
let (status, e) = call(
"POST",
"/v1/forecast",
Some(json!({"birth": birth, "year": 2026, "location": {"country": "JP", "place": "Tokyo"}})),
)
.await;
assert_eq!(status, StatusCode::OK, "{e}");
assert_eq!(e["solar_return"]["moment_utc"], sr["moment_utc"]);
assert_eq!(e["solar_return"]["timezone"], "Asia/Tokyo");
assert_ne!(e["solar_return"]["angles"]["ascendant"]["sign"], sr["angles"]["ascendant"]["sign"]);
// Unknown birth time: no solar return chart, the rest is there.
let (status, u) = call(
"POST",
"/v1/forecast",
Some(json!({"birth": {"date": "1985-07-14", "country": "HU", "place": "Budapest"}, "year": 2026})),
)
.await;
assert_eq!(status, StatusCode::OK, "{u}");
assert!(u["solar_return"].is_null());
assert!(u["forecast"]["profection"].is_null());
let (status, _) = call("POST", "/v1/forecast", Some(json!({"birth": birth, "year": 1985}))).await;
assert_eq!(status, StatusCode::BAD_REQUEST);
}
+238
View File
@@ -280,6 +280,218 @@ pub fn synastry(chart1: &Value, chart2: &Value, result: &Value) -> String {
out
}
/// "2026-08-03, 2027-01-15 (retrograde)" from a list of exact hits.
fn exact_dates(list: &Value) -> String {
list.as_array()
.into_iter()
.flatten()
.map(|e| {
let date = e["date"].as_str().unwrap_or("?");
if e["retrograde"].as_bool() == Some(true) { format!("{date} (retrograde)") } else { date.to_string() }
})
.collect::<Vec<_>>()
.join(", ")
}
/// One contact of a transiting or progressed planet with a natal point.
fn contact_line(out: &mut String, c: &Value, moving: &str) {
let planet = c["planet"].as_str().unwrap_or("?");
let natal = c["natal_point"].as_str().unwrap_or("?");
let mut line = format!(
"- {moving}{} {} natal {} ({})",
point_name(planet),
words(c["aspect"].as_str().unwrap_or("?")),
point_name(natal),
c["nature"].as_str().unwrap_or("neutral")
);
// A planet back at its own natal place (or in aspect to it, for transits): a life cycle.
if planet == natal && (moving.is_empty() || c["aspect"] == "conjunction") {
line.push_str(", cycle");
}
let exact = exact_dates(&c["exact"]);
if exact.is_empty() {
let _ = write!(
line,
": not exact this year, closest {:.1}° around {}",
c["min_orb"].as_f64().unwrap_or(0.0),
c["peak"].as_str().unwrap_or("?")
);
} else {
let _ = write!(line, ": exact {exact}");
}
let periods: Vec<String> = c["periods"]
.as_array()
.into_iter()
.flatten()
.map(|p| format!("{} to {}", p["start"].as_str().unwrap_or("?"), p["end"].as_str().unwrap_or("?")))
.collect();
if !periods.is_empty() {
let _ = write!(line, "; within orb {}", periods.join(", "));
}
if let Some(h) = c["house"].as_i64() {
let _ = write!(line, "; {moving}{} in natal house {h}", point_name(planet));
}
let _ = writeln!(out, "{line}");
}
/// One year of a chart: the natal chart, then the stored horoscope-api
/// `/v1/forecast` result (solar return chart, profection, transits,
/// progressions, eclipses). The place of the birthday and the exact age are
/// left out; the age goes in by decade.
pub fn forecast(chart: &Value, result: &Value) -> String {
let f = &result["forecast"];
let known = time_known(chart);
let mut out = format!(
"YEARLY FORECAST: one year of life, from the solar return on {} to the next one on {}.\n",
f["start"].as_str().unwrap_or("?"),
f["end"].as_str().unwrap_or("?")
);
if let Some(age) = f["age"].as_i64() {
let _ = writeln!(out, "Age group: {}s.", age / 10 * 10);
}
out.push('\n');
out.push_str(&natal(chart));
let sr = &result["solar_return"];
if sr.is_object() {
out.push_str("\nSOLAR RETURN CHART (cast for the moment of the solar return at the place of the birthday):\n");
angle_lines(&mut out, sr, "");
if let Some(h) = sr["natal_house_of_ascendant"].as_i64() {
let _ = writeln!(out, "- The solar return Ascendant falls in natal house {h}.");
}
point_lines(&mut out, sr, "", true);
aspect_lines(&mut out, &sr["aspects"], "Solar return aspects (tightest first):", 15);
} else {
out.push_str("\nSOLAR RETURN CHART: none, because the birth time is unknown.\n");
}
let p = &f["profection"];
if p.is_object() {
let planets = names(&p["planets_in_sign"]);
let _ = writeln!(
out,
"\nANNUAL PROFECTION: the year activates natal house {} ({}); lord of the year: {} (natal {} in {}, house {}).{}",
p["house"],
capitalize(p["sign"].as_str().unwrap_or("?")),
point_name(p["lord"].as_str().unwrap_or("?")),
point_name(p["lord"].as_str().unwrap_or("?")),
capitalize(p["lord_sign"].as_str().unwrap_or("?")),
p["lord_house"],
if planets.is_empty() { String::new() } else { format!(" Natal planets in that sign: {planets}.") }
);
}
out.push_str("\nSLOW-PLANET TRANSITS to the natal chart (orb 1°; in order of their peak; dates are local days):\n");
let transits = f["transits"].as_array().map(Vec::as_slice).unwrap_or_default();
if transits.is_empty() {
out.push_str("- none\n");
}
for c in transits {
contact_line(&mut out, c, "");
}
let houses = f["transit_houses"].as_array().map(Vec::as_slice).unwrap_or_default();
if known && !houses.is_empty() {
out.push_str("\nSlow planets in the natal houses:\n");
for h in houses {
let mut line = format!(
"- {}: house {} at the start",
point_name(h["planet"].as_str().unwrap_or("?")),
h["house_at_start"]
);
for i in h["ingresses"].as_array().into_iter().flatten() {
let retro = if i["retrograde"].as_bool() == Some(true) { " (retrograde)" } else { "" };
let _ = write!(line, "; enters house {} on {}{retro}", i["house"], i["date"].as_str().unwrap_or("?"));
}
let _ = writeln!(out, "{line}");
}
}
let prog = &f["progressions"];
out.push_str("\nSECONDARY PROGRESSIONS (a day for a year), at the start of the year:\n");
for b in prog["bodies"].as_array().into_iter().flatten() {
let mut line = format!("- Progressed {}: {}", point_name(b["planet"].as_str().unwrap_or("?")), position(b));
if let Some(h) = b["house"].as_i64() {
let _ = write!(line, ", natal house {h}");
}
if b["retrograde"].as_bool() == Some(true) {
line.push_str(", retrograde");
}
if b["approximate"].as_bool() == Some(true) {
line.push_str(" (uncertain: the birth time is unknown)");
}
for i in b["sign_changes"].as_array().into_iter().flatten() {
let _ = write!(
line,
"; enters {} on {}",
capitalize(i["sign"].as_str().unwrap_or("?")),
i["date"].as_str().unwrap_or("?")
);
}
for i in b["house_changes"].as_array().into_iter().flatten() {
let _ = write!(line, "; enters natal house {} on {}", i["house"], i["date"].as_str().unwrap_or("?"));
}
let _ = writeln!(out, "{line}");
}
if let Some(phase) = prog["lunar_phase"].as_str() {
let change = &prog["lunar_phase_change"];
let change = if change.is_object() {
format!(
", turns {} on {}",
words(change["phase"].as_str().unwrap_or("?")),
change["date"].as_str().unwrap_or("?")
)
} else {
String::new()
};
let _ = writeln!(out, "- Progressed lunation phase: {}{change}", words(phase));
}
let contacts = prog["contacts"].as_array().map(Vec::as_slice).unwrap_or_default();
if !contacts.is_empty() {
out.push_str("Progressed planets in aspect to natal points (orb 1°):\n");
for c in contacts {
contact_line(&mut out, c, "progressed ");
}
}
let eclipses = f["eclipses"].as_array().map(Vec::as_slice).unwrap_or_default();
if !eclipses.is_empty() {
out.push_str("\nECLIPSES during the year:\n");
for e in eclipses {
let mut line = format!(
"- {}: {} {} eclipse at {}",
e["date"].as_str().unwrap_or("?"),
e["eclipse_type"].as_str().unwrap_or("?"),
e["kind"].as_str().unwrap_or("?"),
position(e)
);
if let Some(h) = e["house"].as_i64() {
let _ = write!(line, ", natal house {h}");
}
let hits: Vec<String> = e["contacts"]
.as_array()
.into_iter()
.flatten()
.map(|c| {
format!(
"{} natal {} (orb {:.1}°)",
words(c["aspect"].as_str().unwrap_or("?")),
point_name(c["point"].as_str().unwrap_or("?")),
c["orb"].as_f64().unwrap_or(0.0)
)
})
.collect();
if hits.is_empty() {
line.push_str("; no close contact with the natal chart");
} else {
let _ = write!(line, "; {}", hits.join(", "));
}
let _ = writeln!(out, "{line}");
}
}
out
}
/// Aspects between main points and angles, tightest first.
fn aspect_lines(out: &mut String, aspects: &Value, heading: &str, limit: usize) {
let mut list: Vec<&Value> = aspects
@@ -362,6 +574,32 @@ mod tests {
assert!(text.contains("- Venus: Libra 4°12', domicile"));
}
#[test]
fn forecast_view() {
// The stored horoscope-api /v1/forecast result of the chart below (year 2026).
let text = forecast(&fixture("natal-1990-03-15.json"), &fixture("forecast-1990-03-15.json"));
assert_private(&text);
for expected in [
"YEARLY FORECAST: one year of life, from the solar return on 2026-03-15 to the next one on 2027-03-15.",
"Age group: 30s.",
"NATAL CHART",
"SOLAR RETURN CHART (cast for",
"- The solar return Ascendant falls in natal house 10.",
"ANNUAL PROFECTION: the year activates natal house 1 (Leo); lord of the year: Sun",
"- progressed Moon trine natal Moon (harmonious): exact 2027-02-24",
"- Neptune sextile natal Mars (harmonious): exact 2026-04-19, 2026-09-30 (retrograde), 2027-02-20",
"Slow planets in the natal houses:",
"SECONDARY PROGRESSIONS",
"- Progressed lunation phase:",
"ECLIPSES during the year:",
] {
assert!(text.contains(expected), "missing '{expected}' in:\n{text}");
}
for absent in ["Europe/Budapest", "08:02", "Age group: 36", "36s"] {
assert!(!text.contains(absent), "'{absent}' in:\n{text}");
}
}
#[test]
fn synastry_view() {
// The full horoscope-api response, with both persons' birth data in it.
+16 -1
View File
@@ -34,6 +34,7 @@ pub struct Job {
pub kind: String,
pub chart_id: Option<Uuid>,
pub synastry_id: Option<Uuid>,
pub forecast_id: Option<Uuid>,
pub language: String,
pub model: String,
pub prompt_version: String,
@@ -78,7 +79,7 @@ impl Analyzer {
"UPDATE analyses SET status = 'running', started_at = now(), attempts = attempts + 1 \
WHERE id = (SELECT id FROM analyses WHERE status = 'pending' AND next_attempt_at <= now() \
ORDER BY next_attempt_at LIMIT 1 FOR UPDATE SKIP LOCKED) \
RETURNING id, kind, chart_id, synastry_id, language, model, prompt_version, attempts",
RETURNING id, kind, chart_id, synastry_id, forecast_id, language, model, prompt_version, attempts",
)
.fetch_optional(&self.db)
.await?;
@@ -95,6 +96,7 @@ impl Analyzer {
let text = match kind {
Kind::Natal | Kind::Summary => self.natal_text(job.chart_id).await?,
Kind::Synastry => self.synastry_text(job.synastry_id).await?,
Kind::Forecast => self.forecast_text(job.forecast_id).await?,
};
let (base, revision) = prompt::split_version(&job.prompt_version);
if base != PROMPT_VERSION {
@@ -138,6 +140,19 @@ impl Analyzer {
Ok(compact::synastry(&chart1, &chart2, &result))
}
/// The compact text of a stored forecast with its natal chart.
async fn forecast_text(&self, forecast_id: Option<Uuid>) -> Result<String, LlmError> {
let (result, chart): (Value, Value) = sqlx::query_as(
"SELECT f.result, c.result FROM forecasts f JOIN charts c ON c.id = f.chart_id WHERE f.id = $1",
)
.bind(forecast_id)
.fetch_optional(&self.db)
.await
.map_err(|e| LlmError::Transient(format!("database: {e}")))?
.ok_or_else(|| LlmError::Permanent("the forecast was deleted".into()))?;
Ok(compact::forecast(&chart, &result))
}
/// Takes the oldest waiting prompt test run, if any.
pub async fn claim_preview(&self) -> Result<Option<PreviewJob>, sqlx::Error> {
let job: Option<PreviewJob> = sqlx::query_as(
File diff suppressed because it is too large Load Diff