Yearly forecast: solar return, transits, progressions, profection, eclipses
- astro-engine: forecast module (solar return moment, slow-planet transits
with exact dates and periods, natal house ingresses, secondary
progressions, annual profection, eclipses via Swiss Ephemeris)
- horoscope-api: POST /v1/forecast, solar return chart cast for the place
of the birthday
- backend: forecasts table, /v1/charts/{id}/forecasts, /v1/forecasts/{id}
and its analyses using a new 'forecast' unit; current year of life open,
the next one 30 days before the birthday
- packages: Páros and Család include forecasts (6 000 / 11 000 Ft),
+1 éves előrejelzés add-on 2 500 Ft; Egy elemzés unchanged
- worker and prompt: forecast kind with five sections and forecast rules
(trends, no event predictions); no birth data, place or exact age sent
- frontend: /kepletek/{id}/elorejelzes with the solar return wheel, the
keys of the year, a monthly timeline, transit list and detailed forecast
- data export: forecasts added, model name removed
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
This commit is contained in:
@@ -156,7 +156,8 @@ pub async fn export(State(state): St, auth: AuthUser) -> ApiResult<impl IntoResp
|
||||
"charts": rows("SELECT json_build_object('id', id, 'label', label, 'is_primary', is_primary, 'birth_data', birth_data, 'result', result, 'created_at', created_at) FROM charts WHERE owner_id = $1").await?,
|
||||
"synastries": rows("SELECT json_build_object('id', s.id, 'owner_id', s.owner_id, 'chart1_id', s.chart1_id, 'chart2_id', s.chart2_id, 'result', s.result, 'created_at', s.created_at) FROM synastries s JOIN charts c1 ON c1.id = s.chart1_id JOIN charts c2 ON c2.id = s.chart2_id WHERE s.owner_id = $1 OR c1.owner_id = $1 OR c2.owner_id = $1").await?,
|
||||
"invites": rows("SELECT json_build_object('id', id, 'chart_id', inviter_chart_id, 'message', message, 'created_at', created_at, 'expires_at', expires_at, 'accepted_at', accepted_at) FROM synastry_invites WHERE inviter_id = $1").await?,
|
||||
"analyses": rows("SELECT json_build_object('id', a.id, 'kind', a.kind, 'chart_id', a.chart_id, 'synastry_id', a.synastry_id, 'language', a.language, 'model', a.model, 'status', a.status, 'content', a.content, 'created_at', a.created_at) FROM analyses a WHERE a.requested_by = $1 OR a.chart_id IN (SELECT id FROM charts WHERE owner_id = $1)").await?,
|
||||
"forecasts": rows("SELECT json_build_object('id', f.id, 'chart_id', f.chart_id, 'year', f.year, 'location', f.location, 'result', f.result, 'created_at', f.created_at) FROM forecasts f JOIN charts c ON c.id = f.chart_id WHERE c.owner_id = $1").await?,
|
||||
"analyses": rows("SELECT json_build_object('id', a.id, 'kind', a.kind, 'chart_id', a.chart_id, 'synastry_id', a.synastry_id, 'forecast_id', a.forecast_id, 'language', a.language, 'status', a.status, 'content', a.content, 'created_at', a.created_at) FROM analyses a WHERE a.requested_by = $1 OR a.chart_id IN (SELECT id FROM charts WHERE owner_id = $1)").await?,
|
||||
"credit_ledger": rows("SELECT json_build_object('unit', unit, 'delta', delta, 'reason', reason, 'note', note, 'created_at', created_at) FROM credit_ledger WHERE user_id = $1 ORDER BY created_at").await?,
|
||||
"shares": rows("SELECT json_build_object('slug', slug, 'kind', kind, 'title', title, 'show_birth_data', show_birth_data, 'view_count', view_count, 'created_at', created_at, 'revoked_at', revoked_at) FROM shares WHERE owner_id = $1").await?,
|
||||
});
|
||||
|
||||
@@ -33,12 +33,14 @@ pub async fn list_users(
|
||||
let limit = query.limit.unwrap_or(50).clamp(1, 200);
|
||||
let offset = query.offset.unwrap_or(0).max(0);
|
||||
let pattern = query.q.as_deref().map(|q| format!("%{}%", q.trim().replace(['%', '_'], "")));
|
||||
type Row = (Uuid, String, Option<String>, Vec<String>, bool, OffsetDateTime, Option<OffsetDateTime>, i64, i64, i64);
|
||||
type Row =
|
||||
(Uuid, String, Option<String>, Vec<String>, bool, OffsetDateTime, Option<OffsetDateTime>, i64, i64, i64, i64);
|
||||
let rows: Vec<Row> = sqlx::query_as(
|
||||
"SELECT u.id, u.email, u.display_name, u.roles, u.email_verified_at IS NOT NULL, u.created_at, u.last_login_at, \
|
||||
(SELECT count(*) FROM charts c WHERE c.owner_id = u.id), \
|
||||
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'natal'), \
|
||||
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'synastry') \
|
||||
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'synastry'), \
|
||||
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'forecast') \
|
||||
FROM users u \
|
||||
WHERE $1::text IS NULL OR u.email ILIKE $1 OR u.display_name ILIKE $1 \
|
||||
ORDER BY u.created_at DESC LIMIT $2 OFFSET $3",
|
||||
@@ -50,11 +52,11 @@ pub async fn list_users(
|
||||
.await?;
|
||||
let users: Vec<Value> = rows
|
||||
.into_iter()
|
||||
.map(|(id, email, name, roles, verified, created, last_login, charts, natal, synastry)| {
|
||||
.map(|(id, email, name, roles, verified, created, last_login, charts, natal, synastry, forecast)| {
|
||||
json!({
|
||||
"id": id, "email": email, "display_name": name, "roles": roles, "email_verified": verified,
|
||||
"created_at": rfc3339(created), "last_login_at": rfc3339_opt(last_login),
|
||||
"charts": charts, "analyses_left": {"natal": natal, "synastry": synastry},
|
||||
"charts": charts, "analyses_left": {"natal": natal, "synastry": synastry, "forecast": forecast},
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
//! Text analyses (LLM) of charts and synastries.
|
||||
//!
|
||||
//! A request creates a `pending` analysis and spends one unit of its kind
|
||||
//! (`natal` or `synastry`, see [`credits`]; admins pay nothing); the worker
|
||||
//! (`natal`, `synastry` or `forecast`, see [`credits`]; admins pay nothing); the worker
|
||||
//! writes the text later. A finished analysis with the same cache key (same
|
||||
//! chart or synastry hash, prompt version, model and language) is copied
|
||||
//! instead, free of charge, so the same chart is never paid for twice.
|
||||
@@ -22,6 +22,7 @@ use uuid::Uuid;
|
||||
|
||||
use super::auth::validate_locale;
|
||||
use super::charts::{ChartRow, find_chart, owned_chart};
|
||||
use super::forecasts::{find_forecast, owned_forecast};
|
||||
use super::synastries::{load_synastry, visible_synastry};
|
||||
use super::{IdPath, St};
|
||||
use crate::AppState;
|
||||
@@ -38,6 +39,7 @@ pub struct AnalysisRow {
|
||||
pub kind: String,
|
||||
pub chart_id: Option<Uuid>,
|
||||
pub synastry_id: Option<Uuid>,
|
||||
pub forecast_id: Option<Uuid>,
|
||||
pub language: String,
|
||||
pub prompt_version: String,
|
||||
pub status: String,
|
||||
@@ -48,7 +50,8 @@ pub struct AnalysisRow {
|
||||
pub completed_at: Option<OffsetDateTime>,
|
||||
}
|
||||
|
||||
const ANALYSIS_COLUMNS: &str = "id, kind, chart_id, synastry_id, language, prompt_version, status, content, error, \
|
||||
const ANALYSIS_COLUMNS: &str = "id, kind, chart_id, synastry_id, forecast_id, language, prompt_version, status, \
|
||||
content, error, \
|
||||
credits_charged, created_at, completed_at";
|
||||
|
||||
impl AnalysisRow {
|
||||
@@ -58,6 +61,7 @@ impl AnalysisRow {
|
||||
"kind": self.kind,
|
||||
"chart_id": self.chart_id,
|
||||
"synastry_id": self.synastry_id,
|
||||
"forecast_id": self.forecast_id,
|
||||
"language": self.language,
|
||||
"prompt_version": self.prompt_version,
|
||||
"status": self.status,
|
||||
@@ -77,8 +81,8 @@ pub async fn find_analysis(db: &PgPool, id: Uuid) -> Result<Option<AnalysisRow>,
|
||||
.await?)
|
||||
}
|
||||
|
||||
/// Whether `user` may read the analysis: the chart's owner, or a member of
|
||||
/// the synastry.
|
||||
/// Whether `user` may read the analysis: the owner of the chart (or of the
|
||||
/// forecast's chart), or a member of the synastry.
|
||||
pub async fn can_see(db: &PgPool, analysis: &AnalysisRow, user: Uuid) -> Result<bool, ApiError> {
|
||||
if let Some(chart_id) = analysis.chart_id {
|
||||
return Ok(find_chart(db, chart_id).await?.is_some_and(|c| c.owner_id == user));
|
||||
@@ -86,6 +90,11 @@ pub async fn can_see(db: &PgPool, analysis: &AnalysisRow, user: Uuid) -> Result<
|
||||
if let Some(synastry_id) = analysis.synastry_id {
|
||||
return Ok(load_synastry(db, synastry_id).await?.is_some_and(|s| s.is_member(user)));
|
||||
}
|
||||
if let Some(forecast_id) = analysis.forecast_id
|
||||
&& let Some(forecast) = find_forecast(db, forecast_id).await?
|
||||
{
|
||||
return Ok(find_chart(db, forecast.chart_id).await?.is_some_and(|c| c.owner_id == user));
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
@@ -108,6 +117,7 @@ enum Target {
|
||||
Natal { chart_id: Uuid, hash: String },
|
||||
Summary { chart_id: Uuid, hash: String },
|
||||
Synastry { synastry_id: Uuid, hash: String },
|
||||
Forecast { forecast_id: Uuid, hash: String },
|
||||
}
|
||||
|
||||
async fn request(
|
||||
@@ -122,6 +132,7 @@ async fn request(
|
||||
let unit = match target {
|
||||
_ if admin => None,
|
||||
Target::Synastry { .. } => Some(Unit::Synastry),
|
||||
Target::Forecast { .. } => Some(Unit::Forecast),
|
||||
_ => Some(Unit::Natal),
|
||||
};
|
||||
let model = state.config.analysis_model.clone();
|
||||
@@ -140,10 +151,11 @@ async fn queue(
|
||||
model: &str,
|
||||
unit: Option<Unit>,
|
||||
) -> Result<(StatusCode, AnalysisRow), ApiError> {
|
||||
let (kind, hash, chart_id, synastry_id) = match target {
|
||||
Target::Natal { chart_id, hash } => ("natal", hash, Some(*chart_id), None),
|
||||
Target::Summary { chart_id, hash } => ("summary", hash, Some(*chart_id), None),
|
||||
Target::Synastry { synastry_id, hash } => ("synastry", hash, None, Some(*synastry_id)),
|
||||
let (kind, hash, chart_id, synastry_id, forecast_id) = match target {
|
||||
Target::Natal { chart_id, hash } => ("natal", hash, Some(*chart_id), None, None),
|
||||
Target::Summary { chart_id, hash } => ("summary", hash, Some(*chart_id), None, None),
|
||||
Target::Synastry { synastry_id, hash } => ("synastry", hash, None, Some(*synastry_id), None),
|
||||
Target::Forecast { forecast_id, hash } => ("forecast", hash, None, None, Some(*forecast_id)),
|
||||
};
|
||||
// The cache key leaves out the admin-edited prompt revision, so a chart keeps
|
||||
// its analysis when the prompt changes; copying from another chart needs the same revision.
|
||||
@@ -157,12 +169,13 @@ async fn queue(
|
||||
// Already requested for this chart/synastry: return it.
|
||||
let existing: Option<AnalysisRow> = sqlx::query_as(&format!(
|
||||
"SELECT {ANALYSIS_COLUMNS} FROM analyses \
|
||||
WHERE (chart_id = $1 OR synastry_id = $2) AND cache_key = $3 AND status <> 'failed' \
|
||||
WHERE (chart_id = $1 OR synastry_id = $2 OR forecast_id = $4) AND cache_key = $3 AND status <> 'failed' \
|
||||
ORDER BY created_at DESC LIMIT 1"
|
||||
))
|
||||
.bind(chart_id)
|
||||
.bind(synastry_id)
|
||||
.bind(&cache_key)
|
||||
.bind(forecast_id)
|
||||
.fetch_optional(&state.db)
|
||||
.await?;
|
||||
if let Some(row) = existing {
|
||||
@@ -171,8 +184,9 @@ async fn queue(
|
||||
|
||||
let insert = format!(
|
||||
"INSERT INTO analyses (id, kind, chart_id, synastry_id, requested_by, language, model, prompt_version, \
|
||||
cache_key, status, content, input_tokens, output_tokens, credits_charged, completed_at) \
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15) RETURNING {ANALYSIS_COLUMNS}"
|
||||
cache_key, status, content, input_tokens, output_tokens, credits_charged, completed_at, \
|
||||
forecast_id) \
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16) RETURNING {ANALYSIS_COLUMNS}"
|
||||
);
|
||||
let id = Uuid::now_v7();
|
||||
|
||||
@@ -202,6 +216,7 @@ async fn queue(
|
||||
.bind(output_tokens)
|
||||
.bind(0)
|
||||
.bind(OffsetDateTime::now_utc())
|
||||
.bind(forecast_id)
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
return Ok((StatusCode::CREATED, row));
|
||||
@@ -225,6 +240,7 @@ async fn queue(
|
||||
.bind(None::<i32>)
|
||||
.bind(i32::from(unit.is_some()))
|
||||
.bind(None::<OffsetDateTime>)
|
||||
.bind(forecast_id)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
if let Some(unit) = unit {
|
||||
@@ -309,3 +325,23 @@ pub async fn get_one(State(state): St, auth: AuthUser, WithRejection(Path(id), _
|
||||
}
|
||||
Ok(Json(analysis.view()))
|
||||
}
|
||||
|
||||
pub async fn list_for_forecast(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
owned_forecast(&state.db, id, auth.id()).await?;
|
||||
list_where(&state.db, "forecast_id", id).await
|
||||
}
|
||||
|
||||
pub async fn request_for_forecast(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
body: Bytes,
|
||||
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||||
let (forecast, _) = owned_forecast(&state.db, id, auth.id()).await?;
|
||||
let req = optional_body(&body)?;
|
||||
request(&state, &auth, Target::Forecast { forecast_id: forecast.id, hash: forecast.forecast_hash }, req).await
|
||||
}
|
||||
|
||||
@@ -0,0 +1,303 @@
|
||||
//! Yearly forecasts of a chart: one year of life from a solar return
|
||||
//! (birthday) to the next, calculated by the horoscope service for where the
|
||||
//! person is on the birthday. The calculation (solar return chart, transit
|
||||
//! timeline, progressions, profection, eclipses) is free; its detailed text
|
||||
//! analysis uses a `forecast` unit (see [`super::analyses`]).
|
||||
//!
|
||||
//! Users can calculate the year of life they are in, and the next one from
|
||||
//! [`NEXT_YEAR_DAYS`] days before the birthday; admins any year.
|
||||
|
||||
use axum::Json;
|
||||
use axum::extract::State;
|
||||
use axum::http::StatusCode;
|
||||
use axum_extra::extract::WithRejection;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
use sqlx::PgPool;
|
||||
use time::{Date, Month, OffsetDateTime};
|
||||
use uuid::Uuid;
|
||||
|
||||
use super::charts::{ChartRow, find_chart, owned_chart};
|
||||
use super::{Body, IdPath, St};
|
||||
use crate::auth::AuthUser;
|
||||
use crate::error::{ApiError, ApiResult};
|
||||
use crate::views::{rfc3339, sha256_hex};
|
||||
use db::Role;
|
||||
|
||||
/// The next year of life can be calculated this many days before the birthday.
|
||||
pub const NEXT_YEAR_DAYS: i64 = 30;
|
||||
/// At most this many forecasts (years and places) per chart.
|
||||
const MAX_PER_CHART: i64 = 20;
|
||||
|
||||
#[derive(Debug, Clone, sqlx::FromRow)]
|
||||
pub struct ForecastRow {
|
||||
pub id: Uuid,
|
||||
pub chart_id: Uuid,
|
||||
pub year: i32,
|
||||
pub location: Option<Value>,
|
||||
pub result: Value,
|
||||
pub forecast_hash: String,
|
||||
pub created_at: OffsetDateTime,
|
||||
}
|
||||
|
||||
const FORECAST_COLUMNS: &str = "id, chart_id, year, location, result, forecast_hash, created_at";
|
||||
|
||||
impl ForecastRow {
|
||||
/// Where the year is reckoned, for lists: the place name or the coordinates.
|
||||
fn place(&self) -> Value {
|
||||
let sr = &self.result["solar_return"]["location"];
|
||||
let loc = &self.result["location"];
|
||||
sr.pointer("/place/name").or(loc.get("place")).cloned().unwrap_or(Value::Null)
|
||||
}
|
||||
|
||||
pub fn summary_view(&self) -> Value {
|
||||
let f = &self.result["forecast"];
|
||||
json!({
|
||||
"id": self.id,
|
||||
"chart_id": self.chart_id,
|
||||
"year": self.year,
|
||||
"start": f["start"],
|
||||
"end": f["end"],
|
||||
"place": self.place(),
|
||||
"birth_place": self.location.is_none(),
|
||||
"created_at": rfc3339(self.created_at),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn view(&self) -> Value {
|
||||
let mut v = self.summary_view();
|
||||
v["location"] = self.location.clone().unwrap_or(Value::Null);
|
||||
v["result"] = self.result.clone();
|
||||
v
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn find_forecast(db: &PgPool, id: Uuid) -> Result<Option<ForecastRow>, ApiError> {
|
||||
Ok(sqlx::query_as(&format!("SELECT {FORECAST_COLUMNS} FROM forecasts WHERE id = $1"))
|
||||
.bind(id)
|
||||
.fetch_optional(db)
|
||||
.await?)
|
||||
}
|
||||
|
||||
/// A forecast of a chart of `owner`; 404 otherwise.
|
||||
pub async fn owned_forecast(db: &PgPool, id: Uuid, owner: Uuid) -> Result<(ForecastRow, ChartRow), ApiError> {
|
||||
let forecast = find_forecast(db, id).await?.ok_or(ApiError::NotFound("forecast"))?;
|
||||
let chart = find_chart(db, forecast.chart_id).await?.filter(|c| c.owner_id == owner);
|
||||
chart.map(|c| (forecast, c)).ok_or(ApiError::NotFound("forecast"))
|
||||
}
|
||||
|
||||
/// The Gregorian birth date of a calculated chart.
|
||||
fn birth_date(chart: &ChartRow) -> Option<Date> {
|
||||
let text = chart.result.pointer("/time/date")?.as_str()?;
|
||||
let mut parts = text.split('-').map(str::parse::<i32>);
|
||||
let (y, m, d) = (parts.next()?.ok()?, parts.next()?.ok()?, parts.next()?.ok()?);
|
||||
Date::from_calendar_date(y, Month::try_from(m as u8).ok()?, d as u8).ok()
|
||||
}
|
||||
|
||||
/// The birthday in a year (29 February is the 28th in common years).
|
||||
fn birthday(birth: Date, year: i32) -> Option<Date> {
|
||||
Date::from_calendar_date(year, birth.month(), birth.day())
|
||||
.or_else(|_| Date::from_calendar_date(year, birth.month(), birth.day() - 1))
|
||||
.ok()
|
||||
}
|
||||
|
||||
/// The years (of the solar return starting them) a user can calculate on
|
||||
/// `today`: the current year of life, and the next one close to the birthday.
|
||||
pub fn open_years(birth: Date, today: Date) -> Vec<i32> {
|
||||
let Some(this) = birthday(birth, today.year()) else { return Vec::new() };
|
||||
let current = if today >= this { today.year() } else { today.year() - 1 };
|
||||
let mut years = Vec::new();
|
||||
if current > birth.year() {
|
||||
years.push(current);
|
||||
}
|
||||
if birthday(birth, current + 1).is_some_and(|next| (next - today).whole_days() <= NEXT_YEAR_DAYS) {
|
||||
years.push(current + 1);
|
||||
}
|
||||
years
|
||||
}
|
||||
|
||||
/// Where the person is on the birthday, as the horoscope service takes it.
|
||||
#[derive(Debug, Clone, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Location {
|
||||
country: String,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
place: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
region: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
geonames_id: Option<u64>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
latitude: Option<f64>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
longitude: Option<f64>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Default)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct CreateForecast {
|
||||
/// Defaults to the current year of life.
|
||||
year: Option<i32>,
|
||||
/// Defaults to the birth place.
|
||||
location: Option<Location>,
|
||||
}
|
||||
|
||||
fn is_admin(auth: &AuthUser) -> bool {
|
||||
auth.user.has_role(Role::Admin)
|
||||
}
|
||||
|
||||
/// The years open to this user for a chart (admins: also every earlier one is allowed on request).
|
||||
fn years_for(chart: &ChartRow) -> Vec<i32> {
|
||||
birth_date(chart).map(|b| open_years(b, OffsetDateTime::now_utc().date())).unwrap_or_default()
|
||||
}
|
||||
|
||||
fn current_forecasts_query() -> String {
|
||||
format!(
|
||||
"SELECT {FORECAST_COLUMNS} FROM forecasts WHERE chart_id = $1 AND chart_hash = $2 ORDER BY year DESC, created_at"
|
||||
)
|
||||
}
|
||||
|
||||
/// The forecasts of a chart (for its current birth data) and the years that can be calculated.
|
||||
pub async fn list_for_chart(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(axum::extract::Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let chart = owned_chart(&state.db, id, auth.id()).await?;
|
||||
let rows: Vec<ForecastRow> =
|
||||
sqlx::query_as(¤t_forecasts_query()).bind(chart.id).bind(&chart.chart_hash).fetch_all(&state.db).await?;
|
||||
Ok(Json(json!({
|
||||
"years": years_for(&chart),
|
||||
"birth_place": chart.result.pointer("/location/place/name"),
|
||||
"time_known": chart.result.pointer("/time/time_known"),
|
||||
"forecasts": rows.iter().map(ForecastRow::summary_view).collect::<Vec<_>>(),
|
||||
})))
|
||||
}
|
||||
|
||||
/// Calculates a year (or returns it when already calculated). 201 or 200.
|
||||
pub async fn create(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(axum::extract::Path(id), _): IdPath,
|
||||
WithRejection(Json(req), _): Body<CreateForecast>,
|
||||
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||||
let chart = owned_chart(&state.db, id, auth.id()).await?;
|
||||
let open = years_for(&chart);
|
||||
let year = match req.year {
|
||||
Some(y) if open.contains(&y) || is_admin(&auth) => y,
|
||||
Some(_) => {
|
||||
return Err(ApiError::Refused {
|
||||
code: "forecast_year_closed",
|
||||
message: "Az aktuális évre, és a születésnap előtti 30 napban a következőre kérhetsz előrejelzést."
|
||||
.into(),
|
||||
});
|
||||
}
|
||||
None => *open.first().ok_or(ApiError::Refused {
|
||||
code: "forecast_year_closed",
|
||||
message: "Az első születésnap előtt még nincs éves előrejelzés.".into(),
|
||||
})?,
|
||||
};
|
||||
let location = req.location.map(|l| serde_json::to_value(l).expect("serializable"));
|
||||
let location_key = location.as_ref().map_or_else(|| "birth".to_string(), |l| sha256_hex(&l.to_string()));
|
||||
|
||||
let existing: Option<ForecastRow> = sqlx::query_as(&format!(
|
||||
"SELECT {FORECAST_COLUMNS} FROM forecasts \
|
||||
WHERE chart_id = $1 AND chart_hash = $2 AND year = $3 AND location_key = $4"
|
||||
))
|
||||
.bind(chart.id)
|
||||
.bind(&chart.chart_hash)
|
||||
.bind(year)
|
||||
.bind(&location_key)
|
||||
.fetch_optional(&state.db)
|
||||
.await?;
|
||||
if let Some(row) = existing {
|
||||
return Ok((StatusCode::OK, Json(row.view())));
|
||||
}
|
||||
let (count,): (i64,) = sqlx::query_as("SELECT count(*) FROM forecasts WHERE chart_id = $1")
|
||||
.bind(chart.id)
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
if count >= MAX_PER_CHART && !is_admin(&auth) {
|
||||
return Err(ApiError::conflict(
|
||||
"forecast_limit_reached",
|
||||
format!("at most {MAX_PER_CHART} forecasts can be saved for a chart"),
|
||||
));
|
||||
}
|
||||
|
||||
let mut request = json!({ "birth": chart.birth_data, "year": year });
|
||||
if let Some(l) = &location {
|
||||
request["location"] = l.clone();
|
||||
}
|
||||
let mut result = state.horoscope.forecast(&request).await?;
|
||||
if let Some(obj) = result.as_object_mut() {
|
||||
obj.remove("meta");
|
||||
}
|
||||
let forecast_hash = forecast_hash(&chart.chart_hash, year, &location_key, &result);
|
||||
let row: ForecastRow = sqlx::query_as(&format!(
|
||||
"INSERT INTO forecasts (id, chart_id, chart_hash, year, location, location_key, result, forecast_hash, created_by) \
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) \
|
||||
ON CONFLICT (chart_id, chart_hash, year, location_key) DO UPDATE SET chart_id = EXCLUDED.chart_id \
|
||||
RETURNING {FORECAST_COLUMNS}"
|
||||
))
|
||||
.bind(Uuid::now_v7())
|
||||
.bind(chart.id)
|
||||
.bind(&chart.chart_hash)
|
||||
.bind(year)
|
||||
.bind(&location)
|
||||
.bind(&location_key)
|
||||
.bind(&result)
|
||||
.bind(&forecast_hash)
|
||||
.bind(auth.id())
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
Ok((StatusCode::CREATED, Json(row.view())))
|
||||
}
|
||||
|
||||
/// Identifies a forecast independently of how the place was entered: the
|
||||
/// chart, the year and the resolved place and time zone of the solar return.
|
||||
fn forecast_hash(chart_hash: &str, year: i32, location_key: &str, result: &Value) -> String {
|
||||
let sr = &result["solar_return"];
|
||||
let place = if sr.is_object() {
|
||||
format!(
|
||||
"{:.4}|{:.4}|{}",
|
||||
sr["location"]["latitude"].as_f64().unwrap_or_default(),
|
||||
sr["location"]["longitude"].as_f64().unwrap_or_default(),
|
||||
sr["timezone"].as_str().unwrap_or_default()
|
||||
)
|
||||
} else {
|
||||
location_key.to_string()
|
||||
};
|
||||
sha256_hex(&format!("forecast|{chart_hash}|{year}|{place}"))
|
||||
}
|
||||
|
||||
pub async fn get_one(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(axum::extract::Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let (forecast, _) = owned_forecast(&state.db, id, auth.id()).await?;
|
||||
Ok(Json(forecast.view()))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn date(y: i32, m: u8, d: u8) -> Date {
|
||||
Date::from_calendar_date(y, Month::try_from(m).unwrap(), d).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn years_open_around_the_birthday() {
|
||||
let birth = date(1990, 3, 15);
|
||||
assert_eq!(open_years(birth, date(2026, 11, 18)), vec![2026]);
|
||||
assert_eq!(open_years(birth, date(2027, 3, 1)), vec![2026, 2027]);
|
||||
assert_eq!(open_years(birth, date(2027, 3, 15)), vec![2027]);
|
||||
assert_eq!(open_years(birth, date(2027, 2, 12)), vec![2026]);
|
||||
// Before the first birthday: only the first year, close to it.
|
||||
assert!(open_years(birth, date(1990, 6, 1)).is_empty());
|
||||
assert_eq!(open_years(birth, date(1991, 3, 1)), vec![1991]);
|
||||
// 29 February
|
||||
assert_eq!(open_years(date(1992, 2, 29), date(2027, 2, 28)), vec![2027]);
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@ mod admin;
|
||||
mod analyses;
|
||||
mod auth;
|
||||
mod charts;
|
||||
mod forecasts;
|
||||
mod invitations;
|
||||
mod payments;
|
||||
mod prompts;
|
||||
@@ -73,6 +74,9 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/charts/{id}", get(charts::get_one).patch(charts::update).delete(charts::remove))
|
||||
.route("/v1/charts/{id}/analyses", get(analyses::list_for_chart).post(analyses::request_for_chart))
|
||||
.route("/v1/charts/{id}/summary", post(analyses::summary_for_chart))
|
||||
.route("/v1/charts/{id}/forecasts", get(forecasts::list_for_chart).post(forecasts::create))
|
||||
.route("/v1/forecasts/{id}", get(forecasts::get_one))
|
||||
.route("/v1/forecasts/{id}/analyses", get(analyses::list_for_forecast).post(analyses::request_for_forecast))
|
||||
// synastries and invitations
|
||||
.route("/v1/synastries", get(synastries::list).post(synastries::create))
|
||||
.route("/v1/synastries/{id}", get(synastries::get_one).delete(synastries::remove))
|
||||
|
||||
@@ -53,6 +53,7 @@ pub async fn mock(
|
||||
(Some(id), None) => id,
|
||||
(None, Some(Unit::Natal)) => "single",
|
||||
(None, Some(Unit::Synastry)) => "addon_synastry",
|
||||
(None, Some(Unit::Forecast)) => "addon_forecast",
|
||||
(None, Some(Unit::Person)) => "addon_persons",
|
||||
_ => return Err(ApiError::BadRequest("give either package or unit".into())),
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user