Compare commits
14
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
c20ab45c9d | ||
|
|
f1bd34c394 | ||
|
|
cf625abff2 | ||
|
|
829c33e52f | ||
|
|
03ce97eeaf | ||
|
|
6d2ad4aa0c | ||
|
|
85977cb7af | ||
|
|
742b88183b | ||
|
|
2032837aad | ||
|
|
21640ffd9e | ||
|
|
7f761a0f0e | ||
|
|
30b26340a0 | ||
|
|
7272d0f1f3 | ||
|
|
b53cadcd8c |
@@ -59,7 +59,7 @@ jobs:
|
||||
# astro-engine and horoscope-api need the Swiss Ephemeris sources and
|
||||
# data (scripts/fetch-deps.sh); their tests run locally.
|
||||
- name: Test
|
||||
run: cargo test --locked -p backend -p worker -p db -p horoscope-client -p service-kit -p analysis-prompt
|
||||
run: cargo test --locked -p backend -p worker -p db -p horoscope-client -p service-kit -p analysis-prompt -p email-templates
|
||||
|
||||
build:
|
||||
needs: test
|
||||
|
||||
Generated
+12
@@ -169,6 +169,7 @@ dependencies = [
|
||||
"axum",
|
||||
"axum-extra",
|
||||
"db",
|
||||
"email-templates",
|
||||
"horoscope-client",
|
||||
"http-body-util",
|
||||
"jsonwebtoken",
|
||||
@@ -446,6 +447,13 @@ dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "email-templates"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "email_address"
|
||||
version = "0.2.9"
|
||||
@@ -2867,13 +2875,17 @@ dependencies = [
|
||||
"analysis-prompt",
|
||||
"anyhow",
|
||||
"axum",
|
||||
"base64 0.22.1",
|
||||
"db",
|
||||
"email-templates",
|
||||
"hmac",
|
||||
"lettre",
|
||||
"rand 0.9.5",
|
||||
"reqwest",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"service-kit",
|
||||
"sha2",
|
||||
"sqlx",
|
||||
"time",
|
||||
"tokio",
|
||||
|
||||
@@ -8,6 +8,7 @@ members = [
|
||||
"crates/db",
|
||||
"crates/horoscope-client",
|
||||
"crates/analysis-prompt",
|
||||
"crates/email-templates",
|
||||
"services/horoscope-api",
|
||||
"services/backend",
|
||||
"services/worker",
|
||||
@@ -27,12 +28,14 @@ service-kit = { path = "crates/service-kit" }
|
||||
db = { path = "crates/db" }
|
||||
horoscope-client = { path = "crates/horoscope-client" }
|
||||
analysis-prompt = { path = "crates/analysis-prompt" }
|
||||
email-templates = { path = "crates/email-templates" }
|
||||
|
||||
anyhow = "1"
|
||||
argon2 = { version = "0.5", features = ["std"] }
|
||||
axum = "0.8"
|
||||
axum-extra = { version = "0.10", features = ["cookie"] }
|
||||
base64 = "0.22"
|
||||
hmac = "0.12"
|
||||
jsonwebtoken = { version = "9", default-features = false }
|
||||
lettre = { version = "0.11", default-features = false, features = ["builder", "hostname", "smtp-transport", "tokio1", "tokio1-rustls", "webpki-roots", "ring"] }
|
||||
rand = "0.9"
|
||||
|
||||
@@ -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<id>`, 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<i64>) {
|
||||
@@ -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);
|
||||
|
||||
@@ -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)]
|
||||
|
||||
@@ -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<f64>;
|
||||
|
||||
/// 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<Vec<EclipseEvent>>;
|
||||
}
|
||||
|
||||
@@ -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<T> = std::result::Result<T, EngineError>;
|
||||
|
||||
/// 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<f64> {
|
||||
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<f64> {
|
||||
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<f64> {
|
||||
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<Window>, Vec<(f64, bool)>);
|
||||
|
||||
/// Longitude and daily motion sampled at equal steps.
|
||||
struct Samples {
|
||||
start: f64,
|
||||
step: f64,
|
||||
lon: Vec<f64>,
|
||||
speed: Vec<f64>,
|
||||
}
|
||||
|
||||
impl Samples {
|
||||
fn take(from: f64, to: f64, step: f64, at: &dyn Fn(f64) -> Result<(f64, f64)>) -> Result<Self> {
|
||||
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<f64>) -> Result<Crossings> {
|
||||
let d: Vec<f64> = s.lon.iter().map(|&l| diff(l, target)).collect();
|
||||
let mut windows = Vec::new();
|
||||
let mut open: Option<usize> = 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<Exact>,
|
||||
/// 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<DateRange>,
|
||||
/// 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<u8>,
|
||||
#[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<f64>,
|
||||
targets: &[(PointId, f64)],
|
||||
with_periods: bool,
|
||||
) -> Result<Vec<Contact>> {
|
||||
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<Contact>, Vec<PlanetHouses>)> {
|
||||
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<usize> = (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<Progressions> {
|
||||
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<Profection> {
|
||||
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<Vec<EclipseHit>> {
|
||||
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<EclipseContact> = 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<HouseIngress>,
|
||||
}
|
||||
|
||||
#[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<u8>,
|
||||
pub retrograde: bool,
|
||||
/// The progressed Moon without a birth time: may be months off.
|
||||
pub approximate: bool,
|
||||
pub sign_changes: Vec<SignIngress>,
|
||||
pub house_changes: Vec<HouseIngress>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct PhaseChange {
|
||||
pub phase: MoonPhaseName,
|
||||
pub date: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct Progressions {
|
||||
pub bodies: Vec<ProgressedBody>,
|
||||
/// Phase of the progressed Moon to the progressed Sun at the start of the year.
|
||||
pub lunar_phase: MoonPhaseName,
|
||||
pub lunar_phase_change: Option<PhaseChange>,
|
||||
/// Progressed planets in aspect to natal points during the year.
|
||||
pub contacts: Vec<Contact>,
|
||||
}
|
||||
|
||||
/// 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<PointId>,
|
||||
}
|
||||
|
||||
#[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<u8>,
|
||||
/// Natal points within 3° of the eclipse or its opposite point.
|
||||
pub contacts: Vec<EclipseContact>,
|
||||
}
|
||||
|
||||
/// 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<Profection>,
|
||||
/// Slow-planet transits within the year, by their peak date.
|
||||
pub transits: Vec<Contact>,
|
||||
/// The slow planets' natal houses (birth time known).
|
||||
pub transit_houses: Vec<PlanetHouses>,
|
||||
pub progressions: Progressions,
|
||||
pub eclipses: Vec<EclipseHit>,
|
||||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||||
pub warnings: Vec<String>,
|
||||
}
|
||||
|
||||
/// 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<Forecast> {
|
||||
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");
|
||||
}
|
||||
}
|
||||
@@ -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};
|
||||
|
||||
@@ -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<Vec<EclipseEvent>> {
|
||||
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)]
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
-- Invitations to the closed site. While SIGNUP_MODE=invite, a new account
|
||||
-- (Google or password) needs an open invitation for its address, or the
|
||||
-- invitation link itself (then any address will do).
|
||||
CREATE TABLE invitations (
|
||||
id uuid PRIMARY KEY,
|
||||
email text NOT NULL,
|
||||
message text CHECK (char_length(message) <= 300),
|
||||
locale text NOT NULL,
|
||||
invited_by uuid REFERENCES users (id) ON DELETE SET NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
expires_at timestamptz NOT NULL,
|
||||
sent_count integer NOT NULL DEFAULT 1,
|
||||
last_sent_at timestamptz NOT NULL DEFAULT now(),
|
||||
accepted_at timestamptz,
|
||||
accepted_by uuid REFERENCES users (id) ON DELETE SET NULL,
|
||||
revoked_at timestamptz
|
||||
);
|
||||
-- At most one open invitation per address.
|
||||
CREATE UNIQUE INDEX invitations_open_email_idx ON invitations (email)
|
||||
WHERE accepted_at IS NULL AND revoked_at IS NULL;
|
||||
CREATE INDEX invitations_created_idx ON invitations (created_at DESC);
|
||||
|
||||
-- Link tokens (only their hashes). Every sending issues a new one, and the
|
||||
-- earlier links keep working while the invitation is open.
|
||||
CREATE TABLE invitation_tokens (
|
||||
token_hash bytea PRIMARY KEY,
|
||||
invitation_id uuid NOT NULL REFERENCES invitations (id) ON DELETE CASCADE,
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE INDEX invitation_tokens_invitation_idx ON invitation_tokens (invitation_id);
|
||||
|
||||
-- Addresses that asked for no more invitations (only the SHA-256 of the address).
|
||||
CREATE TABLE email_optouts (
|
||||
email_hash bytea PRIMARY KEY,
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
-- "Tell me when it opens": people without an invitation.
|
||||
CREATE TABLE waitlist (
|
||||
email text PRIMARY KEY,
|
||||
locale text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
@@ -0,0 +1,7 @@
|
||||
-- The unlimited package is no longer sold (it was easy to resell). Nobody
|
||||
-- paid for one (only stand-in payments existed), so the running ones end.
|
||||
DELETE FROM entitlements WHERE entitlement = 'unlimited';
|
||||
ALTER TABLE entitlements DROP CONSTRAINT entitlements_entitlement_check;
|
||||
ALTER TABLE entitlements ADD CONSTRAINT entitlements_entitlement_check
|
||||
CHECK (entitlement IN ('unlimited_persons'));
|
||||
ALTER TABLE entitlements DROP COLUMN expires_at;
|
||||
@@ -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'));
|
||||
@@ -0,0 +1,10 @@
|
||||
[package]
|
||||
name = "email-templates"
|
||||
description = "E-mail texts of Sorsfonalak as HTML and plain text (sent by the worker, previewed by the backend)"
|
||||
edition.workspace = true
|
||||
version.workspace = true
|
||||
license.workspace = true
|
||||
publish.workspace = true
|
||||
|
||||
[dependencies]
|
||||
serde_json.workspace = true
|
||||
@@ -0,0 +1,482 @@
|
||||
//! E-mail texts (Hungarian and English), as plain text and HTML.
|
||||
//!
|
||||
//! The payloads are written by the backend; the validity periods in the
|
||||
//! texts match the token lifetimes there. The worker sends the result, the
|
||||
//! backend renders it for the admin preview.
|
||||
//!
|
||||
//! The layout is deliberately plain for spam filters: one column, inline
|
||||
//! styles, no images, no tracking, every link on the site's own domain, and
|
||||
//! a plain-text part with the same content.
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct Rendered {
|
||||
pub subject: String,
|
||||
pub text: String,
|
||||
pub html: String,
|
||||
/// One-click unsubscribe address for the `List-Unsubscribe` header (RFC 8058).
|
||||
pub unsubscribe_post_url: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum TemplateError {
|
||||
UnknownTemplate(String),
|
||||
MissingField(&'static str),
|
||||
}
|
||||
|
||||
impl std::fmt::Display for TemplateError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
TemplateError::UnknownTemplate(t) => write!(f, "unknown e-mail template '{t}'"),
|
||||
TemplateError::MissingField(field) => write!(f, "e-mail payload has no '{field}'"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
enum Lang {
|
||||
Hu,
|
||||
En,
|
||||
}
|
||||
|
||||
/// One e-mail: greeting, paragraphs, a button and a closing note.
|
||||
struct Content {
|
||||
subject: String,
|
||||
/// The line mail clients show after the subject in the inbox.
|
||||
preheader: Option<String>,
|
||||
greeting: String,
|
||||
intro: String,
|
||||
/// A personal message, shown as a quote.
|
||||
quote: Option<String>,
|
||||
/// A short list after the intro, with its heading.
|
||||
points: Option<(&'static str, Vec<&'static str>)>,
|
||||
button: &'static str,
|
||||
url: String,
|
||||
note: String,
|
||||
/// Why the recipient got this e-mail (for mails they did not ask for).
|
||||
reason: Option<String>,
|
||||
/// Label and page of the unsubscribe link in the footer.
|
||||
unsubscribe: Option<(&'static str, String)>,
|
||||
unsubscribe_post_url: Option<String>,
|
||||
}
|
||||
|
||||
impl Content {
|
||||
fn simple(subject: String, greeting: String, intro: String, button: &'static str, url: String, note: &str) -> Self {
|
||||
Self {
|
||||
subject,
|
||||
preheader: None,
|
||||
greeting,
|
||||
intro,
|
||||
quote: None,
|
||||
points: None,
|
||||
button,
|
||||
url,
|
||||
note: note.to_owned(),
|
||||
reason: None,
|
||||
unsubscribe: None,
|
||||
unsubscribe_post_url: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn render(template: &str, locale: &str, payload: &Value) -> Result<Rendered, TemplateError> {
|
||||
let lang = if locale.eq_ignore_ascii_case("hu") { Lang::Hu } else { Lang::En };
|
||||
let url = field(payload, "url")?;
|
||||
let greeting = |name: Option<String>| match (lang, name) {
|
||||
(Lang::Hu, Some(n)) => format!("Szia {n}!"),
|
||||
(Lang::Hu, None) => "Szia!".to_owned(),
|
||||
(Lang::En, Some(n)) => format!("Hi {n},"),
|
||||
(Lang::En, None) => "Hi,".to_owned(),
|
||||
};
|
||||
let content = match (template, lang) {
|
||||
("verify_email", Lang::Hu) => Content::simple(
|
||||
"Erősítsd meg az e-mail-címed".into(),
|
||||
greeting(name(payload, "display_name")),
|
||||
"Köszönjük, hogy regisztráltál a Sorsfonalakon! Az alábbi gombbal erősítsd meg az e-mail-címed.".into(),
|
||||
"E-mail-cím megerősítése",
|
||||
url,
|
||||
"A link 3 napig érvényes. Ha nem te regisztráltál, nyugodtan hagyd figyelmen kívül ezt a levelet.",
|
||||
),
|
||||
("verify_email", Lang::En) => Content::simple(
|
||||
"Confirm your e-mail address".into(),
|
||||
greeting(name(payload, "display_name")),
|
||||
"Thanks for signing up for Sorsfonalak! Please confirm your e-mail address with the button below.".into(),
|
||||
"Confirm e-mail address",
|
||||
url,
|
||||
"The link is valid for 3 days. If you did not sign up, you can safely ignore this e-mail.",
|
||||
),
|
||||
("reset_password", Lang::Hu) => Content::simple(
|
||||
"Új jelszó megadása".into(),
|
||||
greeting(name(payload, "display_name")),
|
||||
"Jelszó-visszaállítást kértél a Sorsfonalak-fiókodhoz. Az alábbi gombbal adhatsz meg új jelszót.".into(),
|
||||
"Új jelszó megadása",
|
||||
url,
|
||||
"A link 1 óráig érvényes, és csak egyszer használható. Ha nem te kérted, hagyd figyelmen kívül ezt a levelet: a jelszavad nem változik.",
|
||||
),
|
||||
("reset_password", Lang::En) => Content::simple(
|
||||
"Set a new password".into(),
|
||||
greeting(name(payload, "display_name")),
|
||||
"You asked to reset the password of your Sorsfonalak account. Use the button below to set a new one."
|
||||
.into(),
|
||||
"Set a new password",
|
||||
url,
|
||||
"The link is valid for 1 hour and can be used once. If you did not ask for this, ignore this e-mail: your password stays the same.",
|
||||
),
|
||||
("invite_accepted", Lang::Hu) => {
|
||||
let who = name(payload, "invitee_name");
|
||||
Content::simple(
|
||||
match &who {
|
||||
Some(n) => format!("{n} elfogadta a meghívásod"),
|
||||
None => "Elfogadták a meghívásod".into(),
|
||||
},
|
||||
greeting(None),
|
||||
format!(
|
||||
"{} elfogadta a „Mennyire illünk össze?” meghívásod, és elkészült a szinasztriátok.",
|
||||
who.as_deref().unwrap_or("A meghívott")
|
||||
),
|
||||
"Szinasztria megnyitása",
|
||||
url,
|
||||
"A szinasztriát mindketten látjátok, de egymás születési adatait nem.",
|
||||
)
|
||||
}
|
||||
("invite_accepted", Lang::En) => {
|
||||
let who = name(payload, "invitee_name");
|
||||
Content::simple(
|
||||
match &who {
|
||||
Some(n) => format!("{n} accepted your invitation"),
|
||||
None => "Your invitation was accepted".into(),
|
||||
},
|
||||
greeting(None),
|
||||
format!(
|
||||
"{} accepted your “How compatible are we?” invitation, and your synastry is ready.",
|
||||
who.as_deref().unwrap_or("Your invitee")
|
||||
),
|
||||
"Open synastry",
|
||||
url,
|
||||
"You both see the synastry, but not each other's birth data.",
|
||||
)
|
||||
}
|
||||
("invitation", _) => invitation(lang, payload, url)?,
|
||||
_ => return Err(TemplateError::UnknownTemplate(template.to_owned())),
|
||||
};
|
||||
Ok(content.render(lang))
|
||||
}
|
||||
|
||||
/// An invitation to the closed site (sent by an administrator).
|
||||
fn invitation(lang: Lang, payload: &Value, url: String) -> Result<Content, TemplateError> {
|
||||
let inviter = name(payload, "inviter_name");
|
||||
let message = message(payload);
|
||||
let until =
|
||||
payload["expires_on"].as_str().and_then(|d| date(lang, d)).ok_or(TemplateError::MissingField("expires_on"))?;
|
||||
// "2026. december 17." + "-ig" = "2026. december 17-ig"
|
||||
let until_hu = until.trim_end_matches('.');
|
||||
let unsubscribe_url = field(payload, "unsubscribe_url")?;
|
||||
let unsubscribe_post_url = field(payload, "unsubscribe_post_url")?;
|
||||
Ok(match lang {
|
||||
Lang::Hu => Content {
|
||||
subject: match &inviter {
|
||||
Some(n) => format!("{n} meghívott a Sorsfonalakra"),
|
||||
None => "Meghívót kaptál a Sorsfonalakra".into(),
|
||||
},
|
||||
preheader: Some(format!("Születési képlet és rövid elemzés ingyen. A meghívó {until_hu}-ig érvényes.")),
|
||||
greeting: "Szia!".into(),
|
||||
intro: match &inviter {
|
||||
Some(n) => {
|
||||
format!("{n} meghívott a Sorsfonalakra. Az oldal egyelőre zártkörű: csak meghívóval lehet belépni.")
|
||||
}
|
||||
None => {
|
||||
"Meghívót kaptál a Sorsfonalakra. Az oldal egyelőre zártkörű: csak meghívóval lehet belépni.".into()
|
||||
}
|
||||
},
|
||||
quote: message,
|
||||
points: Some((
|
||||
"Mit találsz ott?",
|
||||
vec![
|
||||
"a születési képleted kiszámolva és megrajzolva, ingyen,",
|
||||
"egy rövid, személyre szóló elemzést róla,",
|
||||
"összevetést a szeretteiddel: mennyire illetek össze.",
|
||||
],
|
||||
)),
|
||||
button: "Meghívás elfogadása",
|
||||
url,
|
||||
note: format!(
|
||||
"A meghívó {until_hu}-ig érvényes. Elfogadáskor Google-fiókkal lépsz be, és ezzel a linkkel bármelyik Google-fiókodat használhatod."
|
||||
),
|
||||
reason: Some(match &inviter {
|
||||
Some(n) => {
|
||||
format!("Ezt a levelet azért kaptad, mert {n} megadta az e-mail-címed a Sorsfonalak meghívójában.")
|
||||
}
|
||||
None => {
|
||||
"Ezt a levelet azért kaptad, mert valaki megadta az e-mail-címed a Sorsfonalak meghívójában.".into()
|
||||
}
|
||||
}),
|
||||
unsubscribe: Some(("Nem kérek több meghívót", unsubscribe_url)),
|
||||
unsubscribe_post_url: Some(unsubscribe_post_url),
|
||||
},
|
||||
Lang::En => Content {
|
||||
subject: match &inviter {
|
||||
Some(n) => format!("{n} invited you to Sorsfonalak"),
|
||||
None => "You are invited to Sorsfonalak".into(),
|
||||
},
|
||||
preheader: Some(format!(
|
||||
"Your birth chart and a short reading, free. The invitation is valid until {until}."
|
||||
)),
|
||||
greeting: "Hi,".into(),
|
||||
intro: match &inviter {
|
||||
Some(n) => format!("{n} invited you to Sorsfonalak. The site is invitation-only for now."),
|
||||
None => "You are invited to Sorsfonalak. The site is invitation-only for now.".into(),
|
||||
},
|
||||
quote: message,
|
||||
points: Some((
|
||||
"What you will find there:",
|
||||
vec![
|
||||
"your birth chart, calculated and drawn, for free,",
|
||||
"a short, personal reading of it,",
|
||||
"comparisons with your loved ones: how well you match.",
|
||||
],
|
||||
)),
|
||||
button: "Accept the invitation",
|
||||
url,
|
||||
note: format!(
|
||||
"The invitation is valid until {until}. You sign in with Google, and with this link any of your Google accounts will do."
|
||||
),
|
||||
reason: Some(match &inviter {
|
||||
Some(n) => format!("You got this e-mail because {n} entered your address in a Sorsfonalak invitation."),
|
||||
None => "You got this e-mail because someone entered your address in a Sorsfonalak invitation.".into(),
|
||||
}),
|
||||
unsubscribe: Some(("No more invitations, please", unsubscribe_url)),
|
||||
unsubscribe_post_url: Some(unsubscribe_post_url),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
fn field(payload: &Value, name: &'static str) -> Result<String, TemplateError> {
|
||||
payload[name].as_str().filter(|u| !u.is_empty()).map(str::to_owned).ok_or(TemplateError::MissingField(name))
|
||||
}
|
||||
|
||||
/// A user-supplied name, safe for a subject line.
|
||||
fn name(payload: &Value, field: &str) -> Option<String> {
|
||||
let name: String = payload[field].as_str()?.chars().filter(|c| !c.is_control()).take(60).collect();
|
||||
let name = name.trim();
|
||||
(!name.is_empty()).then(|| name.to_owned())
|
||||
}
|
||||
|
||||
/// The personal message of an invitation: line breaks kept, other control characters dropped.
|
||||
fn message(payload: &Value) -> Option<String> {
|
||||
let text: String =
|
||||
payload["message"].as_str()?.chars().filter(|c| *c == '\n' || !c.is_control()).take(500).collect();
|
||||
let text = text.trim();
|
||||
(!text.is_empty()).then(|| text.to_owned())
|
||||
}
|
||||
|
||||
/// `2026-12-17` as "2026. december 17." or "17 December 2026".
|
||||
fn date(lang: Lang, iso: &str) -> Option<String> {
|
||||
const HU: [&str; 12] = [
|
||||
"január",
|
||||
"február",
|
||||
"március",
|
||||
"április",
|
||||
"május",
|
||||
"június",
|
||||
"július",
|
||||
"augusztus",
|
||||
"szeptember",
|
||||
"október",
|
||||
"november",
|
||||
"december",
|
||||
];
|
||||
const EN: [&str; 12] = [
|
||||
"January",
|
||||
"February",
|
||||
"March",
|
||||
"April",
|
||||
"May",
|
||||
"June",
|
||||
"July",
|
||||
"August",
|
||||
"September",
|
||||
"October",
|
||||
"November",
|
||||
"December",
|
||||
];
|
||||
let mut parts = iso.splitn(3, '-');
|
||||
let (y, m, d) = (parts.next()?, parts.next()?, parts.next()?);
|
||||
let (y, m, d): (u32, usize, u32) = (y.parse().ok()?, m.parse().ok()?, d.get(..2)?.parse().ok()?);
|
||||
let month = m.checked_sub(1).filter(|&i| i < 12)?;
|
||||
Some(match lang {
|
||||
Lang::Hu => format!("{y}. {} {d}.", HU[month]),
|
||||
Lang::En => format!("{d} {} {y}", EN[month]),
|
||||
})
|
||||
}
|
||||
|
||||
fn escape(s: &str) -> String {
|
||||
let mut out = String::with_capacity(s.len());
|
||||
for c in s.chars() {
|
||||
match c {
|
||||
'&' => out.push_str("&"),
|
||||
'<' => out.push_str("<"),
|
||||
'>' => out.push_str(">"),
|
||||
'"' => out.push_str("""),
|
||||
'\'' => out.push_str("'"),
|
||||
_ => out.push(c),
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
const TEXT: &str = "#2a2620";
|
||||
const MUTED: &str = "#6b645a";
|
||||
const FAINT: &str = "#9b948a";
|
||||
const GOLD: &str = "#9a7b3c";
|
||||
|
||||
impl Content {
|
||||
fn render(self, lang: Lang) -> Rendered {
|
||||
let footer = match lang {
|
||||
Lang::Hu => "Ezt a levelet a Sorsfonalak küldte.",
|
||||
Lang::En => "This e-mail was sent by Sorsfonalak.",
|
||||
};
|
||||
|
||||
let mut text = format!("{}\n\n{}\n\n", self.greeting, self.intro);
|
||||
if let Some(q) = &self.quote {
|
||||
for line in q.lines() {
|
||||
text.push_str(&format!("> {line}\n"));
|
||||
}
|
||||
text.push('\n');
|
||||
}
|
||||
if let Some((heading, items)) = &self.points {
|
||||
text.push_str(heading);
|
||||
text.push('\n');
|
||||
for item in items {
|
||||
text.push_str(&format!("- {item}\n"));
|
||||
}
|
||||
text.push('\n');
|
||||
}
|
||||
text.push_str(&format!("{}:\n{}\n\n{}\n\n-- \nSorsfonalak\n", self.button, self.url, self.note));
|
||||
if let Some(reason) = &self.reason {
|
||||
text.push_str(&format!("\n{reason}\n"));
|
||||
}
|
||||
if let Some((label, url)) = &self.unsubscribe {
|
||||
text.push_str(&format!("{label}: {url}\n"));
|
||||
}
|
||||
|
||||
let preheader = self.preheader.as_deref().map_or(String::new(), |p| {
|
||||
format!(
|
||||
r#"<div style="display:none;max-height:0;overflow:hidden;opacity:0;color:transparent">{}</div>"#,
|
||||
escape(p)
|
||||
)
|
||||
});
|
||||
let quote = self.quote.as_deref().map_or(String::new(), |q| {
|
||||
format!(
|
||||
r#"<tr><td style="padding-bottom:24px"><div style="border-left:3px solid {GOLD};padding:4px 0 4px 16px;font-size:16px;line-height:1.6;font-style:italic;color:{TEXT}">{}</div></td></tr>
|
||||
"#,
|
||||
escape(q).replace('\n', "<br>")
|
||||
)
|
||||
});
|
||||
let points = self.points.as_ref().map_or(String::new(), |(heading, items)| {
|
||||
let items: String = items
|
||||
.iter()
|
||||
.map(|i| format!(r#"<li style="margin:0 0 6px">{}</li>"#, escape(i)))
|
||||
.collect();
|
||||
format!(
|
||||
r#"<tr><td style="font-size:16px;line-height:1.6;padding-bottom:24px">{}<ul style="margin:8px 0 0;padding-left:20px">{items}</ul></td></tr>
|
||||
"#,
|
||||
escape(heading)
|
||||
)
|
||||
});
|
||||
let mut small = Vec::new();
|
||||
if let Some(reason) = &self.reason {
|
||||
small.push(escape(reason));
|
||||
}
|
||||
if let Some((label, url)) = &self.unsubscribe {
|
||||
small.push(format!(r#"<a href="{}" style="color:{FAINT}">{}</a>"#, escape(url), escape(label)));
|
||||
}
|
||||
small.push(escape(footer));
|
||||
let small = small.join("<br>");
|
||||
|
||||
let html = format!(
|
||||
r#"<!doctype html>
|
||||
<html lang="{lang}">
|
||||
<head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>{subject}</title></head>
|
||||
<body style="margin:0;padding:0;background:#f4f1ea;font-family:Georgia,'Times New Roman',serif;color:{TEXT}">
|
||||
{preheader}<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="background:#f4f1ea;padding:32px 16px">
|
||||
<tr><td align="center">
|
||||
<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="max-width:520px;background:#ffffff;border-radius:8px;padding:32px">
|
||||
<tr><td style="font-size:20px;letter-spacing:2px;color:{GOLD};padding-bottom:24px">SORSFONALAK</td></tr>
|
||||
<tr><td style="font-size:16px;line-height:1.6;padding-bottom:12px">{greeting}</td></tr>
|
||||
<tr><td style="font-size:16px;line-height:1.6;padding-bottom:24px">{intro}</td></tr>
|
||||
{quote}{points}<tr><td style="padding-bottom:24px"><a href="{url}" style="display:inline-block;background:{GOLD};color:#ffffff;text-decoration:none;padding:12px 24px;border-radius:6px;font-size:16px">{button}</a></td></tr>
|
||||
<tr><td style="font-size:14px;line-height:1.6;color:{MUTED};padding-bottom:16px">{note}</td></tr>
|
||||
<tr><td style="font-size:12px;line-height:1.5;color:{FAINT};word-break:break-all">{url_text}</td></tr>
|
||||
</table>
|
||||
<p style="font-size:12px;line-height:1.5;color:{FAINT};max-width:520px">{small}</p>
|
||||
</td></tr>
|
||||
</table>
|
||||
</body>
|
||||
</html>
|
||||
"#,
|
||||
lang = if lang == Lang::Hu { "hu" } else { "en" },
|
||||
subject = escape(&self.subject),
|
||||
greeting = escape(&self.greeting),
|
||||
intro = escape(&self.intro),
|
||||
url = escape(&self.url),
|
||||
button = escape(self.button),
|
||||
note = escape(&self.note),
|
||||
url_text = escape(&self.url),
|
||||
);
|
||||
Rendered { subject: self.subject, text, html, unsubscribe_post_url: self.unsubscribe_post_url }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use serde_json::json;
|
||||
|
||||
use super::*;
|
||||
|
||||
fn invitation_payload() -> Value {
|
||||
json!({
|
||||
"url": "https://sorsfonalak.test/meghivo/abc",
|
||||
"inviter_name": "Kata",
|
||||
"message": "Gyere, nézd meg!\n<b>Szia</b>",
|
||||
"expires_on": "2026-12-17",
|
||||
"unsubscribe_url": "https://sorsfonalak.test/leiratkozas?token=abc",
|
||||
"unsubscribe_post_url": "https://sorsfonalak.test/api/v1/public/invitations/unsubscribe?token=abc",
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invitation_has_both_parts() {
|
||||
let hu = render("invitation", "hu", &invitation_payload()).unwrap();
|
||||
assert_eq!(hu.subject, "Kata meghívott a Sorsfonalakra");
|
||||
assert!(hu.text.contains("> Gyere, nézd meg!\n> <b>Szia</b>"));
|
||||
assert!(hu.text.contains("A meghívó 2026. december 17-ig érvényes."));
|
||||
assert!(hu.text.contains("Nem kérek több meghívót: https://sorsfonalak.test/leiratkozas?token=abc"));
|
||||
assert!(hu.html.contains("Gyere, nézd meg!<br><b>Szia</b>"));
|
||||
assert!(hu.html.contains(r#"href="https://sorsfonalak.test/meghivo/abc""#));
|
||||
assert!(hu.html.contains("display:none"));
|
||||
assert_eq!(
|
||||
hu.unsubscribe_post_url.as_deref(),
|
||||
Some("https://sorsfonalak.test/api/v1/public/invitations/unsubscribe?token=abc")
|
||||
);
|
||||
|
||||
let mut anonymous = invitation_payload();
|
||||
anonymous["inviter_name"] = Value::Null;
|
||||
anonymous["message"] = Value::Null;
|
||||
let en = render("invitation", "en", &anonymous).unwrap();
|
||||
assert_eq!(en.subject, "You are invited to Sorsfonalak");
|
||||
assert!(en.text.contains("valid until 17 December 2026") && !en.text.contains("> "));
|
||||
assert!(!en.html.contains("border-left"));
|
||||
|
||||
let mut broken = invitation_payload();
|
||||
broken["unsubscribe_url"] = Value::Null;
|
||||
assert_eq!(render("invitation", "hu", &broken), Err(TemplateError::MissingField("unsubscribe_url")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dates() {
|
||||
assert_eq!(date(Lang::Hu, "2027-01-05").as_deref(), Some("2027. január 5."));
|
||||
assert_eq!(date(Lang::En, "2027-01-05T10:00:00Z").as_deref(), Some("5 January 2027"));
|
||||
assert_eq!(date(Lang::Hu, "2027-13-05"), None);
|
||||
}
|
||||
}
|
||||
@@ -43,6 +43,11 @@ impl HoroscopeClient {
|
||||
self.post("/v1/synastry", request).await
|
||||
}
|
||||
|
||||
/// `POST /v1/forecast`
|
||||
pub async fn forecast(&self, request: &Value) -> Result<Value, HoroscopeError> {
|
||||
self.post("/v1/forecast", request).await
|
||||
}
|
||||
|
||||
async fn post(&self, path: &str, body: &Value) -> Result<Value, HoroscopeError> {
|
||||
let response = self
|
||||
.http
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
+7
-3
@@ -10,9 +10,13 @@ GOOGLE_CLIENT_IDS=
|
||||
# These accounts become admins at their first login
|
||||
BOOTSTRAP_ADMIN_EMAILS=
|
||||
|
||||
# Outgoing mail, e.g. smtps://user:password@smtp.example.com:465
|
||||
SMTP_URL=
|
||||
MAIL_FROM=Sorsfonalak <noreply@sorsfonalak.hu>
|
||||
# Outgoing mail: Amazon SES (docs/levelkuldes.md). The credentials go to .env.secrets:
|
||||
# SES_SMTP_USERNAME + SES_SMTP_PASSWORD, or AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY.
|
||||
SES_REGION=eu-central-1
|
||||
MAIL_FROM=Sorsfonalak <hello@sorsfonalak.hu>
|
||||
|
||||
# invite: new accounts need an invitation (default); open: anyone can sign up
|
||||
SIGNUP_MODE=invite
|
||||
|
||||
# Image version; every deployment rewrites it
|
||||
TAG=latest
|
||||
|
||||
+2
-6
@@ -11,12 +11,8 @@
|
||||
}
|
||||
|
||||
{$DOMAIN} {
|
||||
# Temporary gate until launch (user sf, password sf). Remove this block to open the site.
|
||||
# The privacy policy stays public (Google's OAuth consent screen links to it).
|
||||
@gated not path /adatvedelem /_next/static/* /favicon.ico /icon*
|
||||
basic_auth @gated {
|
||||
sf $2a$14$oggzzuNO41uGS5M.TCMlB.bQ6fdXUHtNLx9XahWyKLHjRlpEP1XN6
|
||||
}
|
||||
# No basic auth any more: the site is open, and new accounts need an
|
||||
# invitation (SIGNUP_MODE=invite in the backend).
|
||||
encode zstd gzip
|
||||
reverse_proxy frontend:3000
|
||||
}
|
||||
|
||||
@@ -88,7 +88,8 @@ services:
|
||||
# Stand-in payment (adds an analysis unit at once) until Stripe is connected.
|
||||
MOCK_PAYMENTS: ${MOCK_PAYMENTS:-true}
|
||||
FREE_PERSON_SLOTS: ${FREE_PERSON_SLOTS:-0}
|
||||
UNLIMITED_DAILY_LIMIT: ${UNLIMITED_DAILY_LIMIT:-5}
|
||||
# invite: new accounts need an invitation (admin page "Meghívók"); open: anyone.
|
||||
SIGNUP_MODE: ${SIGNUP_MODE:-invite}
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
@@ -102,8 +103,10 @@ services:
|
||||
image: ${REGISTRY_PREFIX:-registry.sagifer.com/sagifer/sorsfonalak}-worker:${TAG:-latest}
|
||||
environment:
|
||||
DATABASE_URL: postgres://sorsfonalak:${POSTGRES_PASSWORD}@postgres:5432/sorsfonalak
|
||||
SMTP_URL: ${SMTP_URL:-}
|
||||
MAIL_FROM: ${MAIL_FROM:-}
|
||||
# SMTP_URL or the SES credentials come from .env.secrets (docs/levelkuldes.md);
|
||||
# listing them here with an empty default would override that file.
|
||||
SES_REGION: ${SES_REGION:-eu-central-1}
|
||||
MAIL_FROM: ${MAIL_FROM:-Sorsfonalak <hello@sorsfonalak.hu>}
|
||||
PUBLIC_BASE_URL: https://${DOMAIN}
|
||||
env_file:
|
||||
- path: .env.secrets
|
||||
|
||||
+2
-1
@@ -56,7 +56,8 @@ services:
|
||||
# Stand-in payment (adds an analysis unit at once) until Stripe is connected.
|
||||
MOCK_PAYMENTS: ${MOCK_PAYMENTS:-true}
|
||||
FREE_PERSON_SLOTS: ${FREE_PERSON_SLOTS:-0}
|
||||
UNLIMITED_DAILY_LIMIT: ${UNLIMITED_DAILY_LIMIT:-5}
|
||||
# invite: new accounts need an invitation (admin page "Meghívók"); open: anyone.
|
||||
SIGNUP_MODE: ${SIGNUP_MODE:-invite}
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
|
||||
+17
-14
@@ -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 990 Ft | 2 990 Ft | – | – |
|
||||
| Páros | 2 képletelemzés, 1 kapcsolati, 1 személy | 6 990 Ft | 2 330 Ft | 9 868 Ft | 29% |
|
||||
| **Család** (Legnépszerűbb) | 6 képletelemzés, 5 kapcsolati, 5 személy | 11 990 Ft | 1 090 Ft | 37 380 Ft | 68% |
|
||||
| Korlátlan | minden korlátlanul, 12 hónapig | 17 990 Ft | – | – | – |
|
||||
| +1 kapcsolati elemzés | kiegészítő | 3 490 Ft | | | |
|
||||
| +5 személy | kiegészítő | 1 990 Ft | | | |
|
||||
| Egy elemzés | 1 képletelemzés | 2 000 Ft | 2 000 Ft | – | – |
|
||||
| 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, é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 990 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: +4 000 Ft-ért háromszor annyi elemzés. Család: +5 000 Ft-ért majdnem négyszer annyi. Korlátlan: +6 000 Ft-ért nincs határ. 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 (−29%), hogy mellette a Család (−68%) kiugorjon. A Család kapja a kiemelést és a „Legnépszerűbb” címkét.
|
||||
- **A Korlátlan mint felső horgony:** a Család ára mellette mérsékeltnek tűnik; aki sokakat venne fel, annak a 6 000 Ft különbség semmiség.
|
||||
- **Drága kiegészítők:** a +1 kapcsolati elemzés 3 490 Ft, többe kerül, mint egy képletelemzés, és a Páros már kettő árán ad egyet kettőtök képletével együtt. Aki darabonként venne, annak jobban megéri csomagot venni.
|
||||
- **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: +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.
|
||||
|
||||
## Korlátlan csomag
|
||||
## Miért nincs korlátlan csomag
|
||||
|
||||
Egy év; ha még tart, egy újabb a lejárathoz ad hozzá egy évet. Méltányos használat: naponta legfeljebb `UNLIMITED_DAILY_LIMIT` (alapból 5) új részletes elemzés. Legrosszabb esetben is jóval a csomag ára alatt marad a költség, ha valaki nem visszaélésszerűen használja; a napi korlát a gépi tömeges lekérést fogja 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
|
||||
|
||||
|
||||
@@ -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.
|
||||
@@ -0,0 +1,95 @@
|
||||
# Levélküldés élesben: Amazon SES
|
||||
|
||||
Élesben most nincs levélküldő beállítva (`SMTP_URL` üres), így minden levél az `email_outbox` táblában vár. Amíg ez így van, a meghívót kézzel is továbbadhatod: az admin „Meghívók” oldala küldés után kiírja a linket („Link másolása”).
|
||||
|
||||
A meghívó a legkényesebb levéltípus, mert a címzett nem kérte. A spammappát elsősorban a feladó hírneve és a domain hitelesítése dönti el, a sablon csak ezután számít. Ezért kellenek a lenti lépések.
|
||||
|
||||
A SES ára 1000 levelenként 0,10 USD; a mi forgalmunknál ez havi néhány cent.
|
||||
|
||||
## 1. Régió és domain (SES konzol)
|
||||
|
||||
1. **Régió:** `eu-central-1` (Frankfurt), hogy az adatok az EU-ban maradjanak. Minden lépést ebben a régióban kell elvégezni, mert a SES-beállítások régiónként külön élnek.
|
||||
2. *Configuration → Identities → Create identity → Domain*: `sorsfonalak.hu`.
|
||||
- **Easy DKIM**, RSA 2048 bit. A SES három CNAME-rekordot ad (lásd 3. pont).
|
||||
- **Custom MAIL FROM domain:** `mail.sorsfonalak.hu`, és *Behavior on MX failure*: *Use default MAIL FROM domain*. Ettől az SPF is a saját domainünkre szól, ami a DMARC-nál számít. Ehhez egy MX- és egy TXT-rekord kell.
|
||||
3. A domain igazolása után bármelyik `@sorsfonalak.hu` cím lehet feladó. Javaslat: `hello@sorsfonalak.hu`. A `noreply` cím a szűrőknél rosszabb, és válaszolni sem lehet rá.
|
||||
|
||||
## 2. Kilépés a homokozóból (sandbox)
|
||||
|
||||
Új SES-fiók homokozóban indul. Ilyenkor:
|
||||
- csak igazolt címekre lehet küldeni (*Identities → Create identity → Email address*; teszteléshez a saját címed elég);
|
||||
- naponta legfeljebb 200 levél megy ki.
|
||||
|
||||
Meghívót idegen címre csak éles hozzáféréssel lehet küldeni: *Account dashboard → Request production access*. Az AWS kézzel bírálja el, általában egy napon belül. A kérésben érdemes leírni:
|
||||
- tranzakciós levelek (megerősítés, értesítés) és meghívók egy zártkörű oldalra;
|
||||
- meghívót csak az admin küld, személyesen ismert embereknek, kis mennyiségben;
|
||||
- minden meghívóban egykattintásos leiratkozás van, a leiratkozott címekre többé nem megy levél;
|
||||
- a visszapattanó és panaszos címeket a SES fiókszintű tiltólistája kezeli (*Suppression list*: bounces és complaints).
|
||||
|
||||
Fontos: ha a visszapattanási arány 5%, vagy a panaszarány 0,1% fölé megy, az AWS felfüggesztheti a küldést. Ezért csak olyan címre küldj meghívót, amelyről tudod, hogy él.
|
||||
|
||||
## 3. DNS a Cloudflare-en
|
||||
|
||||
| Típus | Név | Tartalom |
|
||||
|---|---|---|
|
||||
| CNAME ×3 | `<kód>._domainkey` | `<kód>.dkim.amazonses.com` (a SES konzol kiírja mindhármat) |
|
||||
| MX | `mail` | `feedback-smtp.eu-central-1.amazonses.com`, prioritás 10 |
|
||||
| TXT | `mail` | `v=spf1 include:amazonses.com ~all` |
|
||||
| TXT | `_dmarc` | `v=DMARC1; p=none; rua=mailto:<a te címed>` |
|
||||
|
||||
- Minden rekord **DNS only** (szürke felhő) legyen; a proxyzott CNAME-mel a DKIM nem működik.
|
||||
- DMARC: induláskor `p=none` (csak jelentés). Ha pár hétig minden levél átmegy, szigorítható `p=quarantine`-ra.
|
||||
- Ha a `hello@sorsfonalak.hu` címre érkező válaszokat is olvasni szeretnéd: a Cloudflare *Email Routing* ingyen továbbítja őket a Gmailedre. Ez a fő domainre (`sorsfonalak.hu`) tesz MX- és SPF-rekordot, ami nem ütközik a `mail.` aldomain rekordjaival.
|
||||
|
||||
## 4. Hozzáférés
|
||||
|
||||
Két út van, mindkettő a szerver `.env.secrets` fájljába kerül (kis- vagy nagybetűvel is jó):
|
||||
|
||||
- **SMTP-hozzáférés** (*SMTP settings → Create SMTP credentials*): egy IAM-felhasználó, amely csak levelet küldhet.
|
||||
```
|
||||
SES_SMTP_USERNAME=AKIA...
|
||||
SES_SMTP_PASSWORD=...
|
||||
```
|
||||
- **IAM-kulcspár**, amelynek van `ses:SendRawEmail` joga:
|
||||
```
|
||||
AWS_ACCESS_KEY_ID=AKIA...
|
||||
AWS_SECRET_ACCESS_KEY=...
|
||||
```
|
||||
Más nevek is jók: a kulcsnál `SES_AUTH_KEY`, `SES_ACCESS_KEY`, `SES_KEY`, `AUTH_KEY`, a titoknál `SES_SECRET`, `SES_SECRET_KEY`, `AWS_SECRET`, `AUTH_SECRET` (a teljes lista: `services/worker/src/ses.rs`).
|
||||
A worker ebből az AWS által leírt módon kiszámolja az SMTP-jelszót. Ha az `AWS_SECRET_ACCESS_KEY` helyére az SMTP-jelszót írtad, azt is felismeri, és változatlanul használja.
|
||||
|
||||
A régió alapból `eu-central-1` (Frankfurt); felülírható a `SES_REGION` változóval. A port 2587, ezt a `SES_SMTP_PORT` írja felül. URL-kódolásra itt nincs szükség, mert a worker maga állítja össze a címet.
|
||||
|
||||
## 5. Tűzfal
|
||||
|
||||
A DigitalOcean a dropleteken tiltja a szokásos kimenő SMTP-portokat (25, 465, 587). A SES erre a **2587**-es portot (STARTTLS) is kínálja.
|
||||
|
||||
A droplet saját tűzfala (`sorsfonalak-fw`, DigitalOcean → Networking → Firewalls) a kimenő forgalmat is szűri. Az **Outbound rules** közé fel kell venni a **TCP 2587**-et (cél: All IPv4, All IPv6), különben a worker nem éri el a SES-t.
|
||||
|
||||
## 6. Indítás
|
||||
|
||||
- A `.env` fájlban opcionális: `MAIL_FROM=Sorsfonalak <hello@sorsfonalak.hu>` (ez az alapérték is).
|
||||
- Utána: `docker compose up -d worker`. A naplóban ennek kell megjelennie: `e-mail delivery enabled`, `via=Amazon SES eu-central-1:2587, credentials from …`.
|
||||
- Az eddig várakozó levelek ekkor kimennek. Ha ezt nem szeretnéd, előtte töröld őket: `DELETE FROM email_outbox WHERE sent_at IS NULL;`.
|
||||
- Hibaüzenetek a naplóban:
|
||||
- `535 Authentication Credentials Invalid`: hibás kulcs, vagy az IAM-felhasználónak nincs `ses:SendRawEmail` joga;
|
||||
- `554 Message rejected: Email address is not verified`: a fiók még homokozóban van, és a címzett nincs igazolva;
|
||||
- időtúllépés: a tűzfalon nincs engedélyezve a kimenő 2587-es port.
|
||||
- Ha mégis kész SMTP-címet adnál meg, az `SMTP_URL` mindig elsőbbséget élvez a SES-változókkal szemben.
|
||||
|
||||
## 7. Próba
|
||||
|
||||
1. Admin → Meghívók → **Teszt küldése magamnak**: megérkezik-e, és nem a spamben van-e.
|
||||
2. A Gmailben a levélnél *⋮ → Eredeti megjelenítése*: az SPF, a DKIM és a DMARC mellett is `PASS` álljon.
|
||||
3. A [mail-tester.com](https://www.mail-tester.com) ad egy egyszeri címet. Küldj rá meghívót az admin oldalról (utána vond vissza), és nézd meg a pontszámot; 9/10 fölött jó. Ehhez már éles hozzáférés kell.
|
||||
|
||||
## Amit a kód már elintéz
|
||||
|
||||
- HTML és szöveges változat ugyanazzal a tartalommal. Egyhasábos, képek és követés nélkül, minden link a saját domainre mutat.
|
||||
- `List-Unsubscribe` és `List-Unsubscribe-Post` (RFC 8058): a Gmail és a többi levelező saját „Leiratkozás” gombot mutat. Aki leiratkozik, annak a címére soha többé nem megy meghívó (`email_optouts`, csak a cím hash-e).
|
||||
- A worker saját domaines `Message-ID`-t tesz a levélre. A SES ezt a sajátjára cseréli, ami rendben van.
|
||||
- Meghívót csak admin küldhet. Egy meghívó legfeljebb háromszor megy ki, 24 óránként egyszer. A személyes üzenet legfeljebb 300 karakter, és nem lehet benne link.
|
||||
|
||||
## Később
|
||||
|
||||
A visszapattanásokról és panaszokról a SES utólag, SNS-értesítésben szól; az SMTP-kapcsolat ezt nem jelzi. Ha lesz forgalom, érdemes bekötni egy SNS → backend webhookot. Ez a meghívólistán megjelölné a visszapattant címeket, és a panaszt tevőket a leiratkozottak közé tenné.
|
||||
@@ -9,6 +9,7 @@ publish.workspace = true
|
||||
[dependencies]
|
||||
db.workspace = true
|
||||
analysis-prompt.workspace = true
|
||||
email-templates.workspace = true
|
||||
horoscope-client.workspace = true
|
||||
service-kit.workspace = true
|
||||
anyhow.workspace = true
|
||||
|
||||
@@ -16,14 +16,14 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh
|
||||
| `PASSWORD_LOGIN` | `false` | e-mail + jelszó regisztráció és belépés; élesben ki van kapcsolva (csak Google, Apple, Facebook), a jelszavas végpontok ilyenkor 403-at adnak |
|
||||
| `MOCK_PAYMENTS` | `false` | próbafizetés a Stripe bekötéséig: a `POST /v1/payments/mock` `{"package": "<id>"}` azonnal jóváírja a katalógus egy csomagját (`{"unit": "natal"}` rövidítés: a legkisebb ilyen csomag); a compose-fájlokban egyelőre `true` |
|
||||
| `FREE_PERSON_SLOTS` | `0` | ennyi személyt vehet fel csomag nélkül egy felhasználó |
|
||||
| `UNLIMITED_DAILY_LIMIT` | `5` | a Korlátlan csomaggal naponta ennyi új részletes elemzés kérhető (méltányos használat; utána 429 `fair_use_limit`) |
|
||||
| `SIGNUP_MODE` | `invite` | `invite`: új fiók csak meghívóval jön létre (403 `not_invited`); `open`: bárki regisztrálhat |
|
||||
| `GOOGLE_CLIENT_IDS` | – | Google OAuth kliens-azonosító(k); üresen a Google-belépés ki van kapcsolva |
|
||||
| `BOOTSTRAP_ADMIN_EMAILS` | – | ezek a címek regisztrációkor vagy belépéskor admin szerepet kapnak (így lesz meg az első admin) |
|
||||
| `SUPPORTED_LOCALES` | `hu,en` | felület- és elemzésnyelvek; az első az alapértelmezett |
|
||||
| `ANALYSIS_MODEL` | `anthropic/claude-opus-5.5` | ez írja a fizetős részletes elemzéseket |
|
||||
| `SUMMARY_MODEL` | `anthropic/claude-sonnet-5.5` | ez írja minden mentett képlet ingyenes rövid összefoglalóját (kb. 1 cent darabonként) |
|
||||
| `ANALYSIS_PROMPT_VERSION` | `v2` | a prompt verziója (az elemzés-gyorsítótár kulcsának része) |
|
||||
| `MAX_CHARTS_PER_USER` | `1000` | biztonsági felső korlát a képletek számára (a korlátlan csomagra is) |
|
||||
| `MAX_CHARTS_PER_USER` | `1000` | biztonsági felső korlát a képletek számára |
|
||||
| `BIND_ADDR`, `LOG_FORMAT`, `RUST_LOG` | `0.0.0.0:8081`, `text`, `info` | |
|
||||
|
||||
## Belépés és jogosultság
|
||||
@@ -36,6 +36,12 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh
|
||||
- **Google:** a frontend a Google Identity Services gombbal vagy a One Tap felülettel szerez ID tokent, és elküldi a `POST /v1/auth/google` végpontra. A backend Google kulcsaival ellenőrzi az aláírást, a kiállítót és a kliens-azonosítót.
|
||||
- Ismeretlen Google-fióknál, ha a Google által igazolt e-mail-címmel már van felhasználó, ahhoz kapcsolja; ha nincs, újat hoz létre.
|
||||
- Ugyanaz a felhasználó több belépési móddal is rendelkezhet (`auth_identities`). A Facebook, az Apple és a passkey ugyanígy adható hozzá.
|
||||
- **Meghívásos regisztráció** (`SIGNUP_MODE=invite`): új fiók (Google vagy jelszó) akkor jön létre, ha
|
||||
- a címre szól élő meghívó (`invitations`), vagy
|
||||
- a kérés a meghívólink tokenjét hozza (`invite_token`): ilyenkor bármelyik cím jó, mert sokan nem azzal a Google-fiókkal lépnek be, amelyiket az ismerősük tudja; a meghívó ezzel elfogy;
|
||||
- vagy egy élő „Mennyire illünk össze?” link tokenjét hozza, illetve a cím a `BOOTSTRAP_ADMIN_EMAILS` listában van.
|
||||
|
||||
Meglévő felhasználók belépése nem változik. Meghívót csak admin küld; a levelet a worker kézbesíti (`invitation` sablon). Minden küldés új linket ad, de a korábbi linkek is élnek, amíg a meghívó nyitott (`invitation_tokens`). A leiratkozott címekre nem megy több meghívó (`email_optouts`, csak hash). Lásd még `docs/levelkuldes.md`.
|
||||
- **Szerepek** (`users.roles`, tömb): `user` (alap), `creator` (cikkírás, 2. fázis), `premium` és `vip` (jelenleg nincs hozzájuk funkció; a fizetős elemzés egységekkel megy), `admin`.
|
||||
- **Guardok:**
|
||||
- `AuthUser`: belépés kell (401);
|
||||
@@ -47,11 +53,11 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh
|
||||
|
||||
| Végpont | Guard | Leírás |
|
||||
|---|---|---|
|
||||
| `GET /v1/config` | – | Google kliens-azonosító, `password_login`, nyelvek, elemző és összefoglaló modell |
|
||||
| `GET /v1/config` | – | Google kliens-azonosító, `password_login`, `signup_mode`, nyelvek, elemző és összefoglaló modell |
|
||||
| `GET /v1/packages` | – | a csomagkatalógus árral, tartalommal, megtakarítással, elemzésenkénti árral (lásd `docs/csomagok.md`) |
|
||||
| `POST /v1/auth/register` | – | `{email, password, display_name?, locale?}` → munkamenet; megerősítő e-mailt küld |
|
||||
| `POST /v1/auth/register` | – | `{email, password, display_name?, locale?, invite_token?}` → munkamenet; megerősítő e-mailt küld |
|
||||
| `POST /v1/auth/login` | – | `{email, password}` |
|
||||
| `POST /v1/auth/google` | – | `{id_token}`; `created: true`, ha most jött létre a fiók |
|
||||
| `POST /v1/auth/google` | – | `{id_token, invite_token?}`; `created: true`, ha most jött létre a fiók; meghívó nélkül 403 `not_invited` |
|
||||
| `POST /v1/auth/logout`, `/logout-all` | user | kijelentkezés erről, illetve minden eszközről |
|
||||
| `POST /v1/auth/verify-email` | – | `{token}` az e-mailben kapott linkből |
|
||||
| `POST /v1/auth/resend-verification` | user | |
|
||||
@@ -79,6 +85,13 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh
|
||||
| `PATCH /v1/admin/users/{id}` | admin | `{roles: [...]}`; a saját admin szerep nem vehető el |
|
||||
| `POST /v1/admin/users/{id}/packages` | admin | `{package, note?}`: csomag kiosztása ajándékként (`package_orders`, ár 0) |
|
||||
| `POST /v1/admin/users/{id}/credits` | admin | `{unit: natal\|synastry, delta, note?}`: elemzések jóváírása vagy levonása |
|
||||
| `GET`/`POST /v1/admin/invitations` | admin | lista (állapot, az utolsó levél állapota, várólista); új: `{emails: [...], message?, locale?}`, címenként `invited` (linkkel), `invalid`, `already_user`, `already_invited` vagy `opted_out` |
|
||||
| `POST /v1/admin/invitations/{id}/resend`, `DELETE …/{id}` | admin | újraküldés új linkkel és újabb 30 nappal (legfeljebb 3 küldés, 24 óránként); visszavonás |
|
||||
| `POST /v1/admin/invitations/preview` | admin | `{message?, locale?, send_to_me?}`: a meghívólevél HTML- és szöveges változata mintalinkekkel; kérésre tesztpéldány az adminnak |
|
||||
| `DELETE /v1/admin/waitlist/{email}` | admin | törlés a várólistáról |
|
||||
| `GET /v1/public/invitations/{token}` | – | a meghívó adatai a belépőoldalnak (ki hívott, üzenet, állapot) |
|
||||
| `POST /v1/public/invitations/unsubscribe?token=` | – | „Nem kérek több meghívót”: a lábléc linkjéről és a levelezők egykattintásos gombjáról (RFC 8058) |
|
||||
| `POST /v1/public/waitlist` | – | `{email, locale?}`; mindig 202, nem árulja el, kinek van fiókja |
|
||||
| `GET /v1/admin/prompts` | admin | a tömör és a részletes elemzés system promptja nyelvenként: érvényes szöveg, alapértelmezett, változatok |
|
||||
| `PUT /v1/admin/prompts/{kind}/{language}` | admin | `{system}` új változatként menti (`null` vagy az alapértelmezett szöveg: vissza a beépítettre); az új elemzések `prompt_version`-je `v2-r<id>` |
|
||||
| `POST /v1/admin/prompts/{kind}/{language}/preview` | admin | `{system, chart_id}`: próbafuttatás a (mentetlen) szöveggel egy saját képleten; nem kerül a képlethez, nem gyorsítótárazott, nem fogy egység; egyszerre legfeljebb 3 |
|
||||
@@ -124,5 +137,5 @@ A [worker](../worker/README.md) kiküldi az e-maileket, megírja az elemzéseket
|
||||
## Korlátok
|
||||
|
||||
- **Saját születési adatok módosítása:** az első mentés után egy órán belül még háromszor javíthatók, utána naponta egyszer (`birth_data_changes` tábla). A tiltott módosítás 429-et ad `birth_data_change_limit` kóddal, a felhasználónak szóló üzenettel („A rendszer csak napi egy módosítást engedélyez. …”). A `/v1/me` `birth_change` mezője mutatja, él-e a napi korlát. Más emberek képleteit ez nem érinti.
|
||||
- **Személyek** (más emberek képletei, `charts.kind = 'person'`): minden új személy egy `person` egységet használ (`credit_ledger`, `reason = 'person'`); a törlés nem adja vissza. Helyet a csomagok adnak; korlátlan az `unlimited_persons` jogosultsággal és futó Korlátlan csomaggal. Ha elfogyott, 409 `person_limit_reached`. Egy személy születési adatai a felvétel után egy órán belül javíthatók (`PATCH /v1/charts/{id}` `birth` mezővel), utána 409 `person_locked`. Részletes elemzés (képlet vagy összevetés) után sem (409 `person_analysed`), és akkor sem, ha valaki más összevetésében szerepel (409 `person_in_synastry`); a saját, elemzés nélküli összevetései a javításkor törlődnek. A `/v1/me` `persons` mezője: `used`, `limit`, `left`, `unlimited`.
|
||||
- **Személyek** (más emberek képletei, `charts.kind = 'person'`): minden új személy egy `person` egységet használ (`credit_ledger`, `reason = 'person'`); a törlés nem adja vissza. Helyet a csomagok adnak; korlátlan az `unlimited_persons` jogosultsággal. Ha elfogyott, 409 `person_limit_reached`. Egy személy születési adatai a felvétel után egy órán belül javíthatók (`PATCH /v1/charts/{id}` `birth` mezővel), utána 409 `person_locked`. A név (`label`) bármikor változhat; ha a `birth` ugyanaz, mint a tárolt (vagy ugyanazt a képletet adja), nincs újraszámolás, és az elemzések, összevetések maradnak. Részletes elemzés (képlet vagy összevetés) után sem (409 `person_analysed`), és akkor sem, ha valaki más összevetésében szerepel (409 `person_in_synastry`); a saját, elemzés nélküli összevetései a javításkor törlődnek. A `/v1/me` `persons` mezője: `used`, `limit`, `left`, `unlimited`.
|
||||
- **Admin:** nincs módosítási korlát, korlátlan személy, a személyek adatai bármikor javíthatók, és a részletes elemzés ingyenes (nem fogy egység).
|
||||
|
||||
@@ -2,6 +2,24 @@
|
||||
|
||||
use anyhow::{Context, bail};
|
||||
|
||||
/// Who may create an account.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum SignupMode {
|
||||
/// Anyone.
|
||||
Open,
|
||||
/// Only invited addresses (or the holder of an invitation link).
|
||||
Invite,
|
||||
}
|
||||
|
||||
impl SignupMode {
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
SignupMode::Open => "open",
|
||||
SignupMode::Invite => "invite",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Config {
|
||||
/// `DATABASE_URL` (required).
|
||||
@@ -45,12 +63,13 @@ pub struct Config {
|
||||
pub summary_model: String,
|
||||
/// `ANALYSIS_PROMPT_VERSION` (default `v2`); part of the analysis cache key.
|
||||
pub prompt_version: String,
|
||||
/// `MAX_CHARTS_PER_USER` (default 1000): a safety cap, also for unlimited packages.
|
||||
/// `MAX_CHARTS_PER_USER` (default 1000): a safety cap.
|
||||
pub max_charts_per_user: i64,
|
||||
/// `FREE_PERSON_SLOTS` (default 0): persons a user may add without a package.
|
||||
pub free_person_slots: i64,
|
||||
/// `UNLIMITED_DAILY_LIMIT` (default 5): new detailed analyses a day with the unlimited package.
|
||||
pub unlimited_daily_limit: i64,
|
||||
/// `SIGNUP_MODE` (`invite` or `open`, default `invite`): whether new
|
||||
/// accounts need an invitation.
|
||||
pub signup_mode: SignupMode,
|
||||
}
|
||||
|
||||
fn var(name: &str) -> Option<String> {
|
||||
@@ -105,7 +124,11 @@ impl Config {
|
||||
prompt_version: var("ANALYSIS_PROMPT_VERSION").unwrap_or_else(|| "v2".into()),
|
||||
max_charts_per_user: parsed("MAX_CHARTS_PER_USER", 1000)?,
|
||||
free_person_slots: parsed("FREE_PERSON_SLOTS", 0)?,
|
||||
unlimited_daily_limit: parsed("UNLIMITED_DAILY_LIMIT", 5)?,
|
||||
signup_mode: match var("SIGNUP_MODE").as_deref() {
|
||||
None | Some("invite") => SignupMode::Invite,
|
||||
Some("open") => SignupMode::Open,
|
||||
Some(other) => bail!("invalid SIGNUP_MODE '{other}': use 'invite' or 'open'"),
|
||||
},
|
||||
};
|
||||
if config.session_ttl_days < 1 {
|
||||
bail!("SESSION_TTL_DAYS must be at least 1");
|
||||
@@ -135,7 +158,7 @@ impl Config {
|
||||
prompt_version: "v1".into(),
|
||||
max_charts_per_user: 50,
|
||||
free_person_slots: 5,
|
||||
unlimited_daily_limit: 3,
|
||||
signup_mode: SignupMode::Open,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Analysis units: a detailed natal analysis uses one `natal` unit, a
|
||||
//! synastry analysis one `synastry` unit. Units come from purchases or an
|
||||
//! admin; a failed analysis gives its unit back (the worker does that).
|
||||
//! synastry analysis one `synastry` unit, a yearly forecast one `forecast`
|
||||
//! unit. Units come from purchases or an admin; a failed analysis gives its
|
||||
//! unit back (the worker does that).
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
@@ -14,6 +15,8 @@ use crate::error::ApiError;
|
||||
pub enum Unit {
|
||||
Natal,
|
||||
Synastry,
|
||||
/// A yearly forecast (see `routes::forecasts`).
|
||||
Forecast,
|
||||
/// A slot for adding a person (see [`crate::persons`]).
|
||||
Person,
|
||||
}
|
||||
@@ -23,6 +26,7 @@ impl Unit {
|
||||
match self {
|
||||
Unit::Natal => "natal",
|
||||
Unit::Synastry => "synastry",
|
||||
Unit::Forecast => "forecast",
|
||||
Unit::Person => "person",
|
||||
}
|
||||
}
|
||||
@@ -33,6 +37,7 @@ impl Unit {
|
||||
pub struct Balance {
|
||||
pub natal: i64,
|
||||
pub synastry: i64,
|
||||
pub forecast: i64,
|
||||
/// Bought person slots (not the slots left; see [`crate::persons::slots`]).
|
||||
pub person: i64,
|
||||
}
|
||||
@@ -42,26 +47,28 @@ impl Balance {
|
||||
match unit {
|
||||
Unit::Natal => self.natal,
|
||||
Unit::Synastry => self.synastry,
|
||||
Unit::Forecast => self.forecast,
|
||||
Unit::Person => self.person,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn view(self) -> Value {
|
||||
json!({ "natal": self.natal, "synastry": self.synastry })
|
||||
json!({ "natal": self.natal, "synastry": self.synastry, "forecast": self.forecast })
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn balance(conn: &mut PgConnection, user_id: Uuid) -> Result<Balance, ApiError> {
|
||||
let (natal, synastry, person): (i64, i64, i64) = sqlx::query_as(
|
||||
let (natal, synastry, forecast, person): (i64, i64, i64, i64) = sqlx::query_as(
|
||||
"SELECT COALESCE(SUM(delta) FILTER (WHERE unit = 'natal'), 0)::bigint, \
|
||||
COALESCE(SUM(delta) FILTER (WHERE unit = 'synastry'), 0)::bigint, \
|
||||
COALESCE(SUM(delta) FILTER (WHERE unit = 'forecast'), 0)::bigint, \
|
||||
COALESCE(SUM(delta) FILTER (WHERE unit = 'person' AND reason <> 'person'), 0)::bigint \
|
||||
FROM credit_ledger WHERE user_id = $1",
|
||||
)
|
||||
.bind(user_id)
|
||||
.fetch_one(conn)
|
||||
.await?;
|
||||
Ok(Balance { natal, synastry, person })
|
||||
Ok(Balance { natal, synastry, forecast, person })
|
||||
}
|
||||
|
||||
/// Spends one unit inside the caller's transaction. The user row is locked
|
||||
|
||||
@@ -16,6 +16,9 @@ pub enum ApiError {
|
||||
InvalidCredentials(String),
|
||||
#[error("{0}")]
|
||||
Forbidden(String),
|
||||
/// Refused, with a code the frontend acts on (e.g. `not_invited`).
|
||||
#[error("{message}")]
|
||||
Refused { code: &'static str, message: String },
|
||||
#[error("{0} not found")]
|
||||
NotFound(&'static str),
|
||||
#[error("{message}")]
|
||||
@@ -51,6 +54,7 @@ impl ApiError {
|
||||
ApiError::Unauthorized => (StatusCode::UNAUTHORIZED, "unauthorized"),
|
||||
ApiError::InvalidCredentials(_) => (StatusCode::UNAUTHORIZED, "invalid_credentials"),
|
||||
ApiError::Forbidden(_) => (StatusCode::FORBIDDEN, "forbidden"),
|
||||
ApiError::Refused { code, .. } => (StatusCode::FORBIDDEN, code),
|
||||
ApiError::NotFound(_) => (StatusCode::NOT_FOUND, "not_found"),
|
||||
ApiError::Conflict { code, .. } => (StatusCode::CONFLICT, code),
|
||||
ApiError::Gone(_) => (StatusCode::GONE, "gone"),
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
//! fixed here; see `docs/csomagok.md` for the reasoning behind it.
|
||||
//!
|
||||
//! A package gives analysis units and person slots (`credit_ledger` rows
|
||||
//! with reason `package`) that never expire, or a time-limited `unlimited`
|
||||
//! entitlement: analyses and persons without limit, with a daily fair-use cap.
|
||||
//! with reason `package`) that never expire. There is no unlimited package on
|
||||
//! purpose: it would be easy to resell (e.g. by an astrologer).
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use sqlx::PgConnection;
|
||||
@@ -14,9 +14,11 @@ use crate::credits::Unit;
|
||||
use crate::error::ApiError;
|
||||
|
||||
/// List prices of the single items, for showing what a package saves.
|
||||
const NATAL_PRICE: i64 = 2_990;
|
||||
const SYNASTRY_PRICE: i64 = 3_490;
|
||||
const PERSON_PRICE: i64 = 398; // 1 990 Ft for five
|
||||
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)]
|
||||
pub enum Tier {
|
||||
@@ -36,9 +38,8 @@ pub struct Package {
|
||||
pub price_huf: i64,
|
||||
pub natal: i64,
|
||||
pub synastry: i64,
|
||||
pub forecast: i64,
|
||||
pub persons: i64,
|
||||
/// Months of unlimited analyses and persons.
|
||||
pub unlimited_months: Option<i64>,
|
||||
/// Badge on the card ("Legnépszerűbb").
|
||||
pub badge: Option<&'static str>,
|
||||
}
|
||||
@@ -49,59 +50,59 @@ pub const CATALOG: [Package; 6] = [
|
||||
name: "Egy elemzés",
|
||||
tagline: "Egy részletes képletelemzés: neked vagy egy felvett személynek.",
|
||||
tier: Tier::Main,
|
||||
price_huf: 2_990,
|
||||
price_huf: 2_000,
|
||||
natal: 1,
|
||||
synastry: 0,
|
||||
forecast: 0,
|
||||
persons: 0,
|
||||
unlimited_months: None,
|
||||
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: 6_990,
|
||||
price_huf: 6_000,
|
||||
natal: 2,
|
||||
synastry: 1,
|
||||
forecast: 2,
|
||||
persons: 1,
|
||||
unlimited_months: None,
|
||||
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: 11_990,
|
||||
price_huf: 11_000,
|
||||
natal: 6,
|
||||
synastry: 5,
|
||||
forecast: 6,
|
||||
persons: 5,
|
||||
unlimited_months: None,
|
||||
badge: Some("Legnépszerűbb"),
|
||||
},
|
||||
Package {
|
||||
id: "unlimited",
|
||||
name: "Korlátlan",
|
||||
tagline: "Egy évig bárki, bármennyi elemzés és összevetés.",
|
||||
tier: Tier::Main,
|
||||
price_huf: 17_990,
|
||||
natal: 0,
|
||||
synastry: 0,
|
||||
persons: 0,
|
||||
unlimited_months: Some(12),
|
||||
badge: None,
|
||||
},
|
||||
Package {
|
||||
id: "addon_synastry",
|
||||
name: "+1 kapcsolati elemzés",
|
||||
tagline: "Egy újabb összevetés részletes elemzése.",
|
||||
tier: Tier::Addon,
|
||||
price_huf: 3_490,
|
||||
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,
|
||||
unlimited_months: None,
|
||||
badge: None,
|
||||
},
|
||||
Package {
|
||||
@@ -109,11 +110,11 @@ pub const CATALOG: [Package; 6] = [
|
||||
name: "+5 személy",
|
||||
tagline: "Még öt ember képlete (az elemzés külön jár).",
|
||||
tier: Tier::Addon,
|
||||
price_huf: 1_990,
|
||||
price_huf: 1_500,
|
||||
natal: 0,
|
||||
synastry: 0,
|
||||
forecast: 0,
|
||||
persons: 5,
|
||||
unlimited_months: None,
|
||||
badge: None,
|
||||
},
|
||||
];
|
||||
@@ -123,19 +124,18 @@ pub fn find(id: &str) -> Option<&'static Package> {
|
||||
}
|
||||
|
||||
impl Package {
|
||||
/// What the contents would cost one by one (`None` for the unlimited one).
|
||||
fn list_price(&self) -> Option<i64> {
|
||||
self.unlimited_months
|
||||
.is_none()
|
||||
.then(|| self.natal * NATAL_PRICE + self.synastry * SYNASTRY_PRICE + self.persons * PERSON_PRICE)
|
||||
/// What the contents would cost one by one.
|
||||
fn list_price(&self) -> i64 {
|
||||
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 savings = self
|
||||
.list_price()
|
||||
.filter(|&list| list > self.price_huf)
|
||||
.map(|list| ((list - self.price_huf) * 100 + list / 2) / list);
|
||||
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!({
|
||||
"id": self.id,
|
||||
"name": self.name,
|
||||
@@ -144,10 +144,10 @@ impl Package {
|
||||
"price_huf": self.price_huf,
|
||||
"natal": self.natal,
|
||||
"synastry": self.synastry,
|
||||
"forecast": self.forecast,
|
||||
"persons": self.persons,
|
||||
"unlimited_months": self.unlimited_months,
|
||||
"badge": self.badge,
|
||||
"list_price_huf": self.list_price(),
|
||||
"list_price_huf": list,
|
||||
"savings_percent": savings,
|
||||
"per_analysis_huf": (analyses > 0).then(|| (self.price_huf + analyses / 2) / analyses),
|
||||
})
|
||||
@@ -197,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;
|
||||
}
|
||||
@@ -216,56 +221,22 @@ pub async fn grant(
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
}
|
||||
if let Some(months) = package.unlimited_months {
|
||||
// Buying again extends from the current end, not from today.
|
||||
sqlx::query(
|
||||
"INSERT INTO entitlements (user_id, entitlement, note, created_by, expires_at) \
|
||||
VALUES ($1, 'unlimited', $2, $3, now() + make_interval(months => $4)) \
|
||||
ON CONFLICT (user_id, entitlement) DO UPDATE SET \
|
||||
expires_at = greatest(entitlements.expires_at, now()) + make_interval(months => $4), \
|
||||
note = EXCLUDED.note, created_by = EXCLUDED.created_by",
|
||||
)
|
||||
.bind(user_id)
|
||||
.bind(package.name)
|
||||
.bind(created_by)
|
||||
.bind(months as i32)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
}
|
||||
Ok(order)
|
||||
}
|
||||
|
||||
/// Until when the user's unlimited package runs (`None`: none, or it ended).
|
||||
pub async fn unlimited_until(conn: &mut PgConnection, user_id: Uuid) -> Result<Option<OffsetDateTime>, ApiError> {
|
||||
let until: Option<OffsetDateTime> = sqlx::query_scalar(
|
||||
"SELECT expires_at FROM entitlements \
|
||||
WHERE user_id = $1 AND entitlement = 'unlimited' AND expires_at > now()",
|
||||
)
|
||||
.bind(user_id)
|
||||
.fetch_optional(conn)
|
||||
.await?
|
||||
.flatten();
|
||||
Ok(until)
|
||||
}
|
||||
|
||||
/// The fair-use cap of the unlimited package: new detailed analyses in 24 hours.
|
||||
pub async fn check_fair_use(conn: &mut PgConnection, user_id: Uuid, daily_limit: i64) -> Result<(), ApiError> {
|
||||
let (count,): (i64,) = sqlx::query_as(
|
||||
"SELECT count(*) FROM analyses WHERE requested_by = $1 AND kind IN ('natal', 'synastry') \
|
||||
AND created_at > now() - interval '24 hours'",
|
||||
)
|
||||
.bind(user_id)
|
||||
.fetch_one(conn)
|
||||
.await?;
|
||||
if count >= daily_limit {
|
||||
return Err(ApiError::Limited {
|
||||
code: "fair_use_limit",
|
||||
message: format!(
|
||||
"A korlátlan csomaggal naponta legfeljebb {daily_limit} új részletes elemzés kérhető. Holnap folytathatod."
|
||||
),
|
||||
});
|
||||
}
|
||||
Ok(())
|
||||
/// The package to show for the user (header, profile): the latest bought or
|
||||
/// given package of the main ladder (top-ups do not count). `None`: no package.
|
||||
pub async fn current(
|
||||
conn: &mut PgConnection,
|
||||
user_id: Uuid,
|
||||
) -> Result<Option<(&'static Package, OffsetDateTime)>, ApiError> {
|
||||
let orders: Vec<(String, OffsetDateTime)> =
|
||||
sqlx::query_as("SELECT package, created_at FROM package_orders WHERE user_id = $1 ORDER BY created_at DESC")
|
||||
.bind(user_id)
|
||||
.fetch_all(conn)
|
||||
.await?;
|
||||
// Orders of packages no longer sold (the former unlimited one) are skipped.
|
||||
Ok(orders.into_iter().find_map(|(id, at)| find(&id).filter(|p| p.tier == Tier::Main).map(|p| (p, at))))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -276,10 +247,12 @@ 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"], 68);
|
||||
assert_eq!(find("couple").unwrap().view()["savings_percent"], 29);
|
||||
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").unwrap().view()["list_price_huf"].is_null());
|
||||
assert!(find("unlimited").is_none());
|
||||
assert!(CATALOG.iter().all(|p| find(p.id).is_some()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
//! Persons: charts of other people (name and birth data) a user adds next to
|
||||
//! their own. Each new person uses one `person` unit, bought in packages;
|
||||
//! deleting a person does not give it back. The `unlimited_persons`
|
||||
//! entitlement, a running unlimited package and admins have no limit.
|
||||
//! entitlement and admins have no limit.
|
||||
//!
|
||||
//! A person's birth data can be corrected within an hour of adding them,
|
||||
//! then it is locked (admins: any time).
|
||||
@@ -54,7 +54,7 @@ pub async fn slots(conn: &mut PgConnection, auth: &AuthUser, free: i64) -> Resul
|
||||
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger \
|
||||
WHERE user_id = $1 AND unit = 'person' AND reason <> 'person'), \
|
||||
EXISTS (SELECT 1 FROM entitlements WHERE user_id = $1 \
|
||||
AND (entitlement = 'unlimited_persons' OR (entitlement = 'unlimited' AND expires_at > now())))",
|
||||
AND entitlement = 'unlimited_persons')",
|
||||
)
|
||||
.bind(auth.id())
|
||||
.fetch_one(conn)
|
||||
|
||||
@@ -32,7 +32,7 @@ pub async fn me(State(state): St, auth: AuthUser) -> ApiResult<Json<Value>> {
|
||||
let balance = credits::balance(&mut conn, auth.id()).await?;
|
||||
let birth_change = crate::birth_changes::view(&mut conn, &auth).await?;
|
||||
let persons = crate::persons::slots(&mut conn, &auth, state.config.free_person_slots).await?;
|
||||
let unlimited = crate::packages::unlimited_until(&mut conn, auth.id()).await?;
|
||||
let package = crate::packages::current(&mut conn, auth.id()).await?;
|
||||
Ok(Json(json!({
|
||||
"user": UserView::from(&auth.user),
|
||||
"providers": providers.into_iter().map(|(p,)| p).collect::<Vec<_>>(),
|
||||
@@ -40,7 +40,7 @@ pub async fn me(State(state): St, auth: AuthUser) -> ApiResult<Json<Value>> {
|
||||
"analyses_left": balance.view(),
|
||||
"birth_change": birth_change,
|
||||
"persons": persons.view(),
|
||||
"unlimited_until": rfc3339_opt(unlimited),
|
||||
"package": package.map(|(p, since)| json!({ "id": p.id, "name": p.name, "since": rfc3339(since) })),
|
||||
})))
|
||||
}
|
||||
|
||||
@@ -130,7 +130,6 @@ pub async fn credits(State(state): St, auth: AuthUser) -> ApiResult<Json<Value>>
|
||||
.await?;
|
||||
Ok(Json(json!({
|
||||
"balance": balance.view(),
|
||||
"analysis_model": state.config.analysis_model,
|
||||
"ledger": ledger.into_iter().map(|(id, unit, delta, reason, analysis_id, note, at)| json!({
|
||||
"id": id, "unit": unit, "delta": delta, "reason": reason,
|
||||
"analysis_id": analysis_id, "note": note, "created_at": rfc3339(at),
|
||||
@@ -157,7 +156,8 @@ pub async fn export(State(state): St, auth: AuthUser) -> ApiResult<impl IntoResp
|
||||
"charts": rows("SELECT json_build_object('id', id, 'label', label, 'is_primary', is_primary, 'birth_data', birth_data, 'result', result, 'created_at', created_at) FROM charts WHERE owner_id = $1").await?,
|
||||
"synastries": rows("SELECT json_build_object('id', s.id, 'owner_id', s.owner_id, 'chart1_id', s.chart1_id, 'chart2_id', s.chart2_id, 'result', s.result, 'created_at', s.created_at) FROM synastries s JOIN charts c1 ON c1.id = s.chart1_id JOIN charts c2 ON c2.id = s.chart2_id WHERE s.owner_id = $1 OR c1.owner_id = $1 OR c2.owner_id = $1").await?,
|
||||
"invites": rows("SELECT json_build_object('id', id, 'chart_id', inviter_chart_id, 'message', message, 'created_at', created_at, 'expires_at', expires_at, 'accepted_at', accepted_at) FROM synastry_invites WHERE inviter_id = $1").await?,
|
||||
"analyses": rows("SELECT json_build_object('id', a.id, 'kind', a.kind, 'chart_id', a.chart_id, 'synastry_id', a.synastry_id, 'language', a.language, 'model', a.model, 'status', a.status, 'content', a.content, 'created_at', a.created_at) FROM analyses a WHERE a.requested_by = $1 OR a.chart_id IN (SELECT id FROM charts WHERE owner_id = $1)").await?,
|
||||
"forecasts": rows("SELECT json_build_object('id', f.id, 'chart_id', f.chart_id, 'year', f.year, 'location', f.location, 'result', f.result, 'created_at', f.created_at) FROM forecasts f JOIN charts c ON c.id = f.chart_id WHERE c.owner_id = $1").await?,
|
||||
"analyses": rows("SELECT json_build_object('id', a.id, 'kind', a.kind, 'chart_id', a.chart_id, 'synastry_id', a.synastry_id, 'forecast_id', a.forecast_id, 'language', a.language, 'status', a.status, 'content', a.content, 'created_at', a.created_at) FROM analyses a WHERE a.requested_by = $1 OR a.chart_id IN (SELECT id FROM charts WHERE owner_id = $1)").await?,
|
||||
"credit_ledger": rows("SELECT json_build_object('unit', unit, 'delta', delta, 'reason', reason, 'note', note, 'created_at', created_at) FROM credit_ledger WHERE user_id = $1 ORDER BY created_at").await?,
|
||||
"shares": rows("SELECT json_build_object('slug', slug, 'kind', kind, 'title', title, 'show_birth_data', show_birth_data, 'view_count', view_count, 'created_at', created_at, 'revoked_at', revoked_at) FROM shares WHERE owner_id = $1").await?,
|
||||
});
|
||||
|
||||
@@ -33,26 +33,14 @@ pub async fn list_users(
|
||||
let limit = query.limit.unwrap_or(50).clamp(1, 200);
|
||||
let offset = query.offset.unwrap_or(0).max(0);
|
||||
let pattern = query.q.as_deref().map(|q| format!("%{}%", q.trim().replace(['%', '_'], "")));
|
||||
type Row = (
|
||||
Uuid,
|
||||
String,
|
||||
Option<String>,
|
||||
Vec<String>,
|
||||
bool,
|
||||
OffsetDateTime,
|
||||
Option<OffsetDateTime>,
|
||||
i64,
|
||||
i64,
|
||||
i64,
|
||||
Option<OffsetDateTime>,
|
||||
);
|
||||
type Row =
|
||||
(Uuid, String, Option<String>, Vec<String>, bool, OffsetDateTime, Option<OffsetDateTime>, i64, i64, i64, i64);
|
||||
let rows: Vec<Row> = sqlx::query_as(
|
||||
"SELECT u.id, u.email, u.display_name, u.roles, u.email_verified_at IS NOT NULL, u.created_at, u.last_login_at, \
|
||||
(SELECT count(*) FROM charts c WHERE c.owner_id = u.id), \
|
||||
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'natal'), \
|
||||
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'synastry'), \
|
||||
(SELECT e.expires_at FROM entitlements e \
|
||||
WHERE e.user_id = u.id AND e.entitlement = 'unlimited' AND e.expires_at > now()) \
|
||||
(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",
|
||||
@@ -64,12 +52,11 @@ pub async fn list_users(
|
||||
.await?;
|
||||
let users: Vec<Value> = rows
|
||||
.into_iter()
|
||||
.map(|(id, email, name, roles, verified, created, last_login, charts, natal, synastry, unlimited)| {
|
||||
.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},
|
||||
"unlimited_until": rfc3339_opt(unlimited),
|
||||
"charts": charts, "analyses_left": {"natal": natal, "synastry": synastry, "forecast": forecast},
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
@@ -167,14 +154,13 @@ pub async fn grant_package(
|
||||
let mut tx = state.db.begin().await?;
|
||||
let order = packages::grant(&mut tx, id, package, Source::Admin, Some(admin.id()), note.as_deref()).await?;
|
||||
let balance = credits::balance(&mut tx, id).await?;
|
||||
let unlimited = packages::unlimited_until(&mut tx, id).await?;
|
||||
tx.commit().await?;
|
||||
tracing::info!(admin = %admin.id(), user = %id, package = package.id, "package granted");
|
||||
Ok((
|
||||
StatusCode::CREATED,
|
||||
Json(json!({
|
||||
"order_id": order, "user_id": id, "package": package.id,
|
||||
"analyses_left": balance.view(), "unlimited_until": rfc3339_opt(unlimited),
|
||||
"analyses_left": balance.view(),
|
||||
})),
|
||||
))
|
||||
}
|
||||
|
||||
@@ -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,24 +22,25 @@ 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;
|
||||
use crate::auth::AuthUser;
|
||||
use crate::credits::{self, Unit};
|
||||
use crate::error::{ApiError, ApiResult};
|
||||
use crate::packages;
|
||||
use crate::views::{rfc3339, rfc3339_opt, sha256_hex};
|
||||
use db::Role;
|
||||
|
||||
#[derive(Debug, Clone, sqlx::FromRow)]
|
||||
/// An analysis as users see it; the model is left out on purpose (a business secret).
|
||||
pub struct AnalysisRow {
|
||||
pub id: Uuid,
|
||||
pub kind: String,
|
||||
pub chart_id: Option<Uuid>,
|
||||
pub synastry_id: Option<Uuid>,
|
||||
pub forecast_id: Option<Uuid>,
|
||||
pub language: String,
|
||||
pub model: String,
|
||||
pub prompt_version: String,
|
||||
pub status: String,
|
||||
pub content: Option<Value>,
|
||||
@@ -49,8 +50,9 @@ pub struct AnalysisRow {
|
||||
pub completed_at: Option<OffsetDateTime>,
|
||||
}
|
||||
|
||||
const ANALYSIS_COLUMNS: &str = "id, kind, chart_id, synastry_id, language, model, prompt_version, status, content, \
|
||||
error, credits_charged, created_at, completed_at";
|
||||
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 {
|
||||
pub fn view(&self) -> Value {
|
||||
@@ -59,8 +61,8 @@ impl AnalysisRow {
|
||||
"kind": self.kind,
|
||||
"chart_id": self.chart_id,
|
||||
"synastry_id": self.synastry_id,
|
||||
"forecast_id": self.forecast_id,
|
||||
"language": self.language,
|
||||
"model": self.model,
|
||||
"prompt_version": self.prompt_version,
|
||||
"status": self.status,
|
||||
"content": self.content,
|
||||
@@ -79,8 +81,8 @@ pub async fn find_analysis(db: &PgPool, id: Uuid) -> Result<Option<AnalysisRow>,
|
||||
.await?)
|
||||
}
|
||||
|
||||
/// Whether `user` may read the analysis: the chart's owner, or a member of
|
||||
/// the synastry.
|
||||
/// Whether `user` may read the analysis: the owner of the chart (or of the
|
||||
/// forecast's chart), or a member of the synastry.
|
||||
pub async fn can_see(db: &PgPool, analysis: &AnalysisRow, user: Uuid) -> Result<bool, ApiError> {
|
||||
if let Some(chart_id) = analysis.chart_id {
|
||||
return Ok(find_chart(db, chart_id).await?.is_some_and(|c| c.owner_id == user));
|
||||
@@ -88,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)
|
||||
}
|
||||
|
||||
@@ -110,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(
|
||||
@@ -119,19 +127,12 @@ async fn request(
|
||||
req: AnalysisRequest,
|
||||
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||||
let language = validate_locale(state, Some(req.language.as_deref().unwrap_or(&auth.user.locale)))?;
|
||||
// Admins and a running unlimited package (within its daily cap) use no unit.
|
||||
// Admins use no unit.
|
||||
let admin = auth.user.has_role(Role::Admin);
|
||||
let unlimited = !admin && {
|
||||
let mut conn = state.db.acquire().await?;
|
||||
let until = packages::unlimited_until(&mut conn, auth.id()).await?;
|
||||
if until.is_some() {
|
||||
packages::check_fair_use(&mut conn, auth.id(), state.config.unlimited_daily_limit).await?;
|
||||
}
|
||||
until.is_some()
|
||||
};
|
||||
let unit = match target {
|
||||
_ if admin || unlimited => None,
|
||||
_ if admin => None,
|
||||
Target::Synastry { .. } => Some(Unit::Synastry),
|
||||
Target::Forecast { .. } => Some(Unit::Forecast),
|
||||
_ => Some(Unit::Natal),
|
||||
};
|
||||
let model = state.config.analysis_model.clone();
|
||||
@@ -150,10 +151,11 @@ async fn queue(
|
||||
model: &str,
|
||||
unit: Option<Unit>,
|
||||
) -> Result<(StatusCode, AnalysisRow), ApiError> {
|
||||
let (kind, hash, chart_id, synastry_id) = match target {
|
||||
Target::Natal { chart_id, hash } => ("natal", hash, Some(*chart_id), None),
|
||||
Target::Summary { chart_id, hash } => ("summary", hash, Some(*chart_id), None),
|
||||
Target::Synastry { synastry_id, hash } => ("synastry", hash, None, Some(*synastry_id)),
|
||||
let (kind, hash, chart_id, synastry_id, forecast_id) = match target {
|
||||
Target::Natal { chart_id, hash } => ("natal", hash, Some(*chart_id), None, None),
|
||||
Target::Summary { chart_id, hash } => ("summary", hash, Some(*chart_id), None, None),
|
||||
Target::Synastry { synastry_id, hash } => ("synastry", hash, None, Some(*synastry_id), None),
|
||||
Target::Forecast { forecast_id, hash } => ("forecast", hash, None, None, Some(*forecast_id)),
|
||||
};
|
||||
// The cache key leaves out the admin-edited prompt revision, so a chart keeps
|
||||
// its analysis when the prompt changes; copying from another chart needs the same revision.
|
||||
@@ -167,12 +169,13 @@ async fn queue(
|
||||
// Already requested for this chart/synastry: return it.
|
||||
let existing: Option<AnalysisRow> = sqlx::query_as(&format!(
|
||||
"SELECT {ANALYSIS_COLUMNS} FROM analyses \
|
||||
WHERE (chart_id = $1 OR synastry_id = $2) AND cache_key = $3 AND status <> 'failed' \
|
||||
WHERE (chart_id = $1 OR synastry_id = $2 OR forecast_id = $4) AND cache_key = $3 AND status <> 'failed' \
|
||||
ORDER BY created_at DESC LIMIT 1"
|
||||
))
|
||||
.bind(chart_id)
|
||||
.bind(synastry_id)
|
||||
.bind(&cache_key)
|
||||
.bind(forecast_id)
|
||||
.fetch_optional(&state.db)
|
||||
.await?;
|
||||
if let Some(row) = existing {
|
||||
@@ -181,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();
|
||||
|
||||
@@ -212,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));
|
||||
@@ -235,6 +240,7 @@ async fn queue(
|
||||
.bind(None::<i32>)
|
||||
.bind(i32::from(unit.is_some()))
|
||||
.bind(None::<OffsetDateTime>)
|
||||
.bind(forecast_id)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
if let Some(unit) = unit {
|
||||
@@ -319,3 +325,23 @@ pub async fn get_one(State(state): St, auth: AuthUser, WithRejection(Path(id), _
|
||||
}
|
||||
Ok(Json(analysis.view()))
|
||||
}
|
||||
|
||||
pub async fn list_for_forecast(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
owned_forecast(&state.db, id, auth.id()).await?;
|
||||
list_where(&state.db, "forecast_id", id).await
|
||||
}
|
||||
|
||||
pub async fn request_for_forecast(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
body: Bytes,
|
||||
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||||
let (forecast, _) = owned_forecast(&state.db, id, auth.id()).await?;
|
||||
let req = optional_body(&body)?;
|
||||
request(&state, &auth, Target::Forecast { forecast_id: forecast.id, hash: forecast.forecast_hash }, req).await
|
||||
}
|
||||
|
||||
@@ -113,16 +113,28 @@ async fn consume_token(conn: &mut PgConnection, token: &str, purpose: &str) -> R
|
||||
row.map(|(id,)| id).ok_or(ApiError::InvalidToken)
|
||||
}
|
||||
|
||||
/// Queues an e-mail for the worker.
|
||||
/// Queues an e-mail to a user for the worker.
|
||||
pub async fn queue_email(conn: &mut PgConnection, user: &User, template: &str, payload: Value) -> Result<(), ApiError> {
|
||||
queue_email_to(conn, Some(user.id), &user.email, template, &user.locale, payload).await
|
||||
}
|
||||
|
||||
/// Queues an e-mail to any address (e.g. an invitation) for the worker.
|
||||
pub async fn queue_email_to(
|
||||
conn: &mut PgConnection,
|
||||
user_id: Option<Uuid>,
|
||||
to: &str,
|
||||
template: &str,
|
||||
locale: &str,
|
||||
payload: Value,
|
||||
) -> Result<(), ApiError> {
|
||||
sqlx::query(
|
||||
"INSERT INTO email_outbox (id, user_id, to_email, template, locale, payload) VALUES ($1, $2, $3, $4, $5, $6)",
|
||||
)
|
||||
.bind(Uuid::now_v7())
|
||||
.bind(user.id)
|
||||
.bind(&user.email)
|
||||
.bind(user_id)
|
||||
.bind(to)
|
||||
.bind(template)
|
||||
.bind(&user.locale)
|
||||
.bind(locale)
|
||||
.bind(payload)
|
||||
.execute(conn)
|
||||
.await?;
|
||||
@@ -156,6 +168,8 @@ pub struct RegisterRequest {
|
||||
password: String,
|
||||
display_name: Option<String>,
|
||||
locale: Option<String>,
|
||||
/// The invitation link's token, while sign-up needs an invitation.
|
||||
invite_token: Option<String>,
|
||||
}
|
||||
|
||||
/// Password endpoints answer 403 while `PASSWORD_LOGIN` is off.
|
||||
@@ -185,6 +199,7 @@ pub async fn register(
|
||||
if exists.is_some() {
|
||||
return Err(ApiError::conflict("email_taken", "an account with this e-mail address already exists"));
|
||||
}
|
||||
super::invitations::admit(&state, &mut tx, &email, req.invite_token.as_deref()).await?;
|
||||
let user_id = Uuid::now_v7();
|
||||
sqlx::query("INSERT INTO users (id, email, display_name, locale) VALUES ($1, $2, $3, $4)")
|
||||
.bind(user_id)
|
||||
@@ -201,6 +216,7 @@ pub async fn register(
|
||||
.bind(&email)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
super::invitations::mark_accepted(&mut tx, user_id, &email, req.invite_token.as_deref()).await?;
|
||||
let mut user = load_user(&mut tx, user_id).await?;
|
||||
apply_bootstrap_admin(&state, &mut tx, &mut user).await?;
|
||||
queue_verification(&state, &mut tx, &user).await?;
|
||||
@@ -266,6 +282,8 @@ pub async fn login(
|
||||
pub struct GoogleRequest {
|
||||
/// ID token (JWT) from Google Identity Services.
|
||||
id_token: String,
|
||||
/// The invitation link's token, while sign-up needs an invitation.
|
||||
invite_token: Option<String>,
|
||||
}
|
||||
|
||||
/// Logs in with Google. An unknown Google account is linked to the existing
|
||||
@@ -311,6 +329,7 @@ pub async fn google(
|
||||
(id, false)
|
||||
}
|
||||
None => {
|
||||
super::invitations::admit(&state, &mut tx, &email, req.invite_token.as_deref()).await?;
|
||||
let id = Uuid::now_v7();
|
||||
let locale = claims
|
||||
.locale
|
||||
@@ -328,6 +347,7 @@ pub async fn google(
|
||||
.bind(locale)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
super::invitations::mark_accepted(&mut tx, id, &email, req.invite_token.as_deref()).await?;
|
||||
(id, true)
|
||||
}
|
||||
};
|
||||
|
||||
@@ -267,15 +267,25 @@ pub async fn update(
|
||||
None => chart.label.clone(),
|
||||
};
|
||||
let is_primary = req.is_primary.unwrap_or(chart.is_primary);
|
||||
let recalculated = match req.birth {
|
||||
// The same birth data again (e.g. only the name changed): no recalculation,
|
||||
// and the analyses and comparisons stay. A new calculation that gives the
|
||||
// same chart keeps them too.
|
||||
let birth = req.birth.map(clean_birth).transpose()?.filter(|b| *b != chart.birth_data);
|
||||
let recalculated = match birth {
|
||||
Some(birth) => Some(corrected_birth(&state, &auth, &chart, birth).await?),
|
||||
None => None,
|
||||
};
|
||||
let chart_changed = recalculated.as_ref().is_some_and(|(_, _, hash)| *hash != chart.chart_hash);
|
||||
let mut tx = state.db.begin().await?;
|
||||
if let Some((birth, result, hash)) = &recalculated {
|
||||
// The old summary, the comparisons (and an admin's analyses) no longer match the chart.
|
||||
sqlx::query("DELETE FROM analyses WHERE chart_id = $1").bind(id).execute(&mut *tx).await?;
|
||||
sqlx::query("DELETE FROM synastries WHERE chart1_id = $1 OR chart2_id = $1").bind(id).execute(&mut *tx).await?;
|
||||
if chart_changed {
|
||||
// The old summary, the comparisons (and an admin's analyses) no longer match the chart.
|
||||
sqlx::query("DELETE FROM analyses WHERE chart_id = $1").bind(id).execute(&mut *tx).await?;
|
||||
sqlx::query("DELETE FROM synastries WHERE chart1_id = $1 OR chart2_id = $1")
|
||||
.bind(id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
}
|
||||
sqlx::query("UPDATE charts SET birth_data = $1, result = $2, chart_hash = $3 WHERE id = $4")
|
||||
.bind(birth)
|
||||
.bind(result)
|
||||
@@ -303,7 +313,7 @@ pub async fn update(
|
||||
birth_changes::record(&mut tx, &auth, id).await?;
|
||||
}
|
||||
tx.commit().await?;
|
||||
if recalculated.is_some() {
|
||||
if chart_changed {
|
||||
queue_summary(&state, &auth, &row).await;
|
||||
}
|
||||
Ok(Json(row.owner_view()))
|
||||
|
||||
@@ -0,0 +1,303 @@
|
||||
//! Yearly forecasts of a chart: one year of life from a solar return
|
||||
//! (birthday) to the next, calculated by the horoscope service for where the
|
||||
//! person is on the birthday. The calculation (solar return chart, transit
|
||||
//! timeline, progressions, profection, eclipses) is free; its detailed text
|
||||
//! analysis uses a `forecast` unit (see [`super::analyses`]).
|
||||
//!
|
||||
//! Users can calculate the year of life they are in, and the next one from
|
||||
//! [`NEXT_YEAR_DAYS`] days before the birthday; admins any year.
|
||||
|
||||
use axum::Json;
|
||||
use axum::extract::State;
|
||||
use axum::http::StatusCode;
|
||||
use axum_extra::extract::WithRejection;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
use sqlx::PgPool;
|
||||
use time::{Date, Month, OffsetDateTime};
|
||||
use uuid::Uuid;
|
||||
|
||||
use super::charts::{ChartRow, find_chart, owned_chart};
|
||||
use super::{Body, IdPath, St};
|
||||
use crate::auth::AuthUser;
|
||||
use crate::error::{ApiError, ApiResult};
|
||||
use crate::views::{rfc3339, sha256_hex};
|
||||
use db::Role;
|
||||
|
||||
/// The next year of life can be calculated this many days before the birthday.
|
||||
pub const NEXT_YEAR_DAYS: i64 = 30;
|
||||
/// At most this many forecasts (years and places) per chart.
|
||||
const MAX_PER_CHART: i64 = 20;
|
||||
|
||||
#[derive(Debug, Clone, sqlx::FromRow)]
|
||||
pub struct ForecastRow {
|
||||
pub id: Uuid,
|
||||
pub chart_id: Uuid,
|
||||
pub year: i32,
|
||||
pub location: Option<Value>,
|
||||
pub result: Value,
|
||||
pub forecast_hash: String,
|
||||
pub created_at: OffsetDateTime,
|
||||
}
|
||||
|
||||
const FORECAST_COLUMNS: &str = "id, chart_id, year, location, result, forecast_hash, created_at";
|
||||
|
||||
impl ForecastRow {
|
||||
/// Where the year is reckoned, for lists: the place name or the coordinates.
|
||||
fn place(&self) -> Value {
|
||||
let sr = &self.result["solar_return"]["location"];
|
||||
let loc = &self.result["location"];
|
||||
sr.pointer("/place/name").or(loc.get("place")).cloned().unwrap_or(Value::Null)
|
||||
}
|
||||
|
||||
pub fn summary_view(&self) -> Value {
|
||||
let f = &self.result["forecast"];
|
||||
json!({
|
||||
"id": self.id,
|
||||
"chart_id": self.chart_id,
|
||||
"year": self.year,
|
||||
"start": f["start"],
|
||||
"end": f["end"],
|
||||
"place": self.place(),
|
||||
"birth_place": self.location.is_none(),
|
||||
"created_at": rfc3339(self.created_at),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn view(&self) -> Value {
|
||||
let mut v = self.summary_view();
|
||||
v["location"] = self.location.clone().unwrap_or(Value::Null);
|
||||
v["result"] = self.result.clone();
|
||||
v
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn find_forecast(db: &PgPool, id: Uuid) -> Result<Option<ForecastRow>, ApiError> {
|
||||
Ok(sqlx::query_as(&format!("SELECT {FORECAST_COLUMNS} FROM forecasts WHERE id = $1"))
|
||||
.bind(id)
|
||||
.fetch_optional(db)
|
||||
.await?)
|
||||
}
|
||||
|
||||
/// A forecast of a chart of `owner`; 404 otherwise.
|
||||
pub async fn owned_forecast(db: &PgPool, id: Uuid, owner: Uuid) -> Result<(ForecastRow, ChartRow), ApiError> {
|
||||
let forecast = find_forecast(db, id).await?.ok_or(ApiError::NotFound("forecast"))?;
|
||||
let chart = find_chart(db, forecast.chart_id).await?.filter(|c| c.owner_id == owner);
|
||||
chart.map(|c| (forecast, c)).ok_or(ApiError::NotFound("forecast"))
|
||||
}
|
||||
|
||||
/// The Gregorian birth date of a calculated chart.
|
||||
fn birth_date(chart: &ChartRow) -> Option<Date> {
|
||||
let text = chart.result.pointer("/time/date")?.as_str()?;
|
||||
let mut parts = text.split('-').map(str::parse::<i32>);
|
||||
let (y, m, d) = (parts.next()?.ok()?, parts.next()?.ok()?, parts.next()?.ok()?);
|
||||
Date::from_calendar_date(y, Month::try_from(m as u8).ok()?, d as u8).ok()
|
||||
}
|
||||
|
||||
/// The birthday in a year (29 February is the 28th in common years).
|
||||
fn birthday(birth: Date, year: i32) -> Option<Date> {
|
||||
Date::from_calendar_date(year, birth.month(), birth.day())
|
||||
.or_else(|_| Date::from_calendar_date(year, birth.month(), birth.day() - 1))
|
||||
.ok()
|
||||
}
|
||||
|
||||
/// The years (of the solar return starting them) a user can calculate on
|
||||
/// `today`: the current year of life, and the next one close to the birthday.
|
||||
pub fn open_years(birth: Date, today: Date) -> Vec<i32> {
|
||||
let Some(this) = birthday(birth, today.year()) else { return Vec::new() };
|
||||
let current = if today >= this { today.year() } else { today.year() - 1 };
|
||||
let mut years = Vec::new();
|
||||
if current > birth.year() {
|
||||
years.push(current);
|
||||
}
|
||||
if birthday(birth, current + 1).is_some_and(|next| (next - today).whole_days() <= NEXT_YEAR_DAYS) {
|
||||
years.push(current + 1);
|
||||
}
|
||||
years
|
||||
}
|
||||
|
||||
/// Where the person is on the birthday, as the horoscope service takes it.
|
||||
#[derive(Debug, Clone, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Location {
|
||||
country: String,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
place: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
region: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
geonames_id: Option<u64>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
latitude: Option<f64>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
longitude: Option<f64>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Default)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct CreateForecast {
|
||||
/// Defaults to the current year of life.
|
||||
year: Option<i32>,
|
||||
/// Defaults to the birth place.
|
||||
location: Option<Location>,
|
||||
}
|
||||
|
||||
fn is_admin(auth: &AuthUser) -> bool {
|
||||
auth.user.has_role(Role::Admin)
|
||||
}
|
||||
|
||||
/// The years open to this user for a chart (admins: also every earlier one is allowed on request).
|
||||
fn years_for(chart: &ChartRow) -> Vec<i32> {
|
||||
birth_date(chart).map(|b| open_years(b, OffsetDateTime::now_utc().date())).unwrap_or_default()
|
||||
}
|
||||
|
||||
fn current_forecasts_query() -> String {
|
||||
format!(
|
||||
"SELECT {FORECAST_COLUMNS} FROM forecasts WHERE chart_id = $1 AND chart_hash = $2 ORDER BY year DESC, created_at"
|
||||
)
|
||||
}
|
||||
|
||||
/// The forecasts of a chart (for its current birth data) and the years that can be calculated.
|
||||
pub async fn list_for_chart(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(axum::extract::Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let chart = owned_chart(&state.db, id, auth.id()).await?;
|
||||
let rows: Vec<ForecastRow> =
|
||||
sqlx::query_as(¤t_forecasts_query()).bind(chart.id).bind(&chart.chart_hash).fetch_all(&state.db).await?;
|
||||
Ok(Json(json!({
|
||||
"years": years_for(&chart),
|
||||
"birth_place": chart.result.pointer("/location/place/name"),
|
||||
"time_known": chart.result.pointer("/time/time_known"),
|
||||
"forecasts": rows.iter().map(ForecastRow::summary_view).collect::<Vec<_>>(),
|
||||
})))
|
||||
}
|
||||
|
||||
/// Calculates a year (or returns it when already calculated). 201 or 200.
|
||||
pub async fn create(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(axum::extract::Path(id), _): IdPath,
|
||||
WithRejection(Json(req), _): Body<CreateForecast>,
|
||||
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||||
let chart = owned_chart(&state.db, id, auth.id()).await?;
|
||||
let open = years_for(&chart);
|
||||
let year = match req.year {
|
||||
Some(y) if open.contains(&y) || is_admin(&auth) => y,
|
||||
Some(_) => {
|
||||
return Err(ApiError::Refused {
|
||||
code: "forecast_year_closed",
|
||||
message: "Az aktuális évre, és a születésnap előtti 30 napban a következőre kérhetsz előrejelzést."
|
||||
.into(),
|
||||
});
|
||||
}
|
||||
None => *open.first().ok_or(ApiError::Refused {
|
||||
code: "forecast_year_closed",
|
||||
message: "Az első születésnap előtt még nincs éves előrejelzés.".into(),
|
||||
})?,
|
||||
};
|
||||
let location = req.location.map(|l| serde_json::to_value(l).expect("serializable"));
|
||||
let location_key = location.as_ref().map_or_else(|| "birth".to_string(), |l| sha256_hex(&l.to_string()));
|
||||
|
||||
let existing: Option<ForecastRow> = sqlx::query_as(&format!(
|
||||
"SELECT {FORECAST_COLUMNS} FROM forecasts \
|
||||
WHERE chart_id = $1 AND chart_hash = $2 AND year = $3 AND location_key = $4"
|
||||
))
|
||||
.bind(chart.id)
|
||||
.bind(&chart.chart_hash)
|
||||
.bind(year)
|
||||
.bind(&location_key)
|
||||
.fetch_optional(&state.db)
|
||||
.await?;
|
||||
if let Some(row) = existing {
|
||||
return Ok((StatusCode::OK, Json(row.view())));
|
||||
}
|
||||
let (count,): (i64,) = sqlx::query_as("SELECT count(*) FROM forecasts WHERE chart_id = $1")
|
||||
.bind(chart.id)
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
if count >= MAX_PER_CHART && !is_admin(&auth) {
|
||||
return Err(ApiError::conflict(
|
||||
"forecast_limit_reached",
|
||||
format!("at most {MAX_PER_CHART} forecasts can be saved for a chart"),
|
||||
));
|
||||
}
|
||||
|
||||
let mut request = json!({ "birth": chart.birth_data, "year": year });
|
||||
if let Some(l) = &location {
|
||||
request["location"] = l.clone();
|
||||
}
|
||||
let mut result = state.horoscope.forecast(&request).await?;
|
||||
if let Some(obj) = result.as_object_mut() {
|
||||
obj.remove("meta");
|
||||
}
|
||||
let forecast_hash = forecast_hash(&chart.chart_hash, year, &location_key, &result);
|
||||
let row: ForecastRow = sqlx::query_as(&format!(
|
||||
"INSERT INTO forecasts (id, chart_id, chart_hash, year, location, location_key, result, forecast_hash, created_by) \
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) \
|
||||
ON CONFLICT (chart_id, chart_hash, year, location_key) DO UPDATE SET chart_id = EXCLUDED.chart_id \
|
||||
RETURNING {FORECAST_COLUMNS}"
|
||||
))
|
||||
.bind(Uuid::now_v7())
|
||||
.bind(chart.id)
|
||||
.bind(&chart.chart_hash)
|
||||
.bind(year)
|
||||
.bind(&location)
|
||||
.bind(&location_key)
|
||||
.bind(&result)
|
||||
.bind(&forecast_hash)
|
||||
.bind(auth.id())
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
Ok((StatusCode::CREATED, Json(row.view())))
|
||||
}
|
||||
|
||||
/// Identifies a forecast independently of how the place was entered: the
|
||||
/// chart, the year and the resolved place and time zone of the solar return.
|
||||
fn forecast_hash(chart_hash: &str, year: i32, location_key: &str, result: &Value) -> String {
|
||||
let sr = &result["solar_return"];
|
||||
let place = if sr.is_object() {
|
||||
format!(
|
||||
"{:.4}|{:.4}|{}",
|
||||
sr["location"]["latitude"].as_f64().unwrap_or_default(),
|
||||
sr["location"]["longitude"].as_f64().unwrap_or_default(),
|
||||
sr["timezone"].as_str().unwrap_or_default()
|
||||
)
|
||||
} else {
|
||||
location_key.to_string()
|
||||
};
|
||||
sha256_hex(&format!("forecast|{chart_hash}|{year}|{place}"))
|
||||
}
|
||||
|
||||
pub async fn get_one(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(axum::extract::Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let (forecast, _) = owned_forecast(&state.db, id, auth.id()).await?;
|
||||
Ok(Json(forecast.view()))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn date(y: i32, m: u8, d: u8) -> Date {
|
||||
Date::from_calendar_date(y, Month::try_from(m).unwrap(), d).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn years_open_around_the_birthday() {
|
||||
let birth = date(1990, 3, 15);
|
||||
assert_eq!(open_years(birth, date(2026, 11, 18)), vec![2026]);
|
||||
assert_eq!(open_years(birth, date(2027, 3, 1)), vec![2026, 2027]);
|
||||
assert_eq!(open_years(birth, date(2027, 3, 15)), vec![2027]);
|
||||
assert_eq!(open_years(birth, date(2027, 2, 12)), vec![2026]);
|
||||
// Before the first birthday: only the first year, close to it.
|
||||
assert!(open_years(birth, date(1990, 6, 1)).is_empty());
|
||||
assert_eq!(open_years(birth, date(1991, 3, 1)), vec![1991]);
|
||||
// 29 February
|
||||
assert_eq!(open_years(date(1992, 2, 29), date(2027, 2, 28)), vec![2027]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,547 @@
|
||||
//! Invitations to the closed site.
|
||||
//!
|
||||
//! While `SIGNUP_MODE=invite`, a new account needs an open invitation for its
|
||||
//! e-mail address, or an invitation link (then any address will do, because
|
||||
//! people often sign in with another Google account than the one their friend
|
||||
//! knows). Only administrators invite; the worker sends the e-mails.
|
||||
//!
|
||||
//! People who asked for no more invitations are kept as the hash of their
|
||||
//! address. People without an invitation can join the waitlist.
|
||||
|
||||
use axum::Json;
|
||||
use axum::extract::{Path, Query, State};
|
||||
use axum::http::StatusCode;
|
||||
use axum_extra::extract::WithRejection;
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
use sqlx::PgConnection;
|
||||
use time::OffsetDateTime;
|
||||
use uuid::Uuid;
|
||||
|
||||
use super::auth::{normalize_email, queue_email_to, validate_locale};
|
||||
use super::{Body, IdPath, St};
|
||||
use crate::AppState;
|
||||
use crate::auth::AdminUser;
|
||||
use crate::config::SignupMode;
|
||||
use crate::error::{ApiError, ApiResult};
|
||||
use crate::views::{rfc3339, rfc3339_opt};
|
||||
|
||||
pub const INVITATION_TTL: time::Duration = time::Duration::days(30);
|
||||
/// A resend is possible this often, and at most this many sendings in all.
|
||||
const RESEND_GAP: time::Duration = time::Duration::hours(24);
|
||||
const MAX_SENDINGS: i32 = 3;
|
||||
const MAX_MESSAGE_CHARS: usize = 300;
|
||||
const MAX_BATCH: usize = 50;
|
||||
|
||||
// --- the gate -------------------------------------------------------------------------------
|
||||
|
||||
/// Whether a new account may be created for `email` (with the invitation link
|
||||
/// `token`, if the visitor came through one).
|
||||
pub async fn admit(
|
||||
state: &AppState,
|
||||
conn: &mut PgConnection,
|
||||
email: &str,
|
||||
token: Option<&str>,
|
||||
) -> Result<(), ApiError> {
|
||||
if state.config.signup_mode == SignupMode::Open || state.config.bootstrap_admin_emails.iter().any(|e| e == email) {
|
||||
return Ok(());
|
||||
}
|
||||
let hash = token.map(|t| db::token_hash(t.trim()));
|
||||
let invited: bool = sqlx::query_scalar(
|
||||
"SELECT EXISTS (SELECT 1 FROM invitations i WHERE i.accepted_at IS NULL AND i.revoked_at IS NULL \
|
||||
AND i.expires_at > now() \
|
||||
AND (i.email = $1 OR i.id IN (SELECT invitation_id FROM invitation_tokens WHERE token_hash = $2))) \
|
||||
-- a \"how compatible are we?\" link also lets the invitee in
|
||||
OR EXISTS (SELECT 1 FROM synastry_invites WHERE token_hash = $2 AND accepted_at IS NULL AND expires_at > now())",
|
||||
)
|
||||
.bind(email)
|
||||
.bind(hash)
|
||||
.fetch_one(&mut *conn)
|
||||
.await?;
|
||||
if invited {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(ApiError::Refused {
|
||||
code: "not_invited",
|
||||
message: "A Sorsfonalak jelenleg meghívásos: ehhez az e-mail-címhez nem tartozik meghívó.".into(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// After a new account is created: its invitations count as accepted, and it leaves the waitlist.
|
||||
pub async fn mark_accepted(
|
||||
conn: &mut PgConnection,
|
||||
user_id: Uuid,
|
||||
email: &str,
|
||||
token: Option<&str>,
|
||||
) -> Result<(), ApiError> {
|
||||
let hash = token.map(|t| db::token_hash(t.trim()));
|
||||
sqlx::query(
|
||||
"UPDATE invitations SET accepted_at = now(), accepted_by = $1 \
|
||||
WHERE accepted_at IS NULL AND revoked_at IS NULL \
|
||||
AND (email = $2 OR (expires_at > now() AND id IN (SELECT invitation_id FROM invitation_tokens WHERE token_hash = $3)))",
|
||||
)
|
||||
.bind(user_id)
|
||||
.bind(email)
|
||||
.bind(hash)
|
||||
.execute(&mut *conn)
|
||||
.await?;
|
||||
sqlx::query("DELETE FROM waitlist WHERE email = $1").bind(email).execute(&mut *conn).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// --- sending ---------------------------------------------------------------------------------
|
||||
|
||||
fn clean_message(message: Option<String>) -> Result<Option<String>, ApiError> {
|
||||
let Some(message) = message.map(|m| m.replace("\r\n", "\n").trim().to_owned()).filter(|m| !m.is_empty()) else {
|
||||
return Ok(None);
|
||||
};
|
||||
if message.chars().count() > MAX_MESSAGE_CHARS {
|
||||
return Err(ApiError::BadRequest(format!("A személyes üzenet legfeljebb {MAX_MESSAGE_CHARS} karakter lehet.")));
|
||||
}
|
||||
// Links in a mail from our domain are what spammers would use this field for.
|
||||
let lower = message.to_lowercase();
|
||||
if lower.contains("://") || lower.contains("www.") {
|
||||
return Err(ApiError::BadRequest("A személyes üzenetben nem lehet link.".into()));
|
||||
}
|
||||
Ok(Some(message))
|
||||
}
|
||||
|
||||
fn links(state: &AppState, token: &str) -> (String, String, String) {
|
||||
let base = &state.config.public_base_url;
|
||||
(
|
||||
format!("{base}/meghivo/{token}"),
|
||||
format!("{base}/leiratkozas?token={token}"),
|
||||
format!("{base}/api/v1/public/invitations/unsubscribe?token={token}"),
|
||||
)
|
||||
}
|
||||
|
||||
fn payload(
|
||||
state: &AppState,
|
||||
token: &str,
|
||||
inviter: Option<&str>,
|
||||
message: Option<&str>,
|
||||
expires: OffsetDateTime,
|
||||
) -> Value {
|
||||
let (url, unsubscribe_url, unsubscribe_post_url) = links(state, token);
|
||||
json!({
|
||||
"url": url,
|
||||
"unsubscribe_url": unsubscribe_url,
|
||||
"unsubscribe_post_url": unsubscribe_post_url,
|
||||
"inviter_name": inviter,
|
||||
"message": message,
|
||||
"expires_on": expires.date().to_string(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Issues a new link token for an invitation and queues the e-mail; returns the link.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
async fn send(
|
||||
state: &AppState,
|
||||
conn: &mut PgConnection,
|
||||
id: Uuid,
|
||||
email: &str,
|
||||
locale: &str,
|
||||
inviter: Option<&str>,
|
||||
message: Option<&str>,
|
||||
expires: OffsetDateTime,
|
||||
) -> Result<String, ApiError> {
|
||||
let token = db::new_token();
|
||||
sqlx::query("INSERT INTO invitation_tokens (token_hash, invitation_id) VALUES ($1, $2)")
|
||||
.bind(db::token_hash(&token))
|
||||
.bind(id)
|
||||
.execute(&mut *conn)
|
||||
.await?;
|
||||
let payload = payload(state, &token, inviter, message, expires);
|
||||
let url = payload["url"].as_str().unwrap_or_default().to_owned();
|
||||
queue_email_to(conn, None, email, "invitation", locale, payload).await?;
|
||||
Ok(url)
|
||||
}
|
||||
|
||||
async fn opted_out(conn: &mut PgConnection, email: &str) -> Result<bool, ApiError> {
|
||||
Ok(sqlx::query_scalar("SELECT EXISTS (SELECT 1 FROM email_optouts WHERE email_hash = $1)")
|
||||
.bind(db::token_hash(email))
|
||||
.fetch_one(conn)
|
||||
.await?)
|
||||
}
|
||||
|
||||
// --- admin ------------------------------------------------------------------------------------
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct CreateInvitations {
|
||||
emails: Vec<String>,
|
||||
message: Option<String>,
|
||||
locale: Option<String>,
|
||||
}
|
||||
|
||||
/// Invites a list of addresses. Each gets a result: `invited` (with the
|
||||
/// link, to pass on by hand if needed), `already_user`, `already_invited`,
|
||||
/// `opted_out` or `invalid`.
|
||||
pub async fn create(
|
||||
State(state): St,
|
||||
AdminUser(admin): AdminUser,
|
||||
WithRejection(Json(req), _): Body<CreateInvitations>,
|
||||
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||||
if req.emails.is_empty() || req.emails.len() > MAX_BATCH {
|
||||
return Err(ApiError::BadRequest(format!("1–{MAX_BATCH} e-mail-cím adható meg egyszerre.")));
|
||||
}
|
||||
let message = clean_message(req.message)?;
|
||||
let locale = validate_locale(&state, req.locale.as_deref())?;
|
||||
let inviter = admin.user.display_name.clone();
|
||||
let mut results = Vec::new();
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
let mut tx = state.db.begin().await?;
|
||||
for raw in &req.emails {
|
||||
let raw = raw.trim();
|
||||
let Ok(email) = normalize_email(raw) else {
|
||||
results.push(json!({ "email": raw, "status": "invalid" }));
|
||||
continue;
|
||||
};
|
||||
if !seen.insert(email.clone()) {
|
||||
continue;
|
||||
}
|
||||
let user: bool = sqlx::query_scalar("SELECT EXISTS (SELECT 1 FROM users WHERE email = $1)")
|
||||
.bind(&email)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
if user {
|
||||
results.push(json!({ "email": email, "status": "already_user" }));
|
||||
continue;
|
||||
}
|
||||
if opted_out(&mut tx, &email).await? {
|
||||
results.push(json!({ "email": email, "status": "opted_out" }));
|
||||
continue;
|
||||
}
|
||||
// An expired open invitation gives way to the new one.
|
||||
sqlx::query(
|
||||
"UPDATE invitations SET revoked_at = now() \
|
||||
WHERE email = $1 AND accepted_at IS NULL AND revoked_at IS NULL AND expires_at <= now()",
|
||||
)
|
||||
.bind(&email)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
let id = Uuid::now_v7();
|
||||
let expires = OffsetDateTime::now_utc() + INVITATION_TTL;
|
||||
let inserted = sqlx::query(
|
||||
"INSERT INTO invitations (id, email, message, locale, invited_by, expires_at) \
|
||||
VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT DO NOTHING",
|
||||
)
|
||||
.bind(id)
|
||||
.bind(&email)
|
||||
.bind(&message)
|
||||
.bind(&locale)
|
||||
.bind(admin.id())
|
||||
.bind(expires)
|
||||
.execute(&mut *tx)
|
||||
.await?
|
||||
.rows_affected();
|
||||
if inserted == 0 {
|
||||
results.push(json!({ "email": email, "status": "already_invited" }));
|
||||
continue;
|
||||
}
|
||||
let url = send(&state, &mut tx, id, &email, &locale, inviter.as_deref(), message.as_deref(), expires).await?;
|
||||
results.push(json!({ "email": email, "status": "invited", "id": id, "url": url }));
|
||||
}
|
||||
tx.commit().await?;
|
||||
Ok((StatusCode::CREATED, Json(json!({ "results": results }))))
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
struct Row {
|
||||
id: Uuid,
|
||||
email: String,
|
||||
message: Option<String>,
|
||||
locale: String,
|
||||
created_at: OffsetDateTime,
|
||||
expires_at: OffsetDateTime,
|
||||
sent_count: i32,
|
||||
last_sent_at: OffsetDateTime,
|
||||
accepted_at: Option<OffsetDateTime>,
|
||||
revoked_at: Option<OffsetDateTime>,
|
||||
invited_by_name: Option<String>,
|
||||
accepted_by_name: Option<String>,
|
||||
mail_created_at: Option<OffsetDateTime>,
|
||||
mail_sent_at: Option<OffsetDateTime>,
|
||||
mail_failed_at: Option<OffsetDateTime>,
|
||||
mail_error: Option<String>,
|
||||
}
|
||||
|
||||
fn status(accepted: Option<OffsetDateTime>, revoked: Option<OffsetDateTime>, expires: OffsetDateTime) -> &'static str {
|
||||
if accepted.is_some() {
|
||||
"accepted"
|
||||
} else if revoked.is_some() {
|
||||
"revoked"
|
||||
} else if expires <= OffsetDateTime::now_utc() {
|
||||
"expired"
|
||||
} else {
|
||||
"pending"
|
||||
}
|
||||
}
|
||||
|
||||
/// Every invitation (newest first) with the state of its last e-mail, and the waitlist.
|
||||
pub async fn list(State(state): St, _admin: AdminUser) -> ApiResult<Json<Value>> {
|
||||
let rows: Vec<Row> = sqlx::query_as(
|
||||
"SELECT i.id, i.email, i.message, i.locale, i.created_at, i.expires_at, i.sent_count, i.last_sent_at, \
|
||||
i.accepted_at, i.revoked_at, inv.display_name AS invited_by_name, \
|
||||
coalesce(acc.display_name, acc.email) AS accepted_by_name, \
|
||||
m.created_at AS mail_created_at, m.sent_at AS mail_sent_at, m.failed_at AS mail_failed_at, m.last_error AS mail_error \
|
||||
FROM invitations i \
|
||||
LEFT JOIN users inv ON inv.id = i.invited_by \
|
||||
LEFT JOIN users acc ON acc.id = i.accepted_by \
|
||||
LEFT JOIN LATERAL (SELECT created_at, sent_at, failed_at, last_error FROM email_outbox \
|
||||
WHERE to_email = i.email AND template = 'invitation' \
|
||||
ORDER BY created_at DESC LIMIT 1) m ON true \
|
||||
ORDER BY i.created_at DESC LIMIT 500",
|
||||
)
|
||||
.fetch_all(&state.db)
|
||||
.await?;
|
||||
let now = OffsetDateTime::now_utc();
|
||||
let invitations: Vec<Value> = rows
|
||||
.into_iter()
|
||||
.map(|r| {
|
||||
let status = status(r.accepted_at, r.revoked_at, r.expires_at);
|
||||
// Sent e-mails are removed from the outbox after a week.
|
||||
let mail = match (r.mail_created_at, r.mail_sent_at, r.mail_failed_at) {
|
||||
(None, _, _) => "archived",
|
||||
(_, Some(_), _) => "sent",
|
||||
(_, None, Some(_)) => "failed",
|
||||
_ => "queued",
|
||||
};
|
||||
let can_resend = matches!(status, "pending" | "expired")
|
||||
&& r.sent_count < MAX_SENDINGS
|
||||
&& r.last_sent_at + RESEND_GAP <= now;
|
||||
json!({
|
||||
"id": r.id, "email": r.email, "message": r.message, "locale": r.locale, "status": status,
|
||||
"created_at": rfc3339(r.created_at), "expires_at": rfc3339(r.expires_at),
|
||||
"sent_count": r.sent_count, "last_sent_at": rfc3339(r.last_sent_at),
|
||||
"accepted_at": rfc3339_opt(r.accepted_at), "accepted_by": r.accepted_by_name,
|
||||
"invited_by": r.invited_by_name,
|
||||
"mail": mail, "mail_error": r.mail_error, "can_resend": can_resend,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
|
||||
let waitlist: Vec<(String, String, OffsetDateTime, Option<String>)> = sqlx::query_as(
|
||||
"SELECT w.email, w.locale, w.created_at, \
|
||||
(SELECT CASE WHEN accepted_at IS NOT NULL THEN 'accepted' WHEN expires_at > now() THEN 'pending' END \
|
||||
FROM invitations WHERE email = w.email AND revoked_at IS NULL ORDER BY created_at DESC LIMIT 1) \
|
||||
FROM waitlist w ORDER BY w.created_at",
|
||||
)
|
||||
.fetch_all(&state.db)
|
||||
.await?;
|
||||
let waitlist: Vec<Value> = waitlist
|
||||
.into_iter()
|
||||
.map(|(email, locale, created, invitation)| {
|
||||
json!({ "email": email, "locale": locale, "created_at": rfc3339(created), "invitation": invitation })
|
||||
})
|
||||
.collect();
|
||||
Ok(Json(
|
||||
json!({ "invitations": invitations, "waitlist": waitlist, "signup_mode": state.config.signup_mode.as_str() }),
|
||||
))
|
||||
}
|
||||
|
||||
/// Sends the invitation again with a new link (the earlier links keep
|
||||
/// working), and gives it another 30 days.
|
||||
pub async fn resend(
|
||||
State(state): St,
|
||||
AdminUser(admin): AdminUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let mut tx = state.db.begin().await?;
|
||||
#[derive(sqlx::FromRow)]
|
||||
struct Open {
|
||||
email: String,
|
||||
message: Option<String>,
|
||||
locale: String,
|
||||
sent_count: i32,
|
||||
last_sent_at: OffsetDateTime,
|
||||
closed: bool,
|
||||
}
|
||||
let Open { email, message, locale, sent_count, last_sent_at: last_sent, closed } = sqlx::query_as(
|
||||
"SELECT email, message, locale, sent_count, last_sent_at, \
|
||||
accepted_at IS NOT NULL OR revoked_at IS NOT NULL AS closed \
|
||||
FROM invitations WHERE id = $1 FOR UPDATE",
|
||||
)
|
||||
.bind(id)
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?
|
||||
.ok_or(ApiError::NotFound("invitation"))?;
|
||||
if closed {
|
||||
return Err(ApiError::conflict("invitation_closed", "Ezt a meghívót már elfogadták vagy visszavonták."));
|
||||
}
|
||||
if sent_count >= MAX_SENDINGS {
|
||||
return Err(ApiError::conflict(
|
||||
"resend_limit",
|
||||
format!("Egy meghívó legfeljebb {MAX_SENDINGS}-szor küldhető el (spamvédelem)."),
|
||||
));
|
||||
}
|
||||
if last_sent + RESEND_GAP > OffsetDateTime::now_utc() {
|
||||
return Err(ApiError::conflict("resend_too_soon", "Újraküldés legkorábban 24 órával az előző küldés után."));
|
||||
}
|
||||
if opted_out(&mut tx, &email).await? {
|
||||
return Err(ApiError::conflict("opted_out", "Ez a cím leiratkozott a meghívókról."));
|
||||
}
|
||||
let expires = OffsetDateTime::now_utc() + INVITATION_TTL;
|
||||
sqlx::query(
|
||||
"UPDATE invitations SET sent_count = sent_count + 1, last_sent_at = now(), expires_at = $2 WHERE id = $1",
|
||||
)
|
||||
.bind(id)
|
||||
.bind(expires)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
let inviter = admin.user.display_name.clone();
|
||||
let url = send(&state, &mut tx, id, &email, &locale, inviter.as_deref(), message.as_deref(), expires).await?;
|
||||
tx.commit().await?;
|
||||
Ok(Json(json!({ "id": id, "url": url, "expires_at": rfc3339(expires) })))
|
||||
}
|
||||
|
||||
pub async fn revoke(State(state): St, _admin: AdminUser, WithRejection(Path(id), _): IdPath) -> ApiResult<StatusCode> {
|
||||
let done = sqlx::query(
|
||||
"UPDATE invitations SET revoked_at = now() WHERE id = $1 AND accepted_at IS NULL AND revoked_at IS NULL",
|
||||
)
|
||||
.bind(id)
|
||||
.execute(&state.db)
|
||||
.await?
|
||||
.rows_affected();
|
||||
if done == 0 {
|
||||
return Err(ApiError::NotFound("open invitation"));
|
||||
}
|
||||
Ok(StatusCode::NO_CONTENT)
|
||||
}
|
||||
|
||||
pub async fn remove_from_waitlist(
|
||||
State(state): St,
|
||||
_admin: AdminUser,
|
||||
WithRejection(Path(email), _): WithRejection<Path<String>, ApiError>,
|
||||
) -> ApiResult<StatusCode> {
|
||||
sqlx::query("DELETE FROM waitlist WHERE email = $1").bind(email.trim().to_lowercase()).execute(&state.db).await?;
|
||||
Ok(StatusCode::NO_CONTENT)
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct PreviewRequest {
|
||||
message: Option<String>,
|
||||
locale: Option<String>,
|
||||
/// Also send it to the admin's own address.
|
||||
#[serde(default)]
|
||||
send_to_me: bool,
|
||||
}
|
||||
|
||||
/// The invitation e-mail with sample links (they lead nowhere), and
|
||||
/// optionally a test copy to the admin.
|
||||
pub async fn preview(
|
||||
State(state): St,
|
||||
AdminUser(admin): AdminUser,
|
||||
WithRejection(Json(req), _): Body<PreviewRequest>,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let message = clean_message(req.message)?;
|
||||
let locale = validate_locale(&state, req.locale.as_deref())?;
|
||||
let payload = payload(
|
||||
&state,
|
||||
"minta",
|
||||
admin.user.display_name.as_deref(),
|
||||
message.as_deref(),
|
||||
OffsetDateTime::now_utc() + INVITATION_TTL,
|
||||
);
|
||||
let mail = email_templates::render("invitation", &locale, &payload)
|
||||
.map_err(|e| ApiError::Internal(format!("invitation template: {e}")))?;
|
||||
if req.send_to_me {
|
||||
let mut conn = state.db.acquire().await?;
|
||||
queue_email_to(&mut conn, Some(admin.id()), &admin.user.email, "invitation", &locale, payload).await?;
|
||||
}
|
||||
Ok(Json(json!({
|
||||
"subject": mail.subject, "text": mail.text, "html": mail.html,
|
||||
"sent_to": req.send_to_me.then_some(&admin.user.email),
|
||||
})))
|
||||
}
|
||||
|
||||
// --- public -------------------------------------------------------------------------------------
|
||||
|
||||
/// Landing data of an invitation link.
|
||||
pub async fn public_view(State(state): St, Path(token): Path<String>) -> ApiResult<Json<Value>> {
|
||||
#[derive(sqlx::FromRow)]
|
||||
struct Landing {
|
||||
inviter: Option<String>,
|
||||
message: Option<String>,
|
||||
expires_at: OffsetDateTime,
|
||||
accepted_at: Option<OffsetDateTime>,
|
||||
revoked_at: Option<OffsetDateTime>,
|
||||
}
|
||||
let l: Landing = sqlx::query_as(
|
||||
"SELECT u.display_name AS inviter, i.message, i.expires_at, i.accepted_at, i.revoked_at \
|
||||
FROM invitation_tokens t JOIN invitations i ON i.id = t.invitation_id \
|
||||
LEFT JOIN users u ON u.id = i.invited_by WHERE t.token_hash = $1",
|
||||
)
|
||||
.bind(db::token_hash(token.trim()))
|
||||
.fetch_optional(&state.db)
|
||||
.await?
|
||||
.ok_or(ApiError::NotFound("invitation"))?;
|
||||
Ok(Json(json!({
|
||||
"inviter_name": l.inviter,
|
||||
"message": l.message,
|
||||
"status": status(l.accepted_at, l.revoked_at, l.expires_at),
|
||||
"expires_at": rfc3339(l.expires_at),
|
||||
})))
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub struct TokenQuery {
|
||||
token: String,
|
||||
}
|
||||
|
||||
/// "No more invitations": from the page behind the footer link, or straight
|
||||
/// from the mail client's unsubscribe button (RFC 8058 one-click POST).
|
||||
pub async fn unsubscribe(
|
||||
State(state): St,
|
||||
WithRejection(Query(q), _): WithRejection<Query<TokenQuery>, ApiError>,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let mut tx = state.db.begin().await?;
|
||||
let email: Option<String> = sqlx::query_scalar(
|
||||
"SELECT i.email FROM invitation_tokens t JOIN invitations i ON i.id = t.invitation_id WHERE t.token_hash = $1",
|
||||
)
|
||||
.bind(db::token_hash(q.token.trim()))
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?;
|
||||
let email = email.ok_or(ApiError::NotFound("invitation"))?;
|
||||
sqlx::query("INSERT INTO email_optouts (email_hash) VALUES ($1) ON CONFLICT DO NOTHING")
|
||||
.bind(db::token_hash(&email))
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
sqlx::query(
|
||||
"UPDATE invitations SET revoked_at = now() WHERE email = $1 AND accepted_at IS NULL AND revoked_at IS NULL",
|
||||
)
|
||||
.bind(&email)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
tx.commit().await?;
|
||||
Ok(Json(json!({ "unsubscribed": true })))
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct WaitlistRequest {
|
||||
email: String,
|
||||
locale: Option<String>,
|
||||
}
|
||||
|
||||
/// Joins the waitlist. Always answers the same, so it does not reveal who has an account.
|
||||
pub async fn join_waitlist(
|
||||
State(state): St,
|
||||
WithRejection(Json(req), _): Body<WaitlistRequest>,
|
||||
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||||
let email = normalize_email(&req.email)?;
|
||||
let locale = validate_locale(&state, req.locale.as_deref())?;
|
||||
sqlx::query(
|
||||
"INSERT INTO waitlist (email, locale) SELECT $1, $2 \
|
||||
WHERE NOT EXISTS (SELECT 1 FROM users WHERE email = $1) \
|
||||
AND (SELECT count(*) FROM waitlist) < 10000 \
|
||||
ON CONFLICT DO NOTHING",
|
||||
)
|
||||
.bind(&email)
|
||||
.bind(&locale)
|
||||
.execute(&state.db)
|
||||
.await?;
|
||||
Ok((StatusCode::ACCEPTED, Json(json!({ "ok": true }))))
|
||||
}
|
||||
@@ -10,6 +10,8 @@ mod admin;
|
||||
mod analyses;
|
||||
mod auth;
|
||||
mod charts;
|
||||
mod forecasts;
|
||||
mod invitations;
|
||||
mod payments;
|
||||
mod prompts;
|
||||
mod shares;
|
||||
@@ -72,6 +74,9 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/charts/{id}", get(charts::get_one).patch(charts::update).delete(charts::remove))
|
||||
.route("/v1/charts/{id}/analyses", get(analyses::list_for_chart).post(analyses::request_for_chart))
|
||||
.route("/v1/charts/{id}/summary", post(analyses::summary_for_chart))
|
||||
.route("/v1/charts/{id}/forecasts", get(forecasts::list_for_chart).post(forecasts::create))
|
||||
.route("/v1/forecasts/{id}", get(forecasts::get_one))
|
||||
.route("/v1/forecasts/{id}/analyses", get(analyses::list_for_forecast).post(analyses::request_for_forecast))
|
||||
// synastries and invitations
|
||||
.route("/v1/synastries", get(synastries::list).post(synastries::create))
|
||||
.route("/v1/synastries/{id}", get(synastries::get_one).delete(synastries::remove))
|
||||
@@ -87,11 +92,19 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
// public, no login
|
||||
.route("/v1/public/shares/{slug}", get(shares::public_view))
|
||||
.route("/v1/public/invites/{token}", get(synastries::public_invite))
|
||||
.route("/v1/public/invitations/unsubscribe", post(invitations::unsubscribe))
|
||||
.route("/v1/public/invitations/{token}", get(invitations::public_view))
|
||||
.route("/v1/public/waitlist", post(invitations::join_waitlist))
|
||||
// administration
|
||||
.route("/v1/admin/users", get(admin::list_users))
|
||||
.route("/v1/admin/users/{id}", patch(admin::update_user))
|
||||
.route("/v1/admin/users/{id}/credits", post(admin::adjust_credits))
|
||||
.route("/v1/admin/users/{id}/packages", post(admin::grant_package))
|
||||
.route("/v1/admin/invitations", get(invitations::list).post(invitations::create))
|
||||
.route("/v1/admin/invitations/preview", post(invitations::preview))
|
||||
.route("/v1/admin/invitations/{id}", delete(invitations::revoke))
|
||||
.route("/v1/admin/invitations/{id}/resend", post(invitations::resend))
|
||||
.route("/v1/admin/waitlist/{email}", delete(invitations::remove_from_waitlist))
|
||||
.route("/v1/admin/prompts", get(prompts::list))
|
||||
.route("/v1/admin/prompts/{kind}/{language}", axum::routing::put(prompts::save))
|
||||
.route("/v1/admin/prompts/{kind}/{language}/preview", post(prompts::start_preview))
|
||||
@@ -125,11 +138,9 @@ async fn public_config(State(state): St) -> Json<Value> {
|
||||
Json(json!({
|
||||
"google_login": { "enabled": state.google.enabled(), "client_id": c.google_client_ids.first() },
|
||||
"locales": c.supported_locales,
|
||||
"analysis_model": c.analysis_model,
|
||||
"summary_model": c.summary_model,
|
||||
"password_login": c.password_login,
|
||||
"mock_payments": c.mock_payments,
|
||||
"unlimited_daily_limit": c.unlimited_daily_limit,
|
||||
"signup_mode": c.signup_mode.as_str(),
|
||||
"password_min_length": crate::auth::MIN_PASSWORD_LEN,
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -14,7 +14,6 @@ use crate::credits::{self, Unit};
|
||||
use crate::error::{ApiError, ApiResult};
|
||||
use crate::packages::{self, CATALOG, Source};
|
||||
use crate::persons;
|
||||
use crate::views::rfc3339;
|
||||
|
||||
/// The package catalog (public).
|
||||
pub async fn catalog() -> Json<Value> {
|
||||
@@ -30,16 +29,14 @@ pub struct MockPayment {
|
||||
unit: Option<Unit>,
|
||||
}
|
||||
|
||||
/// What the user has now: units left, person slots, the unlimited package.
|
||||
/// What the user has now: units left and person slots.
|
||||
pub async fn holdings(state: &crate::AppState, auth: &AuthUser) -> Result<Value, ApiError> {
|
||||
let mut conn = state.db.acquire().await?;
|
||||
let balance = credits::balance(&mut conn, auth.id()).await?;
|
||||
let persons = persons::slots(&mut conn, auth, state.config.free_person_slots).await?;
|
||||
let until = packages::unlimited_until(&mut conn, auth.id()).await?;
|
||||
Ok(json!({
|
||||
"analyses_left": balance.view(),
|
||||
"persons": persons.view(),
|
||||
"unlimited_until": until.map(rfc3339),
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -56,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())),
|
||||
};
|
||||
|
||||
+379
-55
@@ -39,7 +39,7 @@ async fn fake_natal(Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
|
||||
Json(json!({
|
||||
"input": body,
|
||||
"location": {"country": {"name": "Hungary"}, "place": {"name": body["place"]}, "latitude": 47.0, "longitude": 19.0},
|
||||
"time": {"local": format!("{date}T{}:00", time.unwrap_or("12:00")), "utc": format!("{date}T11:00:00Z"), "time_known": time.is_some()},
|
||||
"time": {"date": date, "local": format!("{date}T{}:00", time.unwrap_or("12:00")), "utc": format!("{date}T11:00:00Z"), "time_known": time.is_some()},
|
||||
"astronomy": {"julian_day_ut": 2451545.0},
|
||||
"settings": body.get("options").cloned().unwrap_or(json!({"house_system": "placidus"})),
|
||||
"points": [{"id": "sun", "sign": "cancer", "longitude": 90.4}, {"id": "moon", "sign": "pisces", "longitude": 338.2}],
|
||||
@@ -72,6 +72,24 @@ async fn fake_synastry(Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
|
||||
)
|
||||
}
|
||||
|
||||
async fn fake_forecast(Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
|
||||
let year = body["year"].as_i64().unwrap_or(2026);
|
||||
let loc = body.get("location").cloned().unwrap_or(json!({"country": "HU", "place": body["birth"]["place"]}));
|
||||
(
|
||||
StatusCode::OK,
|
||||
Json(json!({
|
||||
"year": year,
|
||||
"solar_return": {
|
||||
"location": {"place": {"name": loc["place"]}, "latitude": 47.0, "longitude": 19.0},
|
||||
"timezone": "Europe/Budapest", "points": [], "input": {"date": format!("{year}-03-15")}
|
||||
},
|
||||
"location": loc,
|
||||
"forecast": {"start": format!("{year}-03-15"), "end": format!("{}-03-15", year + 1), "transits": []},
|
||||
"meta": {}
|
||||
})),
|
||||
)
|
||||
}
|
||||
|
||||
async fn fake_jwks() -> Json<Value> {
|
||||
Json(
|
||||
json!({"keys": [{"kid": "test-key", "kty": "RSA", "alg": "RS256", "use": "sig", "n": GOOGLE_KEY_N.trim(), "e": "AQAB"}]}),
|
||||
@@ -82,6 +100,7 @@ async fn fake_services() -> String {
|
||||
let app = Router::new()
|
||||
.route("/v1/natal", post(fake_natal))
|
||||
.route("/v1/synastry", post(fake_synastry))
|
||||
.route("/v1/forecast", post(fake_forecast))
|
||||
.route("/jwks", get(fake_jwks));
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let addr = listener.local_addr().unwrap();
|
||||
@@ -222,7 +241,7 @@ async fn register_login_verify_logout(pool: PgPool) {
|
||||
let r = app.get("/v1/me", Some(&token)).await;
|
||||
assert_eq!(r.status, StatusCode::OK);
|
||||
assert_eq!(r.body["providers"], json!(["password"]));
|
||||
assert_eq!(r.body["analyses_left"], json!({"natal": 0, "synastry": 0}));
|
||||
assert_eq!(r.body["analyses_left"], json!({"natal": 0, "synastry": 0, "forecast": 0}));
|
||||
|
||||
// e-mail verification through the queued e-mail's link
|
||||
let url = app.outbox_url("anna@example.com", "verify_email").await;
|
||||
@@ -343,11 +362,14 @@ async fn roles_and_admin_guard(pool: PgPool) {
|
||||
|
||||
let grant = |unit: &str, delta: i32| json!({"unit": unit, "delta": delta, "note": "bonus"});
|
||||
let r = app.post(&format!("/v1/admin/users/{anna}/credits"), Some(&admin), grant("natal", 5)).await;
|
||||
assert_eq!((r.status, &r.body["analyses_left"]), (StatusCode::CREATED, &json!({"natal": 5, "synastry": 0})));
|
||||
assert_eq!(
|
||||
(r.status, &r.body["analyses_left"]),
|
||||
(StatusCode::CREATED, &json!({"natal": 5, "synastry": 0, "forecast": 0}))
|
||||
);
|
||||
let r = app.post(&format!("/v1/admin/users/{anna}/credits"), Some(&admin), grant("chat", 5)).await;
|
||||
assert_eq!(r.status, StatusCode::BAD_REQUEST);
|
||||
let credits = app.get("/v1/credits", Some(&user)).await.body;
|
||||
assert_eq!(credits["balance"], json!({"natal": 5, "synastry": 0}));
|
||||
assert_eq!(credits["balance"], json!({"natal": 5, "synastry": 0, "forecast": 0}));
|
||||
assert_eq!((credits["ledger"][0]["unit"].as_str(), &credits["ledger"][0]["delta"]), (Some("natal"), &json!(5)));
|
||||
}
|
||||
|
||||
@@ -487,8 +509,8 @@ async fn analyses_spend_units_and_reuse_results(pool: PgPool) {
|
||||
let list = app.get(&uri, Some(&anna)).await.body;
|
||||
let summary = &list["analyses"][0];
|
||||
assert_eq!(
|
||||
(summary["kind"].as_str(), summary["status"].as_str(), summary["model"].as_str(), &summary["credits_charged"]),
|
||||
(Some("summary"), Some("pending"), Some("anthropic/claude-summary"), &json!(0))
|
||||
(summary["kind"].as_str(), summary["status"].as_str(), &summary["credits_charged"]),
|
||||
(Some("summary"), Some("pending"), &json!(0))
|
||||
);
|
||||
let r = app.call("POST", &format!("/v1/charts/{}/summary", chart["id"].as_str().unwrap()), Some(&anna), None).await;
|
||||
assert_eq!((r.status, &r.body["id"]), (StatusCode::OK, &summary["id"]));
|
||||
@@ -504,18 +526,32 @@ async fn analyses_spend_units_and_reuse_results(pool: PgPool) {
|
||||
let r = app.call("POST", &uri, Some(&anna), None).await;
|
||||
assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body);
|
||||
assert_eq!(
|
||||
(r.body["status"].as_str(), r.body["language"].as_str(), r.body["model"].as_str(), &r.body["credits_charged"]),
|
||||
(Some("pending"), Some("hu"), Some("anthropic/claude-test"), &json!(1))
|
||||
(r.body["status"].as_str(), r.body["language"].as_str(), &r.body["credits_charged"]),
|
||||
(Some("pending"), Some("hu"), &json!(1))
|
||||
);
|
||||
let first = r.body["id"].as_str().unwrap().to_string();
|
||||
assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 1, "synastry": 0}));
|
||||
// the model is used but never shown to users
|
||||
assert!(r.body.get("model").is_none() && summary.get("model").is_none());
|
||||
let (model,): (String,) = sqlx::query_as("SELECT model FROM analyses WHERE id = $1::uuid")
|
||||
.bind(&first)
|
||||
.fetch_one(&app.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(model, "anthropic/claude-test");
|
||||
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
|
||||
|
||||
@@ -624,6 +660,58 @@ async fn export_and_delete_account(pool: PgPool) {
|
||||
assert_eq!(app.get("/v1/me", Some(&bela)).await.status, StatusCode::OK);
|
||||
}
|
||||
|
||||
/// Only these answer without a session: login and sign-up, the public
|
||||
/// config and catalog, shared links, invitation pages, the waitlist and
|
||||
/// unsubscribing. Every other route (charts, calculations, analyses) needs a
|
||||
/// logged-in user, so other apps cannot use them.
|
||||
const PUBLIC_ROUTES: [&str; 14] = [
|
||||
"/healthz",
|
||||
"/v1/config",
|
||||
"/v1/packages",
|
||||
"/v1/auth/register",
|
||||
"/v1/auth/login",
|
||||
"/v1/auth/google",
|
||||
"/v1/auth/verify-email",
|
||||
"/v1/auth/password-reset",
|
||||
"/v1/auth/password-reset/confirm",
|
||||
"/v1/public/shares/{slug}",
|
||||
"/v1/public/invites/{token}",
|
||||
"/v1/public/invitations/unsubscribe",
|
||||
"/v1/public/invitations/{token}",
|
||||
"/v1/public/waitlist",
|
||||
];
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn everything_else_needs_login(pool: PgPool) {
|
||||
let app = TestApp::new(pool).await;
|
||||
let source = include_str!("routes/mod.rs");
|
||||
let id = uuid::Uuid::now_v7().to_string();
|
||||
let mut checked = 0;
|
||||
for line in source.lines().map(str::trim).filter(|l| l.starts_with(".route(\"")) {
|
||||
let path = line.split('"').nth(1).unwrap();
|
||||
if PUBLIC_ROUTES.contains(&path) {
|
||||
continue;
|
||||
}
|
||||
let uri = path
|
||||
.split('/')
|
||||
.map(|seg| if seg.starts_with('{') { id.as_str() } else { seg })
|
||||
.collect::<Vec<_>>()
|
||||
.join("/");
|
||||
for (name, method) in
|
||||
[("get(", "GET"), ("post(", "POST"), ("patch(", "PATCH"), ("put(", "PUT"), ("delete(", "DELETE")]
|
||||
{
|
||||
if !line.contains(name) {
|
||||
continue;
|
||||
}
|
||||
let body = (method != "GET" && method != "DELETE").then(|| json!({}));
|
||||
let r = app.call(method, &uri, None, body).await;
|
||||
assert_eq!(r.status, StatusCode::UNAUTHORIZED, "{method} {uri} answers without login: {}", r.body);
|
||||
checked += 1;
|
||||
}
|
||||
}
|
||||
assert!(checked > 40, "{checked}");
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn public_config_and_health(pool: PgPool) {
|
||||
let app = TestApp::new(pool).await;
|
||||
@@ -631,8 +719,7 @@ async fn public_config_and_health(pool: PgPool) {
|
||||
assert_eq!(r.body["google_login"]["enabled"], true);
|
||||
assert_eq!(r.body["google_login"]["client_id"], GOOGLE_CLIENT);
|
||||
assert_eq!(r.body["locales"], json!(["hu", "en"]));
|
||||
assert_eq!(r.body["analysis_model"], "anthropic/claude-test");
|
||||
assert_eq!(r.body["summary_model"], "anthropic/claude-summary");
|
||||
assert!(r.body.get("analysis_model").is_none() && r.body.get("summary_model").is_none());
|
||||
assert_eq!(app.get("/healthz", None).await.status, StatusCode::OK);
|
||||
}
|
||||
|
||||
@@ -652,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")]
|
||||
@@ -738,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;
|
||||
@@ -783,9 +876,9 @@ async fn persons_use_package_slots(pool: PgPool) {
|
||||
app.chart(&anna, "Dani", false, "1987-01-01").await;
|
||||
assert_eq!(persons(app.get("/v1/me", Some(&anna)).await.body)["left"], 3);
|
||||
|
||||
// the unlimited package
|
||||
let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "unlimited"})).await;
|
||||
assert_eq!(r.body["persons"], json!({"used": 3, "limit": null, "left": null, "unlimited": true}));
|
||||
// the family package adds five more
|
||||
let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "family"})).await;
|
||||
assert_eq!(r.body["persons"], json!({"used": 3, "limit": 11, "left": 8, "unlimited": false}));
|
||||
app.chart(&anna, "Emma", false, "1988-01-01").await;
|
||||
let list = app.get("/v1/charts", Some(&anna)).await.body;
|
||||
let kinds: Vec<&str> = list["charts"].as_array().unwrap().iter().map(|c| c["kind"].as_str().unwrap()).collect();
|
||||
@@ -802,7 +895,8 @@ async fn persons_use_package_slots(pool: PgPool) {
|
||||
.execute(&app.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let r = app.call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(corrected.clone())).await;
|
||||
let again = json!({"birth": {"date": "1986-01-03", "time": "10:00", "country": "HU", "place": "Szeged"}});
|
||||
let r = app.call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(again)).await;
|
||||
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("person_locked")));
|
||||
let r =
|
||||
app.call("PATCH", &format!("/v1/charts/{}", own["id"].as_str().unwrap()), Some(&anna), Some(corrected)).await;
|
||||
@@ -994,19 +1088,20 @@ async fn grant_package(app: &TestApp, token: &str, user: &str, package: &str) ->
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn packages_grant_units_and_unlimited(pool: PgPool) {
|
||||
async fn packages_grant_units(pool: PgPool) {
|
||||
let app = TestApp::new(pool.clone()).await;
|
||||
let admin = app.register("admin@example.com", "Admin").await;
|
||||
let anna = app.register("anna@example.com", "Anna").await;
|
||||
let anna_id = app.get("/v1/me", Some(&anna)).await.body["user"]["id"].as_str().unwrap().to_string();
|
||||
assert_eq!(app.get("/v1/me", Some(&anna)).await.body["package"], Value::Null);
|
||||
|
||||
// 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", "unlimited", "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!(1090))
|
||||
(&json!("Legnépszerűbb"), &json!(647))
|
||||
);
|
||||
|
||||
// an admin gives a package as a gift
|
||||
@@ -1015,12 +1110,12 @@ async fn packages_grant_units_and_unlimited(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
|
||||
);
|
||||
let me = app.get("/v1/me", Some(&anna)).await.body;
|
||||
assert_eq!((&me["persons"]["limit"], &me["unlimited_until"]), (&json!(10), &Value::Null)); // 5 free + 5
|
||||
assert_eq!(me["persons"]["limit"], 10); // 5 free + 5
|
||||
let (source, price): (String, i32) =
|
||||
sqlx::query_as("SELECT source, price_huf FROM package_orders WHERE package = 'family'")
|
||||
.fetch_one(&pool)
|
||||
@@ -1030,41 +1125,270 @@ async fn packages_grant_units_and_unlimited(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, 6990);
|
||||
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");
|
||||
|
||||
// unlimited: a year, and a second one extends it
|
||||
let bela = app.register("bela@example.com", "Béla").await;
|
||||
let bela_id = app.get("/v1/me", Some(&bela)).await.body["user"]["id"].as_str().unwrap().to_string();
|
||||
grant_package(&app, &admin, &bela_id, "unlimited").await;
|
||||
let r = grant_package(&app, &admin, &bela_id, "unlimited").await;
|
||||
let until = time::OffsetDateTime::parse(
|
||||
r.body["unlimited_until"].as_str().unwrap(),
|
||||
&time::format_description::well_known::Rfc3339,
|
||||
// the unlimited package is not sold any more; an old order of it is skipped
|
||||
let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "unlimited"})).await;
|
||||
assert_eq!(r.status, StatusCode::NOT_FOUND);
|
||||
assert_eq!(grant_package(&app, &admin, &anna_id, "unlimited").await.status, StatusCode::NOT_FOUND);
|
||||
sqlx::query("INSERT INTO package_orders (id, user_id, package, source) VALUES ($1, $2::uuid, 'unlimited', 'mock')")
|
||||
.bind(uuid::Uuid::now_v7())
|
||||
.bind(&anna_id)
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(app.get("/v1/me", Some(&anna)).await.body["package"]["name"], "Páros");
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn renaming_a_person_keeps_chart_and_analyses(pool: PgPool) {
|
||||
let app = TestApp::new(pool.clone()).await;
|
||||
let anna = app.register("anna@example.com", "Anna").await;
|
||||
let own = app.chart(&anna, "Saját", true, "1990-03-15").await;
|
||||
let bela = app.chart(&anna, "Béla", false, "1985-08-02").await;
|
||||
let id = bela["id"].as_str().unwrap();
|
||||
let syn = app.post("/v1/synastries", Some(&anna), json!({"chart1_id": own["id"], "chart2_id": id})).await;
|
||||
assert_eq!(syn.status, StatusCode::CREATED);
|
||||
let summaries = || async {
|
||||
let (n,): (i64,) = sqlx::query_as("SELECT count(*) FROM analyses WHERE chart_id = $1::uuid")
|
||||
.bind(id)
|
||||
.fetch_one(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
n
|
||||
};
|
||||
assert_eq!(summaries().await, 1);
|
||||
|
||||
// the edit form sends the unchanged birth data with the new name
|
||||
let same = json!({"label": "Béla bácsi",
|
||||
"birth": {"date": "1985-08-02", "time": "14:30", "country": "HU", "place": "Szeged"}});
|
||||
let r = app.call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(same.clone())).await;
|
||||
assert_eq!(
|
||||
(r.status, &r.body["label"], &r.body["chart_hash"]),
|
||||
(StatusCode::OK, &json!("Béla bácsi"), &bela["chart_hash"])
|
||||
);
|
||||
assert_eq!(summaries().await, 1);
|
||||
let r = app.get(&format!("/v1/synastries/{}", syn.body["id"].as_str().unwrap()), Some(&anna)).await;
|
||||
assert_eq!(r.status, StatusCode::OK);
|
||||
|
||||
// after the correction window the name can still change
|
||||
sqlx::query("UPDATE charts SET created_at = now() - interval '2 hours' WHERE id = $1::uuid")
|
||||
.bind(id)
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let r = app.call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(json!({"label": "Béla"}))).await;
|
||||
assert_eq!((r.status, &r.body["label"]), (StatusCode::OK, &json!("Béla")));
|
||||
let r = app.call("PATCH", &format!("/v1/charts/{id}"), Some(&anna), Some(same)).await;
|
||||
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
|
||||
}
|
||||
|
||||
async fn google_signup(app: &TestApp, sub: &str, email: &str, invite: Option<&str>) -> Response {
|
||||
app.post(
|
||||
"/v1/auth/google",
|
||||
None,
|
||||
json!({"id_token": google_token(sub, email, GOOGLE_CLIENT), "invite_token": invite}),
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
fn invite_token(url: &str) -> String {
|
||||
url.rsplit('/').next().unwrap().to_string()
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn invitation_only_signup(pool: PgPool) {
|
||||
let app = TestApp::with_config(pool.clone(), |c| c.signup_mode = crate::config::SignupMode::Invite).await;
|
||||
assert_eq!(app.get("/v1/config", None).await.body["signup_mode"], "invite");
|
||||
|
||||
// nobody gets in uninvited, except the bootstrap admin
|
||||
let r = google_signup(&app, "g-x", "stranger@gmail.com", None).await;
|
||||
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::FORBIDDEN, Some("not_invited")));
|
||||
let admin = app.register("admin@example.com", "Admin").await;
|
||||
// an existing user (from before the invitation-only times) is not an admin
|
||||
let user = {
|
||||
let open = TestApp::new(pool.clone()).await;
|
||||
open.register("anna@example.com", "Anna").await
|
||||
};
|
||||
|
||||
// inviting: duplicates, invalid addresses and existing users are sorted out
|
||||
let r = app
|
||||
.post(
|
||||
"/v1/admin/invitations",
|
||||
Some(&admin),
|
||||
json!({"emails": ["Guest@Example.com", "guest@example.com", "nope", "anna@example.com", "kata@example.com"],
|
||||
"message": "Gyere, nézd meg!"}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
|
||||
let statuses: Vec<&str> =
|
||||
r.body["results"].as_array().unwrap().iter().map(|x| x["status"].as_str().unwrap()).collect();
|
||||
assert_eq!(statuses, ["invited", "invalid", "already_user", "invited"]);
|
||||
let guest_url = r.body["results"][0]["url"].as_str().unwrap().to_string();
|
||||
let guest_id = r.body["results"][0]["id"].as_str().unwrap().to_string();
|
||||
let guest_token = invite_token(&guest_url);
|
||||
let r = app.post("/v1/admin/invitations", Some(&admin), json!({"emails": ["guest@example.com"]})).await;
|
||||
assert_eq!(r.body["results"][0]["status"], "already_invited");
|
||||
let r = app
|
||||
.post(
|
||||
"/v1/admin/invitations",
|
||||
Some(&admin),
|
||||
json!({"emails": ["x@example.com"], "message": "nézd: www.spam.hu"}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::BAD_REQUEST);
|
||||
assert_eq!(app.get("/v1/admin/invitations", Some(&user)).await.status, StatusCode::FORBIDDEN);
|
||||
|
||||
// the e-mail and the landing page
|
||||
let (payload,): (Value,) = sqlx::query_as(
|
||||
"SELECT payload FROM email_outbox WHERE to_email = 'guest@example.com' AND template = 'invitation'",
|
||||
)
|
||||
.fetch_one(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let days = (until - time::OffsetDateTime::now_utc()).whole_days();
|
||||
assert!((725..=733).contains(&days), "{days}");
|
||||
assert_eq!(app.get("/v1/me", Some(&bela)).await.body["persons"]["unlimited"], true);
|
||||
|
||||
// analyses use no unit, up to the daily cap (3 in tests)
|
||||
for (i, date) in ["1980-01-01", "1981-01-01", "1982-01-01"].into_iter().enumerate() {
|
||||
let chart = app.chart(&bela, &format!("P{i}"), i == 0, date).await;
|
||||
let r = app
|
||||
.call("POST", &format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap()), Some(&bela), None)
|
||||
.await;
|
||||
assert_eq!((r.status, &r.body["credits_charged"]), (StatusCode::ACCEPTED, &json!(0)), "{}", r.body);
|
||||
assert_eq!(payload["url"], guest_url.as_str());
|
||||
assert_eq!(payload["inviter_name"], "Admin");
|
||||
assert!(
|
||||
payload["unsubscribe_post_url"].as_str().unwrap().contains("/api/v1/public/invitations/unsubscribe?token=")
|
||||
);
|
||||
let r = app.get(&format!("/v1/public/invitations/{guest_token}"), None).await;
|
||||
assert_eq!((r.body["inviter_name"].as_str(), r.body["status"].as_str()), (Some("Admin"), Some("pending")));
|
||||
|
||||
// a resend: not too soon, then with a new link; the old one keeps working
|
||||
let r = app.post(&format!("/v1/admin/invitations/{guest_id}/resend"), Some(&admin), json!({})).await;
|
||||
assert_eq!(r.body["error"]["code"], "resend_too_soon");
|
||||
sqlx::query("UPDATE invitations SET last_sent_at = now() - interval '25 hours'").execute(&pool).await.unwrap();
|
||||
let r = app.post(&format!("/v1/admin/invitations/{guest_id}/resend"), Some(&admin), json!({})).await;
|
||||
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
|
||||
assert_ne!(r.body["url"], guest_url.as_str());
|
||||
|
||||
// the link lets in any Google account, once
|
||||
let r = google_signup(&app, "g-1", "guests.other.account@gmail.com", Some(&guest_token)).await;
|
||||
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
|
||||
let r = google_signup(&app, "g-2", "third@gmail.com", Some(&guest_token)).await;
|
||||
assert_eq!(r.body["error"]["code"], "not_invited");
|
||||
// the invited address itself gets in without the link
|
||||
assert_eq!(google_signup(&app, "g-3", "kata@example.com", None).await.status, StatusCode::CREATED);
|
||||
|
||||
// revoked: no entry
|
||||
let r = app
|
||||
.post("/v1/admin/invitations", Some(&admin), json!({"emails": ["zoli@example.com", "mari@example.com"]}))
|
||||
.await;
|
||||
let zoli_id = r.body["results"][0]["id"].as_str().unwrap().to_string();
|
||||
let mari_token = invite_token(r.body["results"][1]["url"].as_str().unwrap());
|
||||
assert_eq!(
|
||||
app.call("DELETE", &format!("/v1/admin/invitations/{zoli_id}"), Some(&admin), None).await.status,
|
||||
StatusCode::NO_CONTENT
|
||||
);
|
||||
assert_eq!(google_signup(&app, "g-4", "zoli@example.com", None).await.status, StatusCode::FORBIDDEN);
|
||||
|
||||
// unsubscribing (one-click POST): the invitation closes and no new one can be sent
|
||||
let r = app.call("POST", &format!("/v1/public/invitations/unsubscribe?token={mari_token}"), None, None).await;
|
||||
assert_eq!(r.status, StatusCode::OK);
|
||||
assert_eq!(google_signup(&app, "g-5", "mari@example.com", None).await.status, StatusCode::FORBIDDEN);
|
||||
let r = app.post("/v1/admin/invitations", Some(&admin), json!({"emails": ["MARI@example.com"]})).await;
|
||||
assert_eq!(r.body["results"][0]["status"], "opted_out");
|
||||
|
||||
// the waitlist: joining reveals nothing, an invited and accepted address leaves it
|
||||
for email in ["wait@example.com", "anna@example.com"] {
|
||||
let r = app.post("/v1/public/waitlist", None, json!({"email": email})).await;
|
||||
assert_eq!(r.status, StatusCode::ACCEPTED);
|
||||
}
|
||||
let fourth = app.chart(&bela, "P3", false, "1983-01-01").await;
|
||||
let uri = format!("/v1/charts/{}/analyses", fourth["id"].as_str().unwrap());
|
||||
let r = app.call("POST", &uri, Some(&bela), None).await;
|
||||
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::TOO_MANY_REQUESTS, Some("fair_use_limit")));
|
||||
|
||||
// after it ends, units are needed again
|
||||
sqlx::query("UPDATE entitlements SET expires_at = now() - interval '1 day'").execute(&pool).await.unwrap();
|
||||
let r = app.call("POST", &uri, Some(&bela), None).await;
|
||||
assert_eq!(r.status, StatusCode::PAYMENT_REQUIRED);
|
||||
assert_eq!(app.get("/v1/me", Some(&bela)).await.body["unlimited_until"], Value::Null);
|
||||
let list = app.get("/v1/admin/invitations", Some(&admin)).await.body;
|
||||
assert_eq!(list["waitlist"].as_array().unwrap().len(), 1);
|
||||
let statuses: Vec<(&str, &str)> = list["invitations"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.map(|i| (i["email"].as_str().unwrap(), i["status"].as_str().unwrap()))
|
||||
.collect();
|
||||
assert!(
|
||||
statuses.contains(&("guest@example.com", "accepted")) && statuses.contains(&("zoli@example.com", "revoked"))
|
||||
);
|
||||
app.post("/v1/admin/invitations", Some(&admin), json!({"emails": ["wait@example.com"]})).await;
|
||||
assert_eq!(google_signup(&app, "g-6", "wait@example.com", None).await.status, StatusCode::CREATED);
|
||||
assert!(app.get("/v1/admin/invitations", Some(&admin)).await.body["waitlist"].as_array().unwrap().is_empty());
|
||||
|
||||
// preview and a test copy to the admin
|
||||
let r =
|
||||
app.post("/v1/admin/invitations/preview", Some(&admin), json!({"message": "Szia!", "send_to_me": true})).await;
|
||||
assert_eq!(r.body["subject"], "Admin meghívott a Sorsfonalakra");
|
||||
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);
|
||||
}
|
||||
|
||||
@@ -76,6 +76,21 @@ export default async function PrivacyPage() {
|
||||
<td>A megvásárolt szolgáltatás nyújtása, elszámolás</td>
|
||||
<td>Szerződés teljesítése; számviteli kötelezettség (6. cikk (1) c)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Meghívott e-mail-címe, a meghívó neve és személyes üzenete</td>
|
||||
<td>A meghívó elküldése; amíg az oldal zártkörű, csak meghívottak regisztrálhatnak</td>
|
||||
<td>Jogos érdek (6. cikk (1) f)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>A várólistán megadott e-mail-cím</td>
|
||||
<td>Értesítés, ha megnyílik az oldal, vagy meghívót küldünk</td>
|
||||
<td>Hozzájárulás (6. cikk (1) a)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Azok a címek, amelyek leiratkoztak a meghívókról (csak a cím egyirányú lenyomata, hash-e)</td>
|
||||
<td>Hogy ezekre a címekre ne küldjünk több meghívót</td>
|
||||
<td>Jogos érdek (6. cikk (1) f)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>IP-cím, böngésző adatai, a kérések ideje (szervernaplók)</td>
|
||||
<td>Biztonság, hibakeresés, visszaélések kiszűrése</td>
|
||||
@@ -123,6 +138,10 @@ export default async function PrivacyPage() {
|
||||
<li>
|
||||
<strong>Google LLC</strong> – bejelentkezés Google-fiókkal.
|
||||
</li>
|
||||
<li>
|
||||
<strong>Amazon Web Services EMEA SARL</strong> (Amazon SES) – a rendszerlevelek és a meghívók kézbesítése;
|
||||
az Európai Unióban (Frankfurt).
|
||||
</li>
|
||||
<li>
|
||||
<strong>OpenRouter, Inc.</strong> és az általa elért modellszolgáltató (jelenleg{" "}
|
||||
<strong>Anthropic PBC</strong>) – az elemzések megírása, kizárólag a 3. pontban leírt csillagászati
|
||||
@@ -142,6 +161,11 @@ export default async function PrivacyPage() {
|
||||
<li>Fiókod adatait, képleteidet és elemzéseidet a fiókod törléséig.</li>
|
||||
<li>A biztonsági mentésekből a törölt adatok legkésőbb 14 nap után tűnnek el.</li>
|
||||
<li>A szervernaplókat legfeljebb 30 napig őrizzük.</li>
|
||||
<li>
|
||||
Az el nem fogadott meghívókat a lejáratuk vagy visszavonásuk után 30 nappal töröljük. A meghívólevelekben
|
||||
bármikor leiratkozhatsz.
|
||||
</li>
|
||||
<li>A várólistán megadott címet a regisztrációdig, vagy amíg nem kéred a törlését.</li>
|
||||
<li>A számlázáshoz szükséges adatokat a számviteli törvény szerinti ideig (8 évig) őrizzük.</li>
|
||||
</ul>
|
||||
</section>
|
||||
|
||||
@@ -8,9 +8,12 @@ import { ROLE_LABELS, formatDate } from "@/lib/astro";
|
||||
import type { AdminUser, Package, Role } from "@/lib/types";
|
||||
|
||||
const EDITABLE_ROLES: Role[] = ["user", "creator", "admin"];
|
||||
const UNITS: { value: "natal" | "synastry"; label: string }[] = [
|
||||
type UnitKind = "natal" | "synastry" | "forecast";
|
||||
|
||||
const UNITS: { value: UnitKind; label: string }[] = [
|
||||
{ value: "natal", label: "képlet" },
|
||||
{ value: "synastry", label: "szinasztria" },
|
||||
{ value: "forecast", label: "előrejelzés" },
|
||||
];
|
||||
|
||||
export function AdminUsers({ selfId }: { selfId: string }) {
|
||||
@@ -102,7 +105,7 @@ function UserRow({
|
||||
const [status, setStatus] = useState<{ ok: boolean; text: string } | null>(null);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [delta, setDelta] = useState("");
|
||||
const [unit, setUnit] = useState<"natal" | "synastry">("natal");
|
||||
const [unit, setUnit] = useState<UnitKind>("natal");
|
||||
|
||||
async function toggleRole(role: Role, on: boolean) {
|
||||
const roles = on ? [...user.roles, role] : user.roles.filter((r) => r !== role);
|
||||
@@ -175,6 +178,8 @@ function UserRow({
|
||||
képlet {user.analyses_left.natal}
|
||||
<br />
|
||||
szinasztria {user.analyses_left.synastry}
|
||||
<br />
|
||||
előrejelzés {user.analyses_left.forecast ?? 0}
|
||||
</span>
|
||||
<label className="sr-only" htmlFor={`unit-${user.id}`}>
|
||||
Elemzés fajtája
|
||||
@@ -184,7 +189,7 @@ function UserRow({
|
||||
className="inp"
|
||||
style={{ width: 118, minHeight: 36 }}
|
||||
value={unit}
|
||||
onChange={(e) => setUnit(e.target.value as "natal" | "synastry")}
|
||||
onChange={(e) => setUnit(e.target.value as UnitKind)}
|
||||
>
|
||||
{UNITS.map((u) => (
|
||||
<option key={u.value} value={u.value}>
|
||||
@@ -245,11 +250,11 @@ function PackageGrant({
|
||||
setBusy(true);
|
||||
setStatus(null);
|
||||
try {
|
||||
const res = await api<{ analyses_left: AdminUser["analyses_left"]; unlimited_until: string | null }>(
|
||||
const res = await api<{ analyses_left: AdminUser["analyses_left"] }>(
|
||||
`/admin/users/${user.id}/packages`,
|
||||
{ body: { package: pkg.id, note: "admin ajándék" } },
|
||||
);
|
||||
onChange({ ...user, analyses_left: res.analyses_left, unlimited_until: res.unlimited_until });
|
||||
onChange({ ...user, analyses_left: res.analyses_left });
|
||||
setStatus({ ok: true, text: `${pkg.name} kiosztva` });
|
||||
setId("");
|
||||
} catch (err) {
|
||||
@@ -261,9 +266,6 @@ function PackageGrant({
|
||||
|
||||
return (
|
||||
<form onSubmit={give} className="field" style={{ gap: 6 }}>
|
||||
{user.unlimited_until && (
|
||||
<span className="badge badge-gold">Korlátlan {formatDate(user.unlimited_until).replace(/\.$/, "")}-ig</span>
|
||||
)}
|
||||
<div className="row" style={{ gap: 6, flexWrap: "nowrap" }}>
|
||||
<label className="sr-only" htmlFor={`pkg-${user.id}`}>
|
||||
Kiosztandó csomag
|
||||
|
||||
@@ -0,0 +1,472 @@
|
||||
"use client";
|
||||
|
||||
import { useCallback, useEffect, useState } from "react";
|
||||
|
||||
import { api, errorText } from "@/lib/api";
|
||||
import { formatDate } from "@/lib/astro";
|
||||
import type { AdminInvitation, InvitationResult, WaitlistEntry } from "@/lib/types";
|
||||
|
||||
const MAX_MESSAGE = 300;
|
||||
|
||||
const STATUS: Record<AdminInvitation["status"], string> = {
|
||||
pending: "Függőben",
|
||||
accepted: "Elfogadva",
|
||||
expired: "Lejárt",
|
||||
revoked: "Visszavonva",
|
||||
};
|
||||
|
||||
const MAIL: Record<AdminInvitation["mail"], string> = {
|
||||
sent: "Elküldve",
|
||||
queued: "Sorban vár",
|
||||
failed: "Sikertelen",
|
||||
archived: "Elküldve (archív)",
|
||||
};
|
||||
|
||||
const RESULT: Record<InvitationResult["status"], string> = {
|
||||
invited: "meghívva",
|
||||
invalid: "érvénytelen cím",
|
||||
already_user: "már felhasználó",
|
||||
already_invited: "már van élő meghívója (újraküldés a listában)",
|
||||
opted_out: "leiratkozott a meghívókról",
|
||||
};
|
||||
|
||||
interface ListData {
|
||||
invitations: AdminInvitation[];
|
||||
waitlist: WaitlistEntry[];
|
||||
signup_mode: "invite" | "open";
|
||||
}
|
||||
|
||||
function CopyLink({ url }: { url: string }) {
|
||||
const [copied, setCopied] = useState(false);
|
||||
return (
|
||||
<button
|
||||
type="button"
|
||||
className="btn btn-sm btn-ghost"
|
||||
onClick={async () => {
|
||||
try {
|
||||
await navigator.clipboard.writeText(url);
|
||||
setCopied(true);
|
||||
} catch {
|
||||
window.prompt("A meghívólink:", url);
|
||||
}
|
||||
}}
|
||||
>
|
||||
{copied ? "Kimásolva" : "Link másolása"}
|
||||
</button>
|
||||
);
|
||||
}
|
||||
|
||||
/** Addresses from free text: one per line, or separated by commas, semicolons or spaces. */
|
||||
function parseEmails(text: string): string[] {
|
||||
return text
|
||||
.split(/[\s,;]+/)
|
||||
.map((s) => s.trim())
|
||||
.filter(Boolean);
|
||||
}
|
||||
|
||||
export function AdminInvitations() {
|
||||
const [data, setData] = useState<ListData | null>(null);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
|
||||
const load = useCallback(async () => {
|
||||
try {
|
||||
setData(await api<ListData>("/admin/invitations"));
|
||||
setError(null);
|
||||
} catch (e) {
|
||||
setError(errorText(e));
|
||||
}
|
||||
}, []);
|
||||
|
||||
useEffect(() => {
|
||||
load();
|
||||
}, [load]);
|
||||
|
||||
return (
|
||||
<div className="field" style={{ gap: 24 }}>
|
||||
{data?.signup_mode === "open" && (
|
||||
<p className="msg" role="status">
|
||||
A regisztráció most nyitott (<code>SIGNUP_MODE=open</code>): bárki beléphet, a meghívó csak értesítés.
|
||||
</p>
|
||||
)}
|
||||
<InviteForm onSent={load} />
|
||||
{error && (
|
||||
<p className="msg msg-error" role="alert">
|
||||
{error}
|
||||
</p>
|
||||
)}
|
||||
{data && <InvitationList invitations={data.invitations} onChange={load} />}
|
||||
{data && <WaitlistTable waitlist={data.waitlist} onChange={load} />}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function InviteForm({ onSent }: { onSent: () => Promise<void> }) {
|
||||
const [emails, setEmails] = useState("");
|
||||
const [message, setMessage] = useState("");
|
||||
const [locale, setLocale] = useState("hu");
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [results, setResults] = useState<InvitationResult[] | null>(null);
|
||||
const count = parseEmails(emails).length;
|
||||
|
||||
async function submit(e: React.FormEvent) {
|
||||
e.preventDefault();
|
||||
setBusy(true);
|
||||
setError(null);
|
||||
setResults(null);
|
||||
try {
|
||||
const res = await api<{ results: InvitationResult[] }>("/admin/invitations", {
|
||||
body: { emails: parseEmails(emails), message: message.trim() || null, locale },
|
||||
});
|
||||
setResults(res.results);
|
||||
if (res.results.some((r) => r.status === "invited")) setEmails("");
|
||||
await onSent();
|
||||
} catch (err) {
|
||||
setError(errorText(err));
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<section className="card field" style={{ gap: 16 }} aria-labelledby="invite-title">
|
||||
<h2 id="invite-title" style={{ margin: 0 }}>
|
||||
Új meghívó
|
||||
</h2>
|
||||
<form onSubmit={submit} className="field" style={{ gap: 14 }}>
|
||||
<div className="field">
|
||||
<label htmlFor="invite-emails">E-mail-címek</label>
|
||||
<textarea
|
||||
id="invite-emails"
|
||||
className="inp"
|
||||
rows={3}
|
||||
required
|
||||
value={emails}
|
||||
onChange={(e) => setEmails(e.target.value)}
|
||||
placeholder={"kata@pelda.hu\nbela@pelda.hu"}
|
||||
/>
|
||||
<span className="hint">Soronként egy, vagy vesszővel elválasztva; egyszerre legfeljebb 50.</span>
|
||||
</div>
|
||||
<div className="field">
|
||||
<label htmlFor="invite-message">Személyes üzenet (nem kötelező)</label>
|
||||
<textarea
|
||||
id="invite-message"
|
||||
className="inp"
|
||||
rows={3}
|
||||
maxLength={MAX_MESSAGE}
|
||||
value={message}
|
||||
onChange={(e) => setMessage(e.target.value)}
|
||||
placeholder="Szia! Ezt nézd meg, szerintem tetszeni fog."
|
||||
/>
|
||||
<span className="hint">
|
||||
{message.length}/{MAX_MESSAGE} karakter. Link nem lehet benne (spamszűrők miatt).
|
||||
</span>
|
||||
</div>
|
||||
<div className="row" style={{ gap: 12, alignItems: "flex-end", flexWrap: "wrap" }}>
|
||||
<div className="field" style={{ width: 160 }}>
|
||||
<label htmlFor="invite-locale">A levél nyelve</label>
|
||||
<select id="invite-locale" className="inp" value={locale} onChange={(e) => setLocale(e.target.value)}>
|
||||
<option value="hu">magyar</option>
|
||||
<option value="en">angol</option>
|
||||
</select>
|
||||
</div>
|
||||
<button type="submit" className="btn btn-primary" disabled={busy || count === 0}>
|
||||
{busy ? "Küldés…" : count > 1 ? `${count} meghívó küldése` : "Meghívó küldése"}
|
||||
</button>
|
||||
</div>
|
||||
</form>
|
||||
{error && (
|
||||
<p className="msg msg-error" role="alert">
|
||||
{error}
|
||||
</p>
|
||||
)}
|
||||
{results && (
|
||||
<ul className="invite-results" aria-label="Eredmény">
|
||||
{results.map((r) => (
|
||||
<li key={r.email}>
|
||||
<span className={r.status === "invited" ? "msg-ok" : "muted"}>
|
||||
{r.email}: {RESULT[r.status]}
|
||||
</span>
|
||||
{r.url && <CopyLink url={r.url} />}
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
)}
|
||||
<MailPreview message={message} locale={locale} />
|
||||
</section>
|
||||
);
|
||||
}
|
||||
|
||||
/** The invitation e-mail as the recipient sees it, and a test copy to the admin. */
|
||||
function MailPreview({ message, locale }: { message: string; locale: string }) {
|
||||
const [mail, setMail] = useState<{ subject: string; html: string; text: string } | null>(null);
|
||||
const [view, setView] = useState<"html" | "text">("html");
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [note, setNote] = useState<{ ok: boolean; text: string } | null>(null);
|
||||
|
||||
async function show(sendToMe: boolean) {
|
||||
setBusy(true);
|
||||
setNote(null);
|
||||
try {
|
||||
const res = await api<{ subject: string; html: string; text: string; sent_to: string | null }>(
|
||||
"/admin/invitations/preview",
|
||||
{ body: { message: message.trim() || null, locale, send_to_me: sendToMe } },
|
||||
);
|
||||
setMail(res);
|
||||
if (res.sent_to) setNote({ ok: true, text: `Tesztlevél a sorban: ${res.sent_to}. A linkjei nem működnek.` });
|
||||
} catch (e) {
|
||||
setNote({ ok: false, text: errorText(e) });
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<div className="field mail-preview" style={{ gap: 10 }}>
|
||||
<div className="row" style={{ gap: 8, flexWrap: "wrap" }}>
|
||||
<button type="button" className="btn btn-sm" onClick={() => show(false)} disabled={busy}>
|
||||
{mail ? "Előnézet frissítése" : "Levél előnézete"}
|
||||
</button>
|
||||
<button type="button" className="btn btn-sm btn-ghost" onClick={() => show(true)} disabled={busy}>
|
||||
Teszt küldése magamnak
|
||||
</button>
|
||||
</div>
|
||||
{note && (
|
||||
<p className={note.ok ? "msg msg-ok" : "msg msg-error"} role={note.ok ? "status" : "alert"}>
|
||||
{note.text}
|
||||
</p>
|
||||
)}
|
||||
{mail && (
|
||||
<>
|
||||
<p style={{ margin: 0 }}>
|
||||
<span className="muted">Tárgy:</span> <strong>{mail.subject}</strong>
|
||||
</p>
|
||||
<div className="row" role="group" aria-label="Változat" style={{ gap: 4 }}>
|
||||
{(["html", "text"] as const).map((v) => (
|
||||
<button
|
||||
key={v}
|
||||
type="button"
|
||||
className={view === v ? "btn btn-sm" : "btn btn-sm btn-ghost"}
|
||||
aria-pressed={view === v}
|
||||
onClick={() => setView(v)}
|
||||
>
|
||||
{v === "html" ? "HTML" : "Szöveges"}
|
||||
</button>
|
||||
))}
|
||||
</div>
|
||||
{view === "html" ? (
|
||||
<iframe title="A levél HTML-változata" className="mail-frame" srcDoc={mail.html} sandbox="" />
|
||||
) : (
|
||||
<pre className="mail-text">{mail.text}</pre>
|
||||
)}
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function InvitationList({ invitations, onChange }: { invitations: AdminInvitation[]; onChange: () => Promise<void> }) {
|
||||
return (
|
||||
<section className="card" aria-labelledby="invitations-title">
|
||||
<h2 id="invitations-title" style={{ marginTop: 0 }}>
|
||||
Meghívók
|
||||
</h2>
|
||||
{invitations.length === 0 ? (
|
||||
<p className="muted">Még nincs meghívó.</p>
|
||||
) : (
|
||||
<div className="table-wrap">
|
||||
<table>
|
||||
<thead>
|
||||
<tr>
|
||||
<th scope="col">Cím</th>
|
||||
<th scope="col">Állapot</th>
|
||||
<th scope="col">Levél</th>
|
||||
<th scope="col">Küldve</th>
|
||||
<th scope="col">Lejár</th>
|
||||
<th scope="col">
|
||||
<span className="sr-only">Műveletek</span>
|
||||
</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{invitations.map((i) => (
|
||||
<InvitationRow key={i.id} invitation={i} onChange={onChange} />
|
||||
))}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
)}
|
||||
</section>
|
||||
);
|
||||
}
|
||||
|
||||
function InvitationRow({ invitation: i, onChange }: { invitation: AdminInvitation; onChange: () => Promise<void> }) {
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [note, setNote] = useState<string | null>(null);
|
||||
const [url, setUrl] = useState<string | null>(null);
|
||||
|
||||
async function act(kind: "resend" | "revoke") {
|
||||
if (kind === "revoke" && !window.confirm(`Visszavonod a meghívót (${i.email})?`)) return;
|
||||
setBusy(true);
|
||||
setNote(null);
|
||||
try {
|
||||
if (kind === "resend") {
|
||||
const res = await api<{ url: string }>(`/admin/invitations/${i.id}/resend`, { body: {} });
|
||||
setUrl(res.url);
|
||||
} else {
|
||||
await api(`/admin/invitations/${i.id}`, { method: "DELETE" });
|
||||
}
|
||||
await onChange();
|
||||
} catch (e) {
|
||||
setNote(errorText(e));
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<tr>
|
||||
<td>
|
||||
<div>{i.email}</div>
|
||||
{i.message && (
|
||||
<div className="hint invite-msg" title={i.message}>
|
||||
„{i.message}”
|
||||
</div>
|
||||
)}
|
||||
</td>
|
||||
<td>
|
||||
<span className={`badge invite-${i.status}`}>{STATUS[i.status]}</span>
|
||||
{i.accepted_by && <div className="hint">{i.accepted_by}</div>}
|
||||
</td>
|
||||
<td>
|
||||
<span className={i.mail === "failed" ? "msg-error" : i.mail === "queued" ? "muted" : undefined}>
|
||||
{MAIL[i.mail]}
|
||||
</span>
|
||||
{i.mail_error && <div className="hint">{i.mail_error.slice(0, 120)}</div>}
|
||||
</td>
|
||||
<td className="num">
|
||||
{formatDate(i.last_sent_at)}
|
||||
{i.sent_count > 1 && <div className="hint">{i.sent_count}× küldve</div>}
|
||||
</td>
|
||||
<td className="num">{i.status === "pending" || i.status === "expired" ? formatDate(i.expires_at) : "–"}</td>
|
||||
<td>
|
||||
<div className="row" style={{ gap: 4, flexWrap: "nowrap", justifyContent: "flex-end" }}>
|
||||
{url && <CopyLink url={url} />}
|
||||
{i.can_resend && (
|
||||
<button type="button" className="btn btn-sm" onClick={() => act("resend")} disabled={busy}>
|
||||
Újraküldés
|
||||
</button>
|
||||
)}
|
||||
{(i.status === "pending" || i.status === "expired") && (
|
||||
<button type="button" className="btn btn-sm btn-ghost" onClick={() => act("revoke")} disabled={busy}>
|
||||
Visszavonás
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
{note && (
|
||||
<div className="msg-error" role="alert" style={{ fontSize: 13 }}>
|
||||
{note}
|
||||
</div>
|
||||
)}
|
||||
</td>
|
||||
</tr>
|
||||
);
|
||||
}
|
||||
|
||||
function WaitlistTable({ waitlist, onChange }: { waitlist: WaitlistEntry[]; onChange: () => Promise<void> }) {
|
||||
const [busy, setBusy] = useState<string | null>(null);
|
||||
const [note, setNote] = useState<string | null>(null);
|
||||
|
||||
async function invite(w: WaitlistEntry) {
|
||||
setBusy(w.email);
|
||||
setNote(null);
|
||||
try {
|
||||
const res = await api<{ results: InvitationResult[] }>("/admin/invitations", {
|
||||
body: { emails: [w.email], locale: w.locale },
|
||||
});
|
||||
const r = res.results[0];
|
||||
if (r && r.status !== "invited") setNote(`${r.email}: ${RESULT[r.status]}`);
|
||||
await onChange();
|
||||
} catch (e) {
|
||||
setNote(errorText(e));
|
||||
} finally {
|
||||
setBusy(null);
|
||||
}
|
||||
}
|
||||
|
||||
async function remove(w: WaitlistEntry) {
|
||||
setBusy(w.email);
|
||||
setNote(null);
|
||||
try {
|
||||
await api(`/admin/waitlist/${encodeURIComponent(w.email)}`, { method: "DELETE" });
|
||||
await onChange();
|
||||
} catch (e) {
|
||||
setNote(errorText(e));
|
||||
} finally {
|
||||
setBusy(null);
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<section className="card" aria-labelledby="waitlist-title">
|
||||
<h2 id="waitlist-title" style={{ marginTop: 0 }}>
|
||||
Várólista
|
||||
</h2>
|
||||
<p className="hint">Akik meghívó nélkül próbáltak belépni, és kérték, hogy szóljunk nekik.</p>
|
||||
{note && (
|
||||
<p className="msg msg-error" role="alert">
|
||||
{note}
|
||||
</p>
|
||||
)}
|
||||
{waitlist.length === 0 ? (
|
||||
<p className="muted">Üres.</p>
|
||||
) : (
|
||||
<div className="table-wrap">
|
||||
<table>
|
||||
<thead>
|
||||
<tr>
|
||||
<th scope="col">Cím</th>
|
||||
<th scope="col">Feliratkozott</th>
|
||||
<th scope="col">Meghívó</th>
|
||||
<th scope="col">
|
||||
<span className="sr-only">Műveletek</span>
|
||||
</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{waitlist.map((w) => (
|
||||
<tr key={w.email}>
|
||||
<td>{w.email}</td>
|
||||
<td className="num">{formatDate(w.created_at)}</td>
|
||||
<td>{w.invitation === "pending" ? "elküldve" : w.invitation === "accepted" ? "elfogadva" : "–"}</td>
|
||||
<td>
|
||||
<div className="row" style={{ gap: 4, flexWrap: "nowrap", justifyContent: "flex-end" }}>
|
||||
{w.invitation === null && (
|
||||
<button
|
||||
type="button"
|
||||
className="btn btn-sm"
|
||||
onClick={() => invite(w)}
|
||||
disabled={busy !== null}
|
||||
>
|
||||
Meghívás
|
||||
</button>
|
||||
)}
|
||||
<button
|
||||
type="button"
|
||||
className="btn btn-sm btn-ghost"
|
||||
onClick={() => remove(w)}
|
||||
disabled={busy !== null}
|
||||
>
|
||||
Törlés
|
||||
</button>
|
||||
</div>
|
||||
</td>
|
||||
</tr>
|
||||
))}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
)}
|
||||
</section>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
import type { Metadata } from "next";
|
||||
import { notFound } from "next/navigation";
|
||||
|
||||
import { AdminNav } from "@/components/AdminNav";
|
||||
import { requireMe } from "@/lib/server";
|
||||
|
||||
import { AdminInvitations } from "./AdminInvitations";
|
||||
|
||||
export const metadata: Metadata = { title: "Meghívók" };
|
||||
|
||||
export default async function AdminInvitationsPage() {
|
||||
const me = await requireMe("/admin/meghivok");
|
||||
if (!me.user.roles.includes("admin")) notFound();
|
||||
return (
|
||||
<main className="page" style={{ maxWidth: 1180 }}>
|
||||
<AdminNav current="/admin/meghivok" />
|
||||
<div className="page-head">
|
||||
<h1>Meghívók</h1>
|
||||
<p className="muted">
|
||||
Az oldalra csak meglévő felhasználó vagy meghívott léphet be. A meghívó 30 napig érvényes, és a linkkel bármelyik
|
||||
Google-fiókkal elfogadható.
|
||||
</p>
|
||||
</div>
|
||||
<AdminInvitations />
|
||||
</main>
|
||||
);
|
||||
}
|
||||
@@ -1,13 +1,19 @@
|
||||
// Country list and place search for the birth data form (public data from
|
||||
// the horoscope-api; only these two endpoints are passed through).
|
||||
// Country list and place search for the birth data form (from the
|
||||
// horoscope-api; only these two endpoints are passed through, and only for
|
||||
// logged-in users, so other apps cannot use the place search).
|
||||
import type { NextRequest } from "next/server";
|
||||
|
||||
import { getMe } from "@/lib/server";
|
||||
|
||||
const HOROSCOPE_API_URL = (process.env.HOROSCOPE_API_URL ?? "http://localhost:8080").replace(/\/$/, "");
|
||||
const ALLOWED = new Set(["countries", "places"]);
|
||||
|
||||
export async function GET(req: NextRequest, ctx: { params: Promise<{ kind: string }> }) {
|
||||
const { kind } = await ctx.params;
|
||||
if (!ALLOWED.has(kind)) return Response.json({ error: { code: "not_found", message: "not found" } }, { status: 404 });
|
||||
if (!(await getMe())) {
|
||||
return Response.json({ error: { code: "unauthorized", message: "Jelentkezz be." } }, { status: 401 });
|
||||
}
|
||||
try {
|
||||
const res = await fetch(`${HOROSCOPE_API_URL}/v1/${kind}${req.nextUrl.search}`, {
|
||||
// The country list rarely changes.
|
||||
|
||||
@@ -4,7 +4,8 @@ import Script from "next/script";
|
||||
import { useRouter } from "next/navigation";
|
||||
import { useCallback, useEffect, useRef, useState } from "react";
|
||||
|
||||
import { api, errorText } from "@/lib/api";
|
||||
import { Waitlist } from "@/components/Waitlist";
|
||||
import { ApiError, api, errorText } from "@/lib/api";
|
||||
|
||||
/** Google's "G" mark (branding guidelines: unmodified, on the left of the label). */
|
||||
function GoogleMark() {
|
||||
@@ -30,32 +31,57 @@ function GoogleMark() {
|
||||
);
|
||||
}
|
||||
|
||||
/** The e-mail address inside Google's ID token (only for prefilling a form; the backend verifies the token). */
|
||||
function tokenEmail(credential: string): string {
|
||||
try {
|
||||
const part = credential.split(".")[1].replace(/-/g, "+").replace(/_/g, "/");
|
||||
const bytes = Uint8Array.from(atob(part), (c) => c.charCodeAt(0));
|
||||
const email = JSON.parse(new TextDecoder().decode(bytes)).email;
|
||||
return typeof email === "string" ? email : "";
|
||||
} catch {
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* "Continue with Google" in the site's own button style. Google's real
|
||||
* (rendered, invisible) button lies on top of it and receives the click, so
|
||||
* the sign-in still returns an ID token.
|
||||
*/
|
||||
export function GoogleLogin({ clientId, target }: { clientId: string; target: string }) {
|
||||
export function GoogleLogin({
|
||||
clientId,
|
||||
target,
|
||||
inviteToken = null,
|
||||
}: {
|
||||
clientId: string;
|
||||
target: string;
|
||||
/** From an invitation link: lets in any Google account. */
|
||||
inviteToken?: string | null;
|
||||
}) {
|
||||
const router = useRouter();
|
||||
const slot = useRef<HTMLDivElement>(null);
|
||||
const [ready, setReady] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [busy, setBusy] = useState(false);
|
||||
/** Set when the address has no invitation: offer the waitlist for it. */
|
||||
const [uninvited, setUninvited] = useState<string | null>(null);
|
||||
|
||||
const onCredential = useCallback(
|
||||
async (response: GoogleCredentialResponse) => {
|
||||
setBusy(true);
|
||||
setError(null);
|
||||
setUninvited(null);
|
||||
try {
|
||||
await api("/auth/google", { body: { id_token: response.credential } });
|
||||
await api("/auth/google", { body: { id_token: response.credential, invite_token: inviteToken } });
|
||||
router.replace(target);
|
||||
router.refresh();
|
||||
} catch (e) {
|
||||
setError(errorText(e));
|
||||
if (e instanceof ApiError && e.code === "not_invited") setUninvited(tokenEmail(response.credential));
|
||||
else setError(errorText(e));
|
||||
setBusy(false);
|
||||
}
|
||||
},
|
||||
[router, target],
|
||||
[router, target, inviteToken],
|
||||
);
|
||||
|
||||
useEffect(() => {
|
||||
@@ -94,6 +120,16 @@ export function GoogleLogin({ clientId, target }: { clientId: string; target: st
|
||||
{error}
|
||||
</p>
|
||||
)}
|
||||
{uninvited !== null && (
|
||||
<>
|
||||
<p className="msg msg-error" role="alert">
|
||||
{inviteToken
|
||||
? "Ez a meghívó már nem érvényes, és ehhez a Google-fiókhoz sem tartozik másik."
|
||||
: `A Sorsfonalak jelenleg meghívásos, és ${uninvited ? `a(z) ${uninvited} címhez` : "ehhez a fiókhoz"} nem tartozik meghívó. Ha kaptál meghívót egy másik címre, lépj be azzal a Google-fiókkal, vagy nyisd meg a levélben kapott linket.`}
|
||||
</p>
|
||||
<Waitlist email={uninvited} />
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -5,7 +5,8 @@ import { redirect } from "next/navigation";
|
||||
import { Logo } from "@/components/SiteHeader";
|
||||
import { ZodiacWheel } from "@/components/ZodiacWheel";
|
||||
import { BACKEND_URL, getMe } from "@/lib/server";
|
||||
import type { PublicConfig } from "@/lib/types";
|
||||
import { formatDate } from "@/lib/astro";
|
||||
import type { InvitationLanding, PublicConfig } from "@/lib/types";
|
||||
|
||||
import { GoogleLogin } from "./GoogleLogin";
|
||||
|
||||
@@ -26,11 +27,63 @@ async function loadConfig(): Promise<PublicConfig | null> {
|
||||
}
|
||||
}
|
||||
|
||||
async function loadInvitation(token: string): Promise<InvitationLanding | null> {
|
||||
try {
|
||||
const res = await fetch(`${BACKEND_URL}/v1/public/invitations/${encodeURIComponent(token)}`, { cache: "no-store" });
|
||||
return res.ok ? ((await res.json()) as InvitationLanding) : null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
const CLOSED: Record<string, string> = {
|
||||
accepted: "Ezt a meghívót már felhasználták. Ha a tiéd volt, egyszerűen lépj be ugyanazzal a Google-fiókkal.",
|
||||
expired: "Ez a meghívó lejárt. Kérj újat attól, aki meghívott.",
|
||||
revoked: "Ezt a meghívót visszavonták.",
|
||||
};
|
||||
|
||||
/** The invitation the visitor came with: who sent it and what they wrote. */
|
||||
function InvitationCard({ invitation }: { invitation: InvitationLanding | null }) {
|
||||
if (!invitation) {
|
||||
return (
|
||||
<p className="msg msg-error" role="alert">
|
||||
Ez a meghívólink érvénytelen. Ellenőrizd, hogy a teljes linket nyitottad-e meg a levélből.
|
||||
</p>
|
||||
);
|
||||
}
|
||||
if (invitation.status !== "pending") {
|
||||
return (
|
||||
<p className="msg msg-error" role="alert">
|
||||
{CLOSED[invitation.status]}
|
||||
</p>
|
||||
);
|
||||
}
|
||||
return (
|
||||
<div className="card invite-card">
|
||||
<span className="eyebrow">Meghívó</span>
|
||||
<p style={{ margin: 0 }}>
|
||||
{invitation.inviter_name ? <strong>{invitation.inviter_name}</strong> : "Valaki"} meghívott a Sorsfonalakra.
|
||||
</p>
|
||||
{invitation.message && <blockquote className="invite-quote">{invitation.message}</blockquote>}
|
||||
<p className="hint" style={{ margin: 0 }}>
|
||||
Bármelyik Google-fiókoddal elfogadhatod. Érvényes: {formatDate(invitation.expires_at).replace(/\.$/, "")}-ig.
|
||||
</p>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
export default async function LoginPage({ searchParams }: { searchParams: Promise<Record<string, string | string[]>> }) {
|
||||
const target = safeTarget((await searchParams).vissza);
|
||||
const params = await searchParams;
|
||||
const target = safeTarget(params.vissza);
|
||||
if (await getMe()) redirect(target);
|
||||
const config = await loadConfig();
|
||||
const rawToken = Array.isArray(params.meghivo) ? params.meghivo[0] : params.meghivo;
|
||||
const inviteToken = rawToken && /^[A-Za-z0-9_-]{8,200}$/.test(rawToken) ? rawToken : null;
|
||||
const [config, invitation] = await Promise.all([
|
||||
loadConfig(),
|
||||
inviteToken ? loadInvitation(inviteToken) : Promise.resolve(null),
|
||||
]);
|
||||
const clientId = config?.google_login.enabled ? config.google_login.client_id : null;
|
||||
const inviteOnly = config?.signup_mode === "invite";
|
||||
|
||||
return (
|
||||
<div className="auth">
|
||||
@@ -42,26 +95,41 @@ export default async function LoginPage({ searchParams }: { searchParams: Promis
|
||||
<p className="muted" style={{ fontSize: 16 }}>
|
||||
Születési képlet, szinasztria és közösség – egy helyen.
|
||||
</p>
|
||||
<p className="ai-line" style={{ fontSize: 15 }}>
|
||||
Részletes elemzések a legfejlettebb AI-modellekkel: egy tapasztalt asztrológushoz közelítő mélység, töredék
|
||||
áron.
|
||||
</p>
|
||||
</div>
|
||||
</aside>
|
||||
<main className="auth-main">
|
||||
<div className="auth-box">
|
||||
<div className="page-head">
|
||||
<h1 style={{ fontSize: 44 }}>Belépés</h1>
|
||||
<p className="muted">Üdv újra! Lépj be a fiókodba.</p>
|
||||
<h1 style={{ fontSize: 44 }}>{rawToken ? "Meghívó" : "Belépés"}</h1>
|
||||
<p className="muted">{rawToken ? "Lépj be, és már kezdheted is." : "Üdv újra! Lépj be a fiókodba."}</p>
|
||||
</div>
|
||||
{rawToken && <InvitationCard invitation={inviteToken ? invitation : null} />}
|
||||
{config === null ? (
|
||||
<p className="msg msg-error" role="alert">
|
||||
A szerver most nem érhető el. Próbáld újra egy kicsit később.
|
||||
</p>
|
||||
) : clientId ? (
|
||||
<GoogleLogin clientId={clientId} target={target} />
|
||||
<GoogleLogin
|
||||
clientId={clientId}
|
||||
target={target}
|
||||
inviteToken={invitation?.status === "pending" ? inviteToken : null}
|
||||
/>
|
||||
) : (
|
||||
<p className="msg msg-error" role="alert">
|
||||
A Google-belépés még nincs beállítva (a backend <code>GOOGLE_CLIENT_IDS</code> változója üres).
|
||||
</p>
|
||||
)}
|
||||
<p className="auth-foot">Még nincs fiókod? Az első belépéskor létrejön.</p>
|
||||
<p className="auth-foot">
|
||||
{rawToken
|
||||
? "A fiókod az első belépéskor jön létre."
|
||||
: inviteOnly
|
||||
? "Az oldal jelenleg meghívásos: új fiók csak meghívóval jön létre."
|
||||
: "Még nincs fiókod? Az első belépéskor létrejön."}
|
||||
</p>
|
||||
<p className="hint">
|
||||
A belépéssel elfogadod, hogy a születési adataidat a képleted kiszámításához tároljuk. Bármikor törölheted
|
||||
őket a profilodban. Részletek: <Link href="/adatvedelem">adatvédelmi tájékoztató</Link>.
|
||||
|
||||
@@ -1,28 +1,28 @@
|
||||
import type { Metadata } from "next";
|
||||
|
||||
import { AiNote } from "@/components/AiNote";
|
||||
import { PackageCards } from "@/components/PackageCards";
|
||||
import { formatDate } from "@/lib/astro";
|
||||
import { backendGet, requireMe } from "@/lib/server";
|
||||
import type { Package, PublicConfig } from "@/lib/types";
|
||||
|
||||
export const metadata: Metadata = { title: "Csomagok" };
|
||||
|
||||
const faq = (dailyLimit: number): [string, string][] => [
|
||||
const FAQ: [string, string][] = [
|
||||
[
|
||||
"Lejárnak a megvett elemzések?",
|
||||
"Nem. A csomagokban kapott elemzések és személyhelyek addig megmaradnak, amíg fel nem használod őket. Csak a Korlátlan csomag szól egy évre.",
|
||||
"Nem. A csomagokban kapott elemzések és személyhelyek addig megmaradnak, amíg fel nem használod őket.",
|
||||
],
|
||||
[
|
||||
"Mi a különbség a képletelemzés és a kapcsolati elemzés között?",
|
||||
"A képletelemzés egy ember születési képletét írja le hat fejezetben. A kapcsolati elemzés két képletet vet össze: mi vonz, hol súrlódtok, és mit ad a kapcsolat.",
|
||||
],
|
||||
[
|
||||
"Mire kell a személyhely?",
|
||||
"A saját képleted mellé felvett emberekhez (társ, gyerek, barát). Egy személy felvétele egy helyet használ; a képlete és a rövid összefoglalója ingyenes, a részletes elemzés külön jár.",
|
||||
"Mi az éves előrejelzés?",
|
||||
"Egy év születésnaptól születésnapig. A szolár képletből (a Nap visszatérése a születési helyére), a lassú bolygók tranzitjaiból, a progresszióból, az év urából és a fogyatkozásokból áll össze, öt fejezetben és negyedévenkénti idővonallal. A számított idővonal ingyenes, a részletes szöveg egy előrejelzést használ.",
|
||||
],
|
||||
[
|
||||
"Van korlát a Korlátlan csomagban?",
|
||||
`Méltányos használat: naponta legfeljebb ${dailyLimit} új részletes elemzés kérhető. Ha még tart, egy újabb Korlátlan csomag a lejárathoz ad hozzá egy évet.`,
|
||||
"Mire kell a személyhely?",
|
||||
"A saját képleted mellé felvett emberekhez (társ, gyerek, barát). Egy személy felvétele egy helyet használ; a képlete és a rövid összefoglalója ingyenes, a részletes elemzés külön jár.",
|
||||
],
|
||||
];
|
||||
|
||||
@@ -47,24 +47,21 @@ export default async function PackagesPage() {
|
||||
</p>
|
||||
</div>
|
||||
|
||||
<AiNote />
|
||||
|
||||
<section className="card holdings" aria-label="Amid most van">
|
||||
<span className="eyebrow">Most</span>
|
||||
{me.unlimited_until ? (
|
||||
<p>
|
||||
<strong>Korlátlan csomag</strong> {formatDate(me.unlimited_until).replace(/\.$/, "")}-ig.
|
||||
</p>
|
||||
) : (
|
||||
<p>
|
||||
<strong>{left.natal}</strong> képletelemzés · <strong>{left.synastry}</strong> kapcsolati elemzés ·{" "}
|
||||
{slots.unlimited ? (
|
||||
"korlátlan személy"
|
||||
) : (
|
||||
<>
|
||||
<strong>{slots.left}</strong> szabad személyhely
|
||||
</>
|
||||
)}
|
||||
</p>
|
||||
)}
|
||||
<p>
|
||||
<strong>{left.natal}</strong> képletelemzés · <strong>{left.synastry}</strong> kapcsolati elemzés ·{" "}
|
||||
<strong>{left.forecast}</strong> éves előrejelzés ·{" "}
|
||||
{slots.unlimited ? (
|
||||
"korlátlan személy"
|
||||
) : (
|
||||
<>
|
||||
<strong>{slots.left}</strong> szabad személyhely
|
||||
</>
|
||||
)}
|
||||
</p>
|
||||
</section>
|
||||
|
||||
<PackageCards packages={packages} canPay={canPay} />
|
||||
@@ -83,7 +80,7 @@ export default async function PackagesPage() {
|
||||
<section className="card" aria-labelledby="faq-title">
|
||||
<h2 id="faq-title">Gyakori kérdések</h2>
|
||||
<dl className="faq">
|
||||
{faq(config?.unlimited_daily_limit ?? 5).map(([q, a]) => (
|
||||
{FAQ.map(([q, a]) => (
|
||||
<div key={q}>
|
||||
<dt>{q}</dt>
|
||||
<dd className="muted">{a}</dd>
|
||||
|
||||
@@ -57,6 +57,14 @@ p { margin: 0; }
|
||||
.nav a { color: var(--ink-2); text-decoration: none; padding: 10px 12px; border-radius: 8px; min-height: 44px; display: inline-flex; align-items: center; }
|
||||
.nav a:hover, .nav a[aria-current="page"] { color: var(--gold); background: rgba(217, 180, 106, 0.08); }
|
||||
.who { display: flex; align-items: center; gap: 12px; color: var(--muted); font-size: 14px; }
|
||||
.pkg-pill {
|
||||
display: inline-flex; align-items: center; gap: 6px; min-height: 32px; padding: 0 12px; border-radius: 999px;
|
||||
border: 1px solid rgba(217, 180, 106, 0.5); color: var(--gold); text-decoration: none; font-size: 13px; white-space: nowrap;
|
||||
}
|
||||
.pkg-pill:hover { background: rgba(217, 180, 106, 0.08); color: var(--gold); }
|
||||
.pkg-pill-detail { color: var(--muted); }
|
||||
.pkg-pill-detail::before { content: "·"; margin-right: 6px; }
|
||||
.pkg-pill-empty { border-color: var(--line-2); color: var(--ink-2); }
|
||||
|
||||
/* Layout */
|
||||
.page { max-width: 960px; margin: 0 auto; padding: 32px 16px 64px; display: flex; flex-direction: column; gap: 24px; }
|
||||
@@ -307,6 +315,7 @@ td.num { font-variant-numeric: tabular-nums; white-space: nowrap; }
|
||||
h1 { font-size: 32px; }
|
||||
.site-header { padding: 10px 16px; gap: 12px; }
|
||||
.nav { order: 3; flex-basis: 100%; }
|
||||
.who-name { display: none; }
|
||||
.card { padding: 18px; }
|
||||
.auth-aside { padding: 28px 20px; min-height: 0; }
|
||||
.wheel { width: 60%; }
|
||||
@@ -549,3 +558,55 @@ a.pair-row:hover strong { color: var(--gold); }
|
||||
.pkg-grid, .pkg-grid-compact { grid-template-columns: 1fr; }
|
||||
.pkg-tagline { min-height: 0; }
|
||||
}
|
||||
|
||||
/* Invitations */
|
||||
.invite-card { display: flex; flex-direction: column; gap: 8px; }
|
||||
.invite-quote {
|
||||
margin: 0; padding: 2px 0 2px 14px; border-left: 3px solid var(--gold);
|
||||
font-style: italic; white-space: pre-line; color: var(--ink);
|
||||
}
|
||||
.waitlist { display: flex; flex-direction: column; gap: 10px; }
|
||||
.invite-results { margin: 0; padding: 0; list-style: none; display: flex; flex-direction: column; gap: 4px; }
|
||||
.invite-results li { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
|
||||
.invite-msg { max-width: 280px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
||||
.invite-accepted { border-color: color-mix(in srgb, var(--ok) 50%, transparent); color: var(--ok); }
|
||||
.invite-pending { border-color: rgba(217, 180, 106, 0.5); color: var(--gold); }
|
||||
.invite-expired, .invite-revoked { color: var(--muted); }
|
||||
.mail-frame { width: 100%; height: 640px; border: 1px solid var(--line); border-radius: 8px; background: #f4f1ea; }
|
||||
.mail-text {
|
||||
margin: 0; padding: 16px; border: 1px solid var(--line); border-radius: 8px; max-height: 640px; overflow: auto;
|
||||
white-space: pre-wrap; font-size: 13px; line-height: 1.5;
|
||||
}
|
||||
|
||||
/* The note on the AI analyses (packages page, analysis offer, login) */
|
||||
.ai-note { gap: 6px; padding: 16px 20px; border-left: 3px solid var(--gold); }
|
||||
.ai-note h2 { font-size: 24px; }
|
||||
.ai-note p { margin: 0; max-width: 72ch; line-height: 1.65; }
|
||||
.ai-line { margin: 0; color: var(--ink-2); line-height: 1.6; padding-left: 12px; border-left: 2px solid var(--gold); max-width: 64ch; }
|
||||
|
||||
/* Yearly forecast: timeline and transit list */
|
||||
.timeline { display: flex; flex-direction: column; gap: 18px; }
|
||||
.timeline-month h3 { font-size: 20px; margin: 0 0 8px; text-transform: capitalize; }
|
||||
.timeline-month ol, .transit-list { margin: 0; padding: 0; list-style: none; display: flex; flex-direction: column; gap: 6px; }
|
||||
.timeline-item {
|
||||
display: grid; grid-template-columns: 64px 56px 1fr; gap: 10px; align-items: baseline;
|
||||
padding: 8px 12px; border-left: 3px solid var(--line); border-radius: 4px; background: rgba(255, 255, 255, 0.02);
|
||||
}
|
||||
.timeline-date { color: var(--muted); font-variant-numeric: tabular-nums; white-space: nowrap; }
|
||||
.timeline-glyph { font-size: 17px; color: var(--gold); white-space: nowrap; }
|
||||
.timeline-text { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
|
||||
.timeline-item.tone-tense, .transit-list .tone-tense { border-left-color: var(--tense); }
|
||||
.timeline-item.tone-harmonic, .transit-list .tone-harmonic { border-left-color: var(--harmonic); }
|
||||
.timeline-item.tone-neutral, .transit-list .tone-neutral { border-left-color: var(--gold); }
|
||||
.transit-list li {
|
||||
display: grid; grid-template-columns: 72px 1fr; gap: 10px; align-items: baseline;
|
||||
padding: 8px 12px; border-left: 3px solid var(--line); border-radius: 4px;
|
||||
}
|
||||
.transit-list li > span:last-child { display: flex; flex-direction: column; gap: 2px; }
|
||||
.transit-list .sym { font-size: 17px; color: var(--gold); white-space: nowrap; }
|
||||
.transit-list .pill { align-self: flex-start; font-size: 12px; padding: 1px 8px; border: 1px solid var(--gold); border-radius: 999px; color: var(--gold); }
|
||||
.plain-list { margin: 8px 0 12px; padding-left: 18px; display: flex; flex-direction: column; gap: 4px; }
|
||||
@media (max-width: 560px) {
|
||||
.timeline-item { grid-template-columns: 52px 1fr; }
|
||||
.timeline-glyph { display: none; }
|
||||
}
|
||||
|
||||
@@ -0,0 +1,127 @@
|
||||
"use client";
|
||||
|
||||
import { useRouter } from "next/navigation";
|
||||
import { useState } from "react";
|
||||
|
||||
import { CountrySelect, PlaceSearch } from "@/app/profil/BirthForm";
|
||||
import { api, errorText } from "@/lib/api";
|
||||
import type { ForecastDetail, Place } from "@/lib/types";
|
||||
|
||||
/**
|
||||
* Calculates a year: which year (when two are open) and where the person is
|
||||
* on the birthday (the solar return chart is cast for that place).
|
||||
*/
|
||||
export function ForecastStart({
|
||||
chartId,
|
||||
years,
|
||||
birthPlace,
|
||||
timeKnown,
|
||||
compact = false,
|
||||
}: {
|
||||
chartId: string;
|
||||
years: number[];
|
||||
birthPlace: string | null;
|
||||
timeKnown: boolean;
|
||||
compact?: boolean;
|
||||
}) {
|
||||
const router = useRouter();
|
||||
const [year, setYear] = useState(years[0]);
|
||||
const [elsewhere, setElsewhere] = useState(false);
|
||||
const [country, setCountry] = useState("HU");
|
||||
const [place, setPlace] = useState<Place | null>(null);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
|
||||
async function submit(e: React.FormEvent) {
|
||||
e.preventDefault();
|
||||
if (elsewhere && !place) return setError("Válaszd ki a települést a listából.");
|
||||
setBusy(true);
|
||||
setError(null);
|
||||
try {
|
||||
const body: Record<string, unknown> = { year };
|
||||
if (elsewhere && place) body.location = { country, geonames_id: place.geonames_id, place: place.name };
|
||||
const f = await api<ForecastDetail>(`/charts/${chartId}/forecasts`, { body });
|
||||
router.push(`/kepletek/${chartId}/elorejelzes?f=${f.id}`);
|
||||
router.refresh();
|
||||
} catch (err) {
|
||||
setError(errorText(err));
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<form className={compact ? "field" : "card field"} onSubmit={submit} style={{ gap: 14 }}>
|
||||
{!compact && (
|
||||
<>
|
||||
<span className="eyebrow">Éves előrejelzés</span>
|
||||
<h2>Mit hoz az éved?</h2>
|
||||
<p className="muted">
|
||||
Egy év születésnaptól születésnapig. Az év képlete a szolár: az a pillanat, amikor a Nap visszatér a
|
||||
születéskori helyére. Ehhez jönnek a lassú bolygók tranzitjai pontos dátumokkal, a progresszív Hold, az év ura
|
||||
és a fogyatkozások. A számítás és az idővonal ingyenes.
|
||||
</p>
|
||||
</>
|
||||
)}
|
||||
{years.length > 1 && (
|
||||
<fieldset className="field" style={{ border: 0, padding: 0, margin: 0 }}>
|
||||
<legend className="label" style={{ marginBottom: 8 }}>
|
||||
Melyik év?
|
||||
</legend>
|
||||
{years.map((y) => (
|
||||
<label key={y} className="check">
|
||||
<input type="radio" name="year" checked={year === y} onChange={() => setYear(y)} />
|
||||
{y === years[0] ? `A mostani év (${y}-es születésnaptól)` : `A következő év (${y}-es születésnaptól)`}
|
||||
</label>
|
||||
))}
|
||||
</fieldset>
|
||||
)}
|
||||
{timeKnown && (
|
||||
<fieldset className="field" style={{ border: 0, padding: 0, margin: 0 }}>
|
||||
<legend className="label" style={{ marginBottom: 8 }}>
|
||||
Hol vagy a születésnapodon?
|
||||
</legend>
|
||||
<label className="check">
|
||||
<input type="radio" name="where" checked={!elsewhere} onChange={() => setElsewhere(false)} />
|
||||
A születési helyemen{birthPlace ? ` (${birthPlace})` : ""}
|
||||
</label>
|
||||
<label className="check">
|
||||
<input type="radio" name="where" checked={elsewhere} onChange={() => setElsewhere(true)} />
|
||||
Máshol (lakóhely, nyaralás)
|
||||
</label>
|
||||
<span className="hint">
|
||||
A szolár képlet házai attól függnek, hol tartózkodsz a születésnapod pillanatában. Ha nem tudod, add meg
|
||||
a lakóhelyed.
|
||||
</span>
|
||||
</fieldset>
|
||||
)}
|
||||
{timeKnown && elsewhere && (
|
||||
<div className="grid-2">
|
||||
<CountrySelect
|
||||
value={country}
|
||||
onChange={(c) => {
|
||||
setCountry(c);
|
||||
setPlace(null);
|
||||
}}
|
||||
/>
|
||||
<PlaceSearch country={country} value={place} onChange={setPlace} />
|
||||
</div>
|
||||
)}
|
||||
{!timeKnown && (
|
||||
<p className="hint">
|
||||
A születési idő ismeretlen, ezért szolár képlet és az év ura nem számolható; az előrejelzés a tranzitokra és a
|
||||
progresszióra épül.
|
||||
</p>
|
||||
)}
|
||||
{error && (
|
||||
<p className="msg msg-error" role="alert">
|
||||
{error}
|
||||
</p>
|
||||
)}
|
||||
<div className="form-actions">
|
||||
<button type="submit" className="btn btn-primary" disabled={busy}>
|
||||
{busy ? "Számolás…" : compact ? "Kiszámítás" : "Előrejelzés kiszámítása"}
|
||||
</button>
|
||||
</div>
|
||||
</form>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
import type { Metadata } from "next";
|
||||
import Link from "next/link";
|
||||
import { notFound } from "next/navigation";
|
||||
|
||||
import { ChartWheel } from "@/components/ChartWheel";
|
||||
import { DetailedAnalysis } from "@/components/DetailedAnalysis";
|
||||
import { ForecastKeys, ForecastTimeline, ForecastTransits, longDay } from "@/components/ForecastViews";
|
||||
import { Tabs } from "@/components/Tabs";
|
||||
import { backendGet, requireMe } from "@/lib/server";
|
||||
import type { Analysis, Chart, ForecastDetail, ForecastList, PublicConfig } from "@/lib/types";
|
||||
|
||||
import { ForecastStart } from "./ForecastStart";
|
||||
|
||||
export const metadata: Metadata = { title: "Éves előrejelzés" };
|
||||
|
||||
const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
||||
|
||||
/** One year of a chart: the solar return, the year's keys, the timeline and the detailed forecast. */
|
||||
export default async function ForecastPage({
|
||||
params,
|
||||
searchParams,
|
||||
}: {
|
||||
params: Promise<{ id: string }>;
|
||||
searchParams: Promise<{ f?: string }>;
|
||||
}) {
|
||||
const { id } = await params;
|
||||
const { f } = await searchParams;
|
||||
const me = await requireMe(`/kepletek/${id}/elorejelzes`);
|
||||
if (!UUID.test(id)) notFound();
|
||||
const [chart, list, config] = await Promise.all([
|
||||
backendGet<Chart>(`/v1/charts/${id}`),
|
||||
backendGet<ForecastList>(`/v1/charts/${id}/forecasts`),
|
||||
backendGet<PublicConfig>("/v1/config"),
|
||||
]);
|
||||
if (!chart || !list) notFound();
|
||||
const chosenId = f && UUID.test(f) ? f : (list.forecasts[0]?.id ?? null);
|
||||
const [forecast, analyses] = chosenId
|
||||
? await Promise.all([
|
||||
backendGet<ForecastDetail>(`/v1/forecasts/${chosenId}`),
|
||||
backendGet<{ analyses: Analysis[] }>(`/v1/forecasts/${chosenId}/analyses`),
|
||||
])
|
||||
: [null, null];
|
||||
const detailed = (analyses?.analyses ?? []).find((a) => a.status !== "failed") ?? analyses?.analyses[0] ?? null;
|
||||
const name = chart.is_primary ? "Az éved" : `${chart.label} éve`;
|
||||
const sr = forecast?.result.solar_return ?? null;
|
||||
const fc = forecast?.result.forecast;
|
||||
const others = list.forecasts.filter((x) => x.id !== forecast?.id);
|
||||
|
||||
return (
|
||||
<main className="page" style={{ maxWidth: 1180 }}>
|
||||
<div className="page-head">
|
||||
<p className="hint">
|
||||
<Link href={`/kepletek/${chart.id}`}>← {chart.is_primary ? "Születési képletem" : chart.label}</Link>
|
||||
</p>
|
||||
<h1>{forecast ? `${name}: ${forecast.year}–${forecast.year + 1}` : "Éves előrejelzés"}</h1>
|
||||
{forecast && fc && (
|
||||
<p className="muted">
|
||||
{longDay(fc.start)} – {longDay(fc.end)} · {forecast.place ?? "születési hely"}
|
||||
</p>
|
||||
)}
|
||||
</div>
|
||||
|
||||
{!forecast && list.years.length > 0 && (
|
||||
<ForecastStart
|
||||
chartId={chart.id}
|
||||
years={list.years}
|
||||
birthPlace={list.birth_place}
|
||||
timeKnown={list.time_known}
|
||||
/>
|
||||
)}
|
||||
{!forecast && list.years.length === 0 && (
|
||||
<p className="card muted">Az első születésnap előtt még nincs éves előrejelzés.</p>
|
||||
)}
|
||||
|
||||
{forecast && fc && (
|
||||
<>
|
||||
<section className="chart-layout" aria-label="Szolár képlet">
|
||||
{sr ? (
|
||||
<div className="card chart-wheel-card">
|
||||
<ChartWheel chart={sr} timeKnown title="Szolár képlet" />
|
||||
<p className="hint">
|
||||
Szolár képlet: {longDay(sr.local_time.slice(0, 10))} {sr.local_time.slice(11, 16)} helyi idő
|
||||
szerint, {forecast.place}. A Nap ekkor ér vissza pontosan a születéskori helyére.
|
||||
</p>
|
||||
</div>
|
||||
) : (
|
||||
<div className="card">
|
||||
<p className="muted">
|
||||
Szolár képlet nincs, mert a születési idő ismeretlen: a Nap visszatérésének pillanata így akár fél napot
|
||||
is tévedhet. Az előrejelzés a tranzitokra és a progresszióra épül.
|
||||
</p>
|
||||
</div>
|
||||
)}
|
||||
<div className="field chart-side">
|
||||
<ForecastKeys forecast={fc} solarReturn={sr} />
|
||||
{(list.years.length > 0 || others.length > 0) && (
|
||||
<details className="card">
|
||||
<summary>Másik év vagy helyszín</summary>
|
||||
{others.length > 0 && (
|
||||
<ul className="plain-list">
|
||||
{others.map((o) => (
|
||||
<li key={o.id}>
|
||||
<Link href={`/kepletek/${chart.id}/elorejelzes?f=${o.id}`}>
|
||||
{o.year}–{o.year + 1} · {o.place ?? "születési hely"}
|
||||
</Link>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
)}
|
||||
{list.years.length > 0 && (
|
||||
<ForecastStart
|
||||
chartId={chart.id}
|
||||
years={list.years}
|
||||
birthPlace={list.birth_place}
|
||||
timeKnown={list.time_known}
|
||||
compact
|
||||
/>
|
||||
)}
|
||||
</details>
|
||||
)}
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<section className="card chart-tabs" aria-label="Előrejelzés">
|
||||
<Tabs
|
||||
label="Előrejelzés részletei"
|
||||
tabs={[
|
||||
{
|
||||
id: "elemzes",
|
||||
label: "Előrejelzés",
|
||||
content: (
|
||||
<DetailedAnalysis
|
||||
target={{ kind: "forecast", forecastId: forecast.id }}
|
||||
initial={detailed}
|
||||
left={me.analyses_left.forecast}
|
||||
isAdmin={me.user.roles.includes("admin")}
|
||||
canPay={config?.mock_payments ?? false}
|
||||
/>
|
||||
),
|
||||
},
|
||||
{ id: "idovonal", label: "Idővonal", content: <ForecastTimeline forecast={fc} /> },
|
||||
{ id: "tranzitok", label: "Tranzitok", content: <ForecastTransits forecast={fc} /> },
|
||||
]}
|
||||
/>
|
||||
</section>
|
||||
</>
|
||||
)}
|
||||
</main>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
"use client";
|
||||
|
||||
import { useRouter } from "next/navigation";
|
||||
import { useState } from "react";
|
||||
|
||||
import { api, errorText } from "@/lib/api";
|
||||
|
||||
/** Changes only a person's name (any time; the chart and analyses stay). */
|
||||
export function RenamePerson({ id, name }: { id: string; name: string }) {
|
||||
const router = useRouter();
|
||||
const [value, setValue] = useState(name);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
|
||||
async function save(e: React.FormEvent) {
|
||||
e.preventDefault();
|
||||
if (!value.trim()) return setError("Add meg a nevét.");
|
||||
setBusy(true);
|
||||
setError(null);
|
||||
try {
|
||||
await api(`/charts/${id}`, { method: "PATCH", body: { label: value.trim() } });
|
||||
router.push(`/kepletek/${id}`);
|
||||
router.refresh();
|
||||
} catch (err) {
|
||||
setError(errorText(err));
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<form onSubmit={save} className="field" style={{ gap: 16 }} noValidate>
|
||||
<div className="field" style={{ maxWidth: 420 }}>
|
||||
<label htmlFor="rename">Név</label>
|
||||
<input
|
||||
id="rename"
|
||||
className="inp"
|
||||
value={value}
|
||||
maxLength={100}
|
||||
autoComplete="off"
|
||||
onChange={(e) => setValue(e.target.value)}
|
||||
required
|
||||
/>
|
||||
</div>
|
||||
{error && (
|
||||
<p className="msg msg-error" role="alert">
|
||||
{error}
|
||||
</p>
|
||||
)}
|
||||
<div className="form-actions">
|
||||
<button type="submit" className="btn btn-primary" disabled={busy || value.trim() === name}>
|
||||
{busy ? "Mentés…" : "Név mentése"}
|
||||
</button>
|
||||
<button type="button" className="btn btn-ghost" onClick={() => router.push(`/kepletek/${id}`)} disabled={busy}>
|
||||
Mégse
|
||||
</button>
|
||||
</div>
|
||||
</form>
|
||||
);
|
||||
}
|
||||
@@ -1,17 +1,17 @@
|
||||
import type { Metadata } from "next";
|
||||
import Link from "next/link";
|
||||
import { notFound } from "next/navigation";
|
||||
|
||||
import { backendGet, requireMe } from "@/lib/server";
|
||||
import type { Chart } from "@/lib/types";
|
||||
|
||||
import { EditPerson } from "./EditPerson";
|
||||
import { RenamePerson } from "./RenamePerson";
|
||||
|
||||
export const metadata: Metadata = { title: "Adatok javítása" };
|
||||
|
||||
const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
||||
|
||||
/** Correcting a person's birth data (within an hour of adding them; admins any time). */
|
||||
/** Correcting a person: name any time, birth data within an hour of adding them (admins any time). */
|
||||
export default async function EditPersonPage({ params }: { params: Promise<{ id: string }> }) {
|
||||
const { id } = await params;
|
||||
const me = await requireMe(`/kepletek/${id}/javitas`);
|
||||
@@ -26,7 +26,9 @@ export default async function EditPersonPage({ params }: { params: Promise<{ id:
|
||||
<div className="page-head">
|
||||
<h1>{chart.label} adatai</h1>
|
||||
<p className="muted">
|
||||
A javítás után újraszámoljuk a képletet és a rövid összefoglalót.
|
||||
{editable
|
||||
? "Ha a születési adatokon változtatsz, újraszámoljuk a képletet és a rövid összefoglalót. A név módosítása a képletet és az elemzéseket nem érinti."
|
||||
: "A név bármikor módosítható; a képlet és az elemzések maradnak."}
|
||||
</p>
|
||||
</div>
|
||||
<section className="card" aria-label="Születési adatok">
|
||||
@@ -42,10 +44,8 @@ export default async function EditPersonPage({ params }: { params: Promise<{ id:
|
||||
/>
|
||||
) : (
|
||||
<>
|
||||
<p className="muted">A személy születési adatai csak a felvételt követő egy órán belül javíthatók.</p>
|
||||
<Link href={`/kepletek/${id}`} className="btn" style={{ alignSelf: "flex-start" }}>
|
||||
Vissza a képlethez
|
||||
</Link>
|
||||
<RenamePerson id={id} name={chart.label} />
|
||||
<p className="hint">A születési adatok csak a felvételt követő egy órán belül javíthatók.</p>
|
||||
</>
|
||||
)}
|
||||
</section>
|
||||
|
||||
@@ -118,6 +118,16 @@ export default async function ChartPage({ params }: { params: Promise<{ id: stri
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
<Link href={`/kepletek/${chart.id}/elorejelzes`} className="card persons-tile">
|
||||
<span className="eyebrow">Éves előrejelzés</span>
|
||||
<strong>{chart.is_primary ? "Mit hoz az éved?" : `Mit hoz ${chart.label} éve?`}</strong>
|
||||
<span className="muted">
|
||||
Szolár képlet, tranzitok pontos dátumokkal, progresszió: egy év születésnaptól születésnapig.
|
||||
</span>
|
||||
<span className="persons-tile-arrow" aria-hidden="true">
|
||||
→
|
||||
</span>
|
||||
</Link>
|
||||
{!chart.is_primary && own && (
|
||||
<div className="card compare-tile">
|
||||
<span className="eyebrow">Összevetés</span>
|
||||
@@ -160,7 +170,6 @@ export default async function ChartPage({ params }: { params: Promise<{ id: stri
|
||||
initial={detailed}
|
||||
left={me.analyses_left.natal}
|
||||
isAdmin={me.user.roles.includes("admin")}
|
||||
unlimited={me.unlimited_until !== null}
|
||||
canPay={config?.mock_payments ?? false}
|
||||
/>
|
||||
),
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
"use client";
|
||||
|
||||
import { useState } from "react";
|
||||
|
||||
import { api, errorText } from "@/lib/api";
|
||||
|
||||
// A button, not an automatic request: link scanners of mail providers open
|
||||
// every link, and they must not unsubscribe anyone.
|
||||
export function Unsubscribe({ token }: { token: string | null }) {
|
||||
const [state, setState] = useState<"idle" | "busy" | "done">("idle");
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
|
||||
if (!token) {
|
||||
return (
|
||||
<p className="msg msg-error" role="alert">
|
||||
Hiányzik a link vége. Nyisd meg a teljes linket a levélből.
|
||||
</p>
|
||||
);
|
||||
}
|
||||
if (state === "done") {
|
||||
return (
|
||||
<p className="msg msg-ok" role="status">
|
||||
Leiratkoztál: erre a címre nem küldünk több meghívót.
|
||||
</p>
|
||||
);
|
||||
}
|
||||
|
||||
async function confirm() {
|
||||
setState("busy");
|
||||
setError(null);
|
||||
try {
|
||||
await api(`/public/invitations/unsubscribe?token=${encodeURIComponent(token!)}`, { method: "POST" });
|
||||
setState("done");
|
||||
} catch (e) {
|
||||
setError(errorText(e));
|
||||
setState("idle");
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<div className="card field" style={{ gap: 12 }}>
|
||||
<p style={{ margin: 0 }}>
|
||||
Ha leiratkozol, erre az e-mail-címre többé nem küldünk meghívót, és a mostani meghívód is érvényét veszti.
|
||||
</p>
|
||||
<div>
|
||||
<button type="button" className="btn btn-primary" onClick={confirm} disabled={state === "busy"}>
|
||||
{state === "busy" ? "Leiratkozás…" : "Leiratkozom"}
|
||||
</button>
|
||||
</div>
|
||||
{error && (
|
||||
<p className="msg msg-error" role="alert">
|
||||
{error}
|
||||
</p>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
import type { Metadata } from "next";
|
||||
|
||||
import { Unsubscribe } from "./Unsubscribe";
|
||||
|
||||
export const metadata: Metadata = { title: "Leiratkozás", robots: { index: false } };
|
||||
|
||||
/** "No more invitations", from the link in the footer of an invitation e-mail. */
|
||||
export default async function UnsubscribePage({ searchParams }: { searchParams: Promise<Record<string, string | string[]>> }) {
|
||||
const raw = (await searchParams).token;
|
||||
const token = Array.isArray(raw) ? raw[0] : raw;
|
||||
return (
|
||||
<main className="page" style={{ maxWidth: 560 }}>
|
||||
<div className="page-head">
|
||||
<h1>Leiratkozás</h1>
|
||||
<p className="muted">Nem kérsz több meghívót a Sorsfonalakra.</p>
|
||||
</div>
|
||||
<Unsubscribe token={token ?? null} />
|
||||
</main>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
import { redirect } from "next/navigation";
|
||||
|
||||
/** The link in the invitation e-mail: the login page shows the invitation. */
|
||||
export default async function InvitationLink({ params }: { params: Promise<{ token: string }> }) {
|
||||
const { token } = await params;
|
||||
redirect(`/belepes?meghivo=${encodeURIComponent(token)}`);
|
||||
}
|
||||
@@ -127,7 +127,6 @@ export default async function ComparisonPage({ params }: { params: Promise<{ id:
|
||||
initial={detailed}
|
||||
left={me.analyses_left.synastry}
|
||||
isAdmin={me.user.roles.includes("admin")}
|
||||
unlimited={me.unlimited_until !== null}
|
||||
canPay={config?.mock_payments ?? false}
|
||||
note={`Az elemzésben az első fél: ${name1}, a második fél: ${name2}.`}
|
||||
/>
|
||||
|
||||
@@ -69,10 +69,19 @@ export function BirthForm({
|
||||
geonames_id: place.geonames_id,
|
||||
...(ambiguous ? { ambiguous_time: ambiguity } : {}),
|
||||
};
|
||||
// Correcting a person: the birth data only when it changed, so a new
|
||||
// name alone does not recalculate the chart or drop its analyses.
|
||||
const birthChanged =
|
||||
!initial ||
|
||||
ambiguous ||
|
||||
date !== initial.date ||
|
||||
(timeUnknown ? null : time) !== (initial.time?.slice(0, 5) ?? null) ||
|
||||
country !== (initial.country ?? "HU") ||
|
||||
place.geonames_id !== initial.geonames_id;
|
||||
const saved = person?.chartId
|
||||
? await api<{ id: string }>(`/charts/${person.chartId}`, {
|
||||
method: "PATCH",
|
||||
body: { label: name.trim(), birth },
|
||||
body: birthChanged ? { label: name.trim(), birth } : { label: name.trim() },
|
||||
})
|
||||
: await api<{ id: string }>("/charts", {
|
||||
body: person
|
||||
@@ -190,7 +199,7 @@ export function BirthForm({
|
||||
);
|
||||
}
|
||||
|
||||
function CountrySelect({ value, onChange }: { value: string; onChange: (iso2: string) => void }) {
|
||||
export function CountrySelect({ value, onChange }: { value: string; onChange: (iso2: string) => void }) {
|
||||
const [countries, setCountries] = useState<Country[]>([]);
|
||||
useEffect(() => {
|
||||
fetch("/api/geo/countries")
|
||||
@@ -217,7 +226,7 @@ function CountrySelect({ value, onChange }: { value: string; onChange: (iso2: st
|
||||
);
|
||||
}
|
||||
|
||||
function PlaceSearch({
|
||||
export function PlaceSearch({
|
||||
country,
|
||||
value,
|
||||
onChange,
|
||||
|
||||
@@ -46,9 +46,7 @@ export default async function ProfilePage() {
|
||||
<dd>{me.providers.map((p) => PROVIDERS[p] ?? p).join(", ") || "–"}</dd>
|
||||
<dt>Részletes elemzések</dt>
|
||||
<dd>
|
||||
{me.unlimited_until
|
||||
? `Korlátlan, ${formatDate(me.unlimited_until).replace(/\.$/, "")}-ig`
|
||||
: `${me.analyses_left.natal} képlet, ${me.analyses_left.synastry} kapcsolati`}{" "}
|
||||
{`${me.analyses_left.natal} képlet, ${me.analyses_left.synastry} kapcsolati, ${me.analyses_left.forecast} előrejelzés`}{" "}
|
||||
· <Link href="/csomagok">Csomagok</Link>
|
||||
</dd>
|
||||
<dt>Személyek</dt>
|
||||
|
||||
@@ -2,6 +2,7 @@ import Link from "next/link";
|
||||
|
||||
const PAGES = [
|
||||
{ href: "/admin", label: "Felhasználók" },
|
||||
{ href: "/admin/meghivok", label: "Meghívók" },
|
||||
{ href: "/admin/promptok", label: "Promptok" },
|
||||
];
|
||||
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
/** Shown where people decide: the analyses are written by top AI models (never named: a business secret). */
|
||||
export const AI_SHORT =
|
||||
"A legfejlettebb AI-modellek írják: egy tapasztalt asztrológus írásos elemzéséhez közelítő mélység, töredék áron.";
|
||||
|
||||
/** A highlighted note on the analysis quality. */
|
||||
export function AiNote() {
|
||||
return (
|
||||
<section className="card ai-note" aria-labelledby="ai-note-title">
|
||||
<span className="eyebrow">Az elemzésekről</span>
|
||||
<h2 id="ai-note-title">Profi mélység, töredék áron</h2>
|
||||
<p className="muted">
|
||||
Az elemzéseket a legfejlettebb AI-modellek írják, a képleted pontos pozícióiból. Részletességben és
|
||||
árnyaltságban megközelítik egy tapasztalt asztrológus írásos elemzését, annak az árnak a töredékéért.
|
||||
</p>
|
||||
</section>
|
||||
);
|
||||
}
|
||||
@@ -4,10 +4,18 @@ import { Paragraphs, Rich } from "./Rich";
|
||||
|
||||
const NATAL_ORDER = ["personality", "emotions", "mind", "love", "work", "growth"];
|
||||
const SYNASTRY_ORDER = ["attraction", "communication", "emotional_bond", "friction", "long_term"];
|
||||
const FORECAST_ORDER = ["theme", "love", "work", "growth", "timeline"];
|
||||
const ORDER = { natal: NATAL_ORDER, synastry: SYNASTRY_ORDER, forecast: FORECAST_ORDER };
|
||||
|
||||
/** A finished detailed analysis (natal or synastry). */
|
||||
export function AnalysisView({ content, kind = "natal" }: { content: AnalysisContent; kind?: "natal" | "synastry" }) {
|
||||
const order = kind === "synastry" ? SYNASTRY_ORDER : NATAL_ORDER;
|
||||
/** A finished detailed analysis (natal, synastry or yearly forecast). */
|
||||
export function AnalysisView({
|
||||
content,
|
||||
kind = "natal",
|
||||
}: {
|
||||
content: AnalysisContent;
|
||||
kind?: "natal" | "synastry" | "forecast";
|
||||
}) {
|
||||
const order = ORDER[kind];
|
||||
const sections = order.map((key) => content.sections?.[key]).filter((s) => s !== undefined);
|
||||
return (
|
||||
<article className="analysis">
|
||||
@@ -28,7 +36,7 @@ export function AnalysisView({ content, kind = "natal" }: { content: AnalysisCon
|
||||
<div className="analysis-lists">
|
||||
{content.strengths && content.strengths.length > 0 && (
|
||||
<section>
|
||||
<h3>Erősségek</h3>
|
||||
<h3>{kind === "forecast" ? "Lehetőségek" : "Erősségek"}</h3>
|
||||
<ul>
|
||||
{content.strengths.map((t, i) => (
|
||||
<li key={i}>
|
||||
|
||||
@@ -83,7 +83,15 @@ export function arcPath(r1: number, r2: number, from: number, to: number, start:
|
||||
}
|
||||
|
||||
/** The natal chart as a wheel: zodiac, houses, planets and aspect lines. */
|
||||
export function ChartWheel({ chart, timeKnown }: { chart: ChartResult; timeKnown: boolean }) {
|
||||
export function ChartWheel({
|
||||
chart,
|
||||
timeKnown,
|
||||
title = "Születési képlet",
|
||||
}: {
|
||||
chart: ChartResult;
|
||||
timeKnown: boolean;
|
||||
title?: string;
|
||||
}) {
|
||||
const angle = (key: string): Position | null => {
|
||||
const a = chart.angles?.[key];
|
||||
return typeof a === "object" && a !== null ? a : null;
|
||||
@@ -128,7 +136,7 @@ export function ChartWheel({ chart, timeKnown }: { chart: ChartResult; timeKnown
|
||||
role="img"
|
||||
aria-labelledby="wheel-title wheel-desc"
|
||||
>
|
||||
<title id="wheel-title">Születési képlet</title>
|
||||
<title id="wheel-title">{title}</title>
|
||||
<desc id="wheel-desc">
|
||||
{timeKnown && asc ? `Aszcendens ${signName(asc.sign)}. ` : "Születési idő nélkül, házak nélkül. "}
|
||||
{description}
|
||||
|
||||
@@ -6,6 +6,7 @@ import { useEffect, useState } from "react";
|
||||
import { api, errorText } from "@/lib/api";
|
||||
import type { Analysis } from "@/lib/types";
|
||||
|
||||
import { AI_SHORT } from "./AiNote";
|
||||
import { AnalysisLoading } from "./AnalysisLoading";
|
||||
import { PackageChooser } from "./PackageCards";
|
||||
import { AnalysisView } from "./AnalysisView";
|
||||
@@ -15,8 +16,11 @@ const MAX_POLLS = 120; // 10 minutes
|
||||
|
||||
type Step = "offer" | "confirm" | "pay";
|
||||
|
||||
/** What is analysed: a natal chart, or a comparison of two charts. */
|
||||
export type AnalysisTarget = { kind: "natal"; chartId: string } | { kind: "synastry"; synastryId: string };
|
||||
/** What is analysed: a natal chart, a comparison of two charts, or one year of a chart. */
|
||||
export type AnalysisTarget =
|
||||
| { kind: "natal"; chartId: string }
|
||||
| { kind: "synastry"; synastryId: string }
|
||||
| { kind: "forecast"; forecastId: string };
|
||||
|
||||
const TEXTS = {
|
||||
natal: {
|
||||
@@ -45,8 +49,32 @@ const TEXTS = {
|
||||
unitName: "kapcsolati elemzés",
|
||||
packages: ["addon_synastry", "couple", "family"],
|
||||
},
|
||||
forecast: {
|
||||
eyebrow: "Éves előrejelzés",
|
||||
title: "Az éved, fejezetekre bontva",
|
||||
about:
|
||||
"Kb. 1800 szó öt fejezetben: az év fő témája, kapcsolatok, munka és pénz, belső fejlődés, és negyedévenként az év menete " +
|
||||
"a fontos dátumokkal. A végén lehetőségek, kihívások és útravaló. Trendekről és lehetőségekről szól, nem jósol meg biztos eseményeket.",
|
||||
loadingTitle: "Készül az éves előrejelzésed",
|
||||
loading:
|
||||
"Most íródik az öt fejezet a szolár képlet, a tranzitok és a progresszió alapján. Ez általában 1–3 perc; nyugodtan elhagyhatod az oldalt, az előrejelzés elkészül és itt vár.",
|
||||
item: "Részletes éves előrejelzés",
|
||||
unitName: "előrejelzés",
|
||||
packages: ["addon_forecast", "couple", "family"],
|
||||
},
|
||||
};
|
||||
|
||||
function targetPath(target: AnalysisTarget): string {
|
||||
switch (target.kind) {
|
||||
case "natal":
|
||||
return `/charts/${target.chartId}`;
|
||||
case "synastry":
|
||||
return `/synastries/${target.synastryId}`;
|
||||
case "forecast":
|
||||
return `/forecasts/${target.forecastId}`;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The detailed analysis of a chart or a comparison. A saved one is shown at once; otherwise
|
||||
* the offer: admins start it free, users with units confirm, others pay
|
||||
@@ -57,7 +85,6 @@ export function DetailedAnalysis({
|
||||
initial,
|
||||
left,
|
||||
isAdmin,
|
||||
unlimited = false,
|
||||
canPay,
|
||||
note,
|
||||
}: {
|
||||
@@ -65,8 +92,6 @@ export function DetailedAnalysis({
|
||||
initial: Analysis | null;
|
||||
left: number;
|
||||
isAdmin: boolean;
|
||||
/** A running unlimited package: no unit is needed. */
|
||||
unlimited?: boolean;
|
||||
/** The stand-in payment is on (MOCK_PAYMENTS). */
|
||||
canPay: boolean;
|
||||
/** Shown above a finished analysis (e.g. who is the first and the second person). */
|
||||
@@ -78,7 +103,7 @@ export function DetailedAnalysis({
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const waiting = analysis?.status === "pending" || analysis?.status === "running";
|
||||
const t = TEXTS[target.kind];
|
||||
const path = target.kind === "natal" ? `/charts/${target.chartId}` : `/synastries/${target.synastryId}`;
|
||||
const path = targetPath(target);
|
||||
|
||||
useEffect(() => {
|
||||
if (!waiting || !analysis) return;
|
||||
@@ -142,6 +167,7 @@ export function DetailedAnalysis({
|
||||
<h2 id="detailed-title">{t.title}</h2>
|
||||
</div>
|
||||
<p className="muted">{t.about}</p>
|
||||
<p className="ai-line">{AI_SHORT}</p>
|
||||
{analysis?.status === "failed" && (
|
||||
<p className="msg msg-error" role="alert">
|
||||
Az előző kérés nem sikerült{isAdmin ? "" : ", az elemzést visszaadtuk a keretedbe"}. Próbáld újra.
|
||||
@@ -153,12 +179,12 @@ export function DetailedAnalysis({
|
||||
</p>
|
||||
)}
|
||||
|
||||
{isAdmin || unlimited ? (
|
||||
{isAdmin ? (
|
||||
<div className="form-actions">
|
||||
<button type="button" className="btn btn-primary" onClick={start} disabled={busy}>
|
||||
{busy ? "Indítás…" : `${t.item} készítése`}
|
||||
</button>
|
||||
<span className="hint">{isAdmin ? "Adminként ingyenes." : "A korlátlan csomagod része."}</span>
|
||||
<span className="hint">Adminként ingyenes.</span>
|
||||
</div>
|
||||
) : left > 0 ? (
|
||||
step === "confirm" ? (
|
||||
@@ -176,7 +202,7 @@ export function DetailedAnalysis({
|
||||
) : (
|
||||
<div className="form-actions">
|
||||
<button type="button" className="btn btn-primary" onClick={() => setStep("confirm")}>
|
||||
Részletes elemzés kérése
|
||||
{target.kind === "forecast" ? "Részletes előrejelzés kérése" : "Részletes elemzés kérése"}
|
||||
</button>
|
||||
<span className="hint">
|
||||
Még {left} {t.unitName}ed van.
|
||||
@@ -199,7 +225,7 @@ export function DetailedAnalysis({
|
||||
) : (
|
||||
<div className="form-actions">
|
||||
<button type="button" className="btn btn-primary" onClick={() => setStep("pay")}>
|
||||
Részletes elemzés kérése
|
||||
{target.kind === "forecast" ? "Részletes előrejelzés kérése" : "Részletes elemzés kérése"}
|
||||
</button>
|
||||
{target.kind === "natal" && (
|
||||
<Link href="/pelda" className="btn btn-ghost">
|
||||
|
||||
@@ -0,0 +1,295 @@
|
||||
import { ASPECTS, MOON_PHASES, POINTS, dms, orbText, pointName, signName } from "@/lib/astro";
|
||||
import type { Forecast, ForecastContact, SolarReturn } from "@/lib/types";
|
||||
|
||||
/** Sign names with the "into" suffix: Kos → Kosba. */
|
||||
const SIGN_INTO: Record<string, string> = {
|
||||
aries: "Kosba",
|
||||
taurus: "Bikába",
|
||||
gemini: "Ikrekbe",
|
||||
cancer: "Rákba",
|
||||
leo: "Oroszlánba",
|
||||
virgo: "Szűzbe",
|
||||
libra: "Mérlegbe",
|
||||
scorpio: "Skorpióba",
|
||||
sagittarius: "Nyilasba",
|
||||
capricorn: "Bakba",
|
||||
aquarius: "Vízöntőbe",
|
||||
pisces: "Halakba",
|
||||
};
|
||||
|
||||
const ECLIPSE_TYPES: Record<string, string> = {
|
||||
total: "Teljes",
|
||||
annular: "Gyűrűs",
|
||||
hybrid: "Hibrid",
|
||||
partial: "Részleges",
|
||||
penumbral: "Félárnyékos",
|
||||
};
|
||||
|
||||
const utcDate = (iso: string) => {
|
||||
const [y, m, d] = iso.split("-").map(Number);
|
||||
return new Date(Date.UTC(y, m - 1, d));
|
||||
};
|
||||
|
||||
/** `2026-08-20` → `aug. 20.` */
|
||||
export function shortDay(iso: string): string {
|
||||
return new Intl.DateTimeFormat("hu-HU", { month: "short", day: "numeric", timeZone: "UTC" }).format(utcDate(iso));
|
||||
}
|
||||
|
||||
/** `2026-08-20` → `2026. aug. 20.` */
|
||||
export function longDay(iso: string): string {
|
||||
return new Intl.DateTimeFormat("hu-HU", { year: "numeric", month: "short", day: "numeric", timeZone: "UTC" }).format(
|
||||
utcDate(iso),
|
||||
);
|
||||
}
|
||||
|
||||
function monthTitle(key: string): string {
|
||||
return new Intl.DateTimeFormat("hu-HU", { year: "numeric", month: "long", timeZone: "UTC" }).format(
|
||||
utcDate(`${key}-01`),
|
||||
);
|
||||
}
|
||||
|
||||
const glyph = (id: string) => POINTS[id]?.glyph ?? "";
|
||||
|
||||
type Tone = "tense" | "harmonic" | "neutral";
|
||||
|
||||
const toneOf = (c: ForecastContact): Tone =>
|
||||
c.nature === "challenging" ? "tense" : c.nature === "harmonious" ? "harmonic" : "neutral";
|
||||
|
||||
function contactTitle(c: ForecastContact, progressed = false): string {
|
||||
const planet = progressed ? `Progresszív ${pointName(c.planet)}` : pointName(c.planet);
|
||||
return `${planet} ${ASPECTS[c.aspect]?.hu ?? c.aspect} – születési ${pointName(c.natal_point)}`;
|
||||
}
|
||||
|
||||
function periodText(c: ForecastContact, date?: string): string | null {
|
||||
const periods = c.periods ?? [];
|
||||
const p = (date && periods.find((x) => x.start <= date && date <= x.end)) || periods[0];
|
||||
if (!p) return null;
|
||||
return p.start === p.end ? `hatás: ${longDay(p.start)}` : `hatás: ${longDay(p.start)} – ${longDay(p.end)}`;
|
||||
}
|
||||
|
||||
interface Event {
|
||||
date: string;
|
||||
tone: Tone;
|
||||
label: string;
|
||||
title: string;
|
||||
detail: string[];
|
||||
}
|
||||
|
||||
/** Everything datable in the year, in time order. */
|
||||
function events(f: Forecast): Event[] {
|
||||
const out: Event[] = [];
|
||||
const inYear = (d: string) => d >= f.start && d <= f.end;
|
||||
for (const c of f.transits) {
|
||||
const glyphs = `${glyph(c.planet)} ${ASPECTS[c.aspect]?.glyph ?? ""} ${glyph(c.natal_point)}`;
|
||||
if (c.exact.length === 0) {
|
||||
out.push({
|
||||
date: c.peak,
|
||||
tone: toneOf(c),
|
||||
label: glyphs,
|
||||
title: contactTitle(c),
|
||||
detail: [`legközelebb ${orbText(c.min_orb)}`, periodText(c, c.peak) ?? ""].filter(Boolean),
|
||||
});
|
||||
}
|
||||
c.exact.forEach((e, i) => {
|
||||
const pass = c.exact.length > 1 ? `${i + 1}. pontos fényszög` : "pontos";
|
||||
out.push({
|
||||
date: e.date,
|
||||
tone: toneOf(c),
|
||||
label: glyphs,
|
||||
title: contactTitle(c),
|
||||
detail: [
|
||||
e.retrograde ? `${pass}, retrográd mozgás közben` : pass,
|
||||
periodText(c, e.date) ?? "",
|
||||
c.house ? `a ${c.house}. házadban` : "",
|
||||
].filter(Boolean),
|
||||
});
|
||||
});
|
||||
}
|
||||
for (const h of f.transit_houses) {
|
||||
for (const i of h.ingresses) {
|
||||
out.push({
|
||||
date: i.date,
|
||||
tone: "neutral",
|
||||
label: glyph(h.planet),
|
||||
title: `${pointName(h.planet)} a ${i.house}. házadba lép`,
|
||||
detail: i.retrograde ? ["retrográd mozgással"] : [],
|
||||
});
|
||||
}
|
||||
}
|
||||
const p = f.progressions;
|
||||
for (const c of p.contacts) {
|
||||
for (const e of c.exact) {
|
||||
out.push({
|
||||
date: e.date,
|
||||
tone: toneOf(c),
|
||||
label: `${glyph(c.planet)}ᵖ`,
|
||||
title: contactTitle(c, true),
|
||||
detail: ["progresszió, pontos"],
|
||||
});
|
||||
}
|
||||
}
|
||||
for (const b of p.bodies) {
|
||||
const name = `A progresszív ${pointName(b.planet)}`;
|
||||
for (const s of b.sign_changes) {
|
||||
out.push({ date: s.date, tone: "neutral", label: `${glyph(b.planet)}ᵖ`, title: `${name} ${SIGN_INTO[s.sign] ?? signName(s.sign)} lép`, detail: [] });
|
||||
}
|
||||
for (const h of b.house_changes) {
|
||||
out.push({ date: h.date, tone: "neutral", label: `${glyph(b.planet)}ᵖ`, title: `${name} a ${h.house}. házadba lép`, detail: [] });
|
||||
}
|
||||
}
|
||||
if (p.lunar_phase_change) {
|
||||
out.push({
|
||||
date: p.lunar_phase_change.date,
|
||||
tone: "neutral",
|
||||
label: "☽ᵖ",
|
||||
title: `Progresszív holdfázis: ${MOON_PHASES[p.lunar_phase_change.phase] ?? p.lunar_phase_change.phase}`,
|
||||
detail: [],
|
||||
});
|
||||
}
|
||||
for (const e of f.eclipses) {
|
||||
const what = `${ECLIPSE_TYPES[e.eclipse_type] ?? e.eclipse_type} ${e.kind === "solar" ? "napfogyatkozás" : "holdfogyatkozás"}`;
|
||||
out.push({
|
||||
date: e.date,
|
||||
tone: e.contacts.length > 0 ? "tense" : "neutral",
|
||||
label: e.kind === "solar" ? "☉●" : "☽●",
|
||||
title: `${what}, ${signName(e.sign)} ${dms(e.degree_in_sign_dms).split("′")[0]}′`,
|
||||
detail: [
|
||||
e.house ? `a ${e.house}. házadban` : "",
|
||||
...e.contacts.map(
|
||||
(c) => `${ASPECTS[c.aspect]?.hu ?? c.aspect} a születési ${pointName(c.point)} pontoddal (${orbText(c.orb)})`,
|
||||
),
|
||||
].filter(Boolean),
|
||||
});
|
||||
}
|
||||
return out.filter((e) => inYear(e.date)).sort((a, b) => a.date.localeCompare(b.date));
|
||||
}
|
||||
|
||||
/** The year month by month: exact transits, ingresses, progressions, eclipses. */
|
||||
export function ForecastTimeline({ forecast }: { forecast: Forecast }) {
|
||||
const list = events(forecast);
|
||||
const months = new Map<string, Event[]>();
|
||||
for (const e of list) {
|
||||
const key = e.date.slice(0, 7);
|
||||
months.set(key, [...(months.get(key) ?? []), e]);
|
||||
}
|
||||
if (list.length === 0) return <p className="muted">Ebben az évben nincs pontos lassú bolygós fényszög.</p>;
|
||||
return (
|
||||
<div className="timeline">
|
||||
<p className="hint">
|
||||
A lassú bolygók (Jupiter–Plútó) fényszögei a születési képletedhez 1° hatásfokon belül, a progresszió és a
|
||||
fogyatkozások. Egy tranzit a teljes hatásidő alatt érződik, a pontos napok körül a legerősebben.
|
||||
</p>
|
||||
{[...months.entries()].map(([key, items]) => (
|
||||
<section key={key} className="timeline-month" aria-label={monthTitle(key)}>
|
||||
<h3>{monthTitle(key)}</h3>
|
||||
<ol>
|
||||
{items.map((e, i) => (
|
||||
<li key={i} className={`timeline-item tone-${e.tone}`}>
|
||||
<span className="timeline-date">{shortDay(e.date)}</span>
|
||||
<span className="timeline-glyph" aria-hidden="true">
|
||||
{e.label}
|
||||
</span>
|
||||
<span className="timeline-text">
|
||||
<strong>{e.title}</strong>
|
||||
{e.detail.length > 0 && <span className="hint">{e.detail.join(" · ")}</span>}
|
||||
</span>
|
||||
</li>
|
||||
))}
|
||||
</ol>
|
||||
</section>
|
||||
))}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
/** The main facts of the year at a glance. */
|
||||
export function ForecastKeys({ forecast, solarReturn }: { forecast: Forecast; solarReturn: SolarReturn | null }) {
|
||||
const sun = solarReturn?.points.find((p) => p.id === "sun");
|
||||
const moon = solarReturn?.points.find((p) => p.id === "moon");
|
||||
const asc = solarReturn?.angles?.ascendant;
|
||||
const ascSign = typeof asc === "object" && asc !== null ? asc.sign : null;
|
||||
const prof = forecast.profection;
|
||||
const pmoon = forecast.progressions.bodies.find((b) => b.planet === "moon");
|
||||
const exact = forecast.transits.filter((t) => t.exact.length > 0).length;
|
||||
return (
|
||||
<div className="card" style={{ gap: 12 }}>
|
||||
<span className="eyebrow">Az év kulcsai</span>
|
||||
<dl className="facts">
|
||||
{ascSign && (
|
||||
<>
|
||||
<dt>Szolár Aszcendens</dt>
|
||||
<dd>
|
||||
{signName(ascSign)}
|
||||
{solarReturn?.natal_house_of_ascendant ? `, a születési ${solarReturn.natal_house_of_ascendant}. házadban` : ""}
|
||||
</dd>
|
||||
</>
|
||||
)}
|
||||
{sun?.house && (
|
||||
<>
|
||||
<dt>Szolár Nap</dt>
|
||||
<dd>a {sun.house}. házban: ez az év fő terepe</dd>
|
||||
</>
|
||||
)}
|
||||
{moon?.house && (
|
||||
<>
|
||||
<dt>Szolár Hold</dt>
|
||||
<dd>
|
||||
{signName(moon.sign)}, a {moon.house}. házban
|
||||
</dd>
|
||||
</>
|
||||
)}
|
||||
{prof && (
|
||||
<>
|
||||
<dt>Az év ura</dt>
|
||||
<dd>
|
||||
{pointName(prof.lord)} ({prof.house}. ház, {signName(prof.sign)})
|
||||
</dd>
|
||||
</>
|
||||
)}
|
||||
{pmoon && (
|
||||
<>
|
||||
<dt>Progresszív Hold</dt>
|
||||
<dd>
|
||||
{signName(pmoon.sign)}
|
||||
{pmoon.house ? `, ${pmoon.house}. ház` : ""} ·{" "}
|
||||
{MOON_PHASES[forecast.progressions.lunar_phase] ?? forecast.progressions.lunar_phase}
|
||||
{pmoon.approximate ? " (bizonytalan)" : ""}
|
||||
</dd>
|
||||
</>
|
||||
)}
|
||||
<dt>Tranzitok</dt>
|
||||
<dd>
|
||||
{exact} pontos lassú bolygós fényszög, {forecast.eclipses.length} fogyatkozás
|
||||
</dd>
|
||||
</dl>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
/** All slow-planet transits of the year as a list. */
|
||||
export function ForecastTransits({ forecast }: { forecast: Forecast }) {
|
||||
if (forecast.transits.length === 0) return <p className="muted">Ebben az évben nincs lassú bolygós tranzit.</p>;
|
||||
return (
|
||||
<ul className="transit-list">
|
||||
{forecast.transits.map((c, i) => (
|
||||
<li key={i} className={`tone-${toneOf(c)}`}>
|
||||
<span className="sym" aria-hidden="true">
|
||||
{glyph(c.planet)} {ASPECTS[c.aspect]?.glyph} {glyph(c.natal_point)}
|
||||
</span>
|
||||
<span>
|
||||
<strong>{contactTitle(c)}</strong>
|
||||
{c.planet === c.natal_point && <span className="pill">életciklus</span>}
|
||||
<span className="hint">
|
||||
{c.exact.length > 0
|
||||
? `pontos: ${c.exact.map((e) => longDay(e.date) + (e.retrograde ? " (R)" : "")).join(", ")}`
|
||||
: `nem pontos az évben, legközelebb ${orbText(c.min_orb)}`}
|
||||
{(c.periods ?? []).length > 0 &&
|
||||
` · hatás: ${(c.periods ?? []).map((p) => `${longDay(p.start)} – ${longDay(p.end)}`).join("; ")}`}
|
||||
{c.house ? ` · ${c.house}. ház` : ""}
|
||||
</span>
|
||||
</span>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
);
|
||||
}
|
||||
@@ -11,17 +11,10 @@ export const huf = (n: number) => `${n.toLocaleString("hu-HU")} Ft`;
|
||||
|
||||
/** What a package contains, as short lines. */
|
||||
export function contents(p: Package): string[] {
|
||||
if (p.unlimited_months) {
|
||||
return [
|
||||
"Korlátlan képletelemzés",
|
||||
"Korlátlan kapcsolati elemzés",
|
||||
"Korlátlan számú személy",
|
||||
`${p.unlimited_months} hónapig`,
|
||||
];
|
||||
}
|
||||
const lines: string[] = [];
|
||||
if (p.natal) lines.push(`${p.natal} részletes képletelemzés`);
|
||||
if (p.synastry) lines.push(`${p.synastry} kapcsolati elemzés`);
|
||||
if (p.forecast) lines.push(`${p.forecast} éves előrejelzés`);
|
||||
if (p.persons) lines.push(`${p.persons} személy felvétele`);
|
||||
return lines;
|
||||
}
|
||||
@@ -90,7 +83,7 @@ export function PackageCards({
|
||||
{!compact && <p className="muted pkg-tagline">{p.tagline}</p>}
|
||||
<div className="pkg-price">
|
||||
<strong>{huf(p.price_huf)}</strong>
|
||||
{p.list_price_huf && p.list_price_huf > p.price_huf && (
|
||||
{p.list_price_huf > p.price_huf && (
|
||||
<s className="hint" aria-label={`Külön megvéve ${huf(p.list_price_huf)}`}>
|
||||
{huf(p.list_price_huf)}
|
||||
</s>
|
||||
@@ -102,11 +95,7 @@ export function PackageCards({
|
||||
))}
|
||||
</ul>
|
||||
<p className="hint pkg-per">
|
||||
{p.unlimited_months
|
||||
? "Aki sokakat vesz fel: családot, barátokat."
|
||||
: p.per_analysis_huf
|
||||
? `Elemzésenként ${huf(p.per_analysis_huf)}`
|
||||
: " "}
|
||||
{p.per_analysis_huf ? `Elemzésenként ${huf(p.per_analysis_huf)}` : " "}
|
||||
</p>
|
||||
{step !== null && step > 0 && prev && (
|
||||
<p className="pkg-step">
|
||||
|
||||
@@ -53,11 +53,9 @@ export function PersonActions({
|
||||
) : (
|
||||
<>
|
||||
{ownId && <CompareButton chart1={ownId} chart2={id} />}
|
||||
{editable && (
|
||||
<Link href={`/kepletek/${id}/javitas`} className="btn btn-sm btn-ghost">
|
||||
Adatok javítása
|
||||
</Link>
|
||||
)}
|
||||
<Link href={`/kepletek/${id}/javitas`} className="btn btn-sm btn-ghost">
|
||||
{editable ? "Adatok javítása" : "Átnevezés"}
|
||||
</Link>
|
||||
<button type="button" className="btn btn-sm btn-ghost" onClick={() => setConfirm(true)}>
|
||||
Törlés
|
||||
</button>
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
import { PackageChooser } from "./PackageCards";
|
||||
|
||||
/** Packages that give more persons: a few more, the family package, or unlimited. */
|
||||
/** Packages that give more persons: a few more, or the family package. */
|
||||
export function PersonPacks({ canPay }: { canPay: boolean }) {
|
||||
return <PackageChooser ids={["addon_persons", "family", "unlimited"]} canPay={canPay} />;
|
||||
return <PackageChooser ids={["addon_persons", "family"]} canPay={canPay} />;
|
||||
}
|
||||
|
||||
@@ -13,6 +13,36 @@ export function Logo() {
|
||||
);
|
||||
}
|
||||
|
||||
/** The user's package and what is left of it; leads to the packages page. */
|
||||
function PackageBadge({ me }: { me: Me }) {
|
||||
const { natal, synastry } = me.analyses_left;
|
||||
const left = natal + synastry;
|
||||
let name: string;
|
||||
let detail: string | null;
|
||||
if (me.package) {
|
||||
name = me.package.name;
|
||||
detail = left > 0 ? `${left} elemzés` : "elfogyott";
|
||||
} else if (left > 0) {
|
||||
name = `${left} elemzés`;
|
||||
detail = null;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
const units = `Képletelemzés: ${natal}, kapcsolati elemzés: ${synastry}`;
|
||||
const empty = left === 0;
|
||||
return (
|
||||
<Link
|
||||
href="/csomagok"
|
||||
className={empty ? "pkg-pill pkg-pill-empty" : "pkg-pill"}
|
||||
title={units}
|
||||
aria-label={`Csomagod: ${name}${detail ? `, ${detail}` : ""}. ${units}.`}
|
||||
>
|
||||
<span className="pkg-pill-name">{name}</span>
|
||||
{detail && <span className="pkg-pill-detail">{detail}</span>}
|
||||
</Link>
|
||||
);
|
||||
}
|
||||
|
||||
export function SiteHeader({ me }: { me: Me }) {
|
||||
const links = [
|
||||
{ href: "/keplet", label: "Képletem" },
|
||||
@@ -27,7 +57,8 @@ export function SiteHeader({ me }: { me: Me }) {
|
||||
<Logo />
|
||||
<NavLinks links={links} />
|
||||
<div className="who">
|
||||
<span>{me.user.display_name || me.user.email}</span>
|
||||
<PackageBadge me={me} />
|
||||
<span className="who-name">{me.user.display_name || me.user.email}</span>
|
||||
<LogoutButton />
|
||||
</div>
|
||||
</header>
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
"use client";
|
||||
|
||||
import { useState } from "react";
|
||||
|
||||
import { api, errorText } from "@/lib/api";
|
||||
|
||||
/** "Tell me when it opens": for visitors without an invitation. */
|
||||
export function Waitlist({ email: initial = "" }: { email?: string }) {
|
||||
const [email, setEmail] = useState(initial);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [done, setDone] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
|
||||
async function submit(e: React.FormEvent) {
|
||||
e.preventDefault();
|
||||
setBusy(true);
|
||||
setError(null);
|
||||
try {
|
||||
await api("/public/waitlist", { body: { email, locale: "hu" } });
|
||||
setDone(true);
|
||||
} catch (err) {
|
||||
setError(errorText(err));
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
if (done) {
|
||||
return (
|
||||
<p className="msg msg-ok" role="status">
|
||||
Felírtunk. Ha megnyílik az oldal, vagy meghívót küldünk, ide írunk: <strong>{email}</strong>
|
||||
</p>
|
||||
);
|
||||
}
|
||||
return (
|
||||
<form onSubmit={submit} className="card waitlist">
|
||||
<p style={{ margin: 0 }}>
|
||||
<strong>Szólunk, ha megnyílik.</strong>{" "}
|
||||
<span className="muted">Add meg az e-mail-címed, és felírunk a várólistára.</span>
|
||||
</p>
|
||||
<div className="row" style={{ gap: 8, flexWrap: "wrap" }}>
|
||||
<label htmlFor="waitlist-email" className="sr-only">
|
||||
E-mail-cím
|
||||
</label>
|
||||
<input
|
||||
id="waitlist-email"
|
||||
className="inp"
|
||||
type="email"
|
||||
required
|
||||
autoComplete="email"
|
||||
value={email}
|
||||
onChange={(e) => setEmail(e.target.value)}
|
||||
placeholder="nev@pelda.hu"
|
||||
style={{ flex: "1 1 220px" }}
|
||||
/>
|
||||
<button type="submit" className="btn" disabled={busy}>
|
||||
{busy ? "Küldés…" : "Feliratkozom"}
|
||||
</button>
|
||||
</div>
|
||||
{error && (
|
||||
<p className="msg msg-error" role="alert">
|
||||
{error}
|
||||
</p>
|
||||
)}
|
||||
</form>
|
||||
);
|
||||
}
|
||||
@@ -50,8 +50,6 @@
|
||||
"title": "Oroszlánarc, óceáni mélység"
|
||||
},
|
||||
"source": {
|
||||
"analysis_model": "anthropic/claude-opus-5.5",
|
||||
"summary_model": "anthropic/claude-sonnet-5.5",
|
||||
"prompt_version": "v2",
|
||||
"generated": "2026-11-16"
|
||||
},
|
||||
|
||||
@@ -19,8 +19,8 @@ export interface Me {
|
||||
analyses_left: UnitBalance;
|
||||
birth_change: BirthChange;
|
||||
persons: PersonSlots;
|
||||
/** The unlimited package runs until then (null: none). */
|
||||
unlimited_until: string | null;
|
||||
/** The latest main package bought or given (null: none). */
|
||||
package: { id: string; name: string; since: string } | null;
|
||||
}
|
||||
|
||||
/** A package from the catalog (`GET /v1/packages`). */
|
||||
@@ -32,10 +32,10 @@ export interface Package {
|
||||
price_huf: number;
|
||||
natal: number;
|
||||
synastry: number;
|
||||
forecast: number;
|
||||
persons: number;
|
||||
unlimited_months: number | null;
|
||||
badge: string | null;
|
||||
list_price_huf: number | null;
|
||||
list_price_huf: number;
|
||||
savings_percent: number | null;
|
||||
per_analysis_huf: number | null;
|
||||
}
|
||||
@@ -59,18 +59,17 @@ export interface BirthChange {
|
||||
export interface UnitBalance {
|
||||
natal: number;
|
||||
synastry: number;
|
||||
forecast: number;
|
||||
}
|
||||
|
||||
export interface PublicConfig {
|
||||
google_login: { enabled: boolean; client_id: string | null };
|
||||
locales: string[];
|
||||
analysis_model: string;
|
||||
summary_model: string;
|
||||
password_login: boolean;
|
||||
password_min_length: number;
|
||||
mock_payments: boolean;
|
||||
/** New detailed analyses a day with the unlimited package. */
|
||||
unlimited_daily_limit: number;
|
||||
/** "invite": new accounts need an invitation. */
|
||||
signup_mode: "invite" | "open";
|
||||
}
|
||||
|
||||
export interface Position {
|
||||
@@ -207,7 +206,7 @@ export interface SynastryListItem {
|
||||
|
||||
export interface Analysis {
|
||||
id: string;
|
||||
kind: "natal" | "synastry" | "summary";
|
||||
kind: "natal" | "synastry" | "summary" | "forecast";
|
||||
status: "pending" | "running" | "done" | "failed";
|
||||
model: string;
|
||||
language: string;
|
||||
@@ -228,7 +227,6 @@ export interface AdminUser {
|
||||
last_login_at: string | null;
|
||||
charts: number;
|
||||
analyses_left: UnitBalance;
|
||||
unlimited_until: string | null;
|
||||
}
|
||||
|
||||
export type PromptKind = "summary" | "natal" | "synastry";
|
||||
@@ -298,3 +296,144 @@ export interface Country {
|
||||
iso2: string;
|
||||
name: string;
|
||||
}
|
||||
|
||||
export type InvitationStatus = "pending" | "accepted" | "expired" | "revoked";
|
||||
|
||||
/** What an invitation link shows before login. */
|
||||
export interface InvitationLanding {
|
||||
inviter_name: string | null;
|
||||
message: string | null;
|
||||
status: InvitationStatus;
|
||||
expires_at: string;
|
||||
}
|
||||
|
||||
export interface AdminInvitation {
|
||||
id: string;
|
||||
email: string;
|
||||
message: string | null;
|
||||
locale: string;
|
||||
status: InvitationStatus;
|
||||
created_at: string;
|
||||
expires_at: string;
|
||||
sent_count: number;
|
||||
last_sent_at: string;
|
||||
accepted_at: string | null;
|
||||
accepted_by: string | null;
|
||||
invited_by: string | null;
|
||||
/** The last e-mail: sent, waiting, failed, or already removed from the outbox. */
|
||||
mail: "sent" | "queued" | "failed" | "archived";
|
||||
mail_error: string | null;
|
||||
can_resend: boolean;
|
||||
}
|
||||
|
||||
export interface WaitlistEntry {
|
||||
email: string;
|
||||
locale: string;
|
||||
created_at: string;
|
||||
/** The address's latest invitation, if any. */
|
||||
invitation: "pending" | "accepted" | null;
|
||||
}
|
||||
|
||||
export interface InvitationResult {
|
||||
email: string;
|
||||
status: "invited" | "invalid" | "already_user" | "already_invited" | "opted_out";
|
||||
id?: string;
|
||||
url?: string;
|
||||
}
|
||||
|
||||
/** A calculated year in a list (`GET /v1/charts/{id}/forecasts`). */
|
||||
export interface ForecastSummary {
|
||||
id: string;
|
||||
chart_id: string;
|
||||
year: number;
|
||||
/** First and last day, `YYYY-MM-DD`. */
|
||||
start: string;
|
||||
end: string;
|
||||
place: string | null;
|
||||
/** Reckoned at the birth place. */
|
||||
birth_place: boolean;
|
||||
created_at: string;
|
||||
}
|
||||
|
||||
export interface ForecastList {
|
||||
/** Years that can be calculated now. */
|
||||
years: number[];
|
||||
birth_place: string | null;
|
||||
time_known: boolean;
|
||||
forecasts: ForecastSummary[];
|
||||
}
|
||||
|
||||
export interface ForecastExact {
|
||||
date: string;
|
||||
retrograde: boolean;
|
||||
}
|
||||
|
||||
/** A transiting or progressed planet in aspect to a natal point. */
|
||||
export interface ForecastContact {
|
||||
planet: string;
|
||||
natal_point: string;
|
||||
aspect: string;
|
||||
nature: "harmonious" | "challenging" | "neutral";
|
||||
exact: ForecastExact[];
|
||||
periods?: { start: string; end: string }[];
|
||||
peak: string;
|
||||
min_orb: number;
|
||||
house?: number;
|
||||
}
|
||||
|
||||
export interface HouseIngress {
|
||||
house: number;
|
||||
date: string;
|
||||
retrograde: boolean;
|
||||
}
|
||||
|
||||
export interface Forecast {
|
||||
start: string;
|
||||
end: string;
|
||||
age: number;
|
||||
profection: {
|
||||
house: number;
|
||||
sign: string;
|
||||
lord: string;
|
||||
lord_sign: string;
|
||||
lord_house: number;
|
||||
planets_in_sign: string[];
|
||||
} | null;
|
||||
transits: ForecastContact[];
|
||||
transit_houses: { planet: string; house_at_start: number; ingresses: HouseIngress[] }[];
|
||||
progressions: {
|
||||
bodies: (Position & {
|
||||
planet: string;
|
||||
house: number | null;
|
||||
retrograde: boolean;
|
||||
approximate: boolean;
|
||||
sign_changes: { sign: string; date: string }[];
|
||||
house_changes: HouseIngress[];
|
||||
})[];
|
||||
lunar_phase: string;
|
||||
lunar_phase_change: { phase: string; date: string } | null;
|
||||
contacts: ForecastContact[];
|
||||
};
|
||||
eclipses: (Position & {
|
||||
date: string;
|
||||
kind: "solar" | "lunar";
|
||||
eclipse_type: "total" | "annular" | "hybrid" | "partial" | "penumbral";
|
||||
house: number | null;
|
||||
contacts: { point: string; aspect: string; orb: number }[];
|
||||
})[];
|
||||
warnings?: string[];
|
||||
}
|
||||
|
||||
export type SolarReturn = ChartResult & {
|
||||
moment_utc: string;
|
||||
local_time: string;
|
||||
timezone: string;
|
||||
utc_offset: string;
|
||||
natal_house_of_ascendant: number | null;
|
||||
};
|
||||
|
||||
/** One calculated year (`GET /v1/forecasts/{id}`). */
|
||||
export interface ForecastDetail extends ForecastSummary {
|
||||
location: { country: string; place?: string; geonames_id?: number } | null;
|
||||
result: { year: number; solar_return: SolarReturn | null; forecast: Forecast };
|
||||
}
|
||||
|
||||
@@ -0,0 +1,165 @@
|
||||
//! `POST /v1/forecast`: one year of a natal chart, from the solar return in
|
||||
//! the given year to the next one: the solar return chart (cast for where the
|
||||
//! person is on the birthday), slow-planet transits, progressions, the annual
|
||||
//! profection and eclipses.
|
||||
|
||||
use astro_engine::chart::house_of;
|
||||
use astro_engine::{Forecast, calculate_forecast, solar_return};
|
||||
use geo_tz::tz::format_offset;
|
||||
use jiff::Timestamp;
|
||||
use jiff::tz::Offset;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::AppState;
|
||||
use crate::error::ApiError;
|
||||
use crate::natal::{self, Meta, NatalRequest, NatalResult};
|
||||
|
||||
/// Where the person is on the birthday; the birth place when not given.
|
||||
#[derive(Debug, Clone, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Location {
|
||||
pub country: String,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub place: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub region: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub geonames_id: Option<u64>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub latitude: Option<f64>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub longitude: Option<f64>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub timezone: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct ForecastRequest {
|
||||
/// Birth data as for `POST /v1/natal`.
|
||||
pub birth: NatalRequest,
|
||||
/// The year starts at the solar return (birthday) in this calendar year.
|
||||
pub year: i32,
|
||||
#[serde(default)]
|
||||
pub location: Option<Location>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct SolarReturn {
|
||||
/// The exact moment, RFC 3339 UTC.
|
||||
pub moment_utc: String,
|
||||
/// The same moment on the local clock of the place, `YYYY-MM-DDTHH:MM:SS`.
|
||||
pub local_time: String,
|
||||
pub timezone: String,
|
||||
pub utc_offset: String,
|
||||
/// Natal house the solar return Ascendant falls into.
|
||||
pub natal_house_of_ascendant: Option<u8>,
|
||||
/// The chart of the moment at the place.
|
||||
#[serde(flatten)]
|
||||
pub chart: NatalResult,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct ForecastResponse {
|
||||
pub year: i32,
|
||||
/// `null` when the birth time is unknown: the moment may then be half a day off.
|
||||
pub solar_return: Option<SolarReturn>,
|
||||
/// Where the year is reckoned (dates are local to it).
|
||||
pub location: Location,
|
||||
pub forecast: Forecast,
|
||||
pub meta: Meta,
|
||||
}
|
||||
|
||||
fn bad(msg: impl Into<String>) -> ApiError {
|
||||
ApiError::BadRequest(msg.into())
|
||||
}
|
||||
|
||||
fn timestamp_of(jd: f64) -> Result<Timestamp, ApiError> {
|
||||
let seconds = ((jd - 2_440_587.5) * 86_400.0).round() as i64;
|
||||
Timestamp::from_second(seconds).map_err(|e| ApiError::Internal(e.to_string()))
|
||||
}
|
||||
|
||||
pub fn calculate(state: &AppState, req: ForecastRequest) -> Result<ForecastResponse, ApiError> {
|
||||
let birth = req.birth;
|
||||
let options = birth.options;
|
||||
let natal = natal::calculate(state, birth.clone()).map_err(|e| e.for_person("birth"))?;
|
||||
let birth_year: i32 = natal.time.date[..4].parse().map_err(|_| ApiError::Internal("birth year".into()))?;
|
||||
if req.year <= birth_year || req.year > birth_year + 120 || req.year > 2398 {
|
||||
return Err(bad(format!("year must be after the birth year {birth_year} and at most 120 years later")));
|
||||
}
|
||||
let engine = state.engine.as_ref();
|
||||
let calc = |e: astro_engine::EngineError| ApiError::Calculation(e.to_string());
|
||||
let start = solar_return(engine, &natal.chart, req.year).map_err(calc)?;
|
||||
let end = solar_return(engine, &natal.chart, req.year + 1).map_err(calc)?;
|
||||
|
||||
let location = req.location.unwrap_or_else(|| Location {
|
||||
country: birth.country.clone(),
|
||||
place: birth.place.clone(),
|
||||
region: birth.region.clone(),
|
||||
geonames_id: birth.geonames_id,
|
||||
latitude: birth.latitude,
|
||||
longitude: birth.longitude,
|
||||
timezone: birth.timezone.clone(),
|
||||
});
|
||||
|
||||
// The chart of the solar return moment at the place: given in UTC, so no
|
||||
// local-time ambiguity can move it.
|
||||
let ts = timestamp_of(start)?;
|
||||
let utc = Offset::UTC.to_datetime(ts);
|
||||
let probe = NatalRequest {
|
||||
name: None,
|
||||
date: utc.date().to_string(),
|
||||
time: Some(utc.time().strftime("%H:%M:%S").to_string()),
|
||||
calendar: natal::Calendar::Gregorian,
|
||||
country: location.country.clone(),
|
||||
place: location.place.clone(),
|
||||
region: location.region.clone(),
|
||||
geonames_id: location.geonames_id,
|
||||
latitude: location.latitude,
|
||||
longitude: location.longitude,
|
||||
elevation: None,
|
||||
timezone: None,
|
||||
utc_offset: Some("+00:00".into()),
|
||||
ambiguous_time: Default::default(),
|
||||
options,
|
||||
};
|
||||
let mut chart = natal::calculate(state, probe).map_err(|e| e.for_person("location"))?;
|
||||
chart.time.notes.clear();
|
||||
let place = &chart.location;
|
||||
let zone = state
|
||||
.atlas
|
||||
.choose_zone(
|
||||
&place.country,
|
||||
location.timezone.as_deref(),
|
||||
place.place.as_ref(),
|
||||
(place.latitude, place.longitude),
|
||||
)?
|
||||
.zone;
|
||||
let tz = state.atlas.zones.get(&zone)?;
|
||||
let offset = tz.to_offset(ts);
|
||||
let local = tz.to_datetime(ts);
|
||||
|
||||
let forecast =
|
||||
calculate_forecast(engine, &natal.chart, start, end, f64::from(offset.seconds()) / 3600.0).map_err(calc)?;
|
||||
|
||||
let solar_return = natal.time.time_known.then(|| {
|
||||
let cusps = natal.chart.houses.as_ref().map(|h| {
|
||||
let mut c = [0.0; 12];
|
||||
for (x, cusp) in c.iter_mut().zip(&h.cusps) {
|
||||
*x = cusp.position.longitude;
|
||||
}
|
||||
c
|
||||
});
|
||||
let asc = chart.chart.angles.as_ref().map(|a| a.ascendant.position.longitude);
|
||||
SolarReturn {
|
||||
moment_utc: ts.to_string(),
|
||||
local_time: local.strftime("%Y-%m-%dT%H:%M:%S").to_string(),
|
||||
timezone: zone.clone(),
|
||||
utc_offset: format_offset(offset),
|
||||
natal_house_of_ascendant: cusps.zip(asc).map(|(c, a)| house_of(a, &c)),
|
||||
chart,
|
||||
}
|
||||
});
|
||||
|
||||
Ok(ForecastResponse { year: req.year, solar_return, location, forecast, meta: natal::meta(state) })
|
||||
}
|
||||
@@ -9,6 +9,7 @@
|
||||
//! `horoscope-api healthcheck` performs a local health check (for Docker).
|
||||
|
||||
mod error;
|
||||
mod forecast;
|
||||
mod natal;
|
||||
mod routes;
|
||||
mod synastry;
|
||||
|
||||
@@ -14,6 +14,7 @@ use tracing::Level;
|
||||
|
||||
use crate::AppState;
|
||||
use crate::error::ApiError;
|
||||
use crate::forecast::{self, ForecastRequest, ForecastResponse};
|
||||
use crate::natal::{self, NatalRequest, NatalResponse};
|
||||
use crate::synastry::{self, SynastryRequest, SynastryResponse};
|
||||
|
||||
@@ -28,6 +29,7 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/timezones", get(timezones))
|
||||
.route("/v1/natal", post(natal_chart))
|
||||
.route("/v1/synastry", post(synastry_chart))
|
||||
.route("/v1/forecast", post(forecast_year))
|
||||
.layer(cors())
|
||||
.layer(
|
||||
TraceLayer::new_for_http()
|
||||
@@ -154,3 +156,14 @@ async fn synastry_chart(
|
||||
.map_err(|e| ApiError::Internal(e.to_string()))??;
|
||||
Ok(Json(response))
|
||||
}
|
||||
|
||||
async fn forecast_year(
|
||||
State(state): State<Arc<AppState>>,
|
||||
body: Result<Json<ForecastRequest>, JsonRejection>,
|
||||
) -> AppResult<ForecastResponse> {
|
||||
let Json(request) = body?;
|
||||
let response = tokio::task::spawn_blocking(move || forecast::calculate(&state, request))
|
||||
.await
|
||||
.map_err(|e| ApiError::Internal(e.to_string()))??;
|
||||
Ok(Json(response))
|
||||
}
|
||||
|
||||
@@ -273,3 +273,48 @@ async fn synastry_unknown_time_and_errors() {
|
||||
let (status, _) = call("POST", "/v1/synastry", Some(json!({"person1": {"date": "1985-07-14"}}))).await;
|
||||
assert_eq!(status, StatusCode::BAD_REQUEST);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn forecast_year_with_solar_return() {
|
||||
let birth = json!({"date": "1985-07-14", "time": "14:30", "country": "HU", "place": "Budapest"});
|
||||
let (status, d) = call("POST", "/v1/forecast", Some(json!({"birth": birth, "year": 2026}))).await;
|
||||
assert_eq!(status, StatusCode::OK, "{d}");
|
||||
let sr = &d["solar_return"];
|
||||
assert_eq!(sr["timezone"], "Europe/Budapest");
|
||||
assert!(sr["local_time"].as_str().unwrap().starts_with("2026-07-14T"), "{sr}");
|
||||
assert_eq!(sr["utc_offset"], "+02:00");
|
||||
assert_eq!(sr["points"][0]["sign"], "cancer");
|
||||
assert!(sr["natal_house_of_ascendant"].as_u64().is_some());
|
||||
assert_eq!(sr["location"]["place"]["name"], "Budapest");
|
||||
let f = &d["forecast"];
|
||||
assert_eq!(f["start"], "2026-07-14");
|
||||
assert_eq!(f["age"], 41);
|
||||
assert_eq!(f["profection"]["lord"], "mars");
|
||||
assert!(!f["transits"].as_array().unwrap().is_empty());
|
||||
|
||||
// Elsewhere on the birthday: same moment, other houses.
|
||||
let (status, e) = call(
|
||||
"POST",
|
||||
"/v1/forecast",
|
||||
Some(json!({"birth": birth, "year": 2026, "location": {"country": "JP", "place": "Tokyo"}})),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(status, StatusCode::OK, "{e}");
|
||||
assert_eq!(e["solar_return"]["moment_utc"], sr["moment_utc"]);
|
||||
assert_eq!(e["solar_return"]["timezone"], "Asia/Tokyo");
|
||||
assert_ne!(e["solar_return"]["angles"]["ascendant"]["sign"], sr["angles"]["ascendant"]["sign"]);
|
||||
|
||||
// Unknown birth time: no solar return chart, the rest is there.
|
||||
let (status, u) = call(
|
||||
"POST",
|
||||
"/v1/forecast",
|
||||
Some(json!({"birth": {"date": "1985-07-14", "country": "HU", "place": "Budapest"}, "year": 2026})),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(status, StatusCode::OK, "{u}");
|
||||
assert!(u["solar_return"].is_null());
|
||||
assert!(u["forecast"]["profection"].is_null());
|
||||
|
||||
let (status, _) = call("POST", "/v1/forecast", Some(json!({"birth": birth, "year": 1985}))).await;
|
||||
assert_eq!(status, StatusCode::BAD_REQUEST);
|
||||
}
|
||||
|
||||
@@ -9,14 +9,18 @@ publish.workspace = true
|
||||
[dependencies]
|
||||
db.workspace = true
|
||||
analysis-prompt.workspace = true
|
||||
email-templates.workspace = true
|
||||
service-kit.workspace = true
|
||||
anyhow.workspace = true
|
||||
axum.workspace = true
|
||||
base64.workspace = true
|
||||
hmac.workspace = true
|
||||
lettre.workspace = true
|
||||
rand.workspace = true
|
||||
reqwest.workspace = true
|
||||
serde.workspace = true
|
||||
serde_json.workspace = true
|
||||
sha2.workspace = true
|
||||
sqlx.workspace = true
|
||||
time.workspace = true
|
||||
tokio.workspace = true
|
||||
|
||||
@@ -9,13 +9,15 @@ Háttérmunkák a közös PostgreSQL-adatbázis fölött: e-mail-küldés, szöv
|
||||
- A sorokat `FOR UPDATE SKIP LOCKED` zárolással veszi fel, ezért több worker is futhat egyszerre, és nem küldik el kétszer ugyanazt. A kézbesítés „legalább egyszer” elvű: ha a worker éppen küldés közben áll le, a levél újra kimehet.
|
||||
- Átmeneti hibánál (hálózat, SMTP 4xx) újrapróbálja 1, 2, 4, … percenként, legfeljebb 6 óránként. `MAX_EMAIL_ATTEMPTS` próbálkozás után a levelet sikertelennek jelöli (`failed_at`, `last_error`).
|
||||
- Végleges hibánál nem próbálja újra: ilyen a hibás cím, az SMTP 5xx és az ismeretlen sablon.
|
||||
- Sablonok magyarul és angolul, a felhasználó nyelve szerint (`src/templates.rs`): `verify_email`, `reset_password`, `invite_accepted`. Mindegyik szöveges és HTML-változatban megy ki; a felhasználó nevét HTML-ben escape-eli, és a vezérlőkaraktereket eltávolítja belőle.
|
||||
- Sablonok magyarul és angolul, a címzett nyelve szerint (`crates/email-templates`, a backend admin-előnézete is ezt használja): `verify_email`, `reset_password`, `invite_accepted`, `invitation`. Mindegyik szöveges és HTML-változatban megy ki; a felhasználói szöveget HTML-ben escape-eli, és a vezérlőkaraktereket eltávolítja belőle.
|
||||
- A spamszűrők miatt a `Message-ID` a feladó domainjén van (`<outbox-id@domain>`), a meghívóknál pedig `List-Unsubscribe` és `List-Unsubscribe-Post` fejléc is megy (egykattintásos leiratkozás). Élesítés: `docs/levelkuldes.md`.
|
||||
- Ha nincs `SMTP_URL`, a worker nem küld semmit, a levelek az outboxban várnak.
|
||||
|
||||
**Takarítás** (induláskor, majd óránként)
|
||||
- lejárt munkamenetek és e-mail-tokenek;
|
||||
- elküldött e-mailek 7 nap után (tokenes linkek vannak bennük), sikertelenek 30 nap után;
|
||||
- el nem fogadott meghívók 30 nappal a lejáratuk után.
|
||||
- el nem fogadott „Mennyire illünk össze?” meghívók 30 nappal a lejáratuk után;
|
||||
- el nem fogadott oldalmeghívók 30 nappal a lezárásuk (lejárat vagy visszavonás) után, az elfogadottak pedig, ha a fiókot törölték.
|
||||
|
||||
**Szöveges elemzések** (`analyses`, `pending` → `running` → `done`/`failed`)
|
||||
- A backend létrehozza a `pending` sort, és levon egy elemzési egységet. Egy trigger (`NOTIFY analyses`) felébreszti a workert; egyszerre `ANALYSIS_CONCURRENCY` elemzés készül.
|
||||
@@ -61,6 +63,8 @@ Ugyanazt a radix-elemzést több modellel is megírja, véletlenszerű betűkkel
|
||||
|---|---|---|
|
||||
| `DATABASE_URL` | – (kötelező) | PostgreSQL kapcsolat |
|
||||
| `SMTP_URL` | – | `smtp://mailpit:1025` (fejlesztés), `smtp://user:pass@host:587?tls=required` (STARTTLS), `smtps://user:pass@host:465` (TLS) |
|
||||
| `AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` | – | Amazon SES, ha nincs `SMTP_URL` (a `.env.secrets` fájlból; más nevek is jók, lásd `src/ses.rs`). A titkos kulcsból a worker kiszámolja az SMTP-jelszót. Helyettük `SES_SMTP_USERNAME` + `SES_SMTP_PASSWORD` is megadható |
|
||||
| `SES_REGION`, `SES_SMTP_PORT` | `eu-central-1`, `2587` | SES-régió és port (a DigitalOcean a 25-ös, 465-ös és 587-es portot tiltja) |
|
||||
| `MAIL_FROM` | `Sorsfonalak <noreply@sorsfonalak.local>` | feladó |
|
||||
| `POLL_INTERVAL_SECS` | `30` | tartalék lekérdezési időköz |
|
||||
| `MAX_EMAIL_ATTEMPTS` | `8` | ennyi próbálkozás után sikertelen a levél |
|
||||
|
||||
@@ -280,6 +280,218 @@ pub fn synastry(chart1: &Value, chart2: &Value, result: &Value) -> String {
|
||||
out
|
||||
}
|
||||
|
||||
/// "2026-08-03, 2027-01-15 (retrograde)" from a list of exact hits.
|
||||
fn exact_dates(list: &Value) -> String {
|
||||
list.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(|e| {
|
||||
let date = e["date"].as_str().unwrap_or("?");
|
||||
if e["retrograde"].as_bool() == Some(true) { format!("{date} (retrograde)") } else { date.to_string() }
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join(", ")
|
||||
}
|
||||
|
||||
/// One contact of a transiting or progressed planet with a natal point.
|
||||
fn contact_line(out: &mut String, c: &Value, moving: &str) {
|
||||
let planet = c["planet"].as_str().unwrap_or("?");
|
||||
let natal = c["natal_point"].as_str().unwrap_or("?");
|
||||
let mut line = format!(
|
||||
"- {moving}{} {} natal {} ({})",
|
||||
point_name(planet),
|
||||
words(c["aspect"].as_str().unwrap_or("?")),
|
||||
point_name(natal),
|
||||
c["nature"].as_str().unwrap_or("neutral")
|
||||
);
|
||||
// A planet back at its own natal place (or in aspect to it, for transits): a life cycle.
|
||||
if planet == natal && (moving.is_empty() || c["aspect"] == "conjunction") {
|
||||
line.push_str(", cycle");
|
||||
}
|
||||
let exact = exact_dates(&c["exact"]);
|
||||
if exact.is_empty() {
|
||||
let _ = write!(
|
||||
line,
|
||||
": not exact this year, closest {:.1}° around {}",
|
||||
c["min_orb"].as_f64().unwrap_or(0.0),
|
||||
c["peak"].as_str().unwrap_or("?")
|
||||
);
|
||||
} else {
|
||||
let _ = write!(line, ": exact {exact}");
|
||||
}
|
||||
let periods: Vec<String> = c["periods"]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(|p| format!("{} to {}", p["start"].as_str().unwrap_or("?"), p["end"].as_str().unwrap_or("?")))
|
||||
.collect();
|
||||
if !periods.is_empty() {
|
||||
let _ = write!(line, "; within orb {}", periods.join(", "));
|
||||
}
|
||||
if let Some(h) = c["house"].as_i64() {
|
||||
let _ = write!(line, "; {moving}{} in natal house {h}", point_name(planet));
|
||||
}
|
||||
let _ = writeln!(out, "{line}");
|
||||
}
|
||||
|
||||
/// One year of a chart: the natal chart, then the stored horoscope-api
|
||||
/// `/v1/forecast` result (solar return chart, profection, transits,
|
||||
/// progressions, eclipses). The place of the birthday and the exact age are
|
||||
/// left out; the age goes in by decade.
|
||||
pub fn forecast(chart: &Value, result: &Value) -> String {
|
||||
let f = &result["forecast"];
|
||||
let known = time_known(chart);
|
||||
let mut out = format!(
|
||||
"YEARLY FORECAST: one year of life, from the solar return on {} to the next one on {}.\n",
|
||||
f["start"].as_str().unwrap_or("?"),
|
||||
f["end"].as_str().unwrap_or("?")
|
||||
);
|
||||
if let Some(age) = f["age"].as_i64() {
|
||||
let _ = writeln!(out, "Age group: {}s.", age / 10 * 10);
|
||||
}
|
||||
out.push('\n');
|
||||
out.push_str(&natal(chart));
|
||||
|
||||
let sr = &result["solar_return"];
|
||||
if sr.is_object() {
|
||||
out.push_str("\nSOLAR RETURN CHART (cast for the moment of the solar return at the place of the birthday):\n");
|
||||
angle_lines(&mut out, sr, "");
|
||||
if let Some(h) = sr["natal_house_of_ascendant"].as_i64() {
|
||||
let _ = writeln!(out, "- The solar return Ascendant falls in natal house {h}.");
|
||||
}
|
||||
point_lines(&mut out, sr, "", true);
|
||||
aspect_lines(&mut out, &sr["aspects"], "Solar return aspects (tightest first):", 15);
|
||||
} else {
|
||||
out.push_str("\nSOLAR RETURN CHART: none, because the birth time is unknown.\n");
|
||||
}
|
||||
|
||||
let p = &f["profection"];
|
||||
if p.is_object() {
|
||||
let planets = names(&p["planets_in_sign"]);
|
||||
let _ = writeln!(
|
||||
out,
|
||||
"\nANNUAL PROFECTION: the year activates natal house {} ({}); lord of the year: {} (natal {} in {}, house {}).{}",
|
||||
p["house"],
|
||||
capitalize(p["sign"].as_str().unwrap_or("?")),
|
||||
point_name(p["lord"].as_str().unwrap_or("?")),
|
||||
point_name(p["lord"].as_str().unwrap_or("?")),
|
||||
capitalize(p["lord_sign"].as_str().unwrap_or("?")),
|
||||
p["lord_house"],
|
||||
if planets.is_empty() { String::new() } else { format!(" Natal planets in that sign: {planets}.") }
|
||||
);
|
||||
}
|
||||
|
||||
out.push_str("\nSLOW-PLANET TRANSITS to the natal chart (orb 1°; in order of their peak; dates are local days):\n");
|
||||
let transits = f["transits"].as_array().map(Vec::as_slice).unwrap_or_default();
|
||||
if transits.is_empty() {
|
||||
out.push_str("- none\n");
|
||||
}
|
||||
for c in transits {
|
||||
contact_line(&mut out, c, "");
|
||||
}
|
||||
|
||||
let houses = f["transit_houses"].as_array().map(Vec::as_slice).unwrap_or_default();
|
||||
if known && !houses.is_empty() {
|
||||
out.push_str("\nSlow planets in the natal houses:\n");
|
||||
for h in houses {
|
||||
let mut line = format!(
|
||||
"- {}: house {} at the start",
|
||||
point_name(h["planet"].as_str().unwrap_or("?")),
|
||||
h["house_at_start"]
|
||||
);
|
||||
for i in h["ingresses"].as_array().into_iter().flatten() {
|
||||
let retro = if i["retrograde"].as_bool() == Some(true) { " (retrograde)" } else { "" };
|
||||
let _ = write!(line, "; enters house {} on {}{retro}", i["house"], i["date"].as_str().unwrap_or("?"));
|
||||
}
|
||||
let _ = writeln!(out, "{line}");
|
||||
}
|
||||
}
|
||||
|
||||
let prog = &f["progressions"];
|
||||
out.push_str("\nSECONDARY PROGRESSIONS (a day for a year), at the start of the year:\n");
|
||||
for b in prog["bodies"].as_array().into_iter().flatten() {
|
||||
let mut line = format!("- Progressed {}: {}", point_name(b["planet"].as_str().unwrap_or("?")), position(b));
|
||||
if let Some(h) = b["house"].as_i64() {
|
||||
let _ = write!(line, ", natal house {h}");
|
||||
}
|
||||
if b["retrograde"].as_bool() == Some(true) {
|
||||
line.push_str(", retrograde");
|
||||
}
|
||||
if b["approximate"].as_bool() == Some(true) {
|
||||
line.push_str(" (uncertain: the birth time is unknown)");
|
||||
}
|
||||
for i in b["sign_changes"].as_array().into_iter().flatten() {
|
||||
let _ = write!(
|
||||
line,
|
||||
"; enters {} on {}",
|
||||
capitalize(i["sign"].as_str().unwrap_or("?")),
|
||||
i["date"].as_str().unwrap_or("?")
|
||||
);
|
||||
}
|
||||
for i in b["house_changes"].as_array().into_iter().flatten() {
|
||||
let _ = write!(line, "; enters natal house {} on {}", i["house"], i["date"].as_str().unwrap_or("?"));
|
||||
}
|
||||
let _ = writeln!(out, "{line}");
|
||||
}
|
||||
if let Some(phase) = prog["lunar_phase"].as_str() {
|
||||
let change = &prog["lunar_phase_change"];
|
||||
let change = if change.is_object() {
|
||||
format!(
|
||||
", turns {} on {}",
|
||||
words(change["phase"].as_str().unwrap_or("?")),
|
||||
change["date"].as_str().unwrap_or("?")
|
||||
)
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
let _ = writeln!(out, "- Progressed lunation phase: {}{change}", words(phase));
|
||||
}
|
||||
let contacts = prog["contacts"].as_array().map(Vec::as_slice).unwrap_or_default();
|
||||
if !contacts.is_empty() {
|
||||
out.push_str("Progressed planets in aspect to natal points (orb 1°):\n");
|
||||
for c in contacts {
|
||||
contact_line(&mut out, c, "progressed ");
|
||||
}
|
||||
}
|
||||
|
||||
let eclipses = f["eclipses"].as_array().map(Vec::as_slice).unwrap_or_default();
|
||||
if !eclipses.is_empty() {
|
||||
out.push_str("\nECLIPSES during the year:\n");
|
||||
for e in eclipses {
|
||||
let mut line = format!(
|
||||
"- {}: {} {} eclipse at {}",
|
||||
e["date"].as_str().unwrap_or("?"),
|
||||
e["eclipse_type"].as_str().unwrap_or("?"),
|
||||
e["kind"].as_str().unwrap_or("?"),
|
||||
position(e)
|
||||
);
|
||||
if let Some(h) = e["house"].as_i64() {
|
||||
let _ = write!(line, ", natal house {h}");
|
||||
}
|
||||
let hits: Vec<String> = e["contacts"]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(|c| {
|
||||
format!(
|
||||
"{} natal {} (orb {:.1}°)",
|
||||
words(c["aspect"].as_str().unwrap_or("?")),
|
||||
point_name(c["point"].as_str().unwrap_or("?")),
|
||||
c["orb"].as_f64().unwrap_or(0.0)
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
if hits.is_empty() {
|
||||
line.push_str("; no close contact with the natal chart");
|
||||
} else {
|
||||
let _ = write!(line, "; {}", hits.join(", "));
|
||||
}
|
||||
let _ = writeln!(out, "{line}");
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Aspects between main points and angles, tightest first.
|
||||
fn aspect_lines(out: &mut String, aspects: &Value, heading: &str, limit: usize) {
|
||||
let mut list: Vec<&Value> = aspects
|
||||
@@ -362,6 +574,32 @@ mod tests {
|
||||
assert!(text.contains("- Venus: Libra 4°12', domicile"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn forecast_view() {
|
||||
// The stored horoscope-api /v1/forecast result of the chart below (year 2026).
|
||||
let text = forecast(&fixture("natal-1990-03-15.json"), &fixture("forecast-1990-03-15.json"));
|
||||
assert_private(&text);
|
||||
for expected in [
|
||||
"YEARLY FORECAST: one year of life, from the solar return on 2026-03-15 to the next one on 2027-03-15.",
|
||||
"Age group: 30s.",
|
||||
"NATAL CHART",
|
||||
"SOLAR RETURN CHART (cast for",
|
||||
"- The solar return Ascendant falls in natal house 10.",
|
||||
"ANNUAL PROFECTION: the year activates natal house 1 (Leo); lord of the year: Sun",
|
||||
"- progressed Moon trine natal Moon (harmonious): exact 2027-02-24",
|
||||
"- Neptune sextile natal Mars (harmonious): exact 2026-04-19, 2026-09-30 (retrograde), 2027-02-20",
|
||||
"Slow planets in the natal houses:",
|
||||
"SECONDARY PROGRESSIONS",
|
||||
"- Progressed lunation phase:",
|
||||
"ECLIPSES during the year:",
|
||||
] {
|
||||
assert!(text.contains(expected), "missing '{expected}' in:\n{text}");
|
||||
}
|
||||
for absent in ["Europe/Budapest", "08:02", "Age group: 36", "36s"] {
|
||||
assert!(!text.contains(absent), "'{absent}' in:\n{text}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn synastry_view() {
|
||||
// The full horoscope-api response, with both persons' birth data in it.
|
||||
|
||||
@@ -34,6 +34,7 @@ pub struct Job {
|
||||
pub kind: String,
|
||||
pub chart_id: Option<Uuid>,
|
||||
pub synastry_id: Option<Uuid>,
|
||||
pub forecast_id: Option<Uuid>,
|
||||
pub language: String,
|
||||
pub model: String,
|
||||
pub prompt_version: String,
|
||||
@@ -78,7 +79,7 @@ impl Analyzer {
|
||||
"UPDATE analyses SET status = 'running', started_at = now(), attempts = attempts + 1 \
|
||||
WHERE id = (SELECT id FROM analyses WHERE status = 'pending' AND next_attempt_at <= now() \
|
||||
ORDER BY next_attempt_at LIMIT 1 FOR UPDATE SKIP LOCKED) \
|
||||
RETURNING id, kind, chart_id, synastry_id, language, model, prompt_version, attempts",
|
||||
RETURNING id, kind, chart_id, synastry_id, forecast_id, language, model, prompt_version, attempts",
|
||||
)
|
||||
.fetch_optional(&self.db)
|
||||
.await?;
|
||||
@@ -95,6 +96,7 @@ impl Analyzer {
|
||||
let text = match kind {
|
||||
Kind::Natal | Kind::Summary => self.natal_text(job.chart_id).await?,
|
||||
Kind::Synastry => self.synastry_text(job.synastry_id).await?,
|
||||
Kind::Forecast => self.forecast_text(job.forecast_id).await?,
|
||||
};
|
||||
let (base, revision) = prompt::split_version(&job.prompt_version);
|
||||
if base != PROMPT_VERSION {
|
||||
@@ -138,6 +140,19 @@ impl Analyzer {
|
||||
Ok(compact::synastry(&chart1, &chart2, &result))
|
||||
}
|
||||
|
||||
/// The compact text of a stored forecast with its natal chart.
|
||||
async fn forecast_text(&self, forecast_id: Option<Uuid>) -> Result<String, LlmError> {
|
||||
let (result, chart): (Value, Value) = sqlx::query_as(
|
||||
"SELECT f.result, c.result FROM forecasts f JOIN charts c ON c.id = f.chart_id WHERE f.id = $1",
|
||||
)
|
||||
.bind(forecast_id)
|
||||
.fetch_optional(&self.db)
|
||||
.await
|
||||
.map_err(|e| LlmError::Transient(format!("database: {e}")))?
|
||||
.ok_or_else(|| LlmError::Permanent("the forecast was deleted".into()))?;
|
||||
Ok(compact::forecast(&chart, &result))
|
||||
}
|
||||
|
||||
/// Takes the oldest waiting prompt test run, if any.
|
||||
pub async fn claim_preview(&self) -> Result<Option<PreviewJob>, sqlx::Error> {
|
||||
let job: Option<PreviewJob> = sqlx::query_as(
|
||||
|
||||
@@ -8,7 +8,7 @@ use tokio::sync::watch;
|
||||
const INTERVAL: Duration = Duration::from_secs(3600);
|
||||
|
||||
/// (what, statement) pairs; each returns the number of deleted rows.
|
||||
const STATEMENTS: [(&str, &str); 5] = [
|
||||
const STATEMENTS: [(&str, &str); 6] = [
|
||||
("sessions", "DELETE FROM sessions WHERE expires_at < now()"),
|
||||
("auth_tokens", "DELETE FROM auth_tokens WHERE expires_at < now()"),
|
||||
// Sent e-mails contain links with tokens; keep them a week for support.
|
||||
@@ -18,6 +18,13 @@ const STATEMENTS: [(&str, &str); 5] = [
|
||||
OR failed_at < now() - interval '30 days'",
|
||||
),
|
||||
("invites", "DELETE FROM synastry_invites WHERE accepted_at IS NULL AND expires_at < now() - interval '30 days'"),
|
||||
// Unused invitations 30 days after they closed; accepted ones once the account is deleted.
|
||||
(
|
||||
"invitations",
|
||||
"DELETE FROM invitations WHERE (accepted_at IS NULL \
|
||||
AND least(coalesce(revoked_at, expires_at), expires_at) < now() - interval '30 days') \
|
||||
OR (accepted_at IS NOT NULL AND accepted_by IS NULL)",
|
||||
),
|
||||
("prompt_previews", "DELETE FROM prompt_previews WHERE created_at < now() - interval '30 days'"),
|
||||
];
|
||||
|
||||
|
||||
@@ -8,8 +8,11 @@ use lettre::message::Mailbox;
|
||||
pub struct Config {
|
||||
pub database_url: String,
|
||||
/// `smtp://host:port` (plain, e.g. Mailpit), `smtp://user:pass@host:587?tls=required`
|
||||
/// (STARTTLS) or `smtps://...` (TLS). Unset: e-mails stay in the outbox.
|
||||
/// (STARTTLS) or `smtps://...` (TLS). Without it, Amazon SES from the AWS
|
||||
/// variables (see `ses.rs`). Neither: e-mails stay in the outbox.
|
||||
pub smtp_url: Option<String>,
|
||||
/// For the log: where the SMTP address came from (no secrets).
|
||||
pub smtp_about: Option<String>,
|
||||
/// Sender, e.g. `Sorsfonalak <noreply@sorsfonalak.hu>`.
|
||||
pub mail_from: Mailbox,
|
||||
/// Fallback polling interval; new e-mails are picked up at once via LISTEN/NOTIFY.
|
||||
@@ -44,9 +47,17 @@ where
|
||||
impl Config {
|
||||
pub fn from_env() -> anyhow::Result<Self> {
|
||||
let mail_from = var("MAIL_FROM").unwrap_or_else(|| "Sorsfonalak <noreply@sorsfonalak.local>".into());
|
||||
let (smtp_url, smtp_about) = match var("SMTP_URL") {
|
||||
Some(url) => (Some(url), None),
|
||||
None => match crate::ses::smtp_url(|name| std::env::var(name).ok())? {
|
||||
Some((url, about)) => (Some(url), Some(about)),
|
||||
None => (None, None),
|
||||
},
|
||||
};
|
||||
Ok(Self {
|
||||
database_url: var("DATABASE_URL").context("DATABASE_URL is required")?,
|
||||
smtp_url: var("SMTP_URL"),
|
||||
smtp_url,
|
||||
smtp_about,
|
||||
mail_from: mail_from.parse().with_context(|| format!("invalid MAIL_FROM '{mail_from}'"))?,
|
||||
poll_interval: Duration::from_secs(parsed("POLL_INTERVAL_SECS", 30)?),
|
||||
max_email_attempts: parsed("MAX_EMAIL_ATTEMPTS", 8)?,
|
||||
|
||||
@@ -6,6 +6,7 @@
|
||||
|
||||
use std::time::Duration;
|
||||
|
||||
use lettre::message::header::{Header, HeaderName, HeaderValue};
|
||||
use lettre::message::{Mailbox, MultiPart};
|
||||
use lettre::{AsyncSmtpTransport, AsyncTransport, Message, Tokio1Executor};
|
||||
use serde_json::Value;
|
||||
@@ -24,7 +25,8 @@ pub enum Mailer {
|
||||
/// Collects messages instead of sending; fails for addresses listed in `fail`.
|
||||
#[cfg(test)]
|
||||
Memory {
|
||||
sent: std::sync::Mutex<Vec<(String, Rendered)>>,
|
||||
/// Recipient, rendered mail and the whole message as sent.
|
||||
sent: std::sync::Mutex<Vec<(String, Rendered, String)>>,
|
||||
fail: Vec<(String, bool)>,
|
||||
},
|
||||
}
|
||||
@@ -58,12 +60,19 @@ impl Mailer {
|
||||
Ok(Mailer::Smtp(transport))
|
||||
}
|
||||
|
||||
async fn send(&self, from: &Mailbox, to: &str, mail: &Rendered) -> Result<(), SendError> {
|
||||
async fn send(&self, id: Uuid, from: &Mailbox, to: &str, mail: &Rendered) -> Result<(), SendError> {
|
||||
let to_mailbox: Mailbox = to.parse().map_err(SendError::permanent)?;
|
||||
let message = Message::builder()
|
||||
// A Message-ID on our own domain (lettre would use the container's
|
||||
// host name, which spam filters dislike); the same on every retry.
|
||||
let mut builder = Message::builder()
|
||||
.message_id(Some(format!("<{id}@{}>", from.email.domain())))
|
||||
.from(from.clone())
|
||||
.to(to_mailbox)
|
||||
.subject(&mail.subject)
|
||||
.subject(&mail.subject);
|
||||
if let Some(url) = &mail.unsubscribe_post_url {
|
||||
builder = builder.header(ListUnsubscribe(url.clone())).header(ListUnsubscribePost);
|
||||
}
|
||||
let message = builder
|
||||
.multipart(MultiPart::alternative_plain_html(mail.text.clone(), mail.html.clone()))
|
||||
.map_err(SendError::permanent)?;
|
||||
match self {
|
||||
@@ -77,13 +86,46 @@ impl Mailer {
|
||||
if let Some((_, permanent)) = fail.iter().find(|(addr, _)| addr == to) {
|
||||
return Err(SendError { permanent: *permanent, message: "test failure".into() });
|
||||
}
|
||||
sent.lock().unwrap().push((to.to_owned(), mail.clone()));
|
||||
let raw = String::from_utf8_lossy(&message.formatted()).into_owned();
|
||||
sent.lock().unwrap().push((to.to_owned(), mail.clone(), raw));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `List-Unsubscribe: <url>`: mail clients show an unsubscribe button.
|
||||
#[derive(Clone)]
|
||||
struct ListUnsubscribe(String);
|
||||
|
||||
impl Header for ListUnsubscribe {
|
||||
fn name() -> HeaderName {
|
||||
HeaderName::new_from_ascii_str("List-Unsubscribe")
|
||||
}
|
||||
fn parse(s: &str) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
|
||||
Ok(Self(s.trim().trim_start_matches('<').trim_end_matches('>').to_owned()))
|
||||
}
|
||||
fn display(&self) -> HeaderValue {
|
||||
HeaderValue::new(Self::name(), format!("<{}>", self.0))
|
||||
}
|
||||
}
|
||||
|
||||
/// `List-Unsubscribe-Post`: the button unsubscribes with one POST (RFC 8058).
|
||||
#[derive(Clone)]
|
||||
struct ListUnsubscribePost;
|
||||
|
||||
impl Header for ListUnsubscribePost {
|
||||
fn name() -> HeaderName {
|
||||
HeaderName::new_from_ascii_str("List-Unsubscribe-Post")
|
||||
}
|
||||
fn parse(_: &str) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
|
||||
Ok(Self)
|
||||
}
|
||||
fn display(&self) -> HeaderValue {
|
||||
HeaderValue::new(Self::name(), "List-Unsubscribe=One-Click".into())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Delivery {
|
||||
pub db: PgPool,
|
||||
pub mailer: Mailer,
|
||||
@@ -127,7 +169,7 @@ impl Delivery {
|
||||
for row in &rows {
|
||||
let attempts = row.attempts + 1;
|
||||
let result = match templates::render(&row.template, &row.locale, &row.payload) {
|
||||
Ok(mail) => self.mailer.send(&self.from, &row.to_email, &mail).await,
|
||||
Ok(mail) => self.mailer.send(row.id, &self.from, &row.to_email, &mail).await,
|
||||
Err(e) => Err(SendError::permanent(e)),
|
||||
};
|
||||
match result {
|
||||
|
||||
@@ -15,7 +15,10 @@ mod cleanup;
|
||||
mod compare;
|
||||
mod config;
|
||||
mod email;
|
||||
mod templates;
|
||||
mod ses;
|
||||
mod templates {
|
||||
pub use email_templates::*;
|
||||
}
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
@@ -91,10 +94,11 @@ async fn main() -> anyhow::Result<()> {
|
||||
match &config.smtp_url {
|
||||
Some(url) => {
|
||||
let delivery = email::Delivery::new(pool.clone(), email::Mailer::smtp(url)?, &config);
|
||||
tracing::info!(host = %email::smtp_host(url), "e-mail delivery enabled");
|
||||
let via = config.smtp_about.clone().unwrap_or_else(|| "SMTP_URL".into());
|
||||
tracing::info!(host = %email::smtp_host(url), via = %via, from = %config.mail_from, "e-mail delivery enabled");
|
||||
jobs.spawn(email::run(delivery, config.poll_interval, stop.clone()));
|
||||
}
|
||||
None => tracing::warn!("SMTP_URL is not set: e-mails stay in the outbox"),
|
||||
None => tracing::warn!("neither SMTP_URL nor SES credentials are set: e-mails stay in the outbox"),
|
||||
}
|
||||
match &config.openrouter_api_key {
|
||||
Some(key) => {
|
||||
|
||||
@@ -0,0 +1,172 @@
|
||||
//! Amazon SES over SMTP, configured from AWS-style variables when `SMTP_URL`
|
||||
//! is not set (so the credentials can sit in `.env.secrets` as they are).
|
||||
//!
|
||||
//! Accepted (upper or lower case):
|
||||
//! * `SES_SMTP_USERNAME` + `SES_SMTP_PASSWORD`: SMTP credentials from the SES console;
|
||||
//! * or `AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` (or another name from
|
||||
//! `KEY_NAMES` / `SECRET_NAMES`, e.g. `ses_auth_key` + `ses_secret`): an IAM
|
||||
//! key allowed `ses:SendRawEmail`; the SMTP
|
||||
//! password is derived from it as AWS documents. If the "secret" already is
|
||||
//! an SMTP password, it is used as it is.
|
||||
//! * `SES_REGION` / `AWS_REGION` / `AWS_DEFAULT_REGION` (default `eu-central-1`),
|
||||
//! `SES_SMTP_PORT` (default 2587, STARTTLS: DigitalOcean blocks 25, 465 and 587).
|
||||
|
||||
use base64::Engine;
|
||||
use base64::engine::general_purpose::STANDARD;
|
||||
use hmac::{Hmac, Mac};
|
||||
use sha2::Sha256;
|
||||
|
||||
pub const DEFAULT_REGION: &str = "eu-central-1";
|
||||
|
||||
/// Names the access key id may have in a secrets file.
|
||||
const KEY_NAMES: &[&str] = &[
|
||||
"SES_ACCESS_KEY_ID",
|
||||
"AWS_ACCESS_KEY_ID",
|
||||
"SES_AUTH_KEY",
|
||||
"SES_ACCESS_KEY",
|
||||
"SES_KEY",
|
||||
"AWS_AUTH_KEY",
|
||||
"AWS_ACCESS_KEY",
|
||||
"AUTH_KEY",
|
||||
];
|
||||
/// Names the secret access key may have.
|
||||
const SECRET_NAMES: &[&str] = &[
|
||||
"SES_SECRET_ACCESS_KEY",
|
||||
"AWS_SECRET_ACCESS_KEY",
|
||||
"SES_SECRET",
|
||||
"SES_SECRET_KEY",
|
||||
"SES_AUTH_SECRET",
|
||||
"AWS_SECRET",
|
||||
"AWS_SECRET_KEY",
|
||||
"AUTH_SECRET",
|
||||
];
|
||||
const DEFAULT_PORT: u16 = 2587;
|
||||
|
||||
/// The first set variable among `names`, each tried in upper and lower case.
|
||||
fn var(lookup: &impl Fn(&str) -> Option<String>, names: &[&str]) -> Option<(String, String)> {
|
||||
names.iter().find_map(|name| {
|
||||
[name.to_string(), name.to_lowercase()]
|
||||
.into_iter()
|
||||
.find_map(|n| lookup(&n).map(|v| v.trim().to_owned()).filter(|v| !v.is_empty()).map(|v| (n, v)))
|
||||
})
|
||||
}
|
||||
|
||||
/// The SES SMTP address and a description for the log (no secrets), if credentials are set.
|
||||
pub fn smtp_url(lookup: impl Fn(&str) -> Option<String>) -> anyhow::Result<Option<(String, String)>> {
|
||||
let region =
|
||||
var(&lookup, &["SES_REGION", "AWS_REGION", "AWS_DEFAULT_REGION"]).map_or(DEFAULT_REGION.into(), |(_, v)| v);
|
||||
if !region.chars().all(|c| c.is_ascii_alphanumeric() || c == '-') {
|
||||
anyhow::bail!("invalid SES region '{region}'");
|
||||
}
|
||||
let port: u16 = match var(&lookup, &["SES_SMTP_PORT"]) {
|
||||
Some((_, p)) => p.parse().map_err(|e| anyhow::anyhow!("invalid SES_SMTP_PORT '{p}': {e}"))?,
|
||||
None => DEFAULT_PORT,
|
||||
};
|
||||
let smtp = var(&lookup, &["SES_SMTP_USERNAME", "SES_SMTP_USER"]).zip(var(&lookup, &["SES_SMTP_PASSWORD"]));
|
||||
let (user, password, source) = if let Some(((name, user), (_, password))) = smtp {
|
||||
(user, password, name)
|
||||
} else {
|
||||
let key = var(&lookup, KEY_NAMES);
|
||||
let secret = var(&lookup, SECRET_NAMES);
|
||||
match (key, secret) {
|
||||
(Some((name, key)), Some((_, secret))) => {
|
||||
let password = if is_smtp_password(&secret) { secret } else { smtp_password(&secret, ®ion) };
|
||||
(key, password, name)
|
||||
}
|
||||
(None, None) => return Ok(None),
|
||||
_ => anyhow::bail!("SES: both the access key id and the secret access key are needed"),
|
||||
}
|
||||
};
|
||||
let url =
|
||||
format!("smtp://{}:{}@email-smtp.{region}.amazonaws.com:{port}?tls=required", encode(&user), encode(&password));
|
||||
Ok(Some((url, format!("Amazon SES {region}:{port}, credentials from {source}"))))
|
||||
}
|
||||
|
||||
/// The SES SMTP password of an IAM secret access key (AWS docs, "Obtaining
|
||||
/// Amazon SES SMTP credentials": signature version 4, `SendRawEmail`).
|
||||
pub fn smtp_password(secret: &str, region: &str) -> String {
|
||||
fn sign(key: &[u8], msg: &str) -> Vec<u8> {
|
||||
let mut mac = Hmac::<Sha256>::new_from_slice(key).expect("HMAC takes any key length");
|
||||
mac.update(msg.as_bytes());
|
||||
mac.finalize().into_bytes().to_vec()
|
||||
}
|
||||
let mut signature = sign(format!("AWS4{secret}").as_bytes(), "11111111");
|
||||
for part in [region, "ses", "aws4_request", "SendRawEmail"] {
|
||||
signature = sign(&signature, part);
|
||||
}
|
||||
let mut bytes = vec![0x04];
|
||||
bytes.extend(signature);
|
||||
STANDARD.encode(bytes)
|
||||
}
|
||||
|
||||
/// An SMTP password is a version byte (4) and a 32-byte signature, in base64;
|
||||
/// an IAM secret key is 40 characters.
|
||||
fn is_smtp_password(s: &str) -> bool {
|
||||
s.len() == 44 && STANDARD.decode(s).is_ok_and(|b| b.len() == 33 && b[0] == 0x04)
|
||||
}
|
||||
|
||||
/// Percent-encoding for the user and password part of a URL.
|
||||
fn encode(s: &str) -> String {
|
||||
s.bytes()
|
||||
.map(|b| match b {
|
||||
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => (b as char).to_string(),
|
||||
_ => format!("%{b:02X}"),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::collections::HashMap;
|
||||
|
||||
use super::*;
|
||||
|
||||
fn env(pairs: &[(&str, &str)]) -> impl Fn(&str) -> Option<String> {
|
||||
let map: HashMap<String, String> = pairs.iter().map(|(k, v)| (k.to_string(), v.to_string())).collect();
|
||||
move |k| map.get(k).cloned()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn derives_the_smtp_password() {
|
||||
// The value of AWS's Python example (docs: "Obtaining Amazon SES SMTP credentials") for this made-up key.
|
||||
let password = smtp_password("wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY", "eu-central-1");
|
||||
assert_eq!(password, "BF0/eIJm0ruTHsSjOkRuOGzGF+zeSyE3aiRzrzUQ8LwG");
|
||||
assert!(is_smtp_password(&password));
|
||||
assert!(!is_smtp_password("wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn url_from_variables() {
|
||||
assert!(smtp_url(env(&[])).unwrap().is_none());
|
||||
let (url, about) = smtp_url(env(&[
|
||||
("aws_access_key_id", "AKIAEXAMPLE"),
|
||||
("aws_secret_access_key", "BF0/eIJm0ruTHsSjOkRuOGzGF+zeSyE3aiRzrzUQ8LwG"),
|
||||
]))
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
// already an SMTP password: kept, with + and / encoded
|
||||
assert_eq!(
|
||||
url,
|
||||
"smtp://AKIAEXAMPLE:BF0%2FeIJm0ruTHsSjOkRuOGzGF%2BzeSyE3aiRzrzUQ8LwG@email-smtp.eu-central-1.amazonaws.com:2587?tls=required"
|
||||
);
|
||||
assert_eq!(about, "Amazon SES eu-central-1:2587, credentials from aws_access_key_id");
|
||||
let (url, _) = smtp_url(env(&[
|
||||
("SES_SMTP_USERNAME", "AKIA2"),
|
||||
("SES_SMTP_PASSWORD", "a/b+c="),
|
||||
("SES_REGION", "eu-west-1"),
|
||||
]))
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(url, "smtp://AKIA2:a%2Fb%2Bc%3D@email-smtp.eu-west-1.amazonaws.com:2587?tls=required");
|
||||
assert!(smtp_url(env(&[("AWS_ACCESS_KEY_ID", "AKIA")])).is_err());
|
||||
// other common names; a real secret key is turned into the SMTP password
|
||||
let (url, about) =
|
||||
smtp_url(env(&[("ses_auth_key", "AKIA3"), ("ses_secret", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY")]))
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert!(
|
||||
url.starts_with("smtp://AKIA3:BF0%2FeIJm0ruTHsSjOkRuOGzGF%2BzeSyE3aiRzrzUQ8LwG@email-smtp.eu-central-1.")
|
||||
);
|
||||
assert!(about.ends_with("from ses_auth_key"));
|
||||
}
|
||||
}
|
||||
@@ -1,197 +0,0 @@
|
||||
//! E-mail texts (Hungarian and English), as plain text and HTML.
|
||||
//!
|
||||
//! The payloads are written by the backend (`queue_email`); the validity
|
||||
//! periods in the texts match the token lifetimes there.
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct Rendered {
|
||||
pub subject: String,
|
||||
pub text: String,
|
||||
pub html: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum TemplateError {
|
||||
UnknownTemplate(String),
|
||||
MissingField(&'static str),
|
||||
}
|
||||
|
||||
impl std::fmt::Display for TemplateError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
TemplateError::UnknownTemplate(t) => write!(f, "unknown e-mail template '{t}'"),
|
||||
TemplateError::MissingField(field) => write!(f, "e-mail payload has no '{field}'"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
enum Lang {
|
||||
Hu,
|
||||
En,
|
||||
}
|
||||
|
||||
/// One e-mail: greeting, paragraphs, a button and a closing note.
|
||||
struct Content {
|
||||
subject: String,
|
||||
greeting: String,
|
||||
intro: String,
|
||||
button: &'static str,
|
||||
url: String,
|
||||
note: &'static str,
|
||||
}
|
||||
|
||||
pub fn render(template: &str, locale: &str, payload: &Value) -> Result<Rendered, TemplateError> {
|
||||
let lang = if locale.eq_ignore_ascii_case("hu") { Lang::Hu } else { Lang::En };
|
||||
let url = payload["url"].as_str().filter(|u| !u.is_empty()).ok_or(TemplateError::MissingField("url"))?.to_owned();
|
||||
let greeting = |name: Option<String>| match (lang, name) {
|
||||
(Lang::Hu, Some(n)) => format!("Szia {n}!"),
|
||||
(Lang::Hu, None) => "Szia!".to_owned(),
|
||||
(Lang::En, Some(n)) => format!("Hi {n},"),
|
||||
(Lang::En, None) => "Hi,".to_owned(),
|
||||
};
|
||||
let content = match (template, lang) {
|
||||
("verify_email", Lang::Hu) => Content {
|
||||
subject: "Erősítsd meg az e-mail-címed".into(),
|
||||
greeting: greeting(name(payload, "display_name")),
|
||||
intro: "Köszönjük, hogy regisztráltál a Sorsfonalakon! Az alábbi gombbal erősítsd meg az e-mail-címed."
|
||||
.into(),
|
||||
button: "E-mail-cím megerősítése",
|
||||
url,
|
||||
note: "A link 3 napig érvényes. Ha nem te regisztráltál, nyugodtan hagyd figyelmen kívül ezt a levelet.",
|
||||
},
|
||||
("verify_email", Lang::En) => Content {
|
||||
subject: "Confirm your e-mail address".into(),
|
||||
greeting: greeting(name(payload, "display_name")),
|
||||
intro: "Thanks for signing up for Sorsfonalak! Please confirm your e-mail address with the button below."
|
||||
.into(),
|
||||
button: "Confirm e-mail address",
|
||||
url,
|
||||
note: "The link is valid for 3 days. If you did not sign up, you can safely ignore this e-mail.",
|
||||
},
|
||||
("reset_password", Lang::Hu) => Content {
|
||||
subject: "Új jelszó megadása".into(),
|
||||
greeting: greeting(name(payload, "display_name")),
|
||||
intro: "Jelszó-visszaállítást kértél a Sorsfonalak-fiókodhoz. Az alábbi gombbal adhatsz meg új jelszót."
|
||||
.into(),
|
||||
button: "Új jelszó megadása",
|
||||
url,
|
||||
note: "A link 1 óráig érvényes, és csak egyszer használható. Ha nem te kérted, hagyd figyelmen kívül ezt a levelet: a jelszavad nem változik.",
|
||||
},
|
||||
("reset_password", Lang::En) => Content {
|
||||
subject: "Set a new password".into(),
|
||||
greeting: greeting(name(payload, "display_name")),
|
||||
intro:
|
||||
"You asked to reset the password of your Sorsfonalak account. Use the button below to set a new one."
|
||||
.into(),
|
||||
button: "Set a new password",
|
||||
url,
|
||||
note: "The link is valid for 1 hour and can be used once. If you did not ask for this, ignore this e-mail: your password stays the same.",
|
||||
},
|
||||
("invite_accepted", Lang::Hu) => {
|
||||
let who = name(payload, "invitee_name");
|
||||
Content {
|
||||
subject: match &who {
|
||||
Some(n) => format!("{n} elfogadta a meghívásod"),
|
||||
None => "Elfogadták a meghívásod".into(),
|
||||
},
|
||||
greeting: greeting(None),
|
||||
intro: format!(
|
||||
"{} elfogadta a „Mennyire illünk össze?” meghívásod, és elkészült a szinasztriátok.",
|
||||
who.as_deref().unwrap_or("A meghívott")
|
||||
),
|
||||
button: "Szinasztria megnyitása",
|
||||
url,
|
||||
note: "A szinasztriát mindketten látjátok, de egymás születési adatait nem.",
|
||||
}
|
||||
}
|
||||
("invite_accepted", Lang::En) => {
|
||||
let who = name(payload, "invitee_name");
|
||||
Content {
|
||||
subject: match &who {
|
||||
Some(n) => format!("{n} accepted your invitation"),
|
||||
None => "Your invitation was accepted".into(),
|
||||
},
|
||||
greeting: greeting(None),
|
||||
intro: format!(
|
||||
"{} accepted your “How compatible are we?” invitation, and your synastry is ready.",
|
||||
who.as_deref().unwrap_or("Your invitee")
|
||||
),
|
||||
button: "Open synastry",
|
||||
url,
|
||||
note: "You both see the synastry, but not each other's birth data.",
|
||||
}
|
||||
}
|
||||
_ => return Err(TemplateError::UnknownTemplate(template.to_owned())),
|
||||
};
|
||||
Ok(content.render(lang))
|
||||
}
|
||||
|
||||
/// A user-supplied name, safe for a subject line.
|
||||
fn name(payload: &Value, field: &str) -> Option<String> {
|
||||
let name: String = payload[field].as_str()?.chars().filter(|c| !c.is_control()).take(60).collect();
|
||||
let name = name.trim();
|
||||
(!name.is_empty()).then(|| name.to_owned())
|
||||
}
|
||||
|
||||
fn escape(s: &str) -> String {
|
||||
let mut out = String::with_capacity(s.len());
|
||||
for c in s.chars() {
|
||||
match c {
|
||||
'&' => out.push_str("&"),
|
||||
'<' => out.push_str("<"),
|
||||
'>' => out.push_str(">"),
|
||||
'"' => out.push_str("""),
|
||||
'\'' => out.push_str("'"),
|
||||
_ => out.push(c),
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
impl Content {
|
||||
fn render(self, lang: Lang) -> Rendered {
|
||||
let footer = match lang {
|
||||
Lang::Hu => "Ezt a levelet a Sorsfonalak küldte.",
|
||||
Lang::En => "This e-mail was sent by Sorsfonalak.",
|
||||
};
|
||||
let text = format!(
|
||||
"{}\n\n{}\n\n{}:\n{}\n\n{}\n\n-- \nSorsfonalak\n",
|
||||
self.greeting, self.intro, self.button, self.url, self.note
|
||||
);
|
||||
let html = format!(
|
||||
r#"<!doctype html>
|
||||
<html lang="{lang}">
|
||||
<head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>{subject}</title></head>
|
||||
<body style="margin:0;padding:0;background:#f4f1ea;font-family:Georgia,'Times New Roman',serif;color:#2a2620">
|
||||
<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="background:#f4f1ea;padding:32px 16px">
|
||||
<tr><td align="center">
|
||||
<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="max-width:520px;background:#ffffff;border-radius:8px;padding:32px">
|
||||
<tr><td style="font-size:20px;letter-spacing:2px;color:#9a7b3c;padding-bottom:24px">SORSFONALAK</td></tr>
|
||||
<tr><td style="font-size:16px;line-height:1.6;padding-bottom:12px">{greeting}</td></tr>
|
||||
<tr><td style="font-size:16px;line-height:1.6;padding-bottom:24px">{intro}</td></tr>
|
||||
<tr><td style="padding-bottom:24px"><a href="{url}" style="display:inline-block;background:#9a7b3c;color:#ffffff;text-decoration:none;padding:12px 24px;border-radius:6px;font-size:16px">{button}</a></td></tr>
|
||||
<tr><td style="font-size:14px;line-height:1.6;color:#6b645a;padding-bottom:16px">{note}</td></tr>
|
||||
<tr><td style="font-size:12px;line-height:1.5;color:#9b948a;word-break:break-all">{url_text}</td></tr>
|
||||
</table>
|
||||
<p style="font-size:12px;color:#9b948a;max-width:520px">{footer}</p>
|
||||
</td></tr>
|
||||
</table>
|
||||
</body>
|
||||
</html>
|
||||
"#,
|
||||
lang = if lang == Lang::Hu { "hu" } else { "en" },
|
||||
subject = escape(&self.subject),
|
||||
greeting = escape(&self.greeting),
|
||||
intro = escape(&self.intro),
|
||||
url = escape(&self.url),
|
||||
button = escape(self.button),
|
||||
note = escape(self.note),
|
||||
url_text = escape(&self.url),
|
||||
footer = escape(footer),
|
||||
);
|
||||
Rendered { subject: self.subject, text, html }
|
||||
}
|
||||
}
|
||||
@@ -60,7 +60,7 @@ fn delivery(db: PgPool, fail: Vec<(&str, bool)>) -> Delivery {
|
||||
|
||||
fn sent(d: &Delivery) -> Vec<(String, String)> {
|
||||
let Mailer::Memory { sent, .. } = &d.mailer else { unreachable!() };
|
||||
sent.lock().unwrap().iter().map(|(to, m)| (to.clone(), m.subject.clone())).collect()
|
||||
sent.lock().unwrap().iter().map(|(to, m, _)| (to.clone(), m.subject.clone())).collect()
|
||||
}
|
||||
|
||||
async fn queue(db: &PgPool, to: &str, template: &str) -> Uuid {
|
||||
@@ -123,6 +123,35 @@ async fn delivers_retries_and_gives_up(db: PgPool) {
|
||||
assert_eq!(sent(&d).len(), 1);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn invitation_headers_for_spam_filters(db: PgPool) {
|
||||
let id = Uuid::now_v7();
|
||||
sqlx::query(
|
||||
"INSERT INTO email_outbox (id, to_email, template, locale, payload) VALUES ($1, $2, 'invitation', 'hu', $3)",
|
||||
)
|
||||
.bind(id)
|
||||
.bind("guest@example.com")
|
||||
.bind(json!({
|
||||
"url": "https://example.com/meghivo/t",
|
||||
"inviter_name": "Kata",
|
||||
"message": null,
|
||||
"expires_on": "2026-12-17",
|
||||
"unsubscribe_url": "https://example.com/leiratkozas?token=t",
|
||||
"unsubscribe_post_url": "https://example.com/api/v1/public/invitations/unsubscribe?token=t",
|
||||
}))
|
||||
.execute(&db)
|
||||
.await
|
||||
.unwrap();
|
||||
let d = delivery(db.clone(), vec![]);
|
||||
assert_eq!(d.deliver_due().await.unwrap(), 1);
|
||||
let Mailer::Memory { sent, .. } = &d.mailer else { unreachable!() };
|
||||
let raw = sent.lock().unwrap()[0].2.clone();
|
||||
assert!(raw.contains(&format!("Message-ID: <{id}@example.com>")), "{raw}");
|
||||
assert!(raw.contains("List-Unsubscribe: <https://example.com/api/v1/public/invitations/unsubscribe?token=t>"));
|
||||
assert!(raw.contains("List-Unsubscribe-Post: List-Unsubscribe=One-Click"));
|
||||
assert!(raw.contains("multipart/alternative") && raw.contains("text/plain") && raw.contains("text/html"));
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn concurrent_workers_do_not_send_twice(db: PgPool) {
|
||||
for i in 0..15 {
|
||||
@@ -177,7 +206,14 @@ async fn cleanup_removes_only_expired_data(db: PgPool) {
|
||||
let deleted = crate::cleanup::run_once(&db).await.unwrap();
|
||||
assert_eq!(
|
||||
deleted,
|
||||
vec![("sessions", 1), ("auth_tokens", 0), ("emails", 1), ("invites", 0), ("prompt_previews", 0)]
|
||||
vec![
|
||||
("sessions", 1),
|
||||
("auth_tokens", 0),
|
||||
("emails", 1),
|
||||
("invites", 0),
|
||||
("invitations", 0),
|
||||
("prompt_previews", 0)
|
||||
]
|
||||
);
|
||||
let (left,): (Vec<Uuid>,) =
|
||||
sqlx::query_as("SELECT array_agg(id ORDER BY id) FROM email_outbox").fetch_one(&db).await.unwrap();
|
||||
|
||||
+1945
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user