diff --git a/crates/analysis-prompt/src/lib.rs b/crates/analysis-prompt/src/lib.rs index 4cbc483..181eef8 100644 --- a/crates/analysis-prompt/src/lib.rs +++ b/crates/analysis-prompt/src/lib.rs @@ -17,16 +17,19 @@ pub enum Kind { Synastry, /// A free teaser of a natal chart: a title and a few sentences. Summary, + /// One year of a natal chart: solar return, transits, progressions, profection, eclipses. + Forecast, } impl Kind { - pub const ALL: [Kind; 3] = [Kind::Summary, Kind::Natal, Kind::Synastry]; + pub const ALL: [Kind; 4] = [Kind::Summary, Kind::Natal, Kind::Synastry, Kind::Forecast]; pub fn as_str(self) -> &'static str { match self { Kind::Natal => "natal", Kind::Synastry => "synastry", Kind::Summary => "summary", + Kind::Forecast => "forecast", } } @@ -35,6 +38,7 @@ impl Kind { "natal" => Some(Kind::Natal), "synastry" => Some(Kind::Synastry), "summary" => Some(Kind::Summary), + "forecast" => Some(Kind::Forecast), _ => None, } } @@ -68,10 +72,39 @@ const SYNASTRY_SECTIONS: [(&str, &str); 5] = [ ("long_term", "Long-term potential and shared purpose, including the composite chart"), ]; +const FORECAST_SECTIONS: [(&str, &str); 5] = [ + ( + "theme", + "The main theme of the year: the solar return chart (its Ascendant, the houses of the Sun and the Moon, \ + angular planets, tight aspects), the profected house and the lord of the year", + ), + ( + "love", + "Love, relationships, family and friendships during the year (Venus, the Moon, the 4th, 5th, 7th and 11th \ + houses, and the transits and eclipses touching them)", + ), + ( + "work", + "Work, calling, money and daily life during the year (Midheaven, the 2nd, 6th and 10th houses, Jupiter and \ + Saturn transits)", + ), + ( + "growth", + "Inner development: the progressed Moon's sign, house and lunation phase, the other progressions, and the \ + transits of Uranus, Neptune and Pluto", + ), + ( + "timeline", + "The year in time order from birthday to birthday, in exactly 4 paragraphs, one for each quarter: the main \ + periods and dates (transits, eclipses, progressed Moon ingresses) of that quarter", + ), +]; + fn sections(kind: Kind) -> &'static [(&'static str, &'static str)] { match kind { Kind::Natal => &NATAL_SECTIONS, Kind::Synastry => &SYNASTRY_SECTIONS, + Kind::Forecast => &FORECAST_SECTIONS, Kind::Summary => &[], } } @@ -106,6 +139,13 @@ pub fn schema(kind: Kind) -> Value { ); } let keys: Vec<&str> = sections(kind).iter().map(|(k, _)| *k).collect(); + let (strengths, challenges) = match kind { + Kind::Forecast => ( + "3-5 main opportunities of the year, one sentence each", + "3-5 main challenges of the year, one sentence each", + ), + _ => ("3-5 key strengths, one sentence each", "3-5 key challenges, one sentence each"), + }; json!({ "type": "object", "additionalProperties": false, @@ -114,8 +154,8 @@ pub fn schema(kind: Kind) -> Value { "title": {"type": "string", "description": "Short, evocative title for this analysis (at most 8 words)"}, "summary": {"type": "string", "description": "3-4 sentence overview"}, "sections": {"type": "object", "additionalProperties": false, "required": keys, "properties": props}, - "strengths": {"type": "array", "items": {"type": "string"}, "description": "3-5 key strengths, one sentence each"}, - "challenges": {"type": "array", "items": {"type": "string"}, "description": "3-5 key challenges, one sentence each"}, + "strengths": {"type": "array", "items": {"type": "string"}, "description": strengths}, + "challenges": {"type": "array", "items": {"type": "string"}, "description": challenges}, "advice": {"type": "string", "description": "A closing, encouraging paragraph with concrete guidance"} } }) @@ -133,6 +173,11 @@ Use the usual Hungarian astrological terms: Never leave English words (e.g. fire, earth, air, water) in the Hungarian text. - other: \"a 3. házban\", \"a horoszkóp uralkodója\", retrográd, uralom (domicilium), száműzetés, exaltáció, esés, nappali/éjszakai horoszkóp."; +const HUNGARIAN_FORECAST_TERMS: &str = "\ +Forecast terms in Hungarian: szolár (szoláris visszatérés, a szolár képlet), tranzit (\"a Szaturnusz tranzitja a Napod \ +felett\"), progresszió (a progresszív Hold), profekció, az év ura, napfogyatkozás, holdfogyatkozás, retrográd, \ +Szaturnusz-visszatérés. Write dates the Hungarian way: \"március 12.\", \"március 12-től április 30-ig\", \"2027 januárja\"."; + fn language_name(language: &str) -> &'static str { match language { "hu" => "Hungarian", @@ -151,6 +196,10 @@ pub fn default_system(kind: Kind, language: &str) -> String { "a short free summary of a natal chart (a teaser shown before the detailed, paid analysis)", "Speak to the owner of the chart directly, in the informal second person singular (in Hungarian: tegező forma, \"te\").", ), + Kind::Forecast => ( + "a personal forecast for one year of life, from one birthday to the next", + "Speak to the owner of the chart directly, in the informal second person singular (in Hungarian: tegező forma, \"te\").", + ), Kind::Synastry => ( "a relationship (synastry) interpretation for two people", "Write for both people at once, in the informal second person plural (in Hungarian: \"ti\", \"kettőtök\"). \ @@ -178,6 +227,8 @@ and no medical, legal or financial advice. - Answer with a single JSON object that matches the given schema, and nothing else.", lang = language_name(language), length = match kind { + Kind::Forecast => "Length: each section 2-4 paragraphs (about 150-250 words), the timeline exactly 4 \ + paragraphs; the whole forecast about 1500-2000 words.", Kind::Summary => "Length: one paragraph of 3-4 sentences (60-100 words). Pick the Sun, Moon and Ascendant \ (if the birth time is known) and the single most striking feature of the chart (a very tight aspect, \ a stellium, a strong element emphasis or gap). It must be complete in itself and specific to this chart: \ @@ -185,13 +236,38 @@ and no medical, legal or financial advice. _ => "Length: each section 2-4 paragraphs (about 150-250 words); the whole analysis about 1300-1800 words.", }, ); + if kind == Kind::Forecast { + text.push_str(FORECAST_RULES); + } if language == "hu" { text.push_str("\n\n"); text.push_str(HUNGARIAN_STYLE); + if kind == Kind::Forecast { + text.push('\n'); + text.push_str(HUNGARIAN_FORECAST_TERMS); + } } text } +const FORECAST_RULES: &str = " + +Forecast rules: +- Describe themes, tendencies, opportunities and the timing of periods, never certain events: \"a good time for\", \ +\"may bring\", \"asks for\", not \"will happen\". Nothing about illness, death, accidents, pregnancy, lawsuits or \ +gains and losses of money. +- Use only the dates in the data and do not invent any; a transit is felt during its whole period, most strongly \ +around the exact dates. Retrograde planets make a contact two or three times: describe it as one process. +- Weigh the techniques as an astrologer does: the solar return Ascendant and the houses of the solar return Sun and \ +Moon set the scene; the lord of the year and the profected house say which area of life is activated; exact \ +transits of Saturn, Uranus, Neptune and Pluto to the Sun, Moon, Ascendant, Midheaven and personal planets are the \ +main turning points; Jupiter transits are openings; eclipses matter only where they touch the natal chart; the \ +progressed Moon shows the emotional season. +- A planet meeting its own natal place (marked \"cycle\") is a life milestone, e.g. the Saturn return or the \ +Uranus opposition: name it as such. +- If there is no solar return chart (unknown birth time), build the year on the transits and progressions, and do \ +not mention houses, the Ascendant or the Midheaven."; + /// Splits a stored prompt version (`v2` or `v2-r`, the id of an admin-edited /// system prompt in `prompt_revisions`) into the code version and the revision id. pub fn split_version(version: &str) -> (&str, Option) { @@ -230,6 +306,7 @@ pub fn build(kind: Kind, language: &str, chart_text: &str, system: Option<&str>) Kind::Natal => "natal_analysis", Kind::Synastry => "synastry_analysis", Kind::Summary => "chart_summary", + Kind::Forecast => "forecast_analysis", }, schema: schema(kind), } @@ -301,10 +378,11 @@ pub fn polish(language: &str, content: &mut Value) { /// The analysis as Markdown (for reading and comparing outputs). pub fn to_markdown(kind: Kind, language: &str, content: &Value) -> String { - let (strengths, challenges, advice) = if language == "hu" { - ("Erősségek", "Kihívások", "Útravaló") - } else { - ("Strengths", "Challenges", "Advice") + let (strengths, challenges, advice) = match (language, kind) { + ("hu", Kind::Forecast) => ("Lehetőségek", "Kihívások", "Útravaló"), + ("hu", _) => ("Erősségek", "Kihívások", "Útravaló"), + (_, Kind::Forecast) => ("Opportunities", "Challenges", "Advice"), + _ => ("Strengths", "Challenges", "Advice"), }; let mut md = format!("# {}\n\n_{}_\n\n", content["title"].as_str().unwrap_or(""), content["summary"].as_str().unwrap_or("")); @@ -354,6 +432,17 @@ mod tests { assert!(Kind::ALL.iter().all(|k| Kind::parse(k.as_str()) == Some(*k))); } + #[test] + fn forecast_prompt() { + let p = build(Kind::Forecast, "hu", "SOLAR RETURN", None); + assert_eq!(p.schema_name, "forecast_analysis"); + assert!(p.system.contains("Forecast rules") && p.system.contains("szolár") && p.system.contains("tegező")); + assert!(p.user.contains("- timeline:") && p.user.contains("- theme:")); + let keys = p.schema["properties"]["sections"]["required"].as_array().unwrap().len(); + assert_eq!(keys, 5); + assert!(!default_system(Kind::Natal, "hu").contains("Forecast rules")); + } + #[test] fn validate_rejects_placeholder_titles() { let schema = schema(Kind::Synastry); diff --git a/crates/astro-engine/src/chart.rs b/crates/astro-engine/src/chart.rs index 572f3de..ba9054a 100644 --- a/crates/astro-engine/src/chart.rs +++ b/crates/astro-engine/src/chart.rs @@ -82,7 +82,7 @@ pub enum PointId { } impl PointId { - fn from_planet(body: Body) -> PointId { + pub(crate) fn from_planet(body: Body) -> PointId { match body { Body::Sun => PointId::Sun, Body::Moon => PointId::Moon, @@ -720,7 +720,7 @@ fn above_horizon(lon: f64, ascendant: f64) -> bool { angle::arc(ascendant, lon) >= 180.0 } -fn phase_name(elongation: f64) -> MoonPhaseName { +pub(crate) fn phase_name(elongation: f64) -> MoonPhaseName { use MoonPhaseName::*; [NewMoon, WaxingCrescent, FirstQuarter, WaxingGibbous, FullMoon, WaningGibbous, LastQuarter, WaningCrescent] [((elongation / 45.0).floor() as usize).min(7)] diff --git a/crates/astro-engine/src/engine.rs b/crates/astro-engine/src/engine.rs index a36a55c..152639b 100644 --- a/crates/astro-engine/src/engine.rs +++ b/crates/astro-engine/src/engine.rs @@ -109,6 +109,32 @@ pub struct EphemerisInfo { pub license: String, } +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum EclipseKind { + Solar, + Lunar, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum EclipseType { + Total, + Annular, + /// Annular-total (hybrid) solar eclipse. + Hybrid, + Partial, + Penumbral, +} + +/// An eclipse at its maximum. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct EclipseEvent { + pub kind: EclipseKind, + pub eclipse_type: EclipseType, + pub jd_ut: f64, +} + pub trait Ephemeris: Send + Sync { fn info(&self) -> EphemerisInfo; @@ -129,4 +155,8 @@ pub trait Ephemeris: Send + Sync { /// Ayanamsa value in degrees. fn ayanamsa(&self, jd_ut: f64, ayanamsa: Ayanamsa) -> Result; + + /// Solar eclipses (all types) and lunar eclipses (partial and total, not + /// the barely visible penumbral ones) between two moments, in time order. + fn eclipses(&self, from_jd: f64, to_jd: f64) -> Result>; } diff --git a/crates/astro-engine/src/forecast.rs b/crates/astro-engine/src/forecast.rs new file mode 100644 index 0000000..5b8610c --- /dev/null +++ b/crates/astro-engine/src/forecast.rs @@ -0,0 +1,657 @@ +//! Forecast techniques on top of a natal chart, for one year of life (from a +//! solar return to the next): +//! +//! * [`solar_return`]: the moment the Sun comes back to its natal longitude +//! (the chart of that moment is an ordinary chart, cast by the caller for +//! the place where the person is); +//! * transits of the slow planets (Jupiter to Pluto) to the natal planets +//! and angles, with exact dates and the periods within orb; +//! * secondary progressions ("a day for a year"); +//! * the annual profection (the house and the "lord" of the year); +//! * eclipses on the natal chart. +//! +//! Dates are calendar days at a fixed UTC offset given by the caller. + +use serde::Serialize; + +use crate::angle::separation; +use crate::chart::{ + AspectKind, AspectNature, MoonPhaseName, NatalChart, PointId, ZodiacPosition, house_of, phase_name, +}; +use crate::engine::{EclipseKind, EclipseType, EngineError, Ephemeris, Frame}; +use crate::time::gregorian_from_jdn; +use crate::types::{Body, ZodiacSign, ZodiacType}; + +/// Days in a tropical year: "a day for a year" in progressions. +pub const TROPICAL_YEAR: f64 = 365.242_19; +/// Orb of transits and progressions, degrees. +pub const ORB: f64 = 1.0; +/// Orb of an eclipse on a natal point, degrees. +pub const ECLIPSE_ORB: f64 = 3.0; +/// Days scanned before and after the year, so that passes that began earlier +/// or end later show their whole length. +const MARGIN_DAYS: f64 = 400.0; +/// Passes starting or ending farther than this from the year belong to +/// another cycle and are left out. +const NEAR_DAYS: f64 = 200.0; + +const TRANSITING: [Body; 5] = [Body::Jupiter, Body::Saturn, Body::Uranus, Body::Neptune, Body::Pluto]; +const PROGRESSED: [Body; 5] = [Body::Sun, Body::Moon, Body::Mercury, Body::Venus, Body::Mars]; +const ASPECTS: [AspectKind; 5] = + [AspectKind::Conjunction, AspectKind::Sextile, AspectKind::Square, AspectKind::Trine, AspectKind::Opposition]; + +type Result = std::result::Result; + +/// Signed difference `a - b` in `[-180, 180)`. +fn diff(a: f64, b: f64) -> f64 { + (a - b + 180.0).rem_euclid(360.0) - 180.0 +} + +/// The calendar day of a moment at a fixed UTC offset, `YYYY-MM-DD`. +pub fn date_of(jd_ut: f64, offset_hours: f64) -> String { + let (y, m, d) = gregorian_from_jdn((jd_ut + 0.5 + offset_hours / 24.0).floor() as i64); + format!("{y:04}-{m:02}-{d:02}") +} + +/// The zodiac of the natal chart, geocentric (transits are not topocentric). +fn frame_of(natal: &NatalChart) -> Frame { + let o = natal.settings.options; + Frame { sidereal: (o.zodiac == ZodiacType::Sidereal).then_some(o.ayanamsa), topocentric: None } +} + +fn natal_lon(natal: &NatalChart, id: PointId) -> Option { + natal.points.iter().find(|p| p.id == id).map(|p| p.position.longitude) +} + +fn cusps_of(natal: &NatalChart) -> Option<[f64; 12]> { + let houses = natal.houses.as_ref()?; + let mut cusps = [0.0; 12]; + for (c, h) in cusps.iter_mut().zip(&houses.cusps) { + *c = h.position.longitude; + } + Some(cusps) +} + +/// The natal points transits and progressions are measured to: the ten +/// planets and, with a known birth time, the Ascendant and the Midheaven. +/// Without a birth time the Moon is left out (it may be 7° off). +fn natal_targets(natal: &NatalChart) -> Vec<(PointId, f64)> { + let known = natal.angles.is_some(); + let mut out: Vec<(PointId, f64)> = Body::PLANETS + .iter() + .map(|&b| PointId::from_planet(b)) + .filter(|&id| known || id != PointId::Moon) + .filter_map(|id| natal_lon(natal, id).map(|lon| (id, lon))) + .collect(); + if let Some(a) = &natal.angles { + out.push((PointId::Ascendant, a.ascendant.position.longitude)); + out.push((PointId::Midheaven, a.midheaven.position.longitude)); + } + out +} + +/// The moment near `approx_jd` when `body` (moving forward) reaches `target`. +pub fn return_moment(engine: &dyn Ephemeris, body: Body, target: f64, approx_jd: f64, frame: &Frame) -> Result { + let mut jd = approx_jd; + for _ in 0..50 { + let s = engine.position(body, jd, frame)?; + let d = diff(target, s.longitude); + if d.abs() < 1e-9 { + return Ok(jd); + } + if s.speed_longitude <= 0.0 { + return Err(EngineError::Calculation(format!("{body:?} is not moving forward"))); + } + jd += d / s.speed_longitude; + } + Ok(jd) +} + +/// The solar return of a natal chart in a calendar year (the birthday of that year). +pub fn solar_return(engine: &dyn Ephemeris, natal: &NatalChart, year: i32) -> Result { + let natal_jd = natal.astronomy.julian_day_ut; + let birth_year = gregorian_from_jdn((natal_jd + 0.5).floor() as i64).0; + let sun = natal_lon(natal, PointId::Sun).expect("the Sun is always in a chart"); + let approx = natal_jd + f64::from(year - birth_year) * TROPICAL_YEAR; + return_moment(engine, Body::Sun, sun, approx, &frame_of(natal)) +} + +/// A run of samples within orb: first and last moment. +type Window = (f64, f64); +/// The runs within orb, and the exact moments with "moving backward". +type Crossings = (Vec, Vec<(f64, bool)>); + +/// Longitude and daily motion sampled at equal steps. +struct Samples { + start: f64, + step: f64, + lon: Vec, + speed: Vec, +} + +impl Samples { + fn take(from: f64, to: f64, step: f64, at: &dyn Fn(f64) -> Result<(f64, f64)>) -> Result { + let n = ((to - from) / step).ceil() as usize + 1; + let mut lon = Vec::with_capacity(n); + let mut speed = Vec::with_capacity(n); + for i in 0..n { + let (l, s) = at(from + i as f64 * step)?; + lon.push(l); + speed.push(s); + } + Ok(Self { start: from, step, lon, speed }) + } + + fn jd(&self, i: usize) -> f64 { + self.start + i as f64 * self.step + } +} + +/// Where a moving longitude meets `target`: the runs of samples within `orb` +/// (as moments) and the exact moments (with "retrograde" for backward motion). +fn crossings(s: &Samples, target: f64, orb: f64, lon_at: &dyn Fn(f64) -> Result) -> Result { + let d: Vec = s.lon.iter().map(|&l| diff(l, target)).collect(); + let mut windows = Vec::new(); + let mut open: Option = None; + for (i, x) in d.iter().enumerate() { + match (x.abs() <= orb, open) { + (true, None) => open = Some(i), + (false, Some(first)) => { + windows.push((s.jd(first), s.jd(i - 1))); + open = None; + } + _ => {} + } + } + if let Some(first) = open { + windows.push((s.jd(first), s.jd(d.len() - 1))); + } + let mut exact = Vec::new(); + for i in 0..d.len().saturating_sub(1) { + let (a, b) = (d[i], d[i + 1]); + let crosses = (a <= 0.0 && b > 0.0) || (a >= 0.0 && b < 0.0); + if !crosses || a.abs() > 90.0 || b.abs() > 90.0 { + continue; + } + let (mut lo, mut hi) = (s.jd(i), s.jd(i + 1)); + let rising = b > a; + for _ in 0..30 { + let mid = (lo + hi) / 2.0; + let below = diff(lon_at(mid)?, target) < 0.0; + if below == rising { + lo = mid; + } else { + hi = mid; + } + } + exact.push(((lo + hi) / 2.0, !rising)); + } + Ok((windows, exact)) +} + +#[derive(Debug, Clone, Serialize)] +pub struct DateRange { + pub start: String, + pub end: String, +} + +#[derive(Debug, Clone, Serialize)] +pub struct Exact { + pub date: String, + /// The moving planet is retrograde (a pass while it moves backward). + pub retrograde: bool, +} + +/// A transiting or progressed planet in aspect to a natal point. +#[derive(Debug, Clone, Serialize)] +pub struct Contact { + pub planet: PointId, + pub natal_point: PointId, + pub aspect: AspectKind, + pub nature: AspectNature, + /// Exact hits inside the year. + pub exact: Vec, + /// Periods within orb (transits only): whole passes, which may begin + /// before the year or end after it. + #[serde(skip_serializing_if = "Vec::is_empty")] + pub periods: Vec, + /// When it matters most inside the year: the first exact hit, or else the closest approach. + pub peak: String, + /// The closest orb inside the year (0 when exact). + pub min_orb: f64, + /// Natal house of the moving planet at the peak (birth time known). + #[serde(skip_serializing_if = "Option::is_none")] + pub house: Option, + #[serde(skip)] + peak_jd: f64, +} + +/// One year of a natal chart. +struct Year<'a> { + engine: &'a dyn Ephemeris, + natal: &'a NatalChart, + frame: Frame, + start: f64, + end: f64, + offset: f64, + cusps: Option<[f64; 12]>, +} + +impl Year<'_> { + fn date(&self, jd: f64) -> String { + date_of(jd, self.offset) + } + + fn inside(&self, jd: f64) -> bool { + (self.start..=self.end).contains(&jd) + } + + /// Contacts of one moving planet (sampled in `s`) with the natal points. + fn contacts( + &self, + planet: PointId, + s: &Samples, + lon_at: &dyn Fn(f64) -> Result, + targets: &[(PointId, f64)], + with_periods: bool, + ) -> Result> { + let mut out = Vec::new(); + for &(natal_point, natal) in targets { + for aspect in ASPECTS { + let a = aspect.angle(); + let mut points = vec![natal + a]; + if a != 0.0 && a != 180.0 { + points.push(natal - a); + } + let (mut windows, mut exact) = (Vec::new(), Vec::new()); + for target in points { + let (w, e) = crossings(s, target, ORB, lon_at)?; + windows.extend(w); + exact.extend(e); + } + if !windows.iter().any(|&(from, to)| to >= self.start && from <= self.end) { + continue; + } + windows.retain(|&(from, to)| to >= self.start - NEAR_DAYS && from <= self.end + NEAR_DAYS); + windows.sort_by(|a, b| a.0.total_cmp(&b.0)); + exact.retain(|&(jd, _)| self.inside(jd)); + exact.sort_by(|a, b| a.0.total_cmp(&b.0)); + // The closest approach inside the year among the samples. + let (closest_i, closest) = (0..s.lon.len()) + .filter(|&i| self.inside(s.jd(i))) + .map(|i| (i, separation(s.lon[i], natal))) + .map(|(i, sep)| (i, (sep - a).abs())) + .min_by(|x, y| x.1.total_cmp(&y.1)) + .unwrap_or((0, ORB)); + let (peak_jd, min_orb) = match exact.first() { + Some(&(jd, _)) => (jd, 0.0), + None => (s.jd(closest_i), closest), + }; + let peak_lon = lon_at(peak_jd)?; + out.push(Contact { + planet, + natal_point, + aspect, + nature: aspect.nature(), + exact: exact.iter().map(|&(jd, retrograde)| Exact { date: self.date(jd), retrograde }).collect(), + periods: if with_periods { + windows + .iter() + .map(|&(from, to)| DateRange { start: self.date(from), end: self.date(to) }) + .collect() + } else { + Vec::new() + }, + peak: self.date(peak_jd), + min_orb: (min_orb * 100.0).round() / 100.0, + house: self.cusps.map(|c| house_of(peak_lon, &c)), + peak_jd, + }); + } + } + Ok(out) + } + + fn position(&self, body: Body, jd: f64) -> Result<(f64, f64)> { + let s = self.engine.position(body, jd, &self.frame)?; + Ok((s.longitude, s.speed_longitude)) + } + + fn transits(&self) -> Result<(Vec, Vec)> { + let targets = natal_targets(self.natal); + let mut contacts = Vec::new(); + let mut houses = Vec::new(); + for body in TRANSITING { + let at = |jd: f64| self.position(body, jd); + let lon_at = |jd: f64| at(jd).map(|(l, _)| l); + let s = Samples::take(self.start - MARGIN_DAYS, self.end + MARGIN_DAYS, 1.0, &at)?; + let planet = PointId::from_planet(body); + contacts.extend(self.contacts(planet, &s, &lon_at, &targets, true)?); + if let Some(cusps) = self.cusps { + houses.push(self.house_changes(planet, &s, &cusps)); + } + } + contacts.sort_by(|a, b| a.peak_jd.total_cmp(&b.peak_jd)); + Ok((contacts, houses)) + } + + /// The natal house a sampled planet is in at the start, and when it changes house during the year. + fn house_changes(&self, planet: PointId, s: &Samples, cusps: &[f64; 12]) -> PlanetHouses { + let in_year: Vec = (0..s.lon.len()).filter(|&i| self.inside(s.jd(i))).collect(); + let first = in_year.first().copied().unwrap_or(0); + let mut current = house_of(s.lon[first], cusps); + let at_start = current; + let mut ingresses = Vec::new(); + for &i in &in_year[1.min(in_year.len())..] { + let house = house_of(s.lon[i], cusps); + if house != current { + ingresses.push(HouseIngress { house, date: self.date(s.jd(i)), retrograde: s.speed[i] < 0.0 }); + current = house; + } + } + PlanetHouses { planet, house_at_start: at_start, ingresses } + } + + fn progressions(&self) -> Result { + let natal_jd = self.natal.astronomy.julian_day_ut; + let progressed = |jd: f64| natal_jd + (jd - natal_jd) / TROPICAL_YEAR; + let known = self.natal.angles.is_some(); + let targets = natal_targets(self.natal); + let mut bodies = Vec::new(); + let mut contacts = Vec::new(); + let mut samples = Vec::new(); + for body in PROGRESSED { + // Motion per real day: the progressed speed divided by the year length. + let at = |jd: f64| self.position(body, progressed(jd)).map(|(l, sp)| (l, sp / TROPICAL_YEAR)); + let lon_at = |jd: f64| at(jd).map(|(l, _)| l); + let s = Samples::take(self.start, self.end, 1.0, &at)?; + let planet = PointId::from_planet(body); + let reliable = known || body != Body::Moon; + if reliable { + // A progressed planet meeting its own natal place only matters for the Moon (the progressed lunar return). + let own: Vec<(PointId, f64)> = + targets.iter().copied().filter(|&(id, _)| id != planet || body == Body::Moon).collect(); + contacts.extend(self.contacts(planet, &s, &lon_at, &own, false)?); + } + let start = ZodiacPosition::new(s.lon[0]); + let mut sign_changes = Vec::new(); + let mut house_changes = Vec::new(); + if reliable { + for i in 1..s.lon.len() { + let sign = ZodiacSign::from_longitude(s.lon[i]); + if sign != ZodiacSign::from_longitude(s.lon[i - 1]) { + sign_changes.push(SignIngress { sign, date: self.date(s.jd(i)) }); + } + if let Some(c) = &self.cusps { + let house = house_of(s.lon[i], c); + if house != house_of(s.lon[i - 1], c) { + house_changes.push(HouseIngress { + house, + date: self.date(s.jd(i)), + retrograde: s.speed[i] < 0.0, + }); + } + } + } + } + bodies.push(ProgressedBody { + planet, + house: self.cusps.map(|c| house_of(s.lon[0], &c)), + position: start, + retrograde: s.speed[0] < 0.0, + approximate: !reliable, + sign_changes, + house_changes, + }); + samples.push(s); + } + contacts.sort_by(|a, b| a.peak_jd.total_cmp(&b.peak_jd)); + + // The progressed lunation phase: the progressed Moon's distance from the progressed Sun. + let (sun, moon) = (&samples[0], &samples[1]); + let phase_at = |i: usize| phase_name((moon.lon[i] - sun.lon[i]).rem_euclid(360.0)); + let lunar_phase = phase_at(0); + let lunar_phase_change = if known { + (1..moon.lon.len()) + .find(|&i| phase_at(i) != lunar_phase) + .map(|i| PhaseChange { phase: phase_at(i), date: self.date(moon.jd(i)) }) + } else { + None + }; + Ok(Progressions { bodies, lunar_phase, lunar_phase_change, contacts }) + } + + fn profection(&self, age: i32) -> Option { + let angles = self.natal.angles.as_ref()?; + let cusps = self.cusps?; + let rising = angles.ascendant.position.sign; + let sign = ZodiacSign::ALL[(rising.index() + age.rem_euclid(12) as usize) % 12]; + let lord = sign.traditional_ruler(); + let lord_lon = natal_lon(self.natal, PointId::from_planet(lord))?; + let planets_in_sign = Body::PLANETS + .iter() + .map(|&b| PointId::from_planet(b)) + .filter(|&id| natal_lon(self.natal, id).is_some_and(|lon| ZodiacSign::from_longitude(lon) == sign)) + .collect(); + Some(Profection { + house: (age.rem_euclid(12) + 1) as u8, + sign, + lord: PointId::from_planet(lord), + lord_sign: ZodiacSign::from_longitude(lord_lon), + lord_house: house_of(lord_lon, &cusps), + planets_in_sign, + }) + } + + fn eclipses(&self) -> Result> { + let targets = natal_targets(self.natal); + let mut out = Vec::new(); + for e in self.engine.eclipses(self.start, self.end)? { + let body = match e.kind { + EclipseKind::Solar => Body::Sun, + EclipseKind::Lunar => Body::Moon, + }; + let (lon, _) = self.position(body, e.jd_ut)?; + let mut contacts: Vec = targets + .iter() + .filter_map(|&(point, natal)| { + let sep = separation(lon, natal); + let (aspect, orb) = if sep <= ECLIPSE_ORB { + (AspectKind::Conjunction, sep) + } else if 180.0 - sep <= ECLIPSE_ORB { + (AspectKind::Opposition, 180.0 - sep) + } else { + return None; + }; + Some(EclipseContact { point, aspect, orb: (orb * 100.0).round() / 100.0 }) + }) + .collect(); + contacts.sort_by(|a, b| a.orb.total_cmp(&b.orb)); + out.push(EclipseHit { + date: self.date(e.jd_ut), + kind: e.kind, + eclipse_type: e.eclipse_type, + house: self.cusps.map(|c| house_of(lon, &c)), + position: ZodiacPosition::new(lon), + contacts, + }); + } + Ok(out) + } +} + +#[derive(Debug, Clone, Serialize)] +pub struct HouseIngress { + pub house: u8, + pub date: String, + pub retrograde: bool, +} + +/// A slow planet's way through the natal houses during the year. +#[derive(Debug, Clone, Serialize)] +pub struct PlanetHouses { + pub planet: PointId, + pub house_at_start: u8, + pub ingresses: Vec, +} + +#[derive(Debug, Clone, Serialize)] +pub struct SignIngress { + pub sign: ZodiacSign, + pub date: String, +} + +/// A progressed planet at the start of the year and its sign and house changes during it. +#[derive(Debug, Clone, Serialize)] +pub struct ProgressedBody { + pub planet: PointId, + #[serde(flatten)] + pub position: ZodiacPosition, + /// Natal house (birth time known). + pub house: Option, + pub retrograde: bool, + /// The progressed Moon without a birth time: may be months off. + pub approximate: bool, + pub sign_changes: Vec, + pub house_changes: Vec, +} + +#[derive(Debug, Clone, Serialize)] +pub struct PhaseChange { + pub phase: MoonPhaseName, + pub date: String, +} + +#[derive(Debug, Clone, Serialize)] +pub struct Progressions { + pub bodies: Vec, + /// Phase of the progressed Moon to the progressed Sun at the start of the year. + pub lunar_phase: MoonPhaseName, + pub lunar_phase_change: Option, + /// Progressed planets in aspect to natal points during the year. + pub contacts: Vec, +} + +/// The annual profection: each year of life activates the next house (whole +/// signs from the Ascendant); the ruler of its sign is the lord of the year. +#[derive(Debug, Clone, Serialize)] +pub struct Profection { + pub house: u8, + pub sign: ZodiacSign, + pub lord: PointId, + pub lord_sign: ZodiacSign, + /// Natal house of the lord. + pub lord_house: u8, + /// Natal planets in the profected sign. + pub planets_in_sign: Vec, +} + +#[derive(Debug, Clone, Serialize)] +pub struct EclipseContact { + pub point: PointId, + /// Conjunction or opposition. + pub aspect: AspectKind, + pub orb: f64, +} + +#[derive(Debug, Clone, Serialize)] +pub struct EclipseHit { + pub date: String, + pub kind: EclipseKind, + pub eclipse_type: EclipseType, + /// The Sun (solar eclipse) or the Moon (lunar eclipse) at the maximum. + #[serde(flatten)] + pub position: ZodiacPosition, + /// Natal house of the eclipse (birth time known). + pub house: Option, + /// Natal points within 3° of the eclipse or its opposite point. + pub contacts: Vec, +} + +/// One year of forecasts for a natal chart. +#[derive(Debug, Clone, Serialize)] +pub struct Forecast { + /// First and last day of the year (solar return to the next one). + pub start: String, + pub end: String, + pub start_jd: f64, + pub end_jd: f64, + /// Completed years of life at the start. + pub age: i32, + /// Only with a known birth time. + pub profection: Option, + /// Slow-planet transits within the year, by their peak date. + pub transits: Vec, + /// The slow planets' natal houses (birth time known). + pub transit_houses: Vec, + pub progressions: Progressions, + pub eclipses: Vec, + #[serde(skip_serializing_if = "Vec::is_empty")] + pub warnings: Vec, +} + +/// Forecasts for the year from `start_jd` to `end_jd` (normally a solar return +/// and the next one); dates are given at `offset_hours` from UTC. +pub fn calculate_forecast( + engine: &dyn Ephemeris, + natal: &NatalChart, + start_jd: f64, + end_jd: f64, + offset_hours: f64, +) -> Result { + if end_jd <= start_jd || end_jd - start_jd > 400.0 { + return Err(EngineError::Calculation("the forecast period must be at most about a year".into())); + } + let year = Year { + engine, + natal, + frame: frame_of(natal), + start: start_jd, + end: end_jd, + offset: offset_hours, + cusps: cusps_of(natal), + }; + let age = ((start_jd - natal.astronomy.julian_day_ut) / TROPICAL_YEAR).round() as i32; + let (transits, transit_houses) = year.transits()?; + let mut warnings = Vec::new(); + if natal.angles.is_none() { + warnings.push( + "Birth time unknown: no profection, houses or angles, and the Moon (natal and progressed) is left out of \ + the contacts." + .into(), + ); + } + Ok(Forecast { + start: year.date(start_jd), + end: year.date(end_jd), + start_jd, + end_jd, + age, + profection: year.profection(age), + transits, + transit_houses, + progressions: year.progressions()?, + eclipses: year.eclipses()?, + warnings, + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn signed_difference() { + assert_eq!(diff(10.0, 350.0), 20.0); + assert_eq!(diff(350.0, 10.0), -20.0); + assert_eq!(diff(180.0, 0.0), -180.0); + } + + #[test] + fn dates_at_an_offset() { + // 2000-01-01 12:00 UT + assert_eq!(date_of(2_451_545.0, 0.0), "2000-01-01"); + // 23:30 UT is the next day at UTC+1 + assert_eq!(date_of(2_451_545.479_2, 1.0), "2000-01-02"); + } +} diff --git a/crates/astro-engine/src/lib.rs b/crates/astro-engine/src/lib.rs index 11c964a..499f0f0 100644 --- a/crates/astro-engine/src/lib.rs +++ b/crates/astro-engine/src/lib.rs @@ -4,11 +4,14 @@ //! Swiss Ephemeris, see [`swiss::SwissEphemeris`]); everything astrological on //! top of it (signs, houses, aspects, dignities, lots, summaries) lives in //! [`chart`] and is independent of the engine, so the engine can be replaced -//! without touching the chart logic. [`synastry`] compares two charts. +//! without touching the chart logic. [`synastry`] compares two charts; +//! [`forecast`] looks at one year of a chart (solar return, transits, +//! progressions, profection, eclipses). pub mod angle; pub mod chart; pub mod engine; +pub mod forecast; pub mod synastry; pub mod time; pub mod types; @@ -17,6 +20,10 @@ pub mod types; pub mod swiss; pub use chart::{ChartInput, ChartOptions, NatalChart, calculate_chart}; -pub use engine::{BodyState, EngineError, Ephemeris, EphemerisInfo, Frame, GeoPosition, HouseResult, Obliquity}; +pub use engine::{ + BodyState, EclipseEvent, EclipseKind, EclipseType, EngineError, Ephemeris, EphemerisInfo, Frame, GeoPosition, + HouseResult, Obliquity, +}; +pub use forecast::{Forecast, calculate_forecast, solar_return}; pub use synastry::{Synastry, calculate_synastry}; pub use types::{AspectSet, Ayanamsa, Body, HouseSystem, LilithType, NodeType, ZodiacSign, ZodiacType}; diff --git a/crates/astro-engine/src/swiss.rs b/crates/astro-engine/src/swiss.rs index de4c8f4..3663af0 100644 --- a/crates/astro-engine/src/swiss.rs +++ b/crates/astro-engine/src/swiss.rs @@ -14,7 +14,8 @@ use swisseph_sys as sys; use crate::angle::normalize; use crate::engine::{ - BodyState, EngineError, Ephemeris, EphemerisInfo, Frame, GeoPosition, HouseResult, Obliquity, Result, + BodyState, EclipseEvent, EclipseKind, EclipseType, EngineError, Ephemeris, EphemerisInfo, Frame, GeoPosition, + HouseResult, Obliquity, Result, }; use crate::types::{Ayanamsa, Body, HouseSystem}; @@ -324,6 +325,65 @@ impl Ephemeris for SwissEphemeris { } Ok(daya) } + + fn eclipses(&self, from_jd: f64, to_jd: f64) -> Result> { + let _guard = lock(); + let mut out = Vec::new(); + for kind in [EclipseKind::Solar, EclipseKind::Lunar] { + let mut start = from_jd; + loop { + let mut tret = [0.0f64; 10]; + let mut serr = [0 as c_char; sys::AS_MAXCH]; + // SAFETY: tret has the 10 elements and serr the AS_MAXCH bytes the API requires. + let ret = unsafe { + match kind { + EclipseKind::Solar => sys::swe_sol_eclipse_when_glob( + start, + sys::SEFLG_SWIEPH, + 0, + tret.as_mut_ptr(), + 0, + serr.as_mut_ptr(), + ), + EclipseKind::Lunar => sys::swe_lun_eclipse_when( + start, + sys::SEFLG_SWIEPH, + sys::SE_ECL_TOTAL | sys::SE_ECL_PARTIAL, + tret.as_mut_ptr(), + 0, + serr.as_mut_ptr(), + ), + } + }; + if ret == sys::ERR { + return Err(EngineError::Calculation(c_string(&serr))); + } + let jd = tret[0]; + if jd > to_jd { + break; + } + out.push(EclipseEvent { kind, eclipse_type: eclipse_type(ret), jd_ut: jd }); + // Eclipses of one kind are at least two weeks apart. + start = jd + 10.0; + } + } + out.sort_by(|a, b| a.jd_ut.total_cmp(&b.jd_ut)); + Ok(out) + } +} + +fn eclipse_type(flags: i32) -> EclipseType { + if flags & sys::SE_ECL_ANNULAR_TOTAL != 0 { + EclipseType::Hybrid + } else if flags & sys::SE_ECL_TOTAL != 0 { + EclipseType::Total + } else if flags & sys::SE_ECL_ANNULAR != 0 { + EclipseType::Annular + } else if flags & sys::SE_ECL_PARTIAL != 0 { + EclipseType::Partial + } else { + EclipseType::Penumbral + } } #[cfg(test)] diff --git a/crates/astro-engine/tests/swiss_reference.rs b/crates/astro-engine/tests/swiss_reference.rs index 8f97c39..6fb876b 100644 --- a/crates/astro-engine/tests/swiss_reference.rs +++ b/crates/astro-engine/tests/swiss_reference.rs @@ -163,3 +163,57 @@ fn sidereal_zodiac_subtracts_ayanamsa() { assert!((23.0..24.5).contains(&ayanamsa), "lahiri ayanamsa {ayanamsa}"); assert!(close(tropical.longitude - sidereal.longitude, ayanamsa, 1e-3)); } + +#[test] +fn eclipses_of_2026() { + use astro_engine::{EclipseKind, EclipseType}; + // 2026-01-01 .. 2027-01-01 (UT): annular 17 Feb, total lunar 3 Mar, total solar 12 Aug, partial lunar 28 Aug. + let found = engine().eclipses(2_461_041.5, 2_461_406.5).unwrap(); + let list: Vec<(EclipseKind, EclipseType, String)> = + found.iter().map(|e| (e.kind, e.eclipse_type, astro_engine::forecast::date_of(e.jd_ut, 0.0))).collect(); + assert_eq!( + list, + vec![ + (EclipseKind::Solar, EclipseType::Annular, "2026-02-17".into()), + (EclipseKind::Lunar, EclipseType::Total, "2026-03-03".into()), + (EclipseKind::Solar, EclipseType::Total, "2026-08-12".into()), + (EclipseKind::Lunar, EclipseType::Partial, "2026-08-28".into()), + ] + ); +} + +#[test] +fn solar_return_and_forecast() { + use astro_engine::chart::PointId; + use astro_engine::{calculate_forecast, solar_return}; + let input = ChartInput { jd_ut: JD, observer: BUDAPEST, time_known: true, options: ChartOptions::default() }; + let natal = calculate_chart(engine(), &input).unwrap(); + let sr = solar_return(engine(), &natal, 2026).unwrap(); + // The Sun is back at 112.0007251° (Cancer 22°) on 14 July 2026. + let sun = engine().position(Body::Sun, sr, &Frame::TROPICAL_GEOCENTRIC).unwrap(); + assert!(close(sun.longitude, 112.0007251, 1e-6), "{}", sun.longitude); + assert_eq!(astro_engine::forecast::date_of(sr, 2.0), "2026-07-14"); + let next = solar_return(engine(), &natal, 2027).unwrap(); + assert!((next - sr - 365.25).abs() < 0.1); + + let f = calculate_forecast(engine(), &natal, sr, next, 2.0).unwrap(); + assert_eq!(f.age, 41); + assert_eq!((f.start.as_str(), f.end.as_str()), ("2026-07-14", "2027-07-14")); + // Age 41: the 6th house from a Scorpio Ascendant (Aries), lord Mars. + let p = f.profection.as_ref().unwrap(); + assert_eq!(p.house, 6); + assert_eq!(p.sign, astro_engine::ZodiacSign::Aries); + assert_eq!(p.lord, PointId::Mars); + // Every transit touches the year, has a peak inside it and exact hits inside it. + assert!(!f.transits.is_empty()); + for t in &f.transits { + assert!(t.peak.as_str() >= f.start.as_str() && t.peak.as_str() <= f.end.as_str(), "{t:?}"); + assert!(t.min_orb <= 1.0 && !t.periods.is_empty()); + assert!(t.exact.iter().all(|e| e.date >= f.start && e.date <= f.end)); + } + assert_eq!(f.transit_houses.len(), 5); + assert_eq!(f.progressions.bodies.len(), 5); + // The partial lunar eclipse of 28 Aug 2026 and the two in early 2027 fall in this year. + assert!(f.eclipses.iter().any(|e| e.date == "2026-08-28")); + serde_json::to_string(&f).unwrap(); +} diff --git a/crates/db/migrations/0015_forecasts.sql b/crates/db/migrations/0015_forecasts.sql new file mode 100644 index 0000000..fde1e03 --- /dev/null +++ b/crates/db/migrations/0015_forecasts.sql @@ -0,0 +1,39 @@ +-- Yearly forecasts: one year of a chart from a solar return (birthday) to the +-- next, calculated by the horoscope service for where the person is on the +-- birthday. The calculation is free; its detailed text analysis (kind +-- 'forecast') uses a 'forecast' unit. +CREATE TABLE forecasts ( + id uuid PRIMARY KEY, + chart_id uuid NOT NULL REFERENCES charts ON DELETE CASCADE, + -- The chart it was calculated from; a corrected birth data gives a new forecast. + chart_hash text NOT NULL, + -- Calendar year of the solar return that starts it. + year integer NOT NULL, + -- {country, place, geonames_id, ...}; NULL = the birth place. + location jsonb, + location_key text NOT NULL, + result jsonb NOT NULL, + forecast_hash text NOT NULL, + created_by uuid REFERENCES users ON DELETE SET NULL, + created_at timestamptz NOT NULL DEFAULT now(), + UNIQUE (chart_id, chart_hash, year, location_key) +); + +CREATE INDEX forecasts_chart_idx ON forecasts (chart_id, year DESC); + +ALTER TABLE analyses ADD COLUMN forecast_id uuid REFERENCES forecasts ON DELETE CASCADE; +CREATE INDEX analyses_forecast_idx ON analyses (forecast_id, created_at DESC) WHERE forecast_id IS NOT NULL; + +ALTER TABLE analyses DROP CONSTRAINT analyses_kind_check; +ALTER TABLE analyses ADD CONSTRAINT analyses_kind_check CHECK (kind IN ('natal', 'synastry', 'summary', 'forecast')); + +ALTER TABLE analyses DROP CONSTRAINT analyses_target; +ALTER TABLE analyses ADD CONSTRAINT analyses_target CHECK ( + (kind IN ('natal', 'summary') AND chart_id IS NOT NULL AND synastry_id IS NULL AND forecast_id IS NULL) + OR (kind = 'synastry' AND synastry_id IS NOT NULL AND chart_id IS NULL AND forecast_id IS NULL) + OR (kind = 'forecast' AND forecast_id IS NOT NULL AND chart_id IS NULL AND synastry_id IS NULL) +); + +ALTER TABLE credit_ledger DROP CONSTRAINT credit_ledger_unit_check; +ALTER TABLE credit_ledger ADD CONSTRAINT credit_ledger_unit_check + CHECK (unit IN ('natal', 'synastry', 'forecast', 'person')); diff --git a/crates/horoscope-client/src/lib.rs b/crates/horoscope-client/src/lib.rs index d24355c..f7df0d1 100644 --- a/crates/horoscope-client/src/lib.rs +++ b/crates/horoscope-client/src/lib.rs @@ -43,6 +43,11 @@ impl HoroscopeClient { self.post("/v1/synastry", request).await } + /// `POST /v1/forecast` + pub async fn forecast(&self, request: &Value) -> Result { + self.post("/v1/forecast", request).await + } + async fn post(&self, path: &str, body: &Value) -> Result { let response = self .http diff --git a/crates/swisseph-sys/src/lib.rs b/crates/swisseph-sys/src/lib.rs index bb320e6..7cfea28 100644 --- a/crates/swisseph-sys/src/lib.rs +++ b/crates/swisseph-sys/src/lib.rs @@ -55,6 +55,12 @@ pub const SE_SIDM_YUKTESHWAR: i32 = 7; pub const SE_SIDM_GALCENT_0SAG: i32 = 17; pub const SE_SIDM_TRUE_CITRA: i32 = 27; +pub const SE_ECL_TOTAL: i32 = 4; +pub const SE_ECL_ANNULAR: i32 = 8; +pub const SE_ECL_PARTIAL: i32 = 16; +pub const SE_ECL_ANNULAR_TOTAL: i32 = 32; +pub const SE_ECL_PENUMBRAL: i32 = 64; + unsafe extern "C" { pub fn swe_version(s: *mut c_char) -> *mut c_char; pub fn swe_set_ephe_path(path: *const c_char); @@ -100,6 +106,24 @@ unsafe extern "C" { dret: *mut c_double, serr: *mut c_char, ) -> i32; + /// Next (or previous) solar eclipse anywhere on Earth; `tret[0]` = maximum (UT). + pub fn swe_sol_eclipse_when_glob( + tjd_start: c_double, + ifl: i32, + ifltype: i32, + tret: *mut c_double, + backward: i32, + serr: *mut c_char, + ) -> i32; + /// Next (or previous) lunar eclipse; `tret[0]` = maximum (UT). + pub fn swe_lun_eclipse_when( + tjd_start: c_double, + ifl: i32, + ifltype: i32, + tret: *mut c_double, + backward: i32, + serr: *mut c_char, + ) -> i32; pub fn swe_deltat_ex(tjd: c_double, iflag: i32, serr: *mut c_char) -> c_double; pub fn swe_sidtime(tjd_ut: c_double) -> c_double; } diff --git a/docs/csomagok.md b/docs/csomagok.md index 4fd9c25..c024f86 100644 --- a/docs/csomagok.md +++ b/docs/csomagok.md @@ -4,32 +4,35 @@ A katalógus a kódban van: `services/backend/src/packages.rs` (`CATALOG`). Ár- ## Költség -Egy részletes képletelemzés és egy kapcsolati elemzés is kb. **$0,21 (≈ 80 Ft)** Opus 5.5-tel; a rövid összefoglaló kb. $0,01. A fizetési szolgáltató díja kb. 1,5% + 85 Ft tranzakciónként. Az árak bruttók (27% áfa). +Egy részletes képletelemzés és egy kapcsolati elemzés is kb. **$0,21 (≈ 80 Ft)** Opus 5.5-tel, az éves előrejelzés a hosszabb adatsor miatt valamivel több; a rövid összefoglaló kb. $0,01. A fizetési szolgáltató díja kb. 1,5% + 85 Ft tranzakciónként. Az árak bruttók (27% áfa). ## A lépcső | Csomag | Tartalom | Ár | Elemzésenként | Külön megvéve | Megtakarítás | |---|---|---|---|---|---| | Egy elemzés | 1 képletelemzés | 2 000 Ft | 2 000 Ft | – | – | -| Páros | 2 képletelemzés, 1 kapcsolati, 1 személy | 4 500 Ft | 1 500 Ft | 6 800 Ft | 34% | -| **Család** (Legnépszerűbb) | 6 képletelemzés, 5 kapcsolati, 5 személy | 8 000 Ft | 727 Ft | 26 000 Ft | 69% | +| Páros | 2 képletelemzés, 2 éves előrejelzés, 1 kapcsolati, 1 személy | 6 000 Ft | 1 200 Ft | 11 800 Ft | 49% | +| **Család** (Legnépszerűbb) | 6 képletelemzés, 6 éves előrejelzés, 5 kapcsolati, 5 személy | 11 000 Ft | 647 Ft | 41 000 Ft | 73% | | +1 kapcsolati elemzés | kiegészítő | 2 500 Ft | | | | +| +1 éves előrejelzés | kiegészítő | 2 500 Ft | | | | | +5 személy | kiegészítő | 1 500 Ft | | | | -A „külön megvéve” ár egységárakból jön: képletelemzés 2 000 Ft, kapcsolati elemzés 2 500 Ft, személy 300 Ft (`NATAL_PRICE`, `SYNASTRY_PRICE`, `PERSON_PRICE`). +A „külön megvéve” ár egységárakból jön: képletelemzés 2 000 Ft, kapcsolati elemzés 2 500 Ft, éves előrejelzés 2 500 Ft, személy 300 Ft (`NATAL_PRICE`, `SYNASTRY_PRICE`, `FORECAST_PRICE`, `PERSON_PRICE`). + +Az éves előrejelzés (2026 novembere óta) a Páros és a Család csomagban mindenkinek benne van; külön megvéve drágább, mint egy képletelemzés. Az Egy elemzés csomag változatlanul egy képletelemzés 2 000 Ft-ért. Részletek: `docs/elorejelzes.md`. ## Miért így (a nagyobb felé terelés) - **Horgony:** az Egy elemzés ára (2 000 Ft) az egységár. Minden más ehhez mérve látszik olcsónak; a kártyákon áthúzva ott a „külön megvéve” ár. -- **Kis lépések, nagy ugrások:** minden szint csak egy kicsivel drágább az előzőnél, de sokkal többet ad. Páros: +2 500 Ft-ért háromszor annyi elemzés. Család: +3 500 Ft-ért majdnem négyszer annyi. A kártyán ki is írjuk: „Csak +3 500 Ft a Páros csomaghoz képest”. -- **Csali:** a Páros szándékosan „csak jó” ajánlat (−34%), hogy mellette a Család (−69%) kiugorjon. A Család kapja a kiemelést és a „Legnépszerűbb” címkét. -- **Drága kiegészítők:** a +1 kapcsolati elemzés 2 500 Ft, többe kerül, mint egy képletelemzés, és a Páros alig kétszer ennyiért ad egyet, kettőtök képletével együtt. Aki darabonként venne, annak jobban megéri csomagot venni. +- **Kis lépések, nagy ugrások:** minden szint csak egy kicsivel drágább az előzőnél, de sokkal többet ad. Páros: +4 000 Ft-ért ötször annyi elemzés. Család: +5 000 Ft-ért több mint háromszor annyi. A kártyán ki is írjuk: „Csak +5 000 Ft a Páros csomaghoz képest”. +- **Csali:** a Páros szándékosan „csak jó” ajánlat (−49%), hogy mellette a Család (−73%) kiugorjon. A Család kapja a kiemelést és a „Legnépszerűbb” címkét. +- **Drága kiegészítők:** a +1 kapcsolati elemzés és a +1 éves előrejelzés 2 500 Ft, többe kerül, mint egy képletelemzés, és a Páros alig kétszer ennyiért ad egyet, kettőtök képletével együtt. Aki darabonként venne, annak jobban megéri csomagot venni. - **A vásárlás pillanatában** (a „Részletes elemzés kérése” után) nem egy darabot kínálunk, hanem három csomagot egymás mellett, kiemelt Családdal. - **Nem jár le:** a megvett elemzések megmaradnak, ezért a nagyobb csomag nem kockázat a vevőnek. ## Miért nincs korlátlan csomag -2026 novemberéig volt egy éves Korlátlan csomag (17 990 Ft, napi 5 elemzés). Kivettük: egy asztrológus vagy bárki, aki másoknak készít elemzést, egy csomag áráért több száz elemzést kérhetett volna, és tovább is adhatta volna őket. Most minden elemzés egy egységet használ, így a tömeges használat is darabra fizet; a legnagyobb csomagban is elemzésenként kb. 730 Ft, ami bőven a kb. 80 Ft-os költség fölött van. A `0014` migráció a meglévő (csak próbafizetéssel vagy admin által adott) korlátlan jogosultságokat törölte; a régi rendelések a `package_orders` táblában maradnak, de a fejlécben már nem jelennek meg. +2026 novemberéig volt egy éves Korlátlan csomag (17 990 Ft, napi 5 elemzés). Kivettük: egy asztrológus vagy bárki, aki másoknak készít elemzést, egy csomag áráért több száz elemzést kérhetett volna, és tovább is adhatta volna őket. Most minden elemzés egy egységet használ, így a tömeges használat is darabra fizet; a legnagyobb csomagban is elemzésenként kb. 650 Ft, ami bőven a kb. 80 Ft-os költség fölött van. A `0014` migráció a meglévő (csak próbafizetéssel vagy admin által adott) korlátlan jogosultságokat törölte; a régi rendelések a `package_orders` táblában maradnak, de a fejlécben már nem jelennek meg. ## Későbbre diff --git a/docs/elorejelzes.md b/docs/elorejelzes.md new file mode 100644 index 0000000..67c9ae4 --- /dev/null +++ b/docs/elorejelzes.md @@ -0,0 +1,38 @@ +# Éves előrejelzés + +Egy év születésnaptól születésnapig, több bevett előrejelző módszerből összerakva, ahogy egy asztrológus éves konzultációja is. + +## Módszerek + +| Módszer | Mit ad | Hol számolódik | +|---|---|---| +| **Szolár** (szoláris visszatérés) | Az a pillanat, amikor a Nap visszatér a születéskori hosszúságára; az erre a pillanatra és a születésnapi tartózkodási helyre felállított képlet „az év képlete”. | `astro_engine::forecast::solar_return`, a képlet a horoscope-api-ban | +| **Tranzitok** | A Jupiter, Szaturnusz, Uránusz, Neptunusz és Plútó fő fényszögei (együttállás, szextil, kvadrát, trigon, szembenállás) a tíz bolygóhoz, az Aszcendenshez és az MC-hez, 1° hatásfokkal: pontos dátumok (retrográd áthaladásokkal) és hatásidők. A lassú bolygók házai és házváltásai. | `forecast.rs`, `Year::transits` | +| **Szekunder direkció** | „Egy nap = egy év”: a progresszív Nap, Hold, Merkúr, Vénusz, Mars helye, jegy- és házváltásai, fényszögei a születési képlethez, a progresszív holdfázis. | `Year::progressions` | +| **Éves profekció** | Minden életév egy házat aktivál (egész jegyes házak az Aszcendenstől); a jegy hagyományos uralkodója „az év ura”. | `Year::profection` | +| **Fogyatkozások** | Az év nap- és holdfogyatkozásai (a félárnyékos holdfogyatkozás nélkül), a születési házuk, és ha 3°-on belül érintenek egy születési pontot. | Swiss Ephemeris `swe_sol_eclipse_when_glob`, `swe_lun_eclipse_when` | + +A dátumok a születésnapi hely időzónájában értendő naptári napok. Egy év számítása kb. 0,2 másodperc. + +**Ismeretlen születési idő:** nincs szolár képlet (a pillanat akár fél napot is tévedhet), nincs profekció, ház és tengely; a Hold kimarad a fényszögekből. A tranzitok és a progresszió megmaradnak. + +## Folyamat + +1. `POST /v1/charts/{id}/forecasts` (`{year?, location?}`): a backend a képlet születési adataival hívja a horoscope-api `POST /v1/forecast` végpontját, és az eredményt a `forecasts` táblába menti. Ingyenes; ugyanaz a kérés a meglévőt adja vissza. + - A felhasználó a mostani életévét, és a születésnapja előtti 30 napban a következőt kérheti; admin bármelyiket. + - Képletenként legfeljebb 20 előrejelzés (év × hely). + - Javított születési adatnál új előrejelzés készül (a kulcsban benne van a `chart_hash`). +2. Az oldal (`/kepletek/{id}/elorejelzes`) ebből ingyen mutatja a szolár kört, „az év kulcsait” és a havi idővonalat. +3. `POST /v1/forecasts/{id}/analyses`: a részletes szöveg egy `forecast` egységet használ (admin: ingyen). A worker a `compact::forecast` szövegből és az `analysis-prompt` `Forecast` fajtájából írja: öt fejezet (az év témája, kapcsolatok, munka, belső fejlődés, negyedéves idővonal), lehetőségek, kihívások, útravaló. + +A modellhez nem megy születési dátum, hely vagy pontos életkor (csak évtized), a születésnapi hely sem. + +## Megfogalmazás + +Trendekről, lehetőségekről és időzítésről szól, nem biztos eseményekről. Betegségről, halálról, balesetről, terhességről, perekről és pénzügyi nyereségről vagy veszteségről nem jósol (`FORECAST_RULES` a promptban). + +## Később + +- Havi előrejelzés: holdvisszatérés és a hónap gyorsabb tranzitjai (Mars, Vénusz, Nap). +- Tranzitok a kompozit képletre: „mi vár rátok idén”. +- Az admin promptszerkesztőben az előrejelzés promptja is szerkeszthető legyen. diff --git a/services/backend/src/credits.rs b/services/backend/src/credits.rs index a7e5abf..9cc9c8e 100644 --- a/services/backend/src/credits.rs +++ b/services/backend/src/credits.rs @@ -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 { - 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 diff --git a/services/backend/src/packages.rs b/services/backend/src/packages.rs index c18e822..6200111 100644 --- a/services/backend/src/packages.rs +++ b/services/backend/src/packages.rs @@ -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())); diff --git a/services/backend/src/routes/account.rs b/services/backend/src/routes/account.rs index 149b7cf..ea7a90b 100644 --- a/services/backend/src/routes/account.rs +++ b/services/backend/src/routes/account.rs @@ -156,7 +156,8 @@ pub async fn export(State(state): St, auth: AuthUser) -> ApiResult, Vec, bool, OffsetDateTime, Option, i64, i64, i64); + type Row = + (Uuid, String, Option, Vec, bool, OffsetDateTime, Option, i64, i64, i64, i64); let rows: Vec = 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 = 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(); diff --git a/services/backend/src/routes/analyses.rs b/services/backend/src/routes/analyses.rs index ba92879..8b7f120 100644 --- a/services/backend/src/routes/analyses.rs +++ b/services/backend/src/routes/analyses.rs @@ -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, pub synastry_id: Option, + pub forecast_id: Option, pub language: String, pub prompt_version: String, pub status: String, @@ -48,7 +50,8 @@ pub struct AnalysisRow { pub completed_at: Option, } -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, .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 { 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, ) -> 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 = 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::) .bind(i32::from(unit.is_some())) .bind(None::) + .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> { + 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)> { + 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 +} diff --git a/services/backend/src/routes/forecasts.rs b/services/backend/src/routes/forecasts.rs new file mode 100644 index 0000000..851d040 --- /dev/null +++ b/services/backend/src/routes/forecasts.rs @@ -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, + 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, 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 { + let text = chart.result.pointer("/time/date")?.as_str()?; + let mut parts = text.split('-').map(str::parse::); + 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::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 { + 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, + #[serde(default, skip_serializing_if = "Option::is_none")] + region: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + geonames_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + latitude: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + longitude: Option, +} + +#[derive(Debug, Deserialize, Default)] +#[serde(deny_unknown_fields)] +pub struct CreateForecast { + /// Defaults to the current year of life. + year: Option, + /// Defaults to the birth place. + location: Option, +} + +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 { + 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> { + let chart = owned_chart(&state.db, id, auth.id()).await?; + let rows: Vec = + 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::>(), + }))) +} + +/// 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, +) -> ApiResult<(StatusCode, Json)> { + 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 = 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> { + 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]); + } +} diff --git a/services/backend/src/routes/mod.rs b/services/backend/src/routes/mod.rs index 1814018..a450ed1 100644 --- a/services/backend/src/routes/mod.rs +++ b/services/backend/src/routes/mod.rs @@ -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) -> 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)) diff --git a/services/backend/src/routes/payments.rs b/services/backend/src/routes/payments.rs index 3dec5e0..0d89cd2 100644 --- a/services/backend/src/routes/payments.rs +++ b/services/backend/src/routes/payments.rs @@ -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())), }; diff --git a/services/backend/src/tests.rs b/services/backend/src/tests.rs index 4d0ad66..079ed9a 100644 --- a/services/backend/src/tests.rs +++ b/services/backend/src/tests.rs @@ -39,7 +39,7 @@ async fn fake_natal(Json(body): Json) -> (StatusCode, Json) { 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) -> (StatusCode, Json) { ) } +async fn fake_forecast(Json(body): Json) -> (StatusCode, Json) { + 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 { 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); +} diff --git a/services/frontend/src/app/admin/AdminUsers.tsx b/services/frontend/src/app/admin/AdminUsers.tsx index fd57d31..ff595f2 100644 --- a/services/frontend/src/app/admin/AdminUsers.tsx +++ b/services/frontend/src/app/admin/AdminUsers.tsx @@ -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("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}
szinasztria {user.analyses_left.synastry} +
+ előrejelzés {user.analyses_left.forecast ?? 0}