Main #20

Merged
sagifer merged 6 commits from main into prod 2026-11-19 12:29:52 +01:00
54 changed files with 3229 additions and 116 deletions
+23
View File
@@ -0,0 +1,23 @@
-- Promo codes: an admin makes them for a package, a user redeems one once
-- and gets the package (a `package_orders` row with source `promo`).
CREATE TABLE promo_codes (
id uuid PRIMARY KEY,
-- Upper case, without separators (shown in groups of four).
code text NOT NULL UNIQUE CHECK (code ~ '^[2-9A-HJKMNP-Z]{8,32}$'),
package text NOT NULL,
-- Who it is for or which campaign (admin only).
note text,
created_by uuid REFERENCES users (id) ON DELETE SET NULL,
created_at timestamptz NOT NULL DEFAULT now(),
redeemed_by uuid REFERENCES users (id) ON DELETE SET NULL,
redeemed_at timestamptz,
order_id uuid REFERENCES package_orders (id) ON DELETE SET NULL,
-- An unused code can be withdrawn.
revoked_at timestamptz,
CHECK (redeemed_at IS NULL OR revoked_at IS NULL)
);
CREATE INDEX promo_codes_created_idx ON promo_codes (created_at DESC);
ALTER TABLE package_orders DROP CONSTRAINT package_orders_source_check;
ALTER TABLE package_orders ADD CONSTRAINT package_orders_source_check
CHECK (source IN ('admin', 'mock', 'stripe', 'promo'));
@@ -0,0 +1,3 @@
-- An invitation can come with a package: a promo code made with it, sent in
-- the e-mail and redeemed by itself when the invitee signs up.
ALTER TABLE promo_codes ADD COLUMN invitation_id uuid UNIQUE REFERENCES invitations (id) ON DELETE SET NULL;
@@ -0,0 +1,7 @@
-- "How compatible are we?" invitations from the new person page: who it is
-- for (the inviter's own name for them) and, if the inviter asked us to
-- e-mail it, the address.
ALTER TABLE synastry_invites
ADD COLUMN label text CHECK (char_length(label) <= 80),
ADD COLUMN invitee_email text;
CREATE INDEX synastry_invites_emailed_idx ON synastry_invites (inviter_id, created_at) WHERE invitee_email IS NOT NULL;
@@ -0,0 +1,3 @@
-- The link in the waitlist confirmation e-mail that takes the address off
-- the list (only its hash is kept).
ALTER TABLE waitlist ADD COLUMN token_hash bytea UNIQUE;
+19
View File
@@ -0,0 +1,19 @@
-- Sharing pays in two steps: the first visit of a shared link earns a
-- question (`share_reward`, see shares.rs), and someone who signs up from a
-- shared link and makes their own chart earns the sharer a natal analysis
-- (`referral_reward`, at most three per user).
ALTER TABLE credit_ledger DROP CONSTRAINT credit_ledger_reason_check;
ALTER TABLE credit_ledger ADD CONSTRAINT credit_ledger_reason_check
CHECK (reason IN ('monthly_grant', 'analysis', 'chat', 'refund', 'admin_adjust', 'purchase', 'person', 'package',
'question', 'share_reward', 'referral_reward'));
-- Who came through whose shared link (one row per new user).
CREATE TABLE referrals (
user_id uuid PRIMARY KEY REFERENCES users (id) ON DELETE CASCADE,
referrer_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
share_id uuid REFERENCES shares (id) ON DELETE SET NULL,
created_at timestamptz NOT NULL DEFAULT now(),
-- Set when the new user made their own chart (rewarded or over the limit).
rewarded_at timestamptz
);
CREATE INDEX referrals_referrer_idx ON referrals (referrer_id);
+9
View File
@@ -104,6 +104,15 @@ pub fn random_token(bytes: usize) -> String {
URL_SAFE_NO_PAD.encode(buf)
}
/// Letters and digits that cannot be mixed up when typed (no 0/O, 1/I/L).
pub const CODE_ALPHABET: &[u8] = b"23456789ABCDEFGHJKMNPQRSTUVWXYZ";
/// A random code of `len` characters from [`CODE_ALPHABET`] (about 5 bits each).
pub fn random_code(len: usize) -> String {
let mut rng = rand::rng();
(0..len).map(|_| CODE_ALPHABET[rand::Rng::random_range(&mut rng, 0..CODE_ALPHABET.len())] as char).collect()
}
/// Stored form of a secret token.
pub fn token_hash(token: &str) -> Vec<u8> {
Sha256::digest(token.as_bytes()).to_vec()
+180 -2
View File
@@ -158,6 +158,8 @@ pub fn render(template: &str, locale: &str, payload: &Value) -> Result<Rendered,
)
}
("invitation", _) => invitation(lang, payload, url)?,
("synastry_invite", _) => synastry_invite(lang, payload, url)?,
("waitlist_joined", _) => waitlist_joined(lang, payload, url)?,
_ => return Err(TemplateError::UnknownTemplate(template.to_owned())),
};
Ok(content.render(lang))
@@ -173,6 +175,26 @@ fn invitation(lang: Lang, payload: &Value, url: String) -> Result<Content, Templ
let until_hu = until.trim_end_matches('.');
let unsubscribe_url = field(payload, "unsubscribe_url")?;
let unsubscribe_post_url = field(payload, "unsubscribe_post_url")?;
// A package that comes with the invitation, and its promo code.
let gift = name(payload, "package_name").zip(
payload["promo_code"]
.as_str()
.map(|c| c.chars().filter(|c| c.is_ascii_alphanumeric() || *c == '-').take(40).collect::<String>())
.filter(|c| !c.is_empty()),
);
let gift_line = |hu: bool| {
gift.as_ref().map(|(package, code)| {
if hu {
format!(
" Ajándékba egy „{package}” csomagot is kapsz: a regisztrációval magától jóváíródik. Ha mégis kellene, a promókódod: {code}."
)
} else {
format!(
" You also get the “{package}” package as a gift: it is added when you sign up. Should you need it, your promo code is {code}."
)
}
})
};
Ok(match lang {
Lang::Hu => Content {
subject: match &inviter {
@@ -188,7 +210,7 @@ fn invitation(lang: Lang, payload: &Value, url: String) -> Result<Content, Templ
None => {
"Meghívót kaptál a Sorsfonalakra. Az oldal egyelőre zártkörű: csak meghívóval lehet belépni.".into()
}
},
} + &gift_line(true).unwrap_or_default(),
quote: message,
points: Some((
"Mit találsz ott?",
@@ -226,7 +248,7 @@ fn invitation(lang: Lang, payload: &Value, url: String) -> Result<Content, Templ
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(),
},
} + &gift_line(false).unwrap_or_default(),
quote: message,
points: Some((
"What you will find there:",
@@ -262,6 +284,129 @@ fn name(payload: &Value, field: &str) -> Option<String> {
(!name.is_empty()).then(|| name.to_owned())
}
/// The confirmation of a waitlist sign-up, with the link that takes the address off the list.
fn waitlist_joined(lang: Lang, payload: &Value, url: String) -> Result<Content, TemplateError> {
let unsubscribe_url = field(payload, "unsubscribe_url")?;
let unsubscribe_post_url = field(payload, "unsubscribe_post_url")?;
Ok(match lang {
Lang::Hu => Content {
subject: "Felírtunk a Sorsfonalak várólistájára".into(),
preheader: Some("Amint bejuthatsz, ide írunk.".into()),
greeting: "Szia!".into(),
intro: "Köszönjük, hogy kíváncsi vagy a Sorsfonalakra! Az oldal egyelőre zártkörű, de felírtunk a várólistára: amint bejuthatsz, erre a címre írunk."
.into(),
quote: None,
points: Some((
"Mi vár rád?",
vec![
"a születési képleted percre pontosan kiszámolva és megrajzolva, egy rövid elemzéssel,",
"részletes elemzés, éves előrejelzés és kapcsolati összevetés azokkal, akiket szeretsz.",
],
)),
button: "Körülnézek",
url,
note: "Ha nem te iratkoztál fel, vagy meggondoltad magad, a lenti linkkel törölheted a címed a listáról.".into(),
reason: Some("Ezt a levelet azért kaptad, mert ezt a címet megadták a Sorsfonalak várólistáján.".into()),
unsubscribe: Some(("Leiratkozás a várólistáról", unsubscribe_url)),
unsubscribe_post_url: Some(unsubscribe_post_url),
},
Lang::En => Content {
subject: "You are on the Sorsfonalak waitlist".into(),
preheader: Some("We will write as soon as you can get in.".into()),
greeting: "Hi,".into(),
intro: "Thanks for your interest in Sorsfonalak! The site is invitation-only for now, but you are on the waitlist: we will write to this address as soon as you can get in."
.into(),
quote: None,
points: Some((
"What awaits you:",
vec![
"your birth chart, calculated to the minute and drawn, with a short reading,",
"detailed readings, a yearly forecast and comparisons with the people you love.",
],
)),
button: "Take a look",
url,
note: "If it was not you, or you changed your mind, the link below takes your address off the list.".into(),
reason: Some("You got this e-mail because this address was entered on the Sorsfonalak waitlist.".into()),
unsubscribe: Some(("Leave the waitlist", unsubscribe_url)),
unsubscribe_post_url: Some(unsubscribe_post_url),
},
})
}
/// A user invites someone to compare their charts ("how compatible are we?").
fn synastry_invite(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"))?;
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 => {
let who = inviter.clone().unwrap_or_else(|| "Valaki".into());
Content {
subject: format!("{who} kíváncsi, mennyire illetek össze"),
preheader: Some(format!(
"Születési képletek összevetése a Sorsfonalakon. A meghívó {until_hu}-ig érvényes."
)),
greeting: "Szia!".into(),
intro: format!(
"{who} szeretné összevetni a születési képleteteket a Sorsfonalakon, és megnézni, mennyire illetek össze."
),
quote: message,
points: Some((
"Mit kapsz?",
vec![
"a saját születési képleted kiszámolva és megrajzolva, egy rövid elemzéssel, ingyen,",
"a kettőtök összevetését: hol erős és hol kényes a kapcsolatotok.",
],
)),
button: "Megnézem",
url,
note: format!(
"A meghívó {until_hu}-ig érvényes. Google-fiókkal lépsz be. A születési adataidat {who} nem látja, csak az összevetést."
),
reason: Some(format!(
"Ezt a levelet azért kaptad, mert {who} megadta az e-mail-címed a Sorsfonalakon."
)),
unsubscribe: Some(("Nem kérek több meghívót", unsubscribe_url)),
unsubscribe_post_url: Some(unsubscribe_post_url),
}
}
Lang::En => {
let who = inviter.clone().unwrap_or_else(|| "Someone".into());
Content {
subject: format!("{who} wonders how well you match"),
preheader: Some(format!(
"Comparing birth charts on Sorsfonalak. The invitation is valid until {until}."
)),
greeting: "Hi,".into(),
intro: format!(
"{who} would like to compare your birth charts on Sorsfonalak and see how well you match."
),
quote: message,
points: Some((
"What you get:",
vec![
"your own birth chart, calculated and drawn, with a short reading, for free,",
"the comparison of the two of you: where your relationship is strong and where it is delicate.",
],
)),
button: "Take a look",
url,
note: format!(
"The invitation is valid until {until}. You sign in with Google. {who} does not see your birth data, only the comparison."
),
reason: Some(format!("You got this e-mail because {who} entered your address on Sorsfonalak.")),
unsubscribe: Some(("No more invitations, please", unsubscribe_url)),
unsubscribe_post_url: Some(unsubscribe_post_url),
}
}
})
}
/// The personal message of an invitation: line breaks kept, other control characters dropped.
fn message(payload: &Value) -> Option<String> {
let text: String =
@@ -445,6 +590,31 @@ mod tests {
})
}
#[test]
fn waitlist_confirmation_has_the_leave_link() {
let hu = render("waitlist_joined", "hu", &invitation_payload()).unwrap();
assert_eq!(hu.subject, "Felírtunk a Sorsfonalak várólistájára");
assert!(
hu.text.contains("Leiratkozás a várólistáról: https://sorsfonalak.test/leiratkozas?token=abc"),
"{}",
hu.text
);
assert!(hu.unsubscribe_post_url.is_some());
}
#[test]
fn synastry_invite_names_the_inviter() {
let hu = render("synastry_invite", "hu", &invitation_payload()).unwrap();
assert_eq!(hu.subject, "Kata kíváncsi, mennyire illetek össze");
assert!(hu.text.contains("> Gyere, nézd meg!"));
assert!(hu.text.contains("A meghívó 2026. december 17-ig érvényes."));
assert!(hu.html.contains(r#"href="https://sorsfonalak.test/meghivo/abc""#));
assert!(hu.text.contains("Nem kérek több meghívót"));
let mut anonymous = invitation_payload();
anonymous["inviter_name"] = Value::Null;
assert_eq!(render("synastry_invite", "en", &anonymous).unwrap().subject, "Someone wonders how well you match");
}
#[test]
fn invitation_has_both_parts() {
let hu = render("invitation", "hu", &invitation_payload()).unwrap();
@@ -468,6 +638,14 @@ mod tests {
assert!(en.text.contains("valid until 17 December 2026") && !en.text.contains("> "));
assert!(!en.html.contains("border-left"));
let mut gift = invitation_payload();
gift["package_name"] = json!("Páros");
gift["promo_code"] = json!("ABCD-EFGH-JKLM");
let hu = render("invitation", "hu", &gift).unwrap();
assert!(hu.text.contains("Ajándékba egy „Páros” csomagot is kapsz"), "{}", hu.text);
assert!(hu.html.contains("ABCD-EFGH-JKLM"));
assert!(!render("invitation", "hu", &invitation_payload()).unwrap().text.contains("Ajándék"));
let mut broken = invitation_payload();
broken["unsubscribe_url"] = Value::Null;
assert_eq!(render("invitation", "hu", &broken), Err(TemplateError::MissingField("unsubscribe_url")));
+7 -2
View File
@@ -85,8 +85,13 @@ services:
ANALYSIS_MODEL: ${ANALYSIS_MODEL:-}
SUMMARY_MODEL: ${SUMMARY_MODEL:-}
PASSWORD_LOGIN: ${PASSWORD_LOGIN:-false}
# Stand-in payment (adds an analysis unit at once) until Stripe is connected.
MOCK_PAYMENTS: ${MOCK_PAYMENTS:-true}
# Purchases are off until real payments are connected; packages come
# from promo codes and admins (MOCK_PAYMENTS=true: pretend purchases).
MOCK_PAYMENTS: ${MOCK_PAYMENTS:-false}
# Users inviting others ("Meghívom"): shown but off until the launch.
USER_INVITES: ${USER_INVITES:-false}
# A new user from a shared link earns the sharer an analysis: off until sign-up opens.
REFERRAL_REWARDS: ${REFERRAL_REWARDS:-false}
FREE_PERSON_SLOTS: ${FREE_PERSON_SLOTS:-0}
# invite: new accounts need an invitation (admin page "Meghívók"); open: anyone.
SIGNUP_MODE: ${SIGNUP_MODE:-invite}
+14 -6
View File
@@ -6,20 +6,28 @@ A képletoldalon, a rövid összefoglaló alatt van a **Megosztás** gomb. Ez eg
- **Visszavonás:** a „Link visszavonása” gomb után az oldal és a kép is 404-et ad.
- **Keresők:** az oldal `noindex`, a keresők nem listázzák.
## Ajándék elemzés a megosztásért
## Jutalom a megosztásért
**Mit kap:** felhasználónként **egyszer** +1 képletelemzést, amikor valaki más először megnyitja a megosztott linkjét. A gomb apró betűvel kiírja: „+1 ajándék elemzés jár érte, ha valaki megnézi”. Ha már megkapta, ezt: „Az ajándék elemzést már megkaptad”.
Egy kattintás önmagában semmit nem bizonyít, ezért kétféle jutalom van:
**Hogyan számolunk:**
- **Ajándék kérdés (megtekintésért):** felhasználónként **egyszer** +1 kérdés, amikor valaki más először megnyitja a megosztott linkjét. A gomb apró betűvel: „+1 ajándék kérdés, ha valaki megnézi”.
- **Ajándék képletelemzés (új felhasználóért):** +1 képletelemzés, ha valaki a megosztott linkről regisztrál és elkészíti a saját képletét. Felhasználónként legfeljebb 3 (`REFERRAL_LIMIT`). Az élesítésig ki van kapcsolva (`REFERRAL_REWARDS=false`), mert meghívásos regisztrációnál a linkről úgysem lehet regisztrálni.
- **A böngésző jelez.** A látogatást a megosztott oldal betöltése után maga a látogató böngészője jelzi (`POST /v1/public/shares/{slug}/visit`). Az előnézet-robotok nem futtatják az oldal szkriptjét, így ők nem számítanak.
**Megtekintés számolása:**
- **A böngésző jelez:** a megosztott oldal betöltése után maga a látogató böngészője jelzi a látogatást (`POST /v1/public/shares/{slug}/visit`). Az előnézet-robotok nem futtatják az oldal szkriptjét, így ők nem számítanak.
- **Ami nem számít:**
- robotnak látszó vagy hiányzó böngészőazonosító;
- a belépett tulajdonos;
- látogatás arról az IP-címről, ahonnan a linket létrehozták. A cím a sluggal sózva, hash-ként van tárolva (`shares.owner_ip_hash`).
- **Számláló:** a `shares.view_count` csak ezeket a valódi látogatásokat számolja.
- **Jutalom egyszer:** a `credit_ledger` `share_reward` sora egyedi indexszel felhasználónként csak egyszer jöhet létre (`credit_ledger_share_reward_once`).
- **`/v1/me`:** a `share_reward_granted` jelzi, ha már megkapta.
- **Jutalom egyszer:** a `share_reward` sor egyedi indexszel felhasználónként egyszer jöhet létre.
**Új felhasználó:**
- **Megjegyzés:** a megosztott oldal a böngészőben megjegyzi a link kódját (`localStorage` `sf_ref`). A Google-regisztráció elküldi (`referral`), és a backend a `referrals` táblába írja, hogy kit ki hozott. Saját link, visszavont link vagy kikapcsolt jutalom esetén nem írja be.
- **Jutalom:** amikor az új felhasználó elkészíti a saját képletét, a megosztó +1 képletelemzést kap (`referral_reward`), ha még nem érte el a hármat. Új felhasználónként egyszer.
- **`/v1/me`:** a `share_reward_granted` és a `referral_rewards` (`{earned, limit}`) mezők mutatják az állapotot.
## Robotok
+58
View File
@@ -0,0 +1,58 @@
# Promókódok
Amíg a fizetés nincs bekötve, a csomagokat promókóddal (és admin ajándékkal) lehet megkapni. Élesben a vásárlás ki van kapcsolva: a `MOCK_PAYMENTS` alapértéke a `deploy/docker-compose.yml`-ben `false`. A csomagkártyákon ilyenkor „Hamarosan” felirat áll.
## Admin: Admin → Promókódok
- **Kódkészítés:**
- Csomag (a fő csomagok és a kiegészítők közül), darab (1–500) és egy megjegyzés: kinek szól, melyik kampány.
- Az elkészült kódok egy listában jelennek meg, a „Mind másolása” gombbal kimásolhatók.
- A kód formája `ABCD-EFGH-JKLM`: 12 karakter, összetéveszthető betűk és számok nélkül (nincs 0/O, 1/I/L).
- **Lista:**
- Szűrhető állapotra: **fel nem használt** (ez az alapértelmezés), beváltott, visszavont, mind.
- Szűrhető csomagra, és kereshető kódrészletre, megjegyzésre vagy a beváltó e-mail-címére.
- A beváltott kódnál látszik, ki és mikor váltotta be.
- **Visszavonás:** fel nem használt kódot vissza lehet vonni. Utána nem váltható be.
## Felhasználó: beváltás
- **Hol lehet beváltani:**
- a fejléc „Kód beváltása” linkje (`/bevaltas`);
- a Csomagok oldal „Van promókódod?” doboza;
- a részletes elemzés ajánlata és a kérdés-válasz rész is ide vezet, ha nincs felhasználható egység.
- **Kitöltött link:** a `sorsfonalak.hu/bevaltas?kod=ABCD-EFGH-JKLM` link kitöltve nyitja meg a kódot. Aki nincs belépve, a belépés után ide tér vissza. Elég ezt a linket elküldeni a meghívottaknak.
- **Beírás:** a kód kis- vagy nagybetűvel, kötőjellel vagy anélkül is beírható.
- **Beváltás = feltöltés:** a kód nem hozzáad, hanem **feltölti** az egyenleget a csomag szintjéig. Minden egységnél (képletelemzés, kapcsolati elemzés, előrejelzés, kérdés, szabad személyhely) az új egyenleg a csomag mennyisége lesz, ha addig kevesebb volt.
- Ami elhasznált belőle, visszajön; ami ennél több van (például vett hozzá), megmarad.
- Példa: a „Páros” csomag 2 képletelemzést ad. Ha valakinek 0 maradt, 2 lesz; ha 5 van, 5 marad.
- Ha a felhasználónak már mindenből megvan a csomag mennyisége, a kódot nem váltjuk be (megmarad későbbre), és ezt üzenetben meg is mondjuk.
- Könyvelés: egy `package_orders` sor `promo` forrással, 0 Ft-tal, és `credit_ledger` sorok csak a ténylegesen hozzáadott mennyiségekkel. A válaszban az `added` mező mondja meg, mi került hozzá.
- **Egyszer:** egy kód egyszer váltható be. A „már felhasználták”, „már nem érvényes” és „nincs ilyen kód” esetekre külön üzenet van.
- **Találgatás ellen:** 10 sikertelen próbálkozás után a felhasználó negyed óráig nem próbálkozhat.
## Meghívó csomaggal
Az Admin → Meghívók oldalon az „Ajándék csomag” választóval minden meghívott kap egy promókódot a választott csomagra (megjegyzés: „meghívó: <cím>”).
- **A levélben** benne van a csomag neve és a kód. A levél előnézete is mutatja (minta kóddal).
- **Regisztrációkor** a kód magától beváltódik, ugyanazzal a feltöltéssel, mint a kézi beváltásnál. Ha mégsem, a kód kézzel is beváltható.
- **Újraküldéskor** a levélben ugyanaz a kód marad.
- **Visszavonás:** a meghívó visszavonása a még fel nem használt kódot is visszavonja.
- **A meghívók listájában** látszik a csomag, és hogy beváltották-e.
- **A várólistán lévőket** is csomaggal lehet meghívni: a „Várólista” táblázat fölötti választóval a „Meghívás” gomb azzal a csomaggal küldi a meghívót.
## Várólista
- **Visszaigazolás:** aki feliratkozik, egyszer kap egy visszaigazoló levelet (`waitlist_joined`), benne leiratkozó linkkel.
- **Leiratkozás:** a link leveszi a címet a listáról, és felveszi a „nem kér levelet” listára, így meghívót sem küldünk oda többet.
- **Korlát:** IP-címenként 15 percen belül legfeljebb 10 levél megy ki, hogy az űrlappal ne lehessen mások postafiókját elárasztani. A lista legfeljebb 10 000 cím.
## API
| Végpont | Ki | Mit csinál |
|---|---|---|
| `POST /v1/admin/promo-codes` `{package, count, note?}` | admin | kódok készítése |
| `GET /v1/admin/promo-codes?status=unused\|used\|revoked\|all&package=&q=&limit=&offset=` | admin | lista |
| `POST /v1/admin/promo-codes/{id}/revoke` | admin | visszavonás |
| `POST /v1/promo-codes/redeem` `{code}` | belépett felhasználó | beváltás (feltöltés); a válaszban az új egyenleg, a csomag és az `added` |
| `POST /v1/admin/invitations` `{emails, message?, locale?, package?}` | admin | meghívó, opcionálisan csomaggal |
+32
View File
@@ -0,0 +1,32 @@
# Személy meghívása
Az „Új személy” oldalon két lehetőség van:
- **Adatok megadása:** a felhasználó maga írja be a születési adatokat. Ez egy személyhelyet használ, ahogy eddig.
- **Meghívom:** egy „Mennyire illünk össze?” meghívó (`synastry_invites`). A meghívott a saját adatait adja meg. Személyhely nem kell hozzá, és akkor is működik, ha a helyek elfogytak.
**Az élesítésig ki van kapcsolva:** a „Meghívom” lehetőség és a Személyek oldal „Hívd meg, akit szeretsz” kártyája látszik, de „Hamarosan” felirattal le van tiltva. A backend `invites_disabled` hibával utasítja el. Bekapcsolás: `USER_INVITES=true` a szerver `.env` fájljában. Az adminok a kapcsolótól függetlenül meghívhatnak, hogy ki tudják próbálni.
## Menete
1. **A meghívó elkészül.** A meghívó megadhatja, kinek szól (ezt csak ő látja), a meghívott e-mail-címét (nem kötelező) és egy üzenetet (legfeljebb 300 karakter, link nélkül). A link `/meghivas/<kód>`, 14 napig érvényes. Megosztható másolással, a telefon megosztás menüjével, WhatsAppon vagy Facebookon.
2. **Levél** (`synastry_invite` sablon), ha e-mail-cím is van:
- naponta legfeljebb 10 levél felhasználónként, a többi meghívó csak linkkel megy;
- aki leiratkozott a meghívókról, nem kap levelet (a link ilyenkor is működik);
- a levél alján leiratkozó link van, ugyanaz a végpont, mint az oldalmeghívóknál.
3. **A meghívott a linkről érkezik.**
- Belép Google-lal. Meghívásos regisztrációnál a link kódja engedi be.
- Ha még nincs képlete, megadja a születési adatait, és rögtön elkészül az összevetés (`POST /v1/invites/accept`).
- Az összevetés oldalára jut.
4. **A meghívó értesítést kap** (`invite_accepted`, a link az `/osszevetesek/<id>` oldalra visz). A Személyek oldalon a „Meghívóid” listában látszanak a függő meghívók (visszavonhatók) és az elmúlt 30 nap elfogadott meghívói.
## Ki mit fizet
| Mi | Ár |
|---|---|
| A meghívott képlete és rövid összefoglalója | ingyen, mint mindenkinek |
| Az összevetés rajza és táblázatai | ingyen |
| Kapcsolati elemzés | 1 kapcsolati egység, annak, aki elindítja; mindketten látják, és mindketten kérdezhetnek róla |
| A meghívott részletes képletelemzése | csak ha ő kéri, a saját egységéből |
A meghívó a meghívott születési adatait nem látja, csak a bolygóállásokat és az összevetést.
+12
View File
@@ -45,6 +45,14 @@ pub struct Config {
/// `MOCK_PAYMENTS` (default `false`): a stand-in payment that adds an
/// analysis unit at once, until Stripe is connected.
pub mock_payments: bool,
/// `USER_INVITES` (default `false`): users may invite others ("how
/// compatible are we?" links, which also let the invitee sign up). Off
/// until the launch; admins may always.
pub user_invites: bool,
/// `REFERRAL_REWARDS` (default `false`): someone who signs up from a
/// shared link and makes their own chart earns the sharer a natal
/// analysis (at most three). Off until sign-up opens.
pub referral_rewards: bool,
/// `GOOGLE_CLIENT_IDS`: comma-separated OAuth client ids accepted as the
/// ID token audience; empty disables Google login.
pub google_client_ids: Vec<String>,
@@ -119,6 +127,8 @@ impl Config {
session_ttl_days: parsed("SESSION_TTL_DAYS", 30)?,
password_login: parsed("PASSWORD_LOGIN", false)?,
mock_payments: parsed("MOCK_PAYMENTS", false)?,
user_invites: parsed("USER_INVITES", false)?,
referral_rewards: parsed("REFERRAL_REWARDS", false)?,
google_client_ids: list("GOOGLE_CLIENT_IDS"),
google_jwks_url: var("GOOGLE_JWKS_URL")
.unwrap_or_else(|| "https://www.googleapis.com/oauth2/v3/certs".into()),
@@ -156,6 +166,8 @@ impl Config {
session_ttl_days: 30,
password_login: true,
mock_payments: true,
user_invites: true,
referral_rewards: true,
google_client_ids: vec!["test-client.apps.googleusercontent.com".into()],
google_jwks_url,
bootstrap_admin_emails: vec!["admin@example.com".into()],
+64 -10
View File
@@ -184,6 +184,8 @@ impl Package {
pub enum Source {
Admin,
Mock,
/// A redeemed promo code.
Promo,
}
impl Source {
@@ -191,11 +193,25 @@ impl Source {
match self {
Source::Admin => "admin",
Source::Mock => "mock",
Source::Promo => "promo",
}
}
}
/// Records an order and gives its contents, inside the caller's transaction.
impl Package {
/// What the package gives, unit by unit.
pub fn contents(&self) -> [(Unit, i64); 5] {
[
(Unit::Natal, self.natal),
(Unit::Synastry, self.synastry),
(Unit::Forecast, self.forecast),
(Unit::Person, self.persons),
(Unit::Question, self.questions),
]
}
}
/// Records an order and adds its contents, inside the caller's transaction.
pub async fn grant(
tx: &mut PgConnection,
user_id: Uuid,
@@ -203,10 +219,55 @@ pub async fn grant(
source: Source,
created_by: Option<Uuid>,
note: Option<&str>,
) -> Result<Uuid, ApiError> {
record(tx, user_id, package, source, created_by, note, &package.contents()).await
}
/// Fills the user's units up to what the package gives (promo codes): a unit
/// below the package's amount is raised to it, used units come back, more
/// than that stays as it is. `persons_left` is the free person slots now
/// (`None`: unlimited, nothing to add). Returns the order and what was added
/// (nothing at all: no order is recorded).
pub async fn top_up(
tx: &mut PgConnection,
user_id: Uuid,
package: &Package,
persons_left: Option<i64>,
note: Option<&str>,
) -> Result<Option<(Uuid, Vec<(Unit, i64)>)>, ApiError> {
sqlx::query("SELECT id FROM users WHERE id = $1 FOR UPDATE").bind(user_id).execute(&mut *tx).await?;
let balance = crate::credits::balance(tx, user_id).await?;
let added: Vec<(Unit, i64)> = package
.contents()
.into_iter()
.map(|(unit, n)| {
let have = match unit {
Unit::Person => persons_left.unwrap_or(i64::MAX),
unit => balance.of(unit),
};
(unit, (n - have).max(0))
})
.filter(|&(_, n)| n > 0)
.collect();
if added.is_empty() {
return Ok(None);
}
let order = record(tx, user_id, package, Source::Promo, None, note, &added).await?;
Ok(Some((order, added)))
}
async fn record(
tx: &mut PgConnection,
user_id: Uuid,
package: &Package,
source: Source,
created_by: Option<Uuid>,
note: Option<&str>,
contents: &[(Unit, i64)],
) -> Result<Uuid, ApiError> {
let order = Uuid::now_v7();
let price = match source {
Source::Admin => 0,
Source::Admin | Source::Promo => 0,
Source::Mock => package.price_huf,
};
sqlx::query(
@@ -222,14 +283,7 @@ pub async fn grant(
.bind(created_by)
.execute(&mut *tx)
.await?;
let contents = [
(Unit::Natal, package.natal),
(Unit::Synastry, package.synastry),
(Unit::Forecast, package.forecast),
(Unit::Person, package.persons),
(Unit::Question, package.questions),
];
for (unit, n) in contents {
for &(unit, n) in contents {
if n == 0 {
continue;
}
+14
View File
@@ -62,6 +62,20 @@ pub async fn slots(conn: &mut PgConnection, auth: &AuthUser, free: i64) -> Resul
Ok(Slots { used, granted: free + bought, unlimited: entitled || auth.user.has_role(Role::Admin) })
}
/// The free person slots of a user without unlimited slots (for topping up).
pub async fn left(conn: &mut PgConnection, user_id: Uuid, free: i64) -> Result<i64, ApiError> {
let (used, bought): (i64, i64) = sqlx::query_as(
"SELECT \
(SELECT COUNT(*) FROM credit_ledger WHERE user_id = $1 AND unit = 'person' AND reason = 'person'), \
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger \
WHERE user_id = $1 AND unit = 'person' AND reason <> 'person')",
)
.bind(user_id)
.fetch_one(conn)
.await?;
Ok((free + bought - used).max(0))
}
/// Fails when no slot is left (a quick check before calculating a chart).
pub async fn check(conn: &mut PgConnection, auth: &AuthUser, free: i64) -> Result<(), ApiError> {
if slots(conn, auth, free).await?.left() == Some(0) {
+4 -1
View File
@@ -34,6 +34,7 @@ pub async fn me(State(state): St, auth: AuthUser) -> ApiResult<Json<Value>> {
let persons = crate::persons::slots(&mut conn, &auth, state.config.free_person_slots).await?;
let package = crate::packages::current(&mut conn, auth.id()).await?;
let share_reward = super::shares::reward_granted(&state.db, auth.id()).await?;
let referrals = super::shares::referral_rewards(&mut conn, auth.id()).await?;
Ok(Json(json!({
"user": UserView::from(&auth.user),
"providers": providers.into_iter().map(|(p,)| p).collect::<Vec<_>>(),
@@ -42,8 +43,10 @@ pub async fn me(State(state): St, auth: AuthUser) -> ApiResult<Json<Value>> {
"birth_change": birth_change,
"persons": persons.view(),
"package": package.map(|(p, since)| json!({ "id": p.id, "name": p.name, "since": rfc3339(since) })),
// The free analysis for a shared link is used up (once per user).
// The free question for a shared link is used up (once per user).
"share_reward_granted": share_reward,
// Natal analyses earned by bringing new users, and how many can be.
"referral_rewards": { "earned": referrals, "limit": super::shares::REFERRAL_LIMIT },
})))
}
+23 -2
View File
@@ -170,6 +170,8 @@ pub struct RegisterRequest {
locale: Option<String>,
/// The invitation link's token, while sign-up needs an invitation.
invite_token: Option<String>,
/// The slug of the shared link the visitor came from.
referral: Option<String>,
}
/// Password endpoints answer 403 while `PASSWORD_LOGIN` is off.
@@ -216,7 +218,15 @@ 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?;
super::invitations::mark_accepted(
&mut tx,
user_id,
&email,
req.invite_token.as_deref(),
state.config.free_person_slots,
)
.await?;
super::shares::record_referral(&mut tx, state.config.referral_rewards, user_id, req.referral.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?;
@@ -284,6 +294,8 @@ pub struct GoogleRequest {
id_token: String,
/// The invitation link's token, while sign-up needs an invitation.
invite_token: Option<String>,
/// The slug of the shared link the visitor came from.
referral: Option<String>,
}
/// Logs in with Google. An unknown Google account is linked to the existing
@@ -347,7 +359,16 @@ pub async fn google(
.bind(locale)
.execute(&mut *tx)
.await?;
super::invitations::mark_accepted(&mut tx, id, &email, req.invite_token.as_deref()).await?;
super::invitations::mark_accepted(
&mut tx,
id,
&email,
req.invite_token.as_deref(),
state.config.free_person_slots,
)
.await?;
super::shares::record_referral(&mut tx, state.config.referral_rewards, id, req.referral.as_deref())
.await?;
(id, true)
}
};
+4
View File
@@ -184,6 +184,7 @@ pub async fn create(
birth_changes::record(&mut tx, &auth, row.id).await?;
tx.commit().await?;
queue_summary(&state, &auth, &row).await;
super::shares::reward_referral(&state, auth.id()).await?;
return Ok((StatusCode::OK, Json(row.owner_view())));
}
queue_summary(&state, &auth, &chart).await;
@@ -231,6 +232,9 @@ pub async fn create(
}
tx.commit().await?;
queue_summary(&state, &auth, &row).await;
if row.is_primary {
super::shares::reward_referral(&state, auth.id()).await?;
}
Ok((StatusCode::CREATED, Json(row.owner_view())))
}
+137 -15
View File
@@ -7,6 +7,10 @@
//!
//! People who asked for no more invitations are kept as the hash of their
//! address. People without an invitation can join the waitlist.
//!
//! An invitation can come with a package: a promo code is made with it, the
//! e-mail shows it with its redeem link, and it is redeemed by itself when
//! the invitee signs up (revoking the invitation withdraws it).
use axum::Json;
use axum::extract::{Path, Query, State};
@@ -24,8 +28,12 @@ use crate::AppState;
use crate::auth::AdminUser;
use crate::config::SignupMode;
use crate::error::{ApiError, ApiResult};
use crate::packages;
use crate::views::{rfc3339, rfc3339_opt};
/// The package of an invitation, as shown in its e-mail: (code as shown, package name).
type Gift = (String, &'static str);
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);
@@ -68,12 +76,15 @@ pub async fn admit(
}
}
/// After a new account is created: its invitations count as accepted, and it leaves the waitlist.
/// After a new account is created: its invitations count as accepted, it
/// leaves the waitlist, and the packages of those invitations are redeemed
/// (`free_slots`: the person slots everyone gets).
pub async fn mark_accepted(
conn: &mut PgConnection,
user_id: Uuid,
email: &str,
token: Option<&str>,
free_slots: i64,
) -> Result<(), ApiError> {
let hash = token.map(|t| db::token_hash(t.trim()));
sqlx::query(
@@ -87,12 +98,36 @@ pub async fn mark_accepted(
.execute(&mut *conn)
.await?;
sqlx::query("DELETE FROM waitlist WHERE email = $1").bind(email).execute(&mut *conn).await?;
let codes: Vec<(Uuid, String, String)> = sqlx::query_as(
"SELECT p.id, p.code, p.package FROM promo_codes p JOIN invitations i ON i.id = p.invitation_id \
WHERE i.accepted_by = $1 AND p.redeemed_at IS NULL AND p.revoked_at IS NULL FOR UPDATE OF p",
)
.bind(user_id)
.fetch_all(&mut *conn)
.await?;
for (id, code, package) in codes {
let Some(package) = packages::find(&package) else { continue };
let persons_left = crate::persons::left(conn, user_id, free_slots).await?;
super::promo::redeem_code(conn, id, &code, package, user_id, Some(persons_left)).await?;
tracing::info!(user = %user_id, package = package.id, "invitation package redeemed");
}
Ok(())
}
/// The open promo code of an invitation, for its e-mail.
async fn gift_of(conn: &mut PgConnection, invitation_id: Uuid) -> Result<Option<Gift>, sqlx::Error> {
let row: Option<(String, String)> = sqlx::query_as(
"SELECT code, package FROM promo_codes WHERE invitation_id = $1 AND redeemed_at IS NULL AND revoked_at IS NULL",
)
.bind(invitation_id)
.fetch_optional(conn)
.await?;
Ok(row.and_then(|(code, package)| packages::find(&package).map(|p| (super::promo::display(&code), p.name))))
}
// --- sending ---------------------------------------------------------------------------------
fn clean_message(message: Option<String>) -> Result<Option<String>, ApiError> {
pub(super) 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);
};
@@ -107,7 +142,7 @@ fn clean_message(message: Option<String>) -> Result<Option<String>, ApiError> {
Ok(Some(message))
}
fn links(state: &AppState, token: &str) -> (String, String, String) {
pub(super) fn links(state: &AppState, token: &str) -> (String, String, String) {
let base = &state.config.public_base_url;
(
format!("{base}/meghivo/{token}"),
@@ -122,9 +157,14 @@ fn payload(
inviter: Option<&str>,
message: Option<&str>,
expires: OffsetDateTime,
gift: Option<&Gift>,
) -> Value {
let (url, unsubscribe_url, unsubscribe_post_url) = links(state, token);
let base = &state.config.public_base_url;
json!({
"package_name": gift.map(|g| g.1),
"promo_code": gift.map(|g| g.0.as_str()),
"redeem_url": gift.map(|g| format!("{base}/bevaltas?kod={}", g.0)),
"url": url,
"unsubscribe_url": unsubscribe_url,
"unsubscribe_post_url": unsubscribe_post_url,
@@ -145,6 +185,7 @@ async fn send(
inviter: Option<&str>,
message: Option<&str>,
expires: OffsetDateTime,
gift: Option<&Gift>,
) -> Result<String, ApiError> {
let token = db::new_token();
sqlx::query("INSERT INTO invitation_tokens (token_hash, invitation_id) VALUES ($1, $2)")
@@ -152,13 +193,13 @@ async fn send(
.bind(id)
.execute(&mut *conn)
.await?;
let payload = payload(state, &token, inviter, message, expires);
let payload = payload(state, &token, inviter, message, expires, gift);
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> {
pub(super) 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)
@@ -173,6 +214,8 @@ pub struct CreateInvitations {
emails: Vec<String>,
message: Option<String>,
locale: Option<String>,
/// A package from the catalog the invitees get (as a promo code).
package: Option<String>,
}
/// Invites a list of addresses. Each gets a result: `invited` (with the
@@ -188,6 +231,10 @@ pub async fn create(
}
let message = clean_message(req.message)?;
let locale = validate_locale(&state, req.locale.as_deref())?;
let package = match req.package.as_deref().filter(|p| !p.is_empty()) {
Some(id) => Some(packages::find(id).ok_or(ApiError::NotFound("package"))?),
None => None,
};
let inviter = admin.user.display_name.clone();
let mut results = Vec::new();
let mut seen = std::collections::HashSet::new();
@@ -240,8 +287,20 @@ pub async fn create(
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 }));
let gift = match package {
Some(p) => {
let note = format!("meghívó: {email}");
let code = super::promo::new_code(&mut tx, p.id, Some(&note), Some(admin.id()), Some(id)).await?;
Some((super::promo::display(&code), p.name))
}
None => None,
};
let url =
send(&state, &mut tx, id, &email, &locale, inviter.as_deref(), message.as_deref(), expires, gift.as_ref())
.await?;
results.push(json!({
"email": email, "status": "invited", "id": id, "url": url, "promo_code": gift.as_ref().map(|g| &g.0),
}));
}
tx.commit().await?;
Ok((StatusCode::CREATED, Json(json!({ "results": results }))))
@@ -265,6 +324,9 @@ struct Row {
mail_sent_at: Option<OffsetDateTime>,
mail_failed_at: Option<OffsetDateTime>,
mail_error: Option<String>,
promo_code: Option<String>,
promo_package: Option<String>,
promo_redeemed_at: Option<OffsetDateTime>,
}
fn status(accepted: Option<OffsetDateTime>, revoked: Option<OffsetDateTime>, expires: OffsetDateTime) -> &'static str {
@@ -285,8 +347,10 @@ pub async fn list(State(state): St, _admin: AdminUser) -> ApiResult<Json<Value>>
"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 \
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, \
pc.code AS promo_code, pc.package AS promo_package, pc.redeemed_at AS promo_redeemed_at \
FROM invitations i \
LEFT JOIN promo_codes pc ON pc.invitation_id = i.id \
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 \
@@ -318,6 +382,12 @@ pub async fn list(State(state): St, _admin: AdminUser) -> ApiResult<Json<Value>>
"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,
"package": r.promo_package.as_deref().map(|p| json!({
"id": p,
"name": packages::find(p).map(|p| p.name),
"code": r.promo_code.as_deref().map(super::promo::display),
"redeemed_at": rfc3339_opt(r.promo_redeemed_at),
})),
})
})
.collect();
@@ -391,22 +461,34 @@ pub async fn resend(
.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?;
let gift = gift_of(&mut tx, id).await?;
let url =
send(&state, &mut tx, id, &email, &locale, inviter.as_deref(), message.as_deref(), expires, gift.as_ref())
.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 mut tx = state.db.begin().await?;
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)
.execute(&mut *tx)
.await?
.rows_affected();
if done == 0 {
return Err(ApiError::NotFound("open invitation"));
}
// Its package goes with it.
sqlx::query(
"UPDATE promo_codes SET revoked_at = now() WHERE invitation_id = $1 AND redeemed_at IS NULL AND revoked_at IS NULL",
)
.bind(id)
.execute(&mut *tx)
.await?;
tx.commit().await?;
Ok(StatusCode::NO_CONTENT)
}
@@ -427,6 +509,8 @@ pub struct PreviewRequest {
/// Also send it to the admin's own address.
#[serde(default)]
send_to_me: bool,
/// Show it with this package (a sample code).
package: Option<String>,
}
/// The invitation e-mail with sample links (they lead nowhere), and
@@ -438,12 +522,17 @@ pub async fn preview(
) -> ApiResult<Json<Value>> {
let message = clean_message(req.message)?;
let locale = validate_locale(&state, req.locale.as_deref())?;
let gift = match req.package.as_deref().filter(|p| !p.is_empty()) {
Some(id) => Some(("MINT-AKOD-XXXX".to_string(), packages::find(id).ok_or(ApiError::NotFound("package"))?.name)),
None => None,
};
let payload = payload(
&state,
"minta",
admin.user.display_name.as_deref(),
message.as_deref(),
OffsetDateTime::now_utc() + INVITATION_TTL,
gift.as_ref(),
);
let mail = email_templates::render("invitation", &locale, &payload)
.map_err(|e| ApiError::Internal(format!("invitation template: {e}")))?;
@@ -498,8 +587,13 @@ pub async fn unsubscribe(
WithRejection(Query(q), _): WithRejection<Query<TokenQuery>, ApiError>,
) -> ApiResult<Json<Value>> {
let mut tx = state.db.begin().await?;
// The link of a site invitation, of a "how compatible are we?" one a user
// had us e-mail, or of the waitlist confirmation.
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",
"SELECT i.email FROM invitation_tokens t JOIN invitations i ON i.id = t.invitation_id WHERE t.token_hash = $1 \
UNION ALL SELECT invitee_email FROM synastry_invites WHERE token_hash = $1 AND invitee_email IS NOT NULL \
UNION ALL SELECT email FROM waitlist WHERE token_hash = $1 \
LIMIT 1",
)
.bind(db::token_hash(q.token.trim()))
.fetch_optional(&mut *tx)
@@ -515,6 +609,7 @@ pub async fn unsubscribe(
.bind(&email)
.execute(&mut *tx)
.await?;
sqlx::query("DELETE FROM waitlist WHERE email = $1").bind(&email).execute(&mut *tx).await?;
tx.commit().await?;
Ok(Json(json!({ "unsubscribed": true })))
}
@@ -529,19 +624,46 @@ pub struct WaitlistRequest {
/// Joins the waitlist. Always answers the same, so it does not reveal who has an account.
pub async fn join_waitlist(
State(state): St,
headers: axum::http::HeaderMap,
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 \
// Every sign-up sends an e-mail: a few per address, so the form cannot be used to flood someone.
let ip = headers
.get("x-forwarded-for")
.and_then(|v| v.to_str().ok())
.and_then(|v| v.split(',').next())
.map(str::trim)
.unwrap_or("unknown");
let key = format!("waitlist:{ip}");
state.login_limiter.check(&key)?;
let token = db::new_token();
let mut tx = state.db.begin().await?;
let added = sqlx::query(
"INSERT INTO waitlist (email, locale, token_hash) SELECT $1, $2, $3 \
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?;
.bind(db::token_hash(&token))
.execute(&mut *tx)
.await?
.rows_affected()
== 1;
// A confirmation, once, unless the address asked for no more mail from us.
if added && !opted_out(&mut tx, &email).await? {
let (_, unsubscribe_url, unsubscribe_post_url) = links(&state, &token);
let payload = json!({
"url": state.config.public_base_url,
"unsubscribe_url": unsubscribe_url,
"unsubscribe_post_url": unsubscribe_post_url,
});
queue_email_to(&mut tx, None, &email, "waitlist_joined", &locale, payload).await?;
state.login_limiter.failed(&key);
}
tx.commit().await?;
Ok((StatusCode::ACCEPTED, Json(json!({ "ok": true }))))
}
+6
View File
@@ -16,6 +16,7 @@ mod invitations;
mod jobs;
mod models;
mod payments;
mod promo;
mod prompts;
mod questions;
mod recalculate;
@@ -96,6 +97,9 @@ pub fn router(state: Arc<AppState>) -> Router {
.route("/v1/analyses/{id}/questions", get(questions::list).post(questions::ask))
.route("/v1/questions/{id}", get(questions::get_one))
// sharing
.route("/v1/promo-codes/redeem", post(promo::redeem))
.route("/v1/admin/promo-codes", get(promo::list).post(promo::create))
.route("/v1/admin/promo-codes/{id}/revoke", post(promo::revoke))
.route("/v1/shares", get(shares::list).post(shares::create))
.route("/v1/shares/{id}", delete(shares::revoke))
// public, no login
@@ -158,6 +162,8 @@ async fn public_config(State(state): St) -> Json<Value> {
"locales": c.supported_locales,
"password_login": c.password_login,
"mock_payments": c.mock_payments,
"user_invites": c.user_invites,
"referral_rewards": c.referral_rewards,
"signup_mode": c.signup_mode.as_str(),
"password_min_length": crate::auth::MIN_PASSWORD_LEN,
}))
+277
View File
@@ -0,0 +1,277 @@
//! Promo codes. An admin makes a batch for one package (or one comes with an
//! invitation); a logged-in user redeems a code once. Redeeming fills the
//! user's units up to the package's amounts (used ones come back, more than
//! that stays), recorded as an order with source `promo`. Unused codes can be
//! withdrawn. Failed redemptions are rate limited per user, so codes cannot
//! be guessed.
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 time::OffsetDateTime;
use uuid::Uuid;
use super::payments::holdings;
use super::{Body, IdPath, St};
use crate::auth::{AdminUser, AuthUser};
use crate::credits::Unit;
use crate::error::{ApiError, ApiResult};
use crate::packages;
use crate::views::{rfc3339, rfc3339_opt};
/// Characters of a code (12 × ~5 bits: not guessable within the rate limit).
const CODE_LEN: usize = 12;
const MAX_BATCH: i64 = 500;
/// `ABCD-EFGH-JKLM`: the stored code in groups of four.
pub(super) fn display(code: &str) -> String {
code.as_bytes().chunks(4).map(|c| String::from_utf8_lossy(c).into_owned()).collect::<Vec<_>>().join("-")
}
/// What the user typed, as stored: upper case, without spaces and dashes.
fn normalize(input: &str) -> String {
input.chars().filter(|c| c.is_ascii_alphanumeric()).map(|c| c.to_ascii_uppercase()).collect()
}
/// Makes one code for a package inside the caller's transaction; returns the stored code.
pub(super) async fn new_code(
tx: &mut sqlx::PgConnection,
package: &str,
note: Option<&str>,
created_by: Option<Uuid>,
invitation_id: Option<Uuid>,
) -> Result<String, sqlx::Error> {
loop {
let code = db::random_code(CODE_LEN);
// A clash is practically impossible; another code is drawn if it happens.
let inserted = sqlx::query(
"INSERT INTO promo_codes (id, code, package, note, created_by, invitation_id) \
VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT (code) DO NOTHING",
)
.bind(Uuid::now_v7())
.bind(&code)
.bind(package)
.bind(note)
.bind(created_by)
.bind(invitation_id)
.execute(&mut *tx)
.await?
.rows_affected();
if inserted == 1 {
return Ok(code);
}
}
}
/// Redeems an open code for the user inside the caller's transaction (the
/// code row must be locked). Returns what was added; `None`: the user already
/// has everything the package gives, the code stays open.
pub(super) async fn redeem_code(
tx: &mut sqlx::PgConnection,
code_id: Uuid,
code: &str,
package: &packages::Package,
user_id: Uuid,
persons_left: Option<i64>,
) -> Result<Option<Vec<(Unit, i64)>>, ApiError> {
let note = format!("promo code {}", display(code));
let Some((order, added)) = packages::top_up(tx, user_id, package, persons_left, Some(&note)).await? else {
return Ok(None);
};
sqlx::query("UPDATE promo_codes SET redeemed_by = $2, redeemed_at = now(), order_id = $3 WHERE id = $1")
.bind(code_id)
.bind(user_id)
.bind(order)
.execute(&mut *tx)
.await?;
Ok(Some(added))
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NewCodes {
package: String,
count: i64,
note: Option<String>,
}
/// Admin: makes `count` new codes for a package.
pub async fn create(
State(state): St,
admin: AdminUser,
WithRejection(Json(req), _): Body<NewCodes>,
) -> ApiResult<(StatusCode, Json<Value>)> {
let package = packages::find(&req.package).ok_or(ApiError::NotFound("package"))?;
if !(1..=MAX_BATCH).contains(&req.count) {
return Err(ApiError::BadRequest(format!("count must be 1 to {MAX_BATCH}")));
}
let note = req.note.map(|n| n.trim().chars().take(200).collect::<String>()).filter(|n| !n.is_empty());
let mut tx = state.db.begin().await?;
let mut codes = Vec::new();
for _ in 0..req.count {
codes.push(display(&new_code(&mut tx, package.id, note.as_deref(), Some(admin.0.id()), None).await?));
}
tx.commit().await?;
tracing::info!(admin = %admin.0.id(), package = package.id, count = codes.len(), "promo codes created");
Ok((StatusCode::CREATED, Json(json!({ "package": package.id, "note": note, "codes": codes }))))
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CodeQuery {
/// `unused` (default), `used`, `revoked` or `all`.
status: Option<String>,
package: Option<String>,
/// Part of the code, the note or the redeemer's e-mail.
q: Option<String>,
limit: Option<i64>,
offset: Option<i64>,
}
type Row = (
Uuid,
String,
String,
Option<String>,
OffsetDateTime,
Option<OffsetDateTime>,
Option<OffsetDateTime>,
Option<String>,
Option<String>,
);
/// Admin: the codes, newest first, filtered.
pub async fn list(
State(state): St,
_admin: AdminUser,
WithRejection(Query(query), _): WithRejection<Query<CodeQuery>, ApiError>,
) -> ApiResult<Json<Value>> {
let status = query.status.as_deref().unwrap_or("unused");
let condition = match status {
"unused" => "p.redeemed_at IS NULL AND p.revoked_at IS NULL",
"used" => "p.redeemed_at IS NOT NULL",
"revoked" => "p.revoked_at IS NOT NULL",
"all" => "true",
other => return Err(ApiError::BadRequest(format!("unknown status '{other}'"))),
};
let limit = query.limit.unwrap_or(100).clamp(1, 500);
let offset = query.offset.unwrap_or(0).max(0);
let package = query.package.filter(|p| !p.is_empty());
let search = query.q.map(|q| q.trim().to_string()).filter(|q| !q.is_empty());
// A code is searched for without its dashes.
let code_search = search.as_deref().map(normalize).filter(|c| !c.is_empty());
let filter = format!(
"FROM promo_codes p LEFT JOIN users u ON u.id = p.redeemed_by \
WHERE {condition} AND ($1::text IS NULL OR p.package = $1) \
AND ($2::text IS NULL OR p.note ILIKE '%' || $2 || '%' OR u.email ILIKE '%' || $2 || '%' \
OR ($3::text IS NOT NULL AND p.code LIKE '%' || $3 || '%'))"
);
let rows: Vec<Row> = sqlx::query_as(&format!(
"SELECT p.id, p.code, p.package, p.note, p.created_at, p.redeemed_at, p.revoked_at, u.email, u.display_name \
{filter} ORDER BY p.created_at DESC, p.id DESC LIMIT $4 OFFSET $5"
))
.bind(&package)
.bind(&search)
.bind(&code_search)
.bind(limit)
.bind(offset)
.fetch_all(&state.db)
.await?;
let total: i64 = sqlx::query_scalar(&format!("SELECT count(*) {filter}"))
.bind(&package)
.bind(&search)
.bind(&code_search)
.fetch_one(&state.db)
.await?;
let codes: Vec<Value> = rows
.into_iter()
.map(|(id, code, package, note, created, redeemed, revoked, email, name)| {
json!({
"id": id,
"code": display(&code),
"package": package,
"package_name": packages::find(&package).map(|p| p.name),
"note": note,
"created_at": rfc3339(created),
"redeemed_at": rfc3339_opt(redeemed),
"revoked_at": rfc3339_opt(revoked),
"redeemed_by": email.map(|e| json!({ "email": e, "name": name })),
})
})
.collect();
Ok(Json(json!({ "codes": codes, "total": total, "status": status, "limit": limit, "offset": offset })))
}
/// Admin: withdraws an unused code.
pub async fn revoke(State(state): St, _admin: AdminUser, WithRejection(Path(id), _): IdPath) -> ApiResult<StatusCode> {
let result = sqlx::query(
"UPDATE promo_codes SET revoked_at = now() WHERE id = $1 AND redeemed_at IS NULL AND revoked_at IS NULL",
)
.bind(id)
.execute(&state.db)
.await?;
if result.rows_affected() == 0 {
return Err(ApiError::conflict("promo_not_open", "Csak fel nem használt kódot lehet visszavonni."));
}
Ok(StatusCode::NO_CONTENT)
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Redeem {
code: String,
}
/// Redeems a code: the user gets its package. One use per code.
pub async fn redeem(
State(state): St,
auth: AuthUser,
WithRejection(Json(req), _): Body<Redeem>,
) -> ApiResult<Json<Value>> {
let key = format!("promo:{}", auth.id());
state.login_limiter.check(&key)?;
let code = normalize(&req.code);
let mut tx = state.db.begin().await?;
let found: Option<(Uuid, String, Option<OffsetDateTime>, Option<OffsetDateTime>)> =
sqlx::query_as("SELECT id, package, redeemed_at, revoked_at FROM promo_codes WHERE code = $1 FOR UPDATE")
.bind(&code)
.fetch_optional(&mut *tx)
.await?;
let (id, package_id) = match found {
Some((id, package, None, None)) => (id, package),
Some((_, _, Some(_), _)) => {
state.login_limiter.failed(&key);
return Err(ApiError::conflict("promo_used", "Ezt a kódot már felhasználták."));
}
Some((_, _, _, Some(_))) => {
state.login_limiter.failed(&key);
return Err(ApiError::conflict("promo_revoked", "Ez a kód már nem érvényes."));
}
None => {
state.login_limiter.failed(&key);
return Err(ApiError::conflict("promo_unknown", "Nincs ilyen kód. Ellenőrizd, hogy pontosan írtad-e be."));
}
};
let package = packages::find(&package_id).ok_or(ApiError::NotFound("package"))?;
sqlx::query("SELECT id FROM users WHERE id = $1 FOR UPDATE").bind(auth.id()).execute(&mut *tx).await?;
let persons_left = crate::persons::slots(&mut tx, &auth, state.config.free_person_slots).await?.left();
let Some(added) = redeem_code(&mut tx, id, &code, package, auth.id(), persons_left).await? else {
return Err(ApiError::conflict(
"promo_nothing_to_add",
format!(
"Most is megvan minden, amit ez a kód adna ({}), ezért nem váltottuk be. Tedd el későbbre.",
package.name
),
));
};
tx.commit().await?;
state.login_limiter.succeeded(&key);
tracing::info!(user = %auth.id(), package = package.id, "promo code redeemed");
let mut body = holdings(&state, &auth).await?;
body["package"] = json!({ "id": package.id, "name": package.name });
body["added"] = added.iter().map(|(unit, n)| (unit.as_str().to_string(), json!(n))).collect();
Ok(Json(body))
}
+71 -3
View File
@@ -9,8 +9,10 @@
//! share page reports a visit from the visitor's browser
//! (`POST /v1/public/shares/{slug}/visit`): it is counted unless it comes
//! from a robot or from the sharer (logged in, or from the address the link
//! was made at). The sharer's first such visit earns one free natal analysis,
//! once per user.
//! was made at). The sharer's first such visit earns one free question, once
//! per user: a click proves little. A natal analysis is earned by bringing a
//! new user (`REFERRAL_REWARDS`): someone who signs up from a shared link and
//! makes their own chart, at most [`REFERRAL_LIMIT`] times.
use axum::Json;
use axum::extract::{Path, State};
@@ -332,7 +334,7 @@ pub async fn visit(
sqlx::query("UPDATE shares SET view_count = view_count + 1 WHERE id = $1").bind(share.id).execute(&mut *tx).await?;
let rewarded = sqlx::query(
"INSERT INTO credit_ledger (id, user_id, unit, delta, reason, note) \
VALUES ($1, $2, 'natal', 1, 'share_reward', $3) ON CONFLICT DO NOTHING",
VALUES ($1, $2, 'question', 1, 'share_reward', $3) ON CONFLICT DO NOTHING",
)
.bind(Uuid::now_v7())
.bind(share.owner_id)
@@ -348,6 +350,72 @@ pub async fn visit(
Ok(Json(json!({ "counted": true })))
}
/// Natal analyses a user can earn by bringing new users through shared links.
pub const REFERRAL_LIMIT: i64 = 3;
/// A new user came from a shared link (`slug`): remembered for the reward,
/// unless rewards are off, the link is unknown or revoked, or it is their own.
pub(super) async fn record_referral(
conn: &mut sqlx::PgConnection,
enabled: bool,
user_id: Uuid,
slug: Option<&str>,
) -> Result<(), sqlx::Error> {
let Some(slug) = slug.map(str::trim).filter(|s| enabled && !s.is_empty()) else {
return Ok(());
};
sqlx::query(
"INSERT INTO referrals (user_id, referrer_id, share_id) \
SELECT $1, owner_id, id FROM shares WHERE slug = $2 AND revoked_at IS NULL AND owner_id <> $1 \
ON CONFLICT DO NOTHING",
)
.bind(user_id)
.bind(slug)
.execute(conn)
.await?;
Ok(())
}
/// The new user made their own chart: the sharer who brought them gets a
/// natal analysis, while under the limit. Runs once per new user.
pub(super) async fn reward_referral(state: &crate::AppState, user_id: Uuid) -> Result<(), ApiError> {
if !state.config.referral_rewards {
return Ok(());
}
let mut tx = state.db.begin().await?;
let referrer: Option<Uuid> =
sqlx::query_scalar("SELECT referrer_id FROM referrals WHERE user_id = $1 AND rewarded_at IS NULL FOR UPDATE")
.bind(user_id)
.fetch_optional(&mut *tx)
.await?;
let Some(referrer) = referrer else { return Ok(()) };
sqlx::query("SELECT id FROM users WHERE id = $1 FOR UPDATE").bind(referrer).execute(&mut *tx).await?;
let earned = referral_rewards(&mut tx, referrer).await?;
if earned < REFERRAL_LIMIT {
sqlx::query(
"INSERT INTO credit_ledger (id, user_id, unit, delta, reason, note) \
VALUES ($1, $2, 'natal', 1, 'referral_reward', $3)",
)
.bind(Uuid::now_v7())
.bind(referrer)
.bind(format!("new user {user_id} from a shared link"))
.execute(&mut *tx)
.await?;
tracing::info!(referrer = %referrer, user = %user_id, "referral reward granted");
}
sqlx::query("UPDATE referrals SET rewarded_at = now() WHERE user_id = $1").bind(user_id).execute(&mut *tx).await?;
tx.commit().await?;
Ok(())
}
/// Natal analyses the user has earned by bringing new users.
pub async fn referral_rewards(conn: &mut sqlx::PgConnection, user_id: Uuid) -> Result<i64, sqlx::Error> {
sqlx::query_scalar("SELECT count(*) FROM credit_ledger WHERE user_id = $1 AND reason = 'referral_reward'")
.bind(user_id)
.fetch_one(conn)
.await
}
/// Whether the user has already received the reward for sharing.
pub async fn reward_granted(db: &PgPool, user_id: Uuid) -> Result<bool, sqlx::Error> {
sqlx::query_scalar("SELECT EXISTS (SELECT 1 FROM credit_ledger WHERE user_id = $1 AND reason = 'share_reward')")
+70 -9
View File
@@ -24,6 +24,8 @@ use crate::error::{ApiError, ApiResult};
use crate::views::{public_chart, rfc3339, rfc3339_opt, synastry_hash};
const INVITE_TTL: time::Duration = time::Duration::days(14);
/// Invitations a user may have us e-mail in a day (the rest go by link).
const EMAILED_PER_DAY: i64 = 10;
#[derive(Debug, Clone, sqlx::FromRow)]
pub struct SynastryRow {
@@ -238,6 +240,10 @@ pub struct CreateInvite {
/// Defaults to the user's primary chart.
chart_id: Option<Uuid>,
message: Option<String>,
/// Who it is for, as the inviter calls them (only the inviter sees it).
label: Option<String>,
/// Have us e-mail the invitation to this address.
email: Option<String>,
}
async fn chart_or_primary(db: &PgPool, chart_id: Option<Uuid>, user: Uuid) -> Result<ChartRow, ApiError> {
@@ -254,14 +260,61 @@ pub async fn create_invite(
auth: AuthUser,
WithRejection(Json(req), _): Body<CreateInvite>,
) -> ApiResult<(StatusCode, Json<Value>)> {
if !state.config.user_invites && !auth.user.has_role(db::Role::Admin) {
return Err(ApiError::conflict("invites_disabled", "A meghívás hamarosan indul."));
}
let chart = chart_or_primary(&state.db, req.chart_id, auth.id()).await?;
let message = req.message.map(|m| m.trim().chars().take(500).collect::<String>()).filter(|m| !m.is_empty());
// No links: the message may go out in an e-mail from our domain.
let message = super::invitations::clean_message(req.message)?;
let label = req.label.map(|l| l.trim().chars().take(80).collect::<String>()).filter(|l| !l.is_empty());
let email = match req.email.as_deref().map(str::trim).filter(|e| !e.is_empty()) {
Some(raw) => Some(super::auth::normalize_email(raw)?),
None => None,
};
let token = db::new_token();
let id = Uuid::now_v7();
let expires_at = OffsetDateTime::now_utc() + INVITE_TTL;
let url = format!("{}/meghivas/{token}", state.config.public_base_url);
let mut tx = state.db.begin().await?;
let mut emailed = false;
if let Some(to) = &email {
if *to == auth.user.email {
return Err(ApiError::BadRequest("Saját magadat nem hívhatod meg.".into()));
}
let today: i64 = sqlx::query_scalar(
"SELECT count(*) FROM synastry_invites WHERE inviter_id = $1 AND invitee_email IS NOT NULL \
AND created_at > now() - interval '1 day'",
)
.bind(auth.id())
.fetch_one(&mut *tx)
.await?;
if today >= EMAILED_PER_DAY {
return Err(ApiError::conflict(
"invite_mail_limit",
format!(
"Naponta legfeljebb {EMAILED_PER_DAY} meghívót küldünk ki levélben. A linket továbbra is elküldheted."
),
));
}
// Someone who asked for no more invitations gets none; the link still works.
if !super::invitations::opted_out(&mut tx, to).await? {
let (_, unsubscribe_url, unsubscribe_post_url) = super::invitations::links(&state, &token);
let payload = json!({
"url": url,
"inviter_name": auth.user.display_name,
"message": message,
"expires_on": expires_at.date().to_string(),
"unsubscribe_url": unsubscribe_url,
"unsubscribe_post_url": unsubscribe_post_url,
});
super::auth::queue_email_to(&mut tx, None, to, "synastry_invite", &auth.user.locale, payload).await?;
emailed = true;
}
}
sqlx::query(
"INSERT INTO synastry_invites (id, inviter_id, inviter_chart_id, token_hash, message, expires_at) \
VALUES ($1, $2, $3, $4, $5, $6)",
"INSERT INTO synastry_invites (id, inviter_id, inviter_chart_id, token_hash, message, expires_at, label, \
invitee_email) \
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)",
)
.bind(id)
.bind(auth.id())
@@ -269,16 +322,22 @@ pub async fn create_invite(
.bind(db::token_hash(&token))
.bind(&message)
.bind(expires_at)
.execute(&state.db)
.bind(&label)
.bind(&email)
.execute(&mut *tx)
.await?;
tx.commit().await?;
Ok((
StatusCode::CREATED,
Json(json!({
"id": id,
"token": token,
"url": format!("{}/invite/{token}", state.config.public_base_url),
"url": url,
"chart_id": chart.id,
"message": message,
"label": label,
"email": email,
"emailed": emailed,
"expires_at": rfc3339(expires_at),
})),
))
@@ -304,10 +363,12 @@ pub async fn list_invites(State(state): St, auth: AuthUser) -> ApiResult<Json<Va
Option<OffsetDateTime>,
Option<Uuid>,
Option<String>,
Option<String>,
Option<String>,
);
let rows: Vec<Row> = sqlx::query_as(
"SELECT i.id, i.inviter_chart_id, i.message, i.created_at, i.expires_at, i.accepted_at, i.synastry_id, \
u.display_name \
u.display_name, i.label, i.invitee_email \
FROM synastry_invites i LEFT JOIN users u ON u.id = i.accepted_by \
WHERE i.inviter_id = $1 ORDER BY i.created_at DESC",
)
@@ -316,9 +377,9 @@ pub async fn list_invites(State(state): St, auth: AuthUser) -> ApiResult<Json<Va
.await?;
let list: Vec<Value> = rows
.into_iter()
.map(|(id, chart_id, message, created, expires, accepted, synastry_id, accepted_by)| {
.map(|(id, chart_id, message, created, expires, accepted, synastry_id, accepted_by, label, email)| {
json!({
"id": id, "chart_id": chart_id, "message": message,
"id": id, "chart_id": chart_id, "message": message, "label": label, "email": email,
"status": invite_status(accepted, expires),
"created_at": rfc3339(created), "expires_at": rfc3339(expires),
"accepted_at": rfc3339_opt(accepted), "accepted_by": accepted_by, "synastry_id": synastry_id,
@@ -425,7 +486,7 @@ pub async fn accept_invite(
.fetch_optional(&mut *tx)
.await?;
if let Some(inviter) = inviter {
let url = format!("{}/synastry/{}", state.config.public_base_url, row.id);
let url = format!("{}/osszevetesek/{}", state.config.public_base_url, row.id);
super::auth::queue_email(
&mut tx,
&inviter,
+373 -5
View File
@@ -517,6 +517,67 @@ async fn invitation_links_two_users(pool: PgPool) {
assert!(app.outbox_url("anna@example.com", "invite_accepted").await.ends_with(&synastry_id));
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn a_person_can_be_invited_by_mail(pool: PgPool) {
let app = TestApp::new(pool.clone()).await;
let anna = app.register("anna@example.com", "Anna").await;
app.chart(&anna, "Saját", true, "1990-03-15").await;
// links are not allowed in the message (it may go out in our e-mail)
let r =
app.post("/v1/invites", Some(&anna), json!({"message": "nézd: www.x.hu", "email": "bela@example.com"})).await;
assert_eq!(r.status, StatusCode::BAD_REQUEST);
let r = app.post("/v1/invites", Some(&anna), json!({"email": "anna@example.com"})).await;
assert_eq!(r.status, StatusCode::BAD_REQUEST, "not herself");
let r = app
.post(
"/v1/invites",
Some(&anna),
json!({"label": "Béla", "email": " Bela@Example.com ", "message": "Nézzük meg, mennyire illünk!"}),
)
.await;
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
let token = r.body["token"].as_str().unwrap().to_string();
assert!(r.body["url"].as_str().unwrap().ends_with(&format!("/meghivas/{token}")));
assert_eq!((r.body["emailed"].as_bool(), r.body["email"].as_str()), (Some(true), Some("bela@example.com")));
let (template, payload): (String, Value) =
sqlx::query_as("SELECT template, payload FROM email_outbox WHERE to_email = 'bela@example.com'")
.fetch_one(&pool)
.await
.unwrap();
assert_eq!((template.as_str(), &payload["inviter_name"]), ("synastry_invite", &json!("Anna")));
let invites = app.get("/v1/invites", Some(&anna)).await.body;
assert_eq!(
(&invites["invites"][0]["label"], &invites["invites"][0]["status"]),
(&json!("Béla"), &json!("pending"))
);
// the address can opt out; the next invitation goes by link only
let r = app.post(&format!("/v1/public/invitations/unsubscribe?token={token}"), None, json!({})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
let r = app.post("/v1/invites", Some(&anna), json!({"email": "bela@example.com"})).await;
assert_eq!((r.status, r.body["emailed"].as_bool()), (StatusCode::CREATED, Some(false)));
// at most ten e-mailed a day
for i in 2..10 {
let r = app.post("/v1/invites", Some(&anna), json!({"email": format!("p{i}@example.com")})).await;
assert_eq!(r.status, StatusCode::CREATED);
}
let r = app.post("/v1/invites", Some(&anna), json!({"email": "p10@example.com"})).await;
assert_eq!(r.body["error"]["code"], "invite_mail_limit");
let r = app.post("/v1/invites", Some(&anna), json!({"label": "link only"})).await;
assert_eq!(r.status, StatusCode::CREATED, "a link is still fine");
// accepted: the inviter's mail leads to the comparison page
let bela = app.register("bela@example.com", "Béla").await;
app.chart(&bela, "Saját", true, "1976-09-03").await;
let r = app.post("/v1/invites/accept", Some(&bela), json!({"token": token})).await;
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
let url = app.outbox_url("anna@example.com", "invite_accepted").await;
assert!(url.ends_with(&format!("/osszevetesek/{}", r.body["id"].as_str().unwrap())), "{url}");
}
/// Gives `token`'s user analysis units (the admin endpoint is tested in `roles_and_admin_guard`).
async fn grant_units(app: &TestApp, token: &str, unit: &str, delta: i32) {
let id = app.get("/v1/me", Some(token)).await.body["user"]["id"].as_str().unwrap().to_string();
@@ -740,7 +801,7 @@ const PUBLIC_ROUTES: [&str; 15] = [
];
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn a_visit_by_someone_else_earns_one_analysis_once(pool: PgPool) {
async fn a_visit_by_someone_else_earns_one_question_once(pool: PgPool) {
let app = TestApp::new(pool).await;
let anna = app.register("anna@example.com", "Anna").await;
let chart = app.chart(&anna, "Saját", true, "1990-03-15").await;
@@ -751,7 +812,7 @@ async fn a_visit_by_someone_else_earns_one_analysis_once(pool: PgPool) {
let visit = format!("/v1/public/shares/{}/visit", r.body["slug"].as_str().unwrap());
let browser = ("user-agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) Mobile/15E148");
let me = || async { app.get("/v1/me", Some(&anna)).await.body };
let before = me().await["analyses_left"]["natal"].as_i64().unwrap();
let before = me().await["analyses_left"]["question"].as_i64().unwrap();
// robots, a missing user agent, the sharer's address and the sharer do not count
let elsewhere = ("x-forwarded-for", "198.51.100.1, 172.70.1.1");
@@ -765,7 +826,10 @@ async fn a_visit_by_someone_else_earns_one_analysis_once(pool: PgPool) {
assert_eq!((r.status, &r.body["counted"]), (StatusCode::OK, &json!(false)), "{headers:?}");
}
let body = me().await;
assert_eq!((body["analyses_left"]["natal"].as_i64(), &body["share_reward_granted"]), (Some(before), &json!(false)));
assert_eq!(
(body["analyses_left"]["question"].as_i64(), &body["share_reward_granted"]),
(Some(before), &json!(false))
);
// reading the share counts nothing either
app.get(&visit.replace("/visit", ""), None).await;
@@ -776,7 +840,7 @@ async fn a_visit_by_someone_else_earns_one_analysis_once(pool: PgPool) {
}
let body = me().await;
assert_eq!(
(body["analyses_left"]["natal"].as_i64(), &body["share_reward_granted"]),
(body["analyses_left"]["question"].as_i64(), &body["share_reward_granted"]),
(Some(before + 1), &json!(true))
);
let r = app.get("/v1/shares", Some(&anna)).await;
@@ -787,7 +851,7 @@ async fn a_visit_by_someone_else_earns_one_analysis_once(pool: PgPool) {
app.post("/v1/shares", Some(&anna), json!({"kind": "chart", "target_id": chart["id"], "title": "Új"})).await;
let other = format!("/v1/public/shares/{}/visit", r.body["slug"].as_str().unwrap());
app.call_with("POST", &other, None, None, &[browser, elsewhere]).await;
assert_eq!(me().await["analyses_left"]["natal"].as_i64(), Some(before + 1));
assert_eq!(me().await["analyses_left"]["question"].as_i64(), Some(before + 1));
}
#[sqlx::test(migrator = "db::MIGRATOR")]
@@ -1839,3 +1903,307 @@ async fn admins_read_the_error_log(pool: PgPool) {
assert_eq!(r.body["attempts"], 0);
assert!(r.body["next_attempt_at"].is_string());
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn promo_codes_are_made_by_admins_and_redeemed_once(pool: PgPool) {
let app = TestApp::new(pool).await;
let admin = app.register("admin@example.com", "Admin").await; // BOOTSTRAP_ADMIN_EMAILS
let anna = app.register("anna@example.com", "Anna").await;
let bela = app.register("bela@example.com", "Béla").await;
// only admins make codes
let r = app.post("/v1/admin/promo-codes", Some(&anna), json!({"package": "single", "count": 1})).await;
assert_eq!(r.status, StatusCode::FORBIDDEN);
let r = app.post("/v1/admin/promo-codes", Some(&admin), json!({"package": "nincs", "count": 1})).await;
assert_eq!(r.status, StatusCode::NOT_FOUND);
let r = app
.post("/v1/admin/promo-codes", Some(&admin), json!({"package": "single", "count": 3, "note": "meghívottak"}))
.await;
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
let codes: Vec<String> = r.body["codes"].as_array().unwrap().iter().map(|c| c.as_str().unwrap().into()).collect();
assert_eq!(codes.len(), 3);
assert!(codes.iter().all(|c| c.len() == 14 && c.matches('-').count() == 2), "{codes:?}");
// redeemed in any spelling: the package arrives
let before = app.get("/v1/me", Some(&anna)).await.body["analyses_left"]["natal"].as_i64().unwrap();
let typed = format!(" {} ", codes[0].replace('-', " ").to_lowercase());
let r = app.post("/v1/promo-codes/redeem", Some(&anna), json!({"code": typed})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
assert_eq!(r.body["package"]["id"], "single");
let me = app.get("/v1/me", Some(&anna)).await.body;
assert_eq!(me["analyses_left"]["natal"].as_i64(), Some(before + 1));
assert_eq!(me["package"]["id"], "single");
// once only, also for someone else
let r = app.post("/v1/promo-codes/redeem", Some(&bela), json!({"code": codes[0]})).await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("promo_used")));
// a withdrawn code and an unknown one do not work
let list = app.get("/v1/admin/promo-codes", Some(&admin)).await.body;
assert_eq!(list["total"], 2, "unused is the default filter: {list}");
let withdrawn = list["codes"].as_array().unwrap().iter().find(|c| c["code"] == codes[1].as_str()).unwrap().clone();
let r = app
.post(&format!("/v1/admin/promo-codes/{}/revoke", withdrawn["id"].as_str().unwrap()), Some(&admin), json!({}))
.await;
assert_eq!(r.status, StatusCode::NO_CONTENT);
let r = app.post("/v1/promo-codes/redeem", Some(&bela), json!({"code": codes[1]})).await;
assert_eq!(r.body["error"]["code"], "promo_revoked");
let r = app.post("/v1/promo-codes/redeem", Some(&bela), json!({"code": "AAAA-BBBB-CCCC"})).await;
assert_eq!(r.body["error"]["code"], "promo_unknown");
// the filters
let get = |q: &str| {
let uri = format!("/v1/admin/promo-codes?{q}");
let app = &app;
let admin = &admin;
async move { app.get(&uri, Some(admin)).await }
};
let used = get("status=used").await.body;
assert_eq!(
(used["total"].as_i64(), &used["codes"][0]["redeemed_by"]["email"]),
(Some(1), &json!("anna@example.com"))
);
assert_eq!(get("status=revoked").await.body["total"], 1);
assert_eq!(get("status=all").await.body["total"], 3);
assert_eq!(get("status=all&package=addon_questions").await.body["total"], 0);
assert_eq!(get("status=all&q=anna@").await.body["total"], 1);
assert_eq!(get("status=all&q=megh").await.body["total"], 3);
let part = codes[2].split('-').nth(1).unwrap().to_lowercase();
assert_eq!(get(&format!("status=unused&q={part}")).await.body["total"], 1);
// guessing is cut off
for _ in 0..10 {
app.post("/v1/promo-codes/redeem", Some(&bela), json!({"code": "ZZZZ-ZZZZ-ZZZZ"})).await;
}
let r = app.post("/v1/promo-codes/redeem", Some(&bela), json!({"code": codes[2]})).await;
assert_eq!(r.status, StatusCode::TOO_MANY_REQUESTS);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn an_invitation_brings_its_package_and_codes_fill_up(pool: PgPool) {
let app = TestApp::with_config(pool.clone(), |c| c.signup_mode = crate::config::SignupMode::Invite).await;
let admin = app.register("admin@example.com", "Admin").await;
let r = app
.post(
"/v1/admin/invitations",
Some(&admin),
json!({"emails": ["guest@example.com", "other@example.com"], "package": "couple"}),
)
.await;
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
let guest = &r.body["results"][0];
let guest_token = invite_token(guest["url"].as_str().unwrap());
let other_id = r.body["results"][1]["id"].as_str().unwrap().to_string();
// the e-mail shows the package and its code
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();
assert_eq!(payload["package_name"], "Páros");
assert_eq!(payload["promo_code"], guest["promo_code"]);
assert!(
payload["redeem_url"]
.as_str()
.unwrap()
.ends_with(&format!("/bevaltas?kod={}", guest["promo_code"].as_str().unwrap()))
);
let list = app.get("/v1/admin/invitations", Some(&admin)).await.body;
assert_eq!(list["invitations"][0]["package"]["name"], "Páros");
// revoking an invitation withdraws its code
let r = app.call("DELETE", &format!("/v1/admin/invitations/{other_id}"), Some(&admin), None).await;
assert_eq!(r.status, StatusCode::NO_CONTENT);
let codes = app.get("/v1/admin/promo-codes?status=revoked", Some(&admin)).await.body;
assert_eq!((codes["total"].as_i64(), &codes["codes"][0]["note"]), (Some(1), &json!("meghívó: other@example.com")));
// signing up redeems it by itself
let r = google_signup(&app, "g-guest", "guest@example.com", Some(&guest_token)).await;
assert!(r.status.is_success(), "{}", r.body);
let token = r.body["token"].as_str().map(str::to_string).unwrap_or_else(|| {
let cookie = r.headers.get("set-cookie").unwrap().to_str().unwrap();
cookie.split(';').next().unwrap().split('=').nth(1).unwrap().to_string()
});
let me = app.get("/v1/me", Some(&token)).await.body;
let left = &me["analyses_left"];
assert_eq!(
(left["natal"].as_i64(), left["synastry"].as_i64(), left["forecast"].as_i64()),
(Some(2), Some(1), Some(2)),
"{me}"
);
assert_eq!(me["package"]["id"], "couple");
let used = app.get("/v1/admin/promo-codes?status=used", Some(&admin)).await.body;
assert_eq!(used["codes"][0]["redeemed_by"]["email"], "guest@example.com");
// a code fills up: nothing to add while everything is there…
let r = app.post("/v1/admin/promo-codes", Some(&admin), json!({"package": "couple", "count": 1})).await;
let spare = r.body["codes"][0].as_str().unwrap().to_string();
let r = app.post("/v1/promo-codes/redeem", Some(&token), json!({"code": spare})).await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("promo_nothing_to_add")));
// …used units come back, extra ones stay
sqlx::query(
"INSERT INTO credit_ledger (id, user_id, unit, delta, reason) \
SELECT gen_random_uuid(), id, unit, delta, 'admin_adjust' FROM users, \
(VALUES ('natal', -2), ('forecast', 3)) AS v(unit, delta) WHERE email = 'guest@example.com'",
)
.execute(&pool)
.await
.unwrap();
let r = app.post("/v1/promo-codes/redeem", Some(&token), json!({"code": spare})).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
assert_eq!(r.body["added"], json!({"natal": 2}));
let left = &app.get("/v1/me", Some(&token)).await.body["analyses_left"];
assert_eq!(
(left["natal"].as_i64(), left["synastry"].as_i64(), left["forecast"].as_i64()),
(Some(2), Some(1), Some(5))
);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn the_waitlist_confirms_and_can_be_left(pool: PgPool) {
let app = TestApp::with_config(pool.clone(), |c| c.signup_mode = crate::config::SignupMode::Invite).await;
let admin = app.register("admin@example.com", "Admin").await;
let from = |ip: &'static str| [("x-forwarded-for", ip)];
// one confirmation per address, even when sent again
for _ in 0..2 {
let r = app
.call_with(
"POST",
"/v1/public/waitlist",
None,
Some(json!({"email": "Wait@Example.com"})),
&from("198.51.100.7"),
)
.await;
assert_eq!(r.status, StatusCode::ACCEPTED);
}
let mails: Vec<(Value,)> = sqlx::query_as(
"SELECT payload FROM email_outbox WHERE to_email = 'wait@example.com' AND template = 'waitlist_joined'",
)
.fetch_all(&pool)
.await
.unwrap();
assert_eq!(mails.len(), 1);
let leave = mails[0].0["unsubscribe_post_url"].as_str().unwrap().to_string();
let token = leave.rsplit("token=").next().unwrap().to_string();
// leaving: off the list, and no invitation can be sent there any more
let r = app.call("POST", &format!("/v1/public/invitations/unsubscribe?token={token}"), None, None).await;
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
assert!(app.get("/v1/admin/invitations", Some(&admin)).await.body["waitlist"].as_array().unwrap().is_empty());
let r = app.post("/v1/admin/invitations", Some(&admin), json!({"emails": ["wait@example.com"]})).await;
assert_eq!(r.body["results"][0]["status"], "opted_out");
// and signing up again sends nothing
app.call_with(
"POST",
"/v1/public/waitlist",
None,
Some(json!({"email": "wait@example.com"})),
&from("198.51.100.8"),
)
.await;
let count: i64 = sqlx::query_scalar("SELECT count(*) FROM email_outbox WHERE to_email = 'wait@example.com'")
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(count, 1);
// one address cannot flood the form
let mut last = StatusCode::OK;
for i in 0..12 {
let r = app
.call_with(
"POST",
"/v1/public/waitlist",
None,
Some(json!({"email": format!("w{i}@example.com")})),
&from("203.0.113.9"),
)
.await;
last = r.status;
}
assert_eq!(last, StatusCode::TOO_MANY_REQUESTS);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn user_invitations_wait_for_the_launch(pool: PgPool) {
let app = TestApp::with_config(pool, |c| c.user_invites = false).await;
assert_eq!(app.get("/v1/config", None).await.body["user_invites"], false);
let anna = app.register("anna@example.com", "Anna").await;
app.chart(&anna, "Saját", true, "1990-03-15").await;
let r = app.post("/v1/invites", Some(&anna), json!({"label": "Béla"})).await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("invites_disabled")));
// admins may, to try it
let admin = app.register("admin@example.com", "Admin").await;
app.chart(&admin, "Saját", true, "1980-01-01").await;
assert_eq!(app.post("/v1/invites", Some(&admin), json!({})).await.status, StatusCode::CREATED);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn a_new_user_from_a_shared_link_earns_an_analysis(pool: PgPool) {
let app = TestApp::new(pool.clone()).await;
let anna = app.register("anna@example.com", "Anna").await;
let chart = app.chart(&anna, "Saját", true, "1990-03-15").await;
let r = app.post("/v1/shares", Some(&anna), json!({"kind": "chart", "target_id": chart["id"]})).await;
let slug = r.body["slug"].as_str().unwrap().to_string();
let natal = |token: String| {
let app = &app;
async move { app.get("/v1/me", Some(&token)).await.body["analyses_left"]["natal"].as_i64().unwrap() }
};
let before = natal(anna.clone()).await;
let join = |email: String| {
let (app, slug) = (&app, slug.clone());
async move {
let r = app
.post(
"/v1/auth/register",
None,
json!({"email": email, "password": "titkos-jelszo-123", "referral": slug}),
)
.await;
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
r.body["token"].as_str().map(str::to_string).unwrap_or_else(|| {
let cookie = r.headers.get("set-cookie").unwrap().to_str().unwrap();
cookie.split(';').next().unwrap().split('=').nth(1).unwrap().to_string()
})
}
};
// signing up is not enough: the reward comes with their own chart
let bela = join("bela@example.com".into()).await;
assert_eq!(natal(anna.clone()).await, before);
app.chart(&bela, "Saját", true, "1985-08-02").await;
assert_eq!(natal(anna.clone()).await, before + 1);
// a second chart of theirs changes nothing
app.chart(&bela, "Másik", false, "1970-01-01").await;
assert_eq!(natal(anna.clone()).await, before + 1);
// at most three
for i in 0..3 {
let t = join(format!("p{i}@example.com")).await;
app.chart(&t, "Saját", true, "1980-05-05").await;
}
assert_eq!(natal(anna.clone()).await, before + 3);
let me = app.get("/v1/me", Some(&anna)).await.body;
assert_eq!(me["referral_rewards"], json!({"earned": 3, "limit": 3}));
// nothing while the rewards are off
let off = TestApp::with_config(pool, |c| c.referral_rewards = false).await;
let r = off
.post(
"/v1/auth/register",
None,
json!({"email": "late@example.com", "password": "titkos-jelszo-123", "referral": slug}),
)
.await;
assert_eq!(r.status, StatusCode::CREATED);
let count: i64 = sqlx::query_scalar(
"SELECT count(*) FROM referrals r JOIN users u ON u.id = r.user_id WHERE u.email = 'late@example.com'",
)
.fetch_one(&off.pool)
.await
.unwrap();
assert_eq!(count, 0);
}
+417
View File
@@ -0,0 +1,417 @@
import Link from "next/link";
import { ChartWheel } from "@/components/ChartWheel";
import { Rich } from "@/components/Rich";
import { Logo } from "@/components/SiteHeader";
import { Waitlist } from "@/components/Waitlist";
import example from "@/content/pelda.json";
import type { AnalysisContent, ChartResult } from "@/lib/types";
// A quiet starfield, the same on every render.
const STARS = (() => {
let seed = 7;
const rnd = () => {
seed = (seed * 9301 + 49297) % 233280;
return seed / 233280;
};
return Array.from({ length: 70 }, (_, i) => ({
x: (rnd() * 1000).toFixed(1),
y: (rnd() * 600).toFixed(1),
r: (0.6 + rnd() * 1.4).toFixed(1),
t: i % 5,
}));
})();
const MONTHS = ["márc", "ápr", "máj", "jún", "júl", "aug", "szept", "okt", "nov", "dec", "jan", "febr"];
/** Points of a ring of the comparison picture. */
function ring(r: number, degrees: number[]) {
return degrees.map((d) => {
const a = (d * Math.PI) / 180;
return { x: 110 + r * Math.cos(a), y: 110 - r * Math.sin(a) };
});
}
const YOU = ring(72, [15, 70, 128, 190, 236, 300, 338]);
const THEM = ring(100, [40, 95, 150, 205, 262, 318, 355]);
const LINKS: [number, number, string][] = [
[0, 0, "var(--harmonic)"],
[2, 4, "var(--tense)"],
[4, 5, "var(--harmonic)"],
[5, 2, "var(--gold)"],
];
// Sample lines of a forecast timeline (illustration, marked as such).
const EVENTS = [
{ date: "ápr. 9.", glyph: "♃\uFE0E", tone: "harmonic", text: "Jupiter trigon Nap: kinyíló lehetőségek" },
{ date: "júl. 22.", glyph: "♄\uFE0E", tone: "tense", text: "Szaturnusz kvadrát Hold: érzelmi számvetés" },
{ date: "okt. 14.", glyph: "☉\uFE0E", tone: "neutral", text: "Napfogyatkozás a 10. házban: hivatás" },
];
const CHAPTERS = ["Személyiség", "Érzelmek", "Gondolkodás", "Szerelem", "Hivatás", "Fejlődés"];
const SYNASTRY_TOPICS = ["Vonzás", "Kommunikáció", "Érzelmi kötődés", "Súrlódások", "Hosszú táv"];
/** The home page for visitors: what the site does, shown on the example chart. */
export function Landing({ inviteOnly }: { inviteOnly: boolean }) {
const chart = example.chart as unknown as ChartResult;
const analysis = example.analysis as AnalysisContent;
const sections = ["emotions", "love"].map((k) => analysis.sections?.[k]).filter((s) => s !== undefined);
const lead = (analysis.summary ?? "").split(/(?<=\.)\s/)[0];
const signIn = inviteOnly ? "Belépés meghívóval" : "Elkészítem a képletem";
return (
<div className="lp">
<header className="site-header lp-header">
<Logo />
<nav className="nav lp-nav" aria-label="Fő navigáció">
<a href="#elemzes">Elemzés</a>
<a href="#elorejelzes">Előrejelzés</a>
<a href="#osszevetes">Összevetés</a>
<Link href="/pelda">Példa</Link>
</nav>
<Link href="/belepes" className="btn btn-sm">
Belépés
</Link>
</header>
<section className="lp-hero">
<svg className="lp-stars" aria-hidden="true" viewBox="0 0 1000 600" preserveAspectRatio="xMidYMid slice">
{STARS.map((s, i) => (
<circle key={i} cx={s.x} cy={s.y} r={s.r} className={`lp-star lp-t${s.t}`} />
))}
</svg>
<div className="lp-wrap lp-hero-grid">
<div className="lp-hero-text">
<span className="eyebrow lp-rise lp-r1">Születési képlet · Éves előrejelzés · Kapcsolat</span>
<h1 className="lp-title lp-rise lp-r2">
Ahol a csillagok
<br />
összekötnek.
</h1>
<p className="lp-lead lp-rise lp-r3">
Add meg, mikor és hol születtél: percre pontosan kiszámoljuk a képletedet, és személyre szóló elemzést írunk
belőle. Megmutatjuk, mit hoz az éved, és mennyire illetek össze azzal, akit szeretsz.
</p>
<div className="lp-actions lp-rise lp-r4">
<Link href="/belepes" className="btn btn-primary lp-btn">
{signIn}
</Link>
<Link href="/pelda" className="btn lp-btn">
Példaelemzés
</Link>
</div>
<p className="hint lp-rise lp-r4">
{inviteOnly ? (
<>
Az oldal egyelőre meghívásos: meghívóval, Google-fiókkal lépsz be. Ha még nincs meghívód,{" "}
<a href="#varolista">iratkozz fel a várólistára</a>.
</>
) : (
"A képlet és a rövid összefoglaló ingyenes. Google-fiókkal lépsz be."
)}
</p>
</div>
<figure className="lp-figure">
<div className="lp-wheel">
<svg className="lp-orbit" aria-hidden="true" viewBox="0 0 680 680">
<circle cx="340" cy="340" r="334" />
<circle cx="340" cy="6" r="3" className="lp-orbit-dot" />
<circle cx="674" cy="340" r="2" className="lp-orbit-dot" />
<circle cx="104" cy="576" r="2.4" className="lp-orbit-dot" />
</svg>
<ChartWheel chart={chart} timeKnown title="Példa születési képlet" />
</div>
<figcaption className="lp-caption">
<span className="share-trio">
<span>
<span className="sym">☉︎</span> Nap Halak
</span>
<span>
<span className="sym">☽︎</span> Hold Skorpió
</span>
<span>
<span className="lp-asc">ASC</span> Oroszlán
</span>
</span>
<span className="hint">Példa: egy kitalált képlet · {example.birth}</span>
</figcaption>
</figure>
</div>
</section>
<section className="lp-band lp-alt">
<div className="lp-wrap lp-two">
<div className="lp-intro">
<span className="eyebrow">Első lépés</span>
<h2 className="lp-h2">Pár mondat, ami rólad szól</h2>
<p className="lp-text">
A képleted mellé rögtön kapsz egy rövid összefoglalót: mi adja a képleted gerincét, hol feszül, és miben vagy
igazán erős. Ingyen, a belépés után azonnal.
</p>
</div>
<article className="card summary-card lp-float">
<span className="eyebrow">Röviden · ingyenes</span>
<h3 className="summary-title">{example.summary.title}</h3>
<p className="summary-text">
<Rich text={example.summary.summary} />
</p>
</article>
</div>
</section>
<section id="elemzes" className="lp-band">
<div className="lp-wrap lp-stack">
<div className="lp-intro">
<span className="eyebrow">Részletes elemzés</span>
<h2 className="lp-h2">Ha mélyebbre mennél</h2>
<p className="lp-text">
Hat fejezet a személyiségedről, az érzelmeidről, a gondolkodásodról, a szerelemről, a hivatásodról és a
fejlődésed irányáról. A végén erősségek, kihívások és útravaló, és ha kérdésed van, rá is kérdezhetsz.
</p>
</div>
<div className="lp-analysis-grid">
<article className="card lp-paper">
<header className="analysis-head">
<h3 className="lp-paper-title">{analysis.title}</h3>
<p className="analysis-lead">{lead}</p>
</header>
<div className="lp-excerpts">
{sections.map((s) => (
<section key={s.title} className="analysis-section lp-fade">
<h4 className="lp-excerpt-title">{s.title}</h4>
<p className="summary-text">
<Rich text={s.body.split(/\n\s*\n/)[0]} />
</p>
</section>
))}
</div>
<div className="lp-paper-foot">
<span className="hint">Részlet egy kitalált képlet teljes elemzéséből</span>
<Link href="/pelda">Elolvasom a teljes példaelemzést →</Link>
</div>
</article>
<aside className="lp-aside">
<div className="card lp-side-card">
<h3 className="lp-h3">Erősségek</h3>
<ul className="lp-list">
{(analysis.strengths ?? []).slice(0, 2).map((t) => (
<li key={t}>
<Rich text={t} />
</li>
))}
</ul>
</div>
<div className="card lp-side-card">
<h3 className="lp-h3">Kérdezz rá</h3>
<p className="lp-small">
Ami nem világos, vagy amire kíváncsi vagy, megkérdezheted: a válasz a képletedből és az elemzésedből
születik.
</p>
<p className="lp-question">„Mit jelent nekem a Hold–Vénusz kvadrát a párkapcsolatban?”</p>
</div>
</aside>
</div>
<div className="lp-chips">
{CHAPTERS.map((c) => (
<span key={c} className="lp-chip">
{c}
</span>
))}
<span className="lp-chip lp-chip-gold">Útravaló</span>
</div>
</div>
</section>
<section className="lp-band lp-alt">
<div className="lp-wrap lp-stack">
<div className="lp-intro">
<span className="eyebrow">Nemcsak a képleted</span>
<h2 className="lp-h2">Mit hoz az éved, és kivel illetek össze?</h2>
</div>
<div className="lp-features">
<article id="elorejelzes" className="card lp-feature">
<div className="lp-feature-head">
<span className="eyebrow">Éves előrejelzés</span>
<h3 className="lp-feature-title">Egy év, hónapról hónapra</h3>
<p className="lp-text">
Szolár képlet, tranzitok pontos dátumokkal és progresszió: születésnaptól születésnapig, hogy tudd, mikor
mire érdemes figyelni.
</p>
</div>
<div className="lp-panel">
<svg aria-hidden="true" viewBox="0 0 440 70" className="lp-timeline">
<line x1="10" y1="40" x2="430" y2="40" className="lp-tl-track" />
<line x1="10" y1="40" x2="150" y2="40" className="lp-tl-done" />
{MONTHS.map((m, i) => {
const x = 10 + (i * 420) / 11;
return (
<g key={m}>
<line x1={x} y1="34" x2={x} y2="46" className="lp-tl-track" />
<text x={x} y="64" className="lp-tl-month">
{m}
</text>
</g>
);
})}
<circle cx="88" cy="40" r="6" fill="var(--harmonic)" />
<circle cx="228" cy="40" r="6" fill="var(--square)" />
<circle cx="340" cy="40" r="6" fill="var(--gold)" />
<circle cx="150" cy="40" r="5" fill="var(--gold)" className="lp-pulse" />
<circle cx="150" cy="40" r="3.5" fill="var(--ink)" />
<text x="150" y="20" className="lp-tl-now">
most
</text>
</svg>
<ol className="lp-events">
{EVENTS.map((e) => (
<li key={e.date} className={`timeline-item tone-${e.tone}`}>
<span className="timeline-date">{e.date}</span>
<span className="timeline-glyph sym" aria-hidden="true">
{e.glyph}
</span>
<span className="timeline-text">{e.text}</span>
</li>
))}
</ol>
<span className="hint">Minta az idővonalból</span>
</div>
</article>
<article id="osszevetes" className="card lp-feature">
<div className="lp-feature-head">
<span className="eyebrow">Kapcsolati összevetés</span>
<h3 className="lp-feature-title">Mennyire illetek össze?</h3>
<p className="lp-text">
Két képlet egymásra vetítve. Hívd meg, akit szeretsz: ő megadja a saját adatait, és együtt nézitek meg,
hol erős és hol kényes a kapcsolatotok.
</p>
</div>
<div className="lp-panel lp-pair">
<svg aria-hidden="true" viewBox="0 0 220 220" className="lp-rings">
<circle cx="110" cy="110" r="100" className="lp-ring" />
<circle cx="110" cy="110" r="72" className="lp-ring" />
<circle cx="110" cy="110" r="44" className="lp-ring lp-ring-core" />
<g className="lp-spin-back">
{THEM.map((p, i) => (
<circle key={i} cx={p.x} cy={p.y} r="5" fill="var(--p2)" />
))}
</g>
<g className="lp-spin">
{YOU.map((p, i) => (
<circle key={i} cx={p.x} cy={p.y} r="5" fill="var(--ink)" />
))}
</g>
{LINKS.map(([a, b, color]) => (
<line
key={`${a}-${b}`}
x1={YOU[a].x}
y1={YOU[a].y}
x2={THEM[b].x}
y2={THEM[b].y}
stroke={color}
strokeWidth="1.4"
strokeOpacity="0.75"
/>
))}
</svg>
<div className="lp-pair-legend">
<span className="pair-text-row">
<span className="legend-dot legend-p1" /> Te
</span>
<span className="pair-text-row p2-text">
<span className="legend-dot legend-p2" /> Ő
</span>
<span className="nature-bar" aria-hidden="true">
<span className="nature-seg nature-harmonious" style={{ flexGrow: 5 }} />
<span className="nature-seg nature-challenging" style={{ flexGrow: 3 }} />
<span className="nature-seg nature-neutral" style={{ flexGrow: 2 }} />
</span>
<span className="hint">harmonikus · feszült · semleges fényszögek</span>
</div>
</div>
<div className="lp-chips">
{SYNASTRY_TOPICS.map((c) => (
<span key={c} className="lp-chip">
{c}
</span>
))}
</div>
</article>
</div>
</div>
</section>
<section className="lp-band">
<div className="lp-wrap lp-stack">
<h2 className="lp-h2 lp-center">Így működik</h2>
<ol className="lp-steps">
<li className="card">
<span className="lp-step-n">1</span>
<h3 className="lp-step-title">Belépsz, és megadod az adataidat</h3>
<p className="lp-small">
{inviteOnly ? "Meghívóval, Google-fiókkal lépsz be" : "Google-fiókkal lépsz be"}, aztán megadod a születésed
dátumát, idejét és helyét. Ha az időpontot nem tudod, akkor is kiszámoljuk, ami kiszámolható.
</p>
</li>
<li className="card">
<span className="lp-step-n">2</span>
<h3 className="lp-step-title">Kész a képleted, ingyen</h3>
<p className="lp-small">
Megrajzolt radix, bolygóállások, házak, fényszögek és egy rövid, személyre szóló összefoglaló.
</p>
</li>
<li className="card">
<span className="lp-step-n">3</span>
<h3 className="lp-step-title">Ha többet szeretnél</h3>
<p className="lp-small">
Részletes elemzés, éves előrejelzés, kapcsolati összevetés, és kérdések, amikre a saját képleted felel.
</p>
</li>
</ol>
</div>
</section>
<section id="varolista" className="lp-band lp-final">
<div className="lp-wrap lp-final-inner">
<svg aria-hidden="true" viewBox="0 0 120 120" className="lp-spin lp-emblem">
<circle cx="60" cy="60" r="54" className="lp-emblem-outer" />
<circle cx="60" cy="60" r="40" className="lp-ring" />
<circle cx="60" cy="6" r="4" fill="var(--gold)" />
<circle cx="100" cy="88" r="3" fill="var(--ink)" />
<circle cx="24" cy="92" r="2.5" fill="var(--p2)" />
</svg>
<h2 className="lp-h2">Kíváncsi vagy, mit mutat a te képleted?</h2>
<p className="lp-text">
{inviteOnly
? "Egyelőre meghívással lehet csatlakozni. Ha kaptál meghívót, lépj be a Google-fiókoddal. Ha még nem, írd fel magad, és szólunk."
: "Két perc, és ott a képleted a rövid összefoglalóval együtt."}
</p>
<Link href="/belepes" className="btn btn-primary lp-btn lp-btn-big">
{signIn}
</Link>
{inviteOnly && (
<div className="lp-waitlist">
<Waitlist />
</div>
)}
<p className="hint lp-disclaimer">
Az elemzéseket mesterséges intelligencia írja a pontosan kiszámolt képlet alapján. Tájékoztató jellegűek, nem
helyettesítenek szakmai tanácsot.
</p>
</div>
</section>
<footer className="lp-footer">
<div className="lp-wrap lp-footer-inner">
<Logo />
<nav aria-label="Lábléc" className="lp-footer-nav">
<Link href="/pelda">Példaelemzés</Link>
<Link href="/adatvedelem">Adatvédelem</Link>
<Link href="/belepes">Belépés</Link>
</nav>
<span className="hint">© {new Date().getFullYear()} Sorsfonalak</span>
</div>
</footer>
</div>
);
}
@@ -2,6 +2,7 @@
import { useCallback, useEffect, useState } from "react";
import { usePackages } from "@/components/PackageCards";
import { api, errorText } from "@/lib/api";
import { formatDate } from "@/lib/astro";
import type { AdminInvitation, InvitationResult, WaitlistEntry } from "@/lib/types";
@@ -104,6 +105,8 @@ function InviteForm({ onSent }: { onSent: () => Promise<void> }) {
const [emails, setEmails] = useState("");
const [message, setMessage] = useState("");
const [locale, setLocale] = useState("hu");
const [pkg, setPkg] = useState("");
const packages = usePackages();
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
const [results, setResults] = useState<InvitationResult[] | null>(null);
@@ -116,7 +119,7 @@ function InviteForm({ onSent }: { onSent: () => Promise<void> }) {
setResults(null);
try {
const res = await api<{ results: InvitationResult[] }>("/admin/invitations", {
body: { emails: parseEmails(emails), message: message.trim() || null, locale },
body: { emails: parseEmails(emails), message: message.trim() || null, locale, package: pkg || null },
});
setResults(res.results);
if (res.results.some((r) => r.status === "invited")) setEmails("");
@@ -163,6 +166,17 @@ function InviteForm({ onSent }: { onSent: () => Promise<void> }) {
</span>
</div>
<div className="row" style={{ gap: 12, alignItems: "flex-end", flexWrap: "wrap" }}>
<div className="field" style={{ minWidth: 220 }}>
<label htmlFor="invite-package">Ajándék csomag</label>
<select id="invite-package" className="inp" value={pkg} onChange={(e) => setPkg(e.target.value)}>
<option value="">nincs</option>
{(packages ?? []).map((p) => (
<option key={p.id} value={p.id}>
{p.name}
</option>
))}
</select>
</div>
<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)}>
@@ -175,6 +189,12 @@ function InviteForm({ onSent }: { onSent: () => Promise<void> }) {
</button>
</div>
</form>
{pkg && (
<p className="hint" style={{ margin: 0 }}>
Minden meghívott kap egy promókódot erre a csomagra. A levélben benne lesz, és a regisztrációkor magától
beváltódik. A meghívó visszavonása a kódot is visszavonja.
</p>
)}
{error && (
<p className="msg msg-error" role="alert">
{error}
@@ -187,18 +207,19 @@ function InviteForm({ onSent }: { onSent: () => Promise<void> }) {
<span className={r.status === "invited" ? "msg-ok" : "muted"}>
{r.email}: {RESULT[r.status]}
</span>
{r.promo_code && <code className="promo-code">{r.promo_code}</code>}
{r.url && <CopyLink url={r.url} />}
</li>
))}
</ul>
)}
<MailPreview message={message} locale={locale} />
<MailPreview message={message} locale={locale} pkg={pkg} />
</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 }) {
function MailPreview({ message, locale, pkg }: { message: string; locale: string; pkg: 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);
@@ -210,7 +231,7 @@ function MailPreview({ message, locale }: { message: string; locale: string }) {
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 } },
{ body: { message: message.trim() || null, locale, send_to_me: sendToMe, package: pkg || null } },
);
setMail(res);
if (res.sent_to) setNote({ ok: true, text: `Tesztlevél a sorban: ${res.sent_to}. A linkjei nem működnek.` });
@@ -337,6 +358,12 @@ function InvitationRow({ invitation: i, onChange }: { invitation: AdminInvitatio
<td>
<span className={`badge invite-${i.status}`}>{STATUS[i.status]}</span>
{i.accepted_by && <div className="hint">{i.accepted_by}</div>}
{i.package && (
<div className="hint" title={i.package.code ?? undefined}>
Ajándék: {i.package.name ?? i.package.id}
{i.package.redeemed_at ? " (beváltva)" : ""}
</div>
)}
</td>
<td>
<span className={i.mail === "failed" ? "msg-error" : i.mail === "queued" ? "muted" : undefined}>
@@ -376,13 +403,15 @@ function InvitationRow({ invitation: i, onChange }: { invitation: AdminInvitatio
function WaitlistTable({ waitlist, onChange }: { waitlist: WaitlistEntry[]; onChange: () => Promise<void> }) {
const [busy, setBusy] = useState<string | null>(null);
const [note, setNote] = useState<string | null>(null);
const [pkg, setPkg] = useState("");
const packages = usePackages();
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 },
body: { emails: [w.email], locale: w.locale, package: pkg || null },
});
const r = res.results[0];
if (r && r.status !== "invited") setNote(`${r.email}: ${RESULT[r.status]}`);
@@ -413,6 +442,20 @@ function WaitlistTable({ waitlist, onChange }: { waitlist: WaitlistEntry[]; onCh
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>
{waitlist.some((w) => w.invitation === null) && (
<div className="field" style={{ maxWidth: 320 }}>
<label htmlFor="waitlist-package">Ajándék csomag a meghívottaknak</label>
<select id="waitlist-package" className="inp" value={pkg} onChange={(e) => setPkg(e.target.value)}>
<option value="">nincs</option>
{(packages ?? []).map((p) => (
<option key={p.id} value={p.id}>
{p.name}
</option>
))}
</select>
<span className="hint">A „Meghívás” gomb ezzel a csomaggal küldi a meghívót; a regisztrációkor magától jóváíródik.</span>
</div>
)}
{note && (
<p className="msg msg-error" role="alert">
{note}
@@ -0,0 +1,285 @@
"use client";
import { useCallback, useEffect, useState } from "react";
import { api, errorText } from "@/lib/api";
import { formatDate } from "@/lib/astro";
import type { Package, PromoCode } from "@/lib/types";
const PAGE = 100;
const STATUSES: Record<string, string> = {
unused: "fel nem használt",
used: "beváltott",
revoked: "visszavont",
all: "mind",
};
interface Page {
codes: PromoCode[];
total: number;
}
/** Making promo codes and the filtered list of them. */
export function PromoCodes({ packages }: { packages: Package[] }) {
return (
<>
<NewCodes packages={packages} />
<CodeList packages={packages} />
</>
);
}
function NewCodes({ packages }: { packages: Package[] }) {
const [pkg, setPkg] = useState(packages.find((p) => p.id === "single")?.id ?? packages[0]?.id ?? "");
const [count, setCount] = useState(1);
const [note, setNote] = useState("");
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
const [made, setMade] = useState<{ codes: string[]; package: string } | null>(null);
const [copied, setCopied] = useState(false);
async function create(e: React.FormEvent) {
e.preventDefault();
setBusy(true);
setError(null);
try {
const r = await api<{ codes: string[]; package: string }>("/admin/promo-codes", {
body: { package: pkg, count, note: note || null },
});
setMade(r);
setCopied(false);
window.dispatchEvent(new Event("promo-codes-changed"));
} catch (err) {
setError(errorText(err));
} finally {
setBusy(false);
}
}
async function copy() {
if (!made) return;
await navigator.clipboard.writeText(made.codes.join("\n"));
setCopied(true);
}
return (
<section className="card" aria-labelledby="new-codes" style={{ gap: 14 }}>
<h2 id="new-codes">Új kódok</h2>
<form className="promo-form" onSubmit={create}>
<div className="field">
<label htmlFor="promo-package">Csomag</label>
<select id="promo-package" className="inp" value={pkg} onChange={(e) => setPkg(e.target.value)}>
{packages.map((p) => (
<option key={p.id} value={p.id}>
{p.name} ({p.tier === "main" ? "csomag" : "kiegészítő"})
</option>
))}
</select>
</div>
<div className="field">
<label htmlFor="promo-count">Darab</label>
<input
id="promo-count"
className="inp"
type="number"
min={1}
max={500}
value={count}
onChange={(e) => setCount(Math.max(1, Math.min(500, Number(e.target.value) || 1)))}
/>
</div>
<div className="field promo-note">
<label htmlFor="promo-note">Megjegyzés (kinek, melyik kampány)</label>
<input
id="promo-note"
className="inp"
value={note}
maxLength={200}
onChange={(e) => setNote(e.target.value)}
placeholder="pl. meghívottak, első kör"
/>
</div>
<button type="submit" className="btn btn-primary" disabled={busy || !pkg}>
{busy ? "Készül…" : "Kódok készítése"}
</button>
</form>
{error && (
<p className="msg msg-error" role="alert">
{error}
</p>
)}
{made && (
<div className="promo-made">
<p className="msg msg-ok" role="status">
{made.codes.length} új kód: {packages.find((p) => p.id === made.package)?.name ?? made.package}
</p>
<textarea className="inp promo-codes" readOnly rows={Math.min(made.codes.length, 10)} value={made.codes.join("\n")} />
<button type="button" className="btn btn-sm" onClick={copy}>
{copied ? "Kimásolva" : "Mind másolása"}
</button>
</div>
)}
</section>
);
}
function CodeList({ packages }: { packages: Package[] }) {
const [status, setStatus] = useState("unused");
const [pkg, setPkg] = useState("");
const [q, setQ] = useState("");
const [query, setQuery] = useState("");
const [codes, setCodes] = useState<PromoCode[] | null>(null);
const [total, setTotal] = useState(0);
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
const load = useCallback(
async (offset: number) => {
setBusy(true);
setError(null);
const params = new URLSearchParams({ status, limit: String(PAGE), offset: String(offset) });
if (pkg) params.set("package", pkg);
if (query) params.set("q", query);
try {
const page = await api<Page>(`/admin/promo-codes?${params}`);
setCodes((all) => (offset === 0 ? page.codes : [...(all ?? []), ...page.codes]));
setTotal(page.total);
} catch (e) {
setError(errorText(e));
} finally {
setBusy(false);
}
},
[status, pkg, query],
);
useEffect(() => {
load(0);
const reload = () => load(0);
window.addEventListener("promo-codes-changed", reload);
return () => window.removeEventListener("promo-codes-changed", reload);
}, [load]);
// Searching after a short pause in typing.
useEffect(() => {
const t = setTimeout(() => setQuery(q.trim()), 300);
return () => clearTimeout(t);
}, [q]);
async function revoke(c: PromoCode) {
if (!window.confirm(`Visszavonod a(z) ${c.code} kódot? Utána nem váltható be.`)) return;
try {
await api(`/admin/promo-codes/${c.id}/revoke`, { body: {} });
load(0);
} catch (e) {
setError(errorText(e));
}
}
return (
<section className="card" aria-labelledby="code-list" style={{ gap: 12 }}>
<h2 id="code-list">Kódok</h2>
<div className="row" style={{ gap: 12, alignItems: "flex-end" }}>
<div className="field">
<label htmlFor="code-status">Állapot</label>
<select id="code-status" className="inp" value={status} onChange={(e) => setStatus(e.target.value)}>
{Object.entries(STATUSES).map(([v, l]) => (
<option key={v} value={v}>
{l}
</option>
))}
</select>
</div>
<div className="field">
<label htmlFor="code-package">Csomag</label>
<select id="code-package" className="inp" value={pkg} onChange={(e) => setPkg(e.target.value)}>
<option value="">mind</option>
{packages.map((p) => (
<option key={p.id} value={p.id}>
{p.name}
</option>
))}
</select>
</div>
<div className="field" style={{ flex: "1 1 220px" }}>
<label htmlFor="code-search">Keresés</label>
<input
id="code-search"
className="inp"
type="search"
value={q}
onChange={(e) => setQ(e.target.value)}
placeholder="kód, megjegyzés vagy e-mail"
/>
</div>
<p className="hint" style={{ margin: 0 }}>
{total} kód
</p>
</div>
{error && (
<p className="msg msg-error" role="alert">
{error}
</p>
)}
{codes === null ? (
<p className="muted">Betöltés…</p>
) : codes.length === 0 ? (
<p className="muted">Nincs ilyen kód.</p>
) : (
<div className="table-wrap">
<table className="promo-table">
<thead>
<tr>
<th>Kód</th>
<th>Csomag</th>
<th>Megjegyzés</th>
<th>Készült</th>
<th>Állapot</th>
<th />
</tr>
</thead>
<tbody>
{codes.map((c) => (
<tr key={c.id}>
<td>
<code className="promo-code">{c.code}</code>
</td>
<td>{c.package_name ?? c.package}</td>
<td>{c.note ?? <span className="muted">–</span>}</td>
<td className="num">{formatDate(c.created_at)}</td>
<td>
{c.redeemed_at ? (
<>
beváltva {formatDate(c.redeemed_at, true)}
{c.redeemed_by && (
<span className="hint">{c.redeemed_by.name ? `${c.redeemed_by.name} · ` : ""}{c.redeemed_by.email}</span>
)}
</>
) : c.revoked_at ? (
<span className="muted">visszavonva {formatDate(c.revoked_at)}</span>
) : (
<span className="promo-open">szabad</span>
)}
</td>
<td>
{!c.redeemed_at && !c.revoked_at && (
<button type="button" className="btn btn-sm btn-ghost" onClick={() => revoke(c)}>
Visszavonás
</button>
)}
</td>
</tr>
))}
</tbody>
</table>
</div>
)}
{codes && codes.length < total && (
<button type="button" className="btn btn-sm" onClick={() => load(codes.length)} disabled={busy}>
{busy ? "Betöltés…" : "Továbbiak"}
</button>
)}
</section>
);
}
@@ -0,0 +1,29 @@
import type { Metadata } from "next";
import { notFound } from "next/navigation";
import { AdminNav } from "@/components/AdminNav";
import { backendGet, requireMe } from "@/lib/server";
import type { Package } from "@/lib/types";
import { PromoCodes } from "./PromoCodes";
export const metadata: Metadata = { title: "Promókódok" };
export default async function AdminPromoPage() {
const me = await requireMe("/admin/promokodok");
if (!me.user.roles.includes("admin")) notFound();
const catalog = await backendGet<{ packages: Package[] }>("/v1/packages");
return (
<main className="page" style={{ maxWidth: 1180 }}>
<AdminNav current="/admin/promokodok" />
<div className="page-head">
<h1>Promókódok</h1>
<p className="muted">
Egy kód egy csomagot ad, és egyszer váltható be a „Kód beváltása” oldalon (a fejlécben). A beváltó link:
sorsfonalak.hu/bevaltas?kod=KÓD — ezt elég elküldeni, belépés után kitöltve várja.
</p>
</div>
<PromoCodes packages={catalog?.packages ?? []} />
</main>
);
}
@@ -72,7 +72,18 @@ export function GoogleLogin({
setError(null);
setUninvited(null);
try {
await api("/auth/google", { body: { id_token: response.credential, invite_token: inviteToken } });
let referral: string | null = null;
try {
referral = localStorage.getItem("sf_ref");
} catch {
// storage blocked
}
await api("/auth/google", { body: { id_token: response.credential, invite_token: inviteToken, referral } });
try {
localStorage.removeItem("sf_ref");
} catch {
// storage blocked
}
router.replace(target);
router.refresh();
} catch (e) {
@@ -0,0 +1,29 @@
import type { Metadata } from "next";
import { RedeemCode } from "@/components/RedeemCode";
import { requireMe } from "@/lib/server";
export const metadata: Metadata = { title: "Promókód beváltása", robots: { index: false } };
type Props = { searchParams: Promise<{ kod?: string }> };
/** Redeeming a promo code; `?kod=` fills it in (links in invitations). */
export default async function RedeemPage({ searchParams }: Props) {
const { kod } = await searchParams;
await requireMe(kod ? `/bevaltas?kod=${encodeURIComponent(kod)}` : "/bevaltas");
return (
<main className="page" style={{ maxWidth: 640 }}>
<div className="page-head">
<span className="eyebrow">Promókód</span>
<h1>Promókód beváltása</h1>
<p className="muted">
Írd be a kapott kódot. Az egyenlegedet azonnal feltöltjük a csomag szintjéig: amit már elhasználtál belőle,
visszakapod, ami ennél több van, megmarad. Egy kód egyszer váltható be.
</p>
</div>
<section className="card">
<RedeemCode initial={kod ?? ""} />
</section>
</main>
);
}
@@ -2,6 +2,7 @@ import type { Metadata } from "next";
import { AiNote } from "@/components/AiNote";
import { PackageCards } from "@/components/PackageCards";
import { RedeemCode } from "@/components/RedeemCode";
import { backendGet, requireMe } from "@/lib/server";
import type { Package, PublicConfig } from "@/lib/types";
@@ -68,6 +69,16 @@ export default async function PackagesPage() {
</p>
</section>
<section className="card redeem-card" aria-labelledby="redeem-title">
<h2 id="redeem-title">Van promókódod?</h2>
<p className="muted">
{canPay
? "Váltsd be itt: a hozzá tartozó csomag azonnal a tiéd."
: "A csomagok hamarosan megvásárolhatók. Addig promókóddal juthatsz hozzájuk: a hozzá tartozó csomag azonnal a tiéd."}
</p>
<RedeemCode />
</section>
<PackageCards packages={packages} canPay={canPay} />
<section className="field" aria-labelledby="addon-title" style={{ gap: 12 }}>
+192
View File
@@ -722,3 +722,195 @@ a.pair-row:hover strong { color: var(--gold); }
.share-cta { gap: 12px; }
.share-cta h2 { font-size: 24px; }
.share-cta .btn { align-self: flex-start; }
/* Promo codes: redeeming (header, packages page, /bevaltas) and the admin page */
.redeem-link { color: var(--ink-2); font-size: 13px; text-decoration: none; white-space: nowrap; }
.redeem-link:hover { color: var(--gold); text-decoration: underline; text-underline-offset: 3px; }
.redeem { display: flex; flex-direction: column; gap: 8px; }
.redeem-row { display: flex; gap: 8px; flex-wrap: wrap; }
.redeem-input { flex: 1 1 220px; width: auto; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; letter-spacing: 1.5px; text-transform: uppercase; }
.redeem-card { gap: 10px; border-color: rgba(217, 180, 106, 0.35); }
.redeem-card h2 { font-size: 24px; }
.promo-form { display: grid; grid-template-columns: minmax(0, 1.4fr) 110px minmax(0, 2fr) auto; gap: 12px; align-items: end; }
.promo-made { display: flex; flex-direction: column; gap: 8px; align-items: flex-start; }
.promo-codes { min-height: 0; padding: 10px 14px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; line-height: 1.6; resize: vertical; }
.promo-code { font-size: 14px; letter-spacing: 1px; white-space: nowrap; }
.promo-table td { vertical-align: top; }
.promo-table td .hint { display: block; }
.promo-open { color: var(--ok); }
@media (max-width: 760px) {
.promo-form { grid-template-columns: minmax(0, 1fr) 100px; }
.promo-form .promo-note, .promo-form .btn { grid-column: 1 / -1; }
}
@media (max-width: 640px) { .who { flex-wrap: wrap; gap: 8px 12px; } }
/* New person: typed-in data or an invitation */
.mode-switch { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(240px, 100%), 1fr)); gap: 10px; }
.mode-option {
display: flex; flex-direction: column; gap: 4px; padding: 14px 16px; text-align: left; cursor: pointer; font: inherit;
color: var(--ink); background: var(--panel-2); border: 1px solid var(--line-2); border-radius: 12px;
}
.mode-option strong { font-family: var(--font-display); font-size: 21px; font-weight: 600; }
.mode-option span { font-size: 13.5px; color: var(--muted); line-height: 1.45; }
.mode-option:hover { border-color: #5a6790; }
.mode-option[aria-selected="true"] { border-color: var(--gold); background: rgba(217, 180, 106, 0.08); }
.mode-option[aria-selected="true"] strong { color: var(--gold); }
.invite-list { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 8px; }
.invite-list li { display: flex; flex-wrap: wrap; align-items: center; gap: 6px 14px; padding: 10px 0; border-bottom: 1px solid var(--line); }
.invite-list li:last-child { border-bottom: 0; }
.invite-who { display: flex; flex-direction: column; min-width: 0; flex: 1 1 180px; }
/* Home page for visitors (src/app/Landing.tsx) */
.lp { overflow-x: clip; }
.lp-wrap { max-width: 1180px; margin: 0 auto; padding: 0 24px; }
.lp-header { gap: 16px; }
.lp-nav { flex: 1; }
.lp-hero { position: relative; overflow: hidden; }
.lp-stars { position: absolute; inset: 0; width: 100%; height: 100%; }
.lp-star { fill: var(--ink); opacity: 0.25; animation: lp-twinkle 6s ease-in-out infinite; }
.lp-t1 { animation-delay: 1s; animation-duration: 7s; }
.lp-t2 { animation-delay: 2.4s; animation-duration: 5s; }
.lp-t3 { animation-delay: 3.1s; animation-duration: 8s; }
.lp-t4 { animation-delay: 0.6s; animation-duration: 9s; }
.lp-hero-grid {
position: relative; padding-top: 72px; padding-bottom: 88px;
display: grid; grid-template-columns: repeat(auto-fit, minmax(min(440px, 100%), 1fr)); gap: 48px; align-items: center;
}
.lp-hero-text { display: flex; flex-direction: column; gap: 24px; min-width: 0; }
.lp-hero-text .eyebrow { font-size: 13px; letter-spacing: 2px; }
.lp-title { font-size: clamp(44px, 6vw, 76px); line-height: 1.02; letter-spacing: -0.5px; }
.lp-lead { font-size: 19px; line-height: 1.65; color: var(--ink-2); max-width: 540px; }
.lp-actions { display: flex; gap: 12px; flex-wrap: wrap; align-items: center; }
.lp-btn { min-height: 48px; padding: 0 22px; transition: transform 0.2s, background 0.2s, border-color 0.2s; }
.lp-btn:hover { transform: translateY(-1px); }
.lp-btn-big { min-height: 52px; padding: 0 28px; font-size: 16px; }
.lp-figure { margin: 0; display: flex; flex-direction: column; align-items: center; gap: 14px; min-width: 0; }
.lp-wheel {
position: relative; width: 100%; max-width: 560px; border-radius: 50%;
background: radial-gradient(closest-side, rgba(217, 180, 106, 0.07), transparent 72%);
}
.lp-wheel .chart-wheel { position: relative; }
.lp-orbit { position: absolute; inset: 0; width: 100%; height: 100%; animation: lp-spin 240s linear infinite; }
.lp-orbit circle { fill: none; stroke: var(--gold); stroke-opacity: 0.18; stroke-width: 1; stroke-dasharray: 2 10; }
.lp-orbit .lp-orbit-dot { fill: var(--gold); stroke: none; opacity: 0.55; }
/* the wheel comes alive: planets one by one, then the aspect lines */
.lp-wheel .w-point { opacity: 0; animation: lp-fade 0.9s ease-out forwards; }
.lp-wheel .w-point:nth-last-of-type(13) { animation-delay: 0.3s; }
.lp-wheel .w-point:nth-last-of-type(12) { animation-delay: 0.42s; }
.lp-wheel .w-point:nth-last-of-type(11) { animation-delay: 0.54s; }
.lp-wheel .w-point:nth-last-of-type(10) { animation-delay: 0.66s; }
.lp-wheel .w-point:nth-last-of-type(9) { animation-delay: 0.78s; }
.lp-wheel .w-point:nth-last-of-type(8) { animation-delay: 0.9s; }
.lp-wheel .w-point:nth-last-of-type(7) { animation-delay: 1.02s; }
.lp-wheel .w-point:nth-last-of-type(6) { animation-delay: 1.14s; }
.lp-wheel .w-point:nth-last-of-type(5) { animation-delay: 1.26s; }
.lp-wheel .w-point:nth-last-of-type(4) { animation-delay: 1.38s; }
.lp-wheel .w-point:nth-last-of-type(3) { animation-delay: 1.5s; }
.lp-wheel .w-point:nth-last-of-type(2) { animation-delay: 1.62s; }
.lp-wheel .w-point:nth-last-of-type(1) { animation-delay: 1.74s; }
.lp-wheel .w-aspect { stroke-dasharray: 300; stroke-dashoffset: 300; animation: lp-draw 1.8s cubic-bezier(0.4, 0, 0.2, 1) 1.6s forwards; }
.lp-wheel .w-aspect.w-asp-sextile { stroke-dasharray: 5 4; stroke-dashoffset: 0; opacity: 0; animation: lp-fade 1.2s ease-out 2.2s forwards; }
.lp-caption { display: flex; flex-direction: column; align-items: center; gap: 6px; text-align: center; }
.lp-caption .share-trio { justify-content: center; font-size: 15px; }
.lp-asc { color: var(--gold); font-weight: 600; font-size: 12px; letter-spacing: 0.5px; }
.lp-rise { opacity: 0; transform: translateY(14px); animation: lp-rise 0.9s cubic-bezier(0.2, 0.7, 0.2, 1) forwards; }
.lp-r1 { animation-delay: 0.1s; } .lp-r2 { animation-delay: 0.25s; } .lp-r3 { animation-delay: 0.4s; } .lp-r4 { animation-delay: 0.55s; }
.lp-band { border-top: 1px solid var(--line); padding: 96px 0; }
.lp-alt { background: var(--panel-2); }
.lp-two { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(380px, 100%), 1fr)); gap: 48px; align-items: center; }
.lp-stack { display: flex; flex-direction: column; gap: 40px; }
.lp-intro { display: flex; flex-direction: column; gap: 14px; max-width: 720px; }
.lp-intro .eyebrow { font-size: 13px; letter-spacing: 2px; }
.lp-h2 { font-size: clamp(34px, 4vw, 52px); line-height: 1.06; }
.lp-h3 { font-size: 24px; }
.lp-center { text-align: center; }
.lp-text { font-size: 17px; color: var(--ink-2); line-height: 1.65; }
.lp-small { font-size: 15px; color: var(--ink-2); line-height: 1.6; }
.lp-float { padding: 32px; box-shadow: 0 30px 80px rgba(0, 0, 0, 0.35); animation: lp-float 9s ease-in-out infinite; }
.lp-float .summary-title { font-size: 32px; }
.lp-analysis-grid { display: grid; grid-template-columns: minmax(0, 2fr) minmax(0, 1fr); gap: 24px; align-items: start; }
.lp-paper { padding: 36px; gap: 22px; }
.lp-paper-title { font-size: 36px; line-height: 1.08; }
.lp-excerpts { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(280px, 100%), 1fr)); gap: 28px; }
.lp-fade { max-height: 270px; overflow: hidden; -webkit-mask-image: linear-gradient(#000 55%, transparent); mask-image: linear-gradient(#000 55%, transparent); }
.lp-excerpt-title { font-family: var(--font-display); font-size: 24px; font-weight: 600; color: var(--gold); line-height: 1.15; margin: 0; }
.lp-paper-foot { display: flex; gap: 16px; flex-wrap: wrap; align-items: center; justify-content: space-between; border-top: 1px solid var(--line); padding-top: 20px; }
.lp-paper-foot a { font-weight: 600; text-decoration: none; }
.lp-aside { display: flex; flex-direction: column; gap: 20px; min-width: 0; }
.lp-side-card { gap: 12px; }
.lp-list { margin: 0; padding-left: 18px; display: flex; flex-direction: column; gap: 10px; font-size: 15px; line-height: 1.6; color: var(--ink-2); }
.lp-question { margin: 0; padding: 12px 14px; border-radius: var(--radius); background: var(--panel-2); border: 1px solid var(--line-2); font-size: 14px; }
.lp-chips { display: flex; gap: 8px; flex-wrap: wrap; }
.lp-chip { padding: 6px 14px; border-radius: 999px; border: 1px solid var(--line-2); font-size: 14px; color: var(--ink-2); }
.lp-chip-gold { border-color: rgba(217, 180, 106, 0.5); color: var(--gold); }
.lp-features { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(420px, 100%), 1fr)); gap: 24px; }
.lp-feature { padding: 32px; gap: 20px; }
.lp-feature-head { display: flex; flex-direction: column; gap: 10px; }
.lp-feature-title { font-size: 32px; line-height: 1.1; }
.lp-panel { background: var(--panel-2); border: 1px solid var(--line); border-radius: 12px; padding: 20px; display: flex; flex-direction: column; gap: 14px; }
.lp-timeline { width: 100%; height: auto; display: block; }
.lp-tl-track { stroke: var(--line-2); stroke-width: 2; }
.lp-tl-done { stroke: var(--gold); stroke-width: 2; }
.lp-tl-month { fill: var(--muted); font: 400 10px var(--font-body); text-anchor: middle; }
.lp-tl-now { fill: var(--ink); font: 600 11px var(--font-body); text-anchor: middle; }
.lp-pulse { transform-box: fill-box; transform-origin: center; animation: lp-pulse 2.6s ease-in-out infinite; }
.lp-events { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 6px; font-size: 14.5px; }
.lp-pair { display: grid; grid-template-columns: minmax(0, 200px) minmax(0, 1fr); gap: 20px; align-items: center; }
.lp-rings { width: 100%; height: auto; display: block; }
.lp-ring { fill: none; stroke: var(--line-2); stroke-width: 1; }
.lp-ring-core { fill: var(--panel); stroke: var(--line); }
.lp-spin { transform-box: fill-box; transform-origin: center; animation: lp-spin 120s linear infinite; }
.lp-spin-back { transform-box: fill-box; transform-origin: center; animation: lp-spin 160s linear infinite reverse; }
.lp-pair-legend { display: flex; flex-direction: column; gap: 10px; min-width: 0; }
.pair-text-row { display: flex; align-items: center; gap: 8px; font-size: 14px; color: var(--ink-2); }
.pair-text-row.p2-text { color: var(--p2); }
.lp-pair .nature-bar { margin-top: 6px; height: 8px; }
.lp-steps { list-style: none; margin: 0; padding: 0; display: grid; grid-template-columns: repeat(auto-fit, minmax(min(280px, 100%), 1fr)); gap: 24px; }
.lp-steps .card { gap: 12px; padding: 28px; }
.lp-step-n { font-family: var(--font-display); font-size: 44px; font-weight: 600; line-height: 1; color: var(--gold); }
.lp-step-title { font-family: var(--font-body); font-size: 18px; font-weight: 600; line-height: 1.3; }
.lp-final { background: radial-gradient(ellipse at 50% 0%, rgba(217, 180, 106, 0.12), transparent 60%), var(--bg); padding: 104px 0; }
.lp-final-inner { max-width: 820px; display: flex; flex-direction: column; align-items: center; gap: 22px; text-align: center; }
.lp-emblem { width: 88px; height: 88px; }
.lp-emblem-outer { fill: none; stroke: var(--gold); stroke-opacity: 0.5; stroke-width: 1; }
.lp-waitlist { width: 100%; max-width: 520px; text-align: left; }
.lp-disclaimer { max-width: 560px; }
.lp-footer { border-top: 1px solid var(--line); padding: 28px 0; }
.lp-footer-inner { display: flex; gap: 16px; flex-wrap: wrap; align-items: center; justify-content: space-between; }
.lp-footer-nav { display: flex; gap: 18px; flex-wrap: wrap; font-size: 14px; }
.lp-footer-nav a { color: var(--muted); text-decoration: none; }
.lp-footer-nav a:hover { color: var(--gold); }
@keyframes lp-twinkle { 0%, 100% { opacity: 0.15; } 50% { opacity: 0.7; } }
@keyframes lp-fade { to { opacity: 1; } }
@keyframes lp-draw { to { stroke-dashoffset: 0; } }
@keyframes lp-spin { to { transform: rotate(360deg); } }
@keyframes lp-rise { to { opacity: 1; transform: none; } }
@keyframes lp-float { 0%, 100% { transform: translateY(0); } 50% { transform: translateY(-8px); } }
@keyframes lp-pulse { 0%, 100% { transform: scale(1); opacity: 0.9; } 50% { transform: scale(1.6); opacity: 0.2; } }
@media (max-width: 900px) { .lp-analysis-grid { grid-template-columns: minmax(0, 1fr); } }
@media (max-width: 640px) {
.lp-band { padding: 64px 0; }
.lp-hero-grid { padding-top: 40px; padding-bottom: 56px; gap: 32px; }
.lp-wrap { padding: 0 16px; }
.lp-paper, .lp-feature { padding: 22px; }
.lp-pair { grid-template-columns: minmax(0, 1fr); justify-items: center; }
.lp-rings { max-width: 200px; }
.lp-nav { display: none; }
}
@media (prefers-reduced-motion: reduce) {
.lp *, .lp-orbit { animation: none !important; }
.lp-rise, .lp-wheel .w-point { opacity: 1; transform: none; }
.lp-wheel .w-aspect { stroke-dashoffset: 0; }
.lp-wheel .w-aspect.w-asp-sextile { opacity: 1; }
}
.mode-option:disabled { cursor: not-allowed; opacity: 0.75; }
.mode-option:disabled:hover { border-color: var(--line-2); }
.mode-soon { margin-left: 8px; vertical-align: middle; font-family: var(--font-body); font-size: 11px; }
.invite-soon .btn:disabled { cursor: not-allowed; }
@@ -78,6 +78,8 @@ export default async function ChartPage({ params }: { params: Promise<{ id: stri
detailedDone={detailed?.status === "done"}
isAdmin={me.user.roles.includes("admin")}
shareRewardGranted={me.share_reward_granted}
referralOpen={config?.referral_rewards ?? false}
referralsLeft={me.referral_rewards.limit - me.referral_rewards.earned}
/>
<BigThree chart={chart} />
{(elements || modalities || phase) && (
@@ -20,7 +20,7 @@ export function Unsubscribe({ token }: { token: string | null }) {
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.
Leiratkoztál: erre a címre nem küldünk több meghívót, és levettük a várólistáról.
</p>
);
}
@@ -40,7 +40,8 @@ export function Unsubscribe({ token }: { token: string | null }) {
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.
Ha leiratkozol, erre az e-mail-címre többé nem küldünk meghívót, levesszük a várólistáról, é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"}>
@@ -12,7 +12,7 @@ export default async function UnsubscribePage({ searchParams }: { searchParams:
<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>
<p className="muted">Nem kérsz több levelet és meghívót a Sorsfonalakról.</p>
</div>
<Unsubscribe token={token ?? null} />
</main>
@@ -0,0 +1,63 @@
"use client";
import { useRouter } from "next/navigation";
import { useState } from "react";
import { BirthForm } from "@/app/profil/BirthForm";
import { api, errorText } from "@/lib/api";
/** The logged-in invitee: gives their own birth data if needed, then the comparison is made. */
export function AcceptInvite({ token, hasOwnChart }: { token: string; hasOwnChart: boolean }) {
const router = useRouter();
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
const [needsChart, setNeedsChart] = useState(!hasOwnChart);
async function accept() {
setBusy(true);
setError(null);
try {
const s = await api<{ id: string }>("/invites/accept", { body: { token } });
router.push(`/osszevetesek/${s.id}`);
router.refresh();
} catch (e) {
setError(errorText(e));
setBusy(false);
}
}
if (needsChart) {
return (
<div className="field" style={{ gap: 12 }}>
<p>Add meg a születési adataidat: ebből készül a képleted, és ezt vetjük össze.</p>
<BirthForm
initial={null}
onSaved={() => {
setNeedsChart(false);
accept();
}}
/>
{error && (
<p className="msg msg-error" role="alert">
{error}
</p>
)}
</div>
);
}
return (
<div className="field" style={{ gap: 12 }}>
<p>A saját képleteddel vetjük össze.</p>
<div className="form-actions">
<button type="button" className="btn btn-primary" onClick={accept} disabled={busy}>
{busy ? "Készül az összevetés…" : "Összevetés elkészítése"}
</button>
</div>
{error && (
<p className="msg msg-error" role="alert">
{error}
</p>
)}
</div>
);
}
@@ -0,0 +1,95 @@
import type { Metadata } from "next";
import Link from "next/link";
import { GoogleLogin } from "@/app/belepes/GoogleLogin";
import { Logo } from "@/components/SiteHeader";
import { formatDate } from "@/lib/astro";
import { BACKEND_URL, getMe } from "@/lib/server";
import type { PersonInviteLanding, PublicConfig } from "@/lib/types";
import { AcceptInvite } from "./AcceptInvite";
export const metadata: Metadata = {
title: "Mennyire illünk össze?",
description: "Meghívó a születési képletek összevetésére a Sorsfonalakon.",
robots: { index: false },
};
const TOKEN = /^[A-Za-z0-9_-]{8,200}$/;
async function load<T>(path: string): Promise<T | null> {
try {
const res = await fetch(`${BACKEND_URL}${path}`, { cache: "no-store" });
return res.ok ? ((await res.json()) as T) : null;
} catch {
return null;
}
}
/** A "how compatible are we?" link: who invites, login, own birth data, then the comparison. */
export default async function PersonInvitePage({ params }: { params: Promise<{ token: string }> }) {
const { token } = await params;
const valid = TOKEN.test(token);
const [invite, config, me] = await Promise.all([
valid ? load<PersonInviteLanding>(`/v1/public/invites/${token}`) : Promise.resolve(null),
load<PublicConfig>("/v1/config"),
getMe(),
]);
const who = invite?.inviter_name ?? "Valaki";
const clientId = config?.google_login.enabled ? config.google_login.client_id : null;
let body: React.ReactNode;
if (!invite) {
body = <p className="msg msg-error">Ez a meghívólink érvénytelen. Ellenőrizd, hogy a teljes linket nyitottad-e meg.</p>;
} else if (invite.status === "accepted") {
body = (
<p className="muted">
Ezt a meghívót már elfogadták. {me ? <Link href="/osszevetesek">Az összevetéseid itt vannak.</Link> : null}
</p>
);
} else if (invite.status === "expired") {
body = <p className="msg msg-error">Ez a meghívó lejárt vagy visszavonták. Kérj újat attól, aki küldte.</p>;
} else if (!me) {
body = clientId ? (
<>
<GoogleLogin clientId={clientId} target={`/meghivas/${token}`} inviteToken={token} />
<p className="hint">A fiókod az első belépéskor jön létre, bármelyik Google-fiókoddal.</p>
</>
) : (
<p className="msg msg-error">A belépés most nem érhető el. Próbáld újra később.</p>
);
} else {
body = <AcceptInvite token={token} hasOwnChart={me.primary_chart_id !== null} />;
}
return (
<>
{!me && (
<header className="site-header">
<Logo />
</header>
)}
<main className="page" style={{ maxWidth: 720 }}>
<div className="page-head">
<span className="eyebrow">Meghívó</span>
<h1>Mennyire illetek össze?</h1>
{invite && (
<p className="muted">
<strong>{who}</strong> szeretné összevetni a születési képleteteket.
</p>
)}
</div>
{invite?.message && <blockquote className="invite-quote">{invite.message}</blockquote>}
<section className="card" style={{ gap: 14 }}>
{body}
{invite?.status === "pending" && (
<p className="hint">
A saját képletedet és egy rövid elemzést ingyen kapsz. {who} az összevetést látja, a születési adataidat nem.
A meghívó {formatDate(invite.expires_at).replace(/\.$/, "")}-ig érvényes.
</p>
)}
</section>
</main>
</>
);
}
+30 -4
View File
@@ -1,10 +1,36 @@
import type { Metadata } from "next";
import { redirect } from "next/navigation";
import { getMe } from "@/lib/server";
import { BACKEND_URL, getMe } from "@/lib/server";
import type { PublicConfig } from "@/lib/types";
// No home page yet: logged-in users go to their chart (or to the profile to enter
// their birth data), others to login.
import { Landing } from "./Landing";
export const metadata: Metadata = {
title: { absolute: "Sorsfonalak – születési képlet, éves előrejelzés, kapcsolati összevetés" },
description:
"Percre pontos születési képlet és személyre szóló elemzés, éves előrejelzés és kapcsolati összevetés: mennyire illetek össze?",
openGraph: {
type: "website",
siteName: "Sorsfonalak",
locale: "hu_HU",
title: "Sorsfonalak – ahol a csillagok összekötnek",
description: "Születési képlet, részletes elemzés, éves előrejelzés és kapcsolati összevetés.",
},
};
async function signupMode(): Promise<PublicConfig["signup_mode"]> {
try {
const res = await fetch(`${BACKEND_URL}/v1/config`, { next: { revalidate: 300 } });
return res.ok ? ((await res.json()) as PublicConfig).signup_mode : "invite";
} catch {
return "invite";
}
}
/** Visitors get the home page; logged-in users go to their chart (or to the profile for their birth data). */
export default async function Home() {
const me = await getMe();
redirect(!me ? "/belepes" : me.primary_chart_id ? "/keplet" : "/profil");
if (me) redirect(me.primary_chart_id ? "/keplet" : "/profil");
return <Landing inviteOnly={(await signupMode()) !== "open"} />;
}
+32 -2
View File
@@ -3,6 +3,7 @@ import Link from "next/link";
import { ChartCard } from "@/components/ChartCard";
import { PersonActions } from "@/components/PersonActions";
import { PendingInvites } from "@/components/PendingInvites";
import { PersonPacks } from "@/components/PersonPacks";
import { backendGet, requireMe } from "@/lib/server";
import type { ChartListItem, PublicConfig } from "@/lib/types";
@@ -22,6 +23,7 @@ export default async function PersonsPage() {
const isAdmin = me.user.roles.includes("admin");
const slots = me.persons;
const full = slots.left === 0;
const invitesOpen = (config?.user_invites ?? false) || isAdmin;
const now = Date.now();
return (
@@ -46,19 +48,47 @@ export default async function PersonsPage() {
</ChartCard>
))}
{!full && (
{(!full || invitesOpen) && (
<Link href="/szemelyek/uj" className="chart-card chart-card-new">
<span className="chart-card-plus" aria-hidden="true">
+
</span>
<strong className="chart-card-name">Új személy</strong>
<span className="muted">
{slots.unlimited ? "Korlátlan számú személy" : `Még ${slots.left} személyt vehetsz fel`}
{!invitesOpen
? slots.unlimited
? "Korlátlan számú személy"
: `Még ${slots.left} személyt vehetsz fel`
: full
? "Meghívással bármikor"
: slots.unlimited
? "Adatokkal vagy meghívással"
: `Még ${slots.left} személyt vehetsz fel, vagy hívd meg`}
</span>
</Link>
)}
</div>
{invitesOpen ? (
<PendingInvites />
) : (
<section className="card invite-soon" aria-labelledby="invite-soon-title">
<div className="card-head">
<h2 id="invite-soon-title">Hívd meg, akit szeretsz</h2>
<span className="badge">Hamarosan</span>
</div>
<p className="muted">
Hamarosan te is meghívhatod a barátaidat, a családodat vagy a párodat: ők megadják a saját születési adataikat,
ingyen megkapják a képletüket, és együtt megnézitek, mennyire illetek össze.
</p>
<div>
<button type="button" className="btn" disabled>
Meghívó küldése
</button>
</div>
</section>
)}
{!slots.unlimited && (
<section className="card" aria-labelledby="slots-title">
<div className="card-head">
@@ -0,0 +1,88 @@
"use client";
import Link from "next/link";
import { useState } from "react";
import { InvitePerson } from "@/components/InvitePerson";
import { NewPerson } from "./NewPerson";
/**
* Adding a person: typing in their birth data (uses a slot), or inviting
* them to compare charts (they give their own data; no slot used).
*/
export function NewPersonChooser({
canAdd,
hasOwnChart,
invitesOpen,
full,
}: {
/** A slot is free for typed-in data. */
canAdd: boolean;
/** Inviting is on (until the launch it is shown, but off). */
invitesOpen: boolean;
/** Inviting compares with the user's own chart. */
hasOwnChart: boolean;
/** Shown instead of the form when no slot is left. */
full: React.ReactNode;
}) {
const [mode, setMode] = useState<"data" | "invite">(canAdd || !invitesOpen ? "data" : "invite");
return (
<div className="field" style={{ gap: 18 }}>
<div className="mode-switch" role="tablist" aria-label="Hogyan veszed fel?">
<button
type="button"
role="tab"
aria-selected={mode === "data"}
className="mode-option"
onClick={() => setMode("data")}
>
<strong>Adatok megadása</strong>
<span>Te írod be a születési adatait. Egy személyhelyet használ.</span>
</button>
<button
type="button"
role="tab"
aria-selected={mode === "invite"}
aria-disabled={!invitesOpen}
disabled={!invitesOpen}
className="mode-option"
onClick={() => setMode("invite")}
>
<strong>
Meghívom {!invitesOpen && <span className="badge mode-soon">Hamarosan</span>}
</strong>
<span>
{invitesOpen
? "Ő adja meg a saját adatait, és megnézitek, mennyire illetek össze. Ingyenes, nem kell hozzá hely."
: "Hamarosan meghívhatod azokat, akiket szeretsz: ők adják meg a saját adataikat, és együtt nézitek meg, mennyire illetek össze."}
</span>
</button>
</div>
{mode === "data" ? (
canAdd ? (
<>
<NewPerson />
<p className="hint">Az adatokat a felvételt követő egy órán belül még javíthatod, utána nem módosíthatók.</p>
</>
) : (
full
)
) : hasOwnChart ? (
<>
<InvitePerson />
<p className="hint">
A meghívott a saját képletét és rövid összefoglalóját ingyen kapja. Ti ketten az összevetést látjátok, egymás
születési adatait nem. A részletes kapcsolati elemzést bármelyikőtök kérheti egy kapcsolati elemzéssel, és
mindketten látjátok.
</p>
</>
) : (
<p className="muted">
A meghívó a saját képleteddel veti össze az övét, ezért előbb <Link href="/profil#birth">add meg a saját
születési adataidat</Link>.
</p>
)}
</div>
);
}
+15 -14
View File
@@ -4,7 +4,7 @@ import { PersonPacks } from "@/components/PersonPacks";
import { backendGet, requireMe } from "@/lib/server";
import type { PublicConfig } from "@/lib/types";
import { NewPerson } from "./NewPerson";
import { NewPersonChooser } from "./NewPersonChooser";
export const metadata: Metadata = { title: "Új személy" };
@@ -18,22 +18,23 @@ export default async function NewPersonPage() {
<div className="page-head">
<h1>Új személy</h1>
<p className="muted">
Társad, családtagod, barátod: a születési adataiból elkészül a képlete és egy rövid összefoglaló.
Társad, családtagod, barátod: megadhatod a születési adatait, vagy meghívhatod, hogy ő adja meg, és megnézzétek,
mennyire illetek össze.
{!slots.unlimited && slots.left !== null && slots.left > 0 && ` Még ${slots.left} személyt vehetsz fel.`}
</p>
</div>
<section className="card" aria-label="Születési adatok">
{slots.left === 0 ? (
<>
<p className="muted">Elfogytak a helyeid. Újabb személyhez válassz csomagot.</p>
<PersonPacks canPay={config?.mock_payments ?? false} />
</>
) : (
<>
<NewPerson />
<p className="hint">Az adatokat a felvételt követő egy órán belül még javíthatod, utána nem módosíthatók.</p>
</>
)}
<section className="card" aria-label="Új személy">
<NewPersonChooser
canAdd={slots.left !== 0}
hasOwnChart={me.primary_chart_id !== null}
invitesOpen={(config?.user_invites ?? false) || me.user.roles.includes("admin")}
full={
<>
<p className="muted">Elfogytak a helyeid. Újabb személyhez válassz csomagot, vagy hívd meg.</p>
<PersonPacks canPay={config?.mock_payments ?? false} />
</>
}
/>
</section>
</main>
);
@@ -3,6 +3,7 @@ import Link from "next/link";
const PAGES = [
{ href: "/admin", label: "Felhasználók" },
{ href: "/admin/meghivok", label: "Meghívók" },
{ href: "/admin/promokodok", label: "Promókódok" },
{ href: "/admin/promptok", label: "Promptok" },
{ href: "/admin/modellek", label: "Modellek" },
{ href: "/admin/hibak", label: "Hibanapló" },
@@ -1,5 +1,6 @@
"use client";
import Link from "next/link";
import { useCallback, useEffect, useState } from "react";
import { api, ApiError, errorText } from "@/lib/api";
@@ -218,7 +219,9 @@ export function AnalysisQuestions({
<PackageChooser ids={["addon_questions"]} canPay={canPay} onBought={bought} />
</div>
) : (
<p className="hint">Most nincs felhasználható kérdésed. Kérdéseket hamarosan vásárolhatsz.</p>
<p className="hint">
Most nincs felhasználható kérdésed. Ha kaptál promókódot, <Link href="/bevaltas">váltsd be</Link>.
</p>
)}
</section>
);
@@ -26,6 +26,8 @@ export function ChartSummary({
detailedDone = false,
isAdmin = false,
shareRewardGranted = false,
referralOpen = false,
referralsLeft = 0,
}: {
chartId: string;
initial: Analysis | null;
@@ -33,8 +35,11 @@ export function ChartSummary({
detailedDone?: boolean;
/** Admins can write the summary again. */
isAdmin?: boolean;
/** The free analysis for sharing is used up. */
/** The free question for sharing is used up. */
shareRewardGranted?: boolean;
/** New users from shared links earn analyses, and how many more can be. */
referralOpen?: boolean;
referralsLeft?: number;
}) {
const [summary, setSummary] = useState<Analysis | null>(initial);
const [gaveUp, setGaveUp] = useState(false);
@@ -85,7 +90,12 @@ export function ChartSummary({
<p className="summary-text" lang={summary?.language}>
<Rich text={content.summary ?? ""} />
</p>
<ShareChart chartId={chartId} rewardGranted={shareRewardGranted} />
<ShareChart
chartId={chartId}
rewardGranted={shareRewardGranted}
referralOpen={referralOpen}
referralsLeft={referralsLeft}
/>
<a
href="#elemzes"
className="summary-more"
@@ -197,9 +197,7 @@ export function ChartWheel({
dominantBaseline="central"
textAnchor="middle"
>
<title>
{pointName(key)}: {dms(a.degree_in_sign_dms)} {signName(a.sign)}
</title>
<title>{`${pointName(key)}: ${dms(a.degree_in_sign_dms)} ${signName(a.sign)}`}</title>
{label}
</text>
);
@@ -225,8 +223,7 @@ export function ChartWheel({
strokeWidth={(0.6 + 1.9 * s).toFixed(2)}
>
<title>
{pointName(a.point1)} {ASPECTS[a.aspect]?.hu ?? a.aspect} {pointName(a.point2)} (orbis{" "}
{orbText(a.orb)})
{`${pointName(a.point1)} ${ASPECTS[a.aspect]?.hu ?? a.aspect} ${pointName(a.point2)} (orbis ${orbText(a.orb)})`}
</title>
</line>
);
@@ -244,9 +241,9 @@ export function ChartWheel({
return (
<g key={p.id} className="w-point">
<title>
{pointName(p.id)}: {dms(p.degree_in_sign_dms)} {signName(p.sign)}
{p.retrograde ? ", retrográd" : ""}
{timeKnown && p.house ? `, ${p.house}. ház` : ""}
{`${pointName(p.id)}: ${dms(p.degree_in_sign_dms)} ${signName(p.sign)}${p.retrograde ? ", retrográd" : ""}${
timeKnown && p.house ? `, ${p.house}. ház` : ""
}`}
</title>
<line x1={f(t1x)} y1={f(t1y)} x2={f(t2x)} y2={f(t2y)} className="w-point-tick" />
<line x1={f(t2x)} y1={f(t2y)} x2={f(lx)} y2={f(ly)} className="w-leader" />
@@ -273,7 +273,10 @@ export function DetailedAnalysis({
Példa megtekintése
</Link>
)}
<span className="hint">A részletes elemzés fizetős; a csomagok hamarosan elérhetők.</span>
<Link href="/bevaltas" className="btn btn-primary">
Promókód beváltása
</Link>
<span className="hint">A részletes elemzéshez csomag kell. Ha kaptál promókódot, váltsd be.</span>
</div>
)}
</section>
@@ -0,0 +1,170 @@
"use client";
import { useState } from "react";
import { api, errorText } from "@/lib/api";
const MAX_MESSAGE = 300;
interface Created {
url: string;
emailed: boolean;
email: string | null;
label: string | null;
}
/**
* Invites someone to compare charts instead of typing in their birth data:
* they enter their own data, and both see the comparison (not each other's
* birth data). No person slot is used.
*/
export function InvitePerson() {
const [label, setLabel] = useState("");
const [email, setEmail] = useState("");
const [message, setMessage] = useState("");
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
const [created, setCreated] = useState<Created | null>(null);
const [copied, setCopied] = useState(false);
async function submit(e: React.FormEvent) {
e.preventDefault();
setBusy(true);
setError(null);
try {
setCreated(
await api<Created>("/invites", {
body: { label: label.trim() || null, email: email.trim() || null, message: message.trim() || null },
}),
);
} catch (err) {
setError(errorText(err));
} finally {
setBusy(false);
}
}
async function copy() {
if (!created) return;
try {
await navigator.clipboard.writeText(created.url);
setCopied(true);
setTimeout(() => setCopied(false), 2000);
} catch {
setError("Nem sikerült másolni; jelöld ki a linket, és másold kézzel.");
}
}
if (created) {
const text = `Nézzük meg, mennyire illünk össze! ${created.url}`;
return (
<div className="field invite-done" style={{ gap: 12 }}>
<p className="msg msg-ok" role="status">
{created.emailed
? `Elküldtük a meghívót ide: ${created.email}. A linket te is továbbküldheted.`
: created.email
? `Ez a cím nem kér levelet tőlünk, ezért nem írtunk neki. Küldd el neki te a linket.`
: "Kész a meghívó. Küldd el a linket annak, akit meghívsz."}
</p>
<div className="share-link">
<input
className="inp"
readOnly
value={created.url}
aria-label="Meghívó link"
onFocus={(e) => e.currentTarget.select()}
/>
<button type="button" className="btn btn-sm" onClick={copy}>
{copied ? "Kimásolva" : "Másolás"}
</button>
</div>
<div className="form-actions">
{typeof navigator !== "undefined" && "share" in navigator && (
<button
type="button"
className="btn btn-sm btn-primary"
onClick={() => navigator.share({ text: "Nézzük meg, mennyire illünk össze!", url: created.url }).catch(() => {})}
>
Küldés…
</button>
)}
<a className="btn btn-sm" href={`https://wa.me/?text=${encodeURIComponent(text)}`} target="_blank" rel="noopener noreferrer">
WhatsApp
</a>
<a
className="btn btn-sm"
href={`https://www.facebook.com/sharer/sharer.php?u=${encodeURIComponent(created.url)}`}
target="_blank"
rel="noopener noreferrer"
>
Facebook
</a>
<button type="button" className="btn btn-sm btn-ghost" onClick={() => setCreated(null)}>
Újabb meghívó
</button>
</div>
<p className="hint">
A meghívó 14 napig érvényes. Amikor elfogadja, levelet kapsz, és az összevetés megjelenik az Összevetéseid
között.
</p>
</div>
);
}
return (
<form className="field" style={{ gap: 14 }} onSubmit={submit}>
<div className="grid-2">
<div className="field">
<label htmlFor="invite-label">Kit hívsz meg?</label>
<input
id="invite-label"
className="inp"
value={label}
maxLength={80}
onChange={(e) => setLabel(e.target.value)}
placeholder="pl. Anna"
/>
<span className="hint">Csak te látod, a meghívóid között.</span>
</div>
<div className="field">
<label htmlFor="invite-email">E-mail-címe (nem kötelező)</label>
<input
id="invite-email"
className="inp"
type="email"
value={email}
onChange={(e) => setEmail(e.target.value)}
placeholder="anna@pelda.hu"
autoComplete="off"
/>
<span className="hint">Ha megadod, levélben is elküldjük neki.</span>
</div>
</div>
<div className="field">
<label htmlFor="invite-message">Ü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! Nézzük meg, mennyire illünk össze."
/>
<span className="hint">
{message.length}/{MAX_MESSAGE} karakter, link nélkül.
</span>
</div>
<div className="form-actions">
<button type="submit" className="btn btn-primary" disabled={busy}>
{busy ? "Készül…" : "Meghívó készítése"}
</button>
</div>
{error && (
<p className="msg msg-error" role="alert">
{error}
</p>
)}
</form>
);
}
@@ -0,0 +1,85 @@
"use client";
import Link from "next/link";
import { useCallback, useEffect, useState } from "react";
import { api, errorText } from "@/lib/api";
import { formatDate } from "@/lib/astro";
import type { PersonInvite } from "@/lib/types";
/** The user's "how compatible are we?" invitations: waiting ones (revocable) and accepted ones. */
export function PendingInvites() {
const [invites, setInvites] = useState<PersonInvite[] | null>(null);
const [error, setError] = useState<string | null>(null);
const load = useCallback(async () => {
try {
setInvites((await api<{ invites: PersonInvite[] }>("/invites")).invites);
} catch (e) {
setError(errorText(e));
}
}, []);
useEffect(() => {
load();
}, [load]);
async function revoke(i: PersonInvite) {
if (!window.confirm(`Visszavonod a meghívót${i.label ? ` (${i.label})` : ""}? A link nem fog működni.`)) return;
try {
await api(`/invites/${i.id}`, { method: "DELETE" });
await load();
} catch (e) {
setError(errorText(e));
}
}
// Waiting ones, and the accepted ones of the last 30 days.
const recent = Date.now() - 30 * 86_400_000;
const shown = (invites ?? []).filter(
(i) => i.status === "pending" || (i.status === "accepted" && i.accepted_at && Date.parse(i.accepted_at) > recent),
);
if (!error && shown.length === 0) return null;
return (
<section className="card" aria-labelledby="invites-title" style={{ gap: 12 }}>
<h2 id="invites-title">Meghívóid</h2>
{error && (
<p className="msg msg-error" role="alert">
{error}
</p>
)}
<ul className="invite-list">
{shown.map((i) => (
<li key={i.id}>
<span className="invite-who">
<strong>{i.label ?? i.email ?? "Meghívó"}</strong>
{i.label && i.email && <span className="hint">{i.email}</span>}
</span>
{i.status === "pending" ? (
<>
<span className="hint">
Elküldve {formatDate(i.created_at)}, érvényes {formatDate(i.expires_at).replace(/\.$/, "")}-ig
</span>
<button type="button" className="btn btn-sm btn-ghost" onClick={() => revoke(i)}>
Visszavonás
</button>
</>
) : (
<>
<span className="hint">
Elfogadta{i.accepted_by ? `: ${i.accepted_by}` : ""} · {formatDate(i.accepted_at)}
</span>
{i.synastry_id && (
<Link href={`/osszevetesek/${i.synastry_id}`} className="btn btn-sm">
Összevetés
</Link>
)}
</>
)}
</li>
))}
</ul>
</section>
);
}
@@ -0,0 +1,97 @@
"use client";
import Link from "next/link";
import { useRouter } from "next/navigation";
import { useId, useState } from "react";
import { api, ApiError, errorText } from "@/lib/api";
/** Typing help: upper case, groups of four (ABCD-EFGH-JKLM). */
function format(input: string): string {
const clean = input.toUpperCase().replace(/[^0-9A-Z]/g, "").slice(0, 32);
return clean.match(/.{1,4}/g)?.join("-") ?? "";
}
const UNITS: Record<string, string> = {
natal: "képletelemzés",
synastry: "kapcsolati elemzés",
forecast: "éves előrejelzés",
person: "személyhely",
question: "kérdés",
};
/** "+2 képletelemzés, +3 kérdés" */
function addedText(added: Record<string, number>): string {
return Object.entries(added)
.map(([unit, n]) => `+${n} ${UNITS[unit] ?? unit}`)
.join(", ");
}
/**
* Redeeming a promo code. It fills the units up to the package's amounts
* (used ones come back, more than that stays).
*/
export function RedeemCode({ initial = "", compact = false }: { initial?: string; compact?: boolean }) {
const router = useRouter();
const id = useId();
const [code, setCode] = useState(format(initial));
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
const [got, setGot] = useState<{ name: string; added: string } | null>(null);
async function redeem(e: React.FormEvent) {
e.preventDefault();
setBusy(true);
setError(null);
try {
const r = await api<{ package: { name: string }; added: Record<string, number> }>("/promo-codes/redeem", {
body: { code },
});
setGot({ name: r.package.name, added: addedText(r.added ?? {}) });
setCode("");
router.refresh();
} catch (err) {
setError(
err instanceof ApiError && err.status === 429
? "Túl sok sikertelen próbálkozás. Várj negyed órát, és próbáld újra."
: errorText(err),
);
} finally {
setBusy(false);
}
}
return (
<form className={compact ? "redeem redeem-compact" : "redeem"} onSubmit={redeem}>
<label htmlFor={id} className={compact ? "label" : "sr-only"}>
Promókód
</label>
<div className="redeem-row">
<input
id={id}
className="inp redeem-input"
value={code}
onChange={(e) => setCode(format(e.target.value))}
placeholder="XXXX-XXXX-XXXX"
autoComplete="off"
autoCapitalize="characters"
spellCheck={false}
inputMode="text"
aria-describedby={`${id}-msg`}
/>
<button type="submit" className="btn btn-primary" disabled={busy || code.replace(/-/g, "").length < 8}>
{busy ? "Beváltás…" : "Beváltom"}
</button>
</div>
<div id={`${id}-msg`} aria-live="polite">
{error && <p className="msg msg-error">{error}</p>}
{got && (
<p className="msg msg-ok">
Beváltva: <strong>{got.name}</strong>. Feltöltöttük az egyenlegedet: {got.added}.{" "}
<Link href="/keplet">Tovább a képletedhez</Link>
</p>
)}
</div>
</form>
);
}
+25 -10
View File
@@ -22,10 +22,27 @@ function ShareIcon() {
/**
* Share link of a chart with its short summary: copy, Facebook, the phone's
* share menu, revoke. The first visit by someone else earns one free natal
* analysis, once per user (`rewardGranted`: already received).
* share menu, revoke. The first visit by someone else earns a free question,
* once per user (`rewardGranted`: already received); someone who signs up
* from the link and makes their chart earns an analysis (`referralsLeft`,
* while `referralOpen`).
*/
export function ShareChart({ chartId, rewardGranted = false }: { chartId: string; rewardGranted?: boolean }) {
export function ShareChart({
chartId,
rewardGranted = false,
referralOpen = false,
referralsLeft = 0,
}: {
chartId: string;
rewardGranted?: boolean;
referralOpen?: boolean;
referralsLeft?: number;
}) {
const referral = referralOpen && referralsLeft > 0;
const perks = [
!rewardGranted && "+1 ajándék kérdés, ha valaki megnézi",
referral && "+1 elemzés, ha valaki a linkedről csatlakozik",
].filter(Boolean);
const [share, setShare] = useState<Share | null>(null);
const [busy, setBusy] = useState(false);
const [copied, setCopied] = useState(false);
@@ -88,11 +105,7 @@ export function ShareChart({ chartId, rewardGranted = false }: { chartId: string
</span>
<span className="share-button-text">
<strong>{busy ? "Link készül…" : "Oszd meg a képleted"}</strong>
<small>
{rewardGranted
? "Küldd el a barátaidnak, vagy tedd ki Facebookra"
: "+1 ajándék elemzés jár érte, ha valaki megnézi"}
</small>
<small>{perks.length > 0 ? perks.join(" · ") : "Küldd el a barátaidnak, vagy tedd ki Facebookra"}</small>
</span>
</button>
{revoked && <p className="hint">A linket visszavontad.</p>}
@@ -114,8 +127,10 @@ export function ShareChart({ chartId, rewardGranted = false }: { chartId: string
</p>
<p className="share-fine">
{rewardGranted
? "Az ajándék elemzést már megkaptad. Köszönjük, hogy megosztottad!"
: "Ajándék képletelemzés egyszer jár: amikor valaki más először megnyitja a linkedet. A saját megnyitásod nem számít."}
? "Az ajándék kérdést már megkaptad. Köszönjük, hogy megosztottad!"
: "Ajándék kérdés egyszer jár: amikor valaki más először megnyitja a linkedet. A saját megnyitásod nem számít."}
{referral &&
` Ha valaki a linkedről regisztrál és elkészíti a képletét, egy képletelemzést is kapsz (még ${referralsLeft} szerezhető).`}
</p>
<div className="share-link">
<input
@@ -10,6 +10,12 @@ import { useEffect } from "react";
export function ShareVisit({ slug }: { slug: string }) {
useEffect(() => {
const key = `share-visit:${slug}`;
try {
// If they sign up later, the sharer who brought them is remembered.
localStorage.setItem("sf_ref", slug);
} catch {
// storage blocked
}
try {
if (sessionStorage.getItem(key)) return;
sessionStorage.setItem(key, "1");
@@ -58,6 +58,9 @@ export function SiteHeader({ me }: { me: Me }) {
<NavLinks links={links} />
<div className="who">
<PackageBadge me={me} />
<Link href="/bevaltas" className="redeem-link">
Kód beváltása
</Link>
<span className="who-name">{me.user.display_name || me.user.email}</span>
<LogoutButton />
</div>
@@ -1,4 +1,5 @@
import { ASPECTS, POINTS, SIGNS, dms, orbText, pointName, signName } from "@/lib/astro";
import { sideTimeKnown } from "@/lib/synastry";
import type { HouseOverlay, InterAspect, Synastry, SynastryResult } from "@/lib/types";
import { GRID_POINTS, Pos } from "./ChartTables";
@@ -47,7 +48,7 @@ const GRID_ANGLES: [string, string][] = [
function gridPoints(s: Synastry["chart1"]): [string, string][] {
const present = new Set(s.chart.points.map((p) => p.id));
const rows: [string, string][] = GRID_POINTS.filter((id) => present.has(id)).map((id) => [id, POINTS[id]?.glyph ?? id]);
if (s.highlights.time_known) {
if (sideTimeKnown(s)) {
for (const [key, label] of GRID_ANGLES) if (s.chart.angles?.[key]) rows.push([key, label]);
}
return rows;
@@ -72,9 +72,9 @@ function Ring({
return (
<g key={p.id} className="w-point">
<title>
{who}: {pointName(p.id)} {dms(p.degree_in_sign_dms)} {signName(p.sign)}
{p.retrograde ? ", retrográd" : ""}
{timeKnown && p.house ? `, ${p.house}. ház` : ""}
{`${who}: ${pointName(p.id)} ${dms(p.degree_in_sign_dms)} ${signName(p.sign)}${p.retrograde ? ", retrográd" : ""}${
timeKnown && p.house ? `, ${p.house}. ház` : ""
}`}
</title>
<line x1={f(t1x)} y1={f(t1y)} x2={f(t2x)} y2={f(t2y)} className="w-point-tick" />
<line x1={f(t2x)} y1={f(t2y)} x2={f(lx)} y2={f(ly)} className="w-leader" />
@@ -208,9 +208,7 @@ export function SynastryWheel({
const [x, y] = xy(a.longitude, R_LABEL, start);
return (
<text key={key} x={f(x)} y={f(y)} className="w-axis-label" dominantBaseline="central" textAnchor="middle">
<title>
{name1}: {pointName(key)} {dms(a.degree_in_sign_dms)} {signName(a.sign)}
</title>
<title>{`${name1}: ${pointName(key)} ${dms(a.degree_in_sign_dms)} ${signName(a.sign)}`}</title>
{label}
</text>
);
@@ -236,8 +234,7 @@ export function SynastryWheel({
strokeWidth={(0.6 + 1.9 * s).toFixed(2)}
>
<title>
{name1} {pointName(a.person1)} {ASPECTS[a.aspect]?.hu ?? a.aspect} {name2} {pointName(a.person2)} (orbis{" "}
{orbText(a.orb)})
{`${name1} ${pointName(a.person1)} ${ASPECTS[a.aspect]?.hu ?? a.aspect} ${name2} ${pointName(a.person2)} (orbis ${orbText(a.orb)})`}
</title>
</line>
);
+48 -1
View File
@@ -21,8 +21,10 @@ export interface Me {
persons: PersonSlots;
/** The latest main package bought or given (null: none). */
package: { id: string; name: string; since: string } | null;
/** The free analysis for a shared link is used up (once per user). */
/** The free question for a shared link is used up (once per user). */
share_reward_granted: boolean;
/** Natal analyses earned by bringing new users through shared links. */
referral_rewards: { earned: number; limit: number };
}
/** A package from the catalog (`GET /v1/packages`). */
@@ -92,6 +94,10 @@ export interface PublicConfig {
mock_payments: boolean;
/** "invite": new accounts need an invitation. */
signup_mode: "invite" | "open";
/** Users may invite others (off until the launch; admins always may). */
user_invites: boolean;
/** A new user from a shared link earns the sharer an analysis (off until sign-up opens). */
referral_rewards: boolean;
}
export interface Position {
@@ -413,6 +419,8 @@ export interface AdminInvitation {
mail: "sent" | "queued" | "failed" | "archived";
mail_error: string | null;
can_resend: boolean;
/** The package it comes with (a promo code, redeemed at sign-up). */
package: { id: string; name: string | null; code: string | null; redeemed_at: string | null } | null;
}
export interface WaitlistEntry {
@@ -428,6 +436,8 @@ export interface InvitationResult {
status: "invited" | "invalid" | "already_user" | "already_invited" | "opted_out";
id?: string;
url?: string;
/** The promo code of the package sent with it. */
promo_code?: string | null;
}
/** A calculated year in a list (`GET /v1/charts/{id}/forecasts`). */
@@ -526,3 +536,40 @@ export interface ForecastDetail extends ForecastSummary {
location: { country: string; place?: string; geonames_id?: number } | null;
result: { year: number; solar_return: SolarReturn | null; forecast: Forecast };
}
/** A promo code on the admin page (`GET /v1/admin/promo-codes`). */
export interface PromoCode {
id: string;
/** ABCD-EFGH-JKLM */
code: string;
package: string;
package_name: string | null;
note: string | null;
created_at: string;
redeemed_at: string | null;
revoked_at: string | null;
redeemed_by: { email: string; name: string | null } | null;
}
/** A "how compatible are we?" invitation of the user (`GET /v1/invites`). */
export interface PersonInvite {
id: string;
chart_id: string;
label: string | null;
email: string | null;
message: string | null;
status: "pending" | "accepted" | "expired";
created_at: string;
expires_at: string;
accepted_at: string | null;
accepted_by: string | null;
synastry_id: string | null;
}
/** Landing data of a "how compatible are we?" link (`GET /v1/public/invites/{token}`). */
export interface PersonInviteLanding {
inviter_name: string | null;
message: string | null;
status: "pending" | "accepted" | "expired";
expires_at: string;
}