Compare commits
19
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ba11eda64c | ||
|
|
e4905ec5f1 | ||
|
|
f578e84b3f | ||
|
|
76bc965537 | ||
|
|
174ec31351 | ||
|
|
184f19e1f2 | ||
|
|
27ecdf386e | ||
|
|
4338a35202 | ||
|
|
2a0830fda0 | ||
|
|
e530e78c54 | ||
|
|
5e633b959d | ||
|
|
d9e71ed349 | ||
|
|
42a982010d | ||
|
|
a4df094191 | ||
|
|
55101f8637 | ||
|
|
15c88fc6be | ||
|
|
50cf334045 | ||
|
|
ddca7acbd4 | ||
|
|
55f5a1ac60 |
Generated
+1
@@ -170,6 +170,7 @@ dependencies = [
|
||||
"axum-extra",
|
||||
"db",
|
||||
"email-templates",
|
||||
"hmac",
|
||||
"horoscope-client",
|
||||
"http-body-util",
|
||||
"jsonwebtoken",
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
-- Stripe Checkout sessions started from the package cards. The package is
|
||||
-- granted once, when the payment is confirmed (webhook, or the return page
|
||||
-- asking Stripe), and the session id keeps that from happening twice.
|
||||
CREATE TABLE stripe_checkouts (
|
||||
-- Stripe's Checkout Session id (cs_test_… / cs_live_…).
|
||||
id text PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users ON DELETE CASCADE,
|
||||
package text NOT NULL,
|
||||
price_huf integer NOT NULL CHECK (price_huf > 0),
|
||||
live boolean NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
completed_at timestamptz,
|
||||
order_id uuid REFERENCES package_orders ON DELETE SET NULL
|
||||
);
|
||||
|
||||
CREATE INDEX stripe_checkouts_user_idx ON stripe_checkouts (user_id, created_at DESC);
|
||||
@@ -0,0 +1,64 @@
|
||||
-- What a confirmed payment keeps for the invoice, and the invoices issued in
|
||||
-- Billingo by the worker. Card details never reach us: only what Stripe
|
||||
-- reports about the payment and the buyer's billing details.
|
||||
|
||||
-- Payments outlive a deleted account: the accounting law asks for 8 years.
|
||||
ALTER TABLE stripe_checkouts ALTER COLUMN user_id DROP NOT NULL;
|
||||
ALTER TABLE stripe_checkouts DROP CONSTRAINT stripe_checkouts_user_id_fkey;
|
||||
ALTER TABLE stripe_checkouts ADD CONSTRAINT stripe_checkouts_user_id_fkey
|
||||
FOREIGN KEY (user_id) REFERENCES users ON DELETE SET NULL;
|
||||
|
||||
ALTER TABLE stripe_checkouts
|
||||
ADD COLUMN payment_intent text,
|
||||
-- What Stripe charged, in forints.
|
||||
ADD COLUMN amount_huf integer,
|
||||
-- Stripe's customer_details as it came: name, e-mail, address, and for a
|
||||
-- company its name and tax ids.
|
||||
ADD COLUMN customer jsonb;
|
||||
|
||||
-- One invoice per paid checkout. Every invoice detail is kept here (the buyer
|
||||
-- and the item as invoiced, Billingo's whole answer); the PDF itself is
|
||||
-- fetched from Billingo when downloaded.
|
||||
CREATE TABLE invoices (
|
||||
id uuid PRIMARY KEY,
|
||||
checkout_id text NOT NULL UNIQUE REFERENCES stripe_checkouts ON DELETE RESTRICT,
|
||||
user_id uuid REFERENCES users ON DELETE SET NULL,
|
||||
-- pending → issued; failed after the last retry (an admin looks at it).
|
||||
status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'issued', 'failed')),
|
||||
attempts integer NOT NULL DEFAULT 0,
|
||||
next_attempt_at timestamptz NOT NULL DEFAULT now(),
|
||||
last_error text,
|
||||
-- The buyer as invoiced.
|
||||
buyer_name text NOT NULL,
|
||||
buyer_email text,
|
||||
buyer_country text NOT NULL,
|
||||
buyer_post_code text NOT NULL,
|
||||
buyer_city text NOT NULL,
|
||||
buyer_address text NOT NULL,
|
||||
-- Billingo's partner tax type: HAS_TAX_NUMBER, NO_TAX_NUMBER or FOREIGN.
|
||||
buyer_tax_type text NOT NULL CHECK (buyer_tax_type IN ('HAS_TAX_NUMBER', 'NO_TAX_NUMBER', 'FOREIGN')),
|
||||
buyer_tax_number text,
|
||||
-- The single item. vat_rate is Billingo's VAT value: AAM (alanyi
|
||||
-- adómentes: net = gross, no VAT) or a rate like 27%.
|
||||
item_name text NOT NULL,
|
||||
gross_huf integer NOT NULL CHECK (gross_huf > 0),
|
||||
net_huf integer NOT NULL,
|
||||
vat_huf integer NOT NULL,
|
||||
vat_rate text NOT NULL DEFAULT 'AAM',
|
||||
payment_method text NOT NULL DEFAULT 'online_bankcard',
|
||||
-- From Billingo.
|
||||
billingo_partner_id bigint,
|
||||
billingo_document_id bigint UNIQUE,
|
||||
invoice_number text,
|
||||
invoice_date date,
|
||||
fulfillment_date date,
|
||||
due_date date,
|
||||
document jsonb,
|
||||
-- When Billingo e-mailed it to the buyer.
|
||||
sent_at timestamptz,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
issued_at timestamptz
|
||||
);
|
||||
|
||||
CREATE INDEX invoices_user_idx ON invoices (user_id, created_at DESC);
|
||||
CREATE INDEX invoices_due_idx ON invoices (next_attempt_at) WHERE status = 'pending';
|
||||
@@ -0,0 +1,5 @@
|
||||
-- The invoice item must identify the service (Áfa tv. 169. § e): what the
|
||||
-- package contains goes under the item, and the unit is "csomag".
|
||||
ALTER TABLE invoices
|
||||
ADD COLUMN item_comment text,
|
||||
ADD COLUMN item_unit text NOT NULL DEFAULT 'csomag';
|
||||
+1
-1
@@ -68,7 +68,7 @@ A Docker által kinyitott portokat az ufw magától nem szűri, ezért a 80-as
|
||||
`deploy` felhasználóként, a `/opt/sorsfonalak` mappában:
|
||||
|
||||
- `.env`: az itteni `.env.example` kitöltve.
|
||||
- `.env.secrets`: `OPENROUTER_API_KEY=...`.
|
||||
- `.env.secrets`: `OPENROUTER_API_KEY=...`, a levélküldés adatai, és ha van, `STRIPE_SECRET_KEY` / `STRIPE_WEBHOOK_SECRET` és `BILLINGO_API_KEY` (`docs/fizetes.md`).
|
||||
- `docker login registry.sagifer.com` egy `read:package` jogú tokennel. Amíg a `sagifer` fiók nyilvános, erre nincs szükség.
|
||||
|
||||
### Cloudflare (sorsfonalak.hu)
|
||||
|
||||
@@ -85,9 +85,14 @@ services:
|
||||
ANALYSIS_MODEL: ${ANALYSIS_MODEL:-}
|
||||
SUMMARY_MODEL: ${SUMMARY_MODEL:-}
|
||||
PASSWORD_LOGIN: ${PASSWORD_LOGIN:-false}
|
||||
# Purchases are off until real payments are connected; packages come
|
||||
# from promo codes and admins (MOCK_PAYMENTS=true: pretend purchases).
|
||||
# Without the Stripe keys purchases are off; packages come from promo
|
||||
# codes and admins (MOCK_PAYMENTS=true: pretend purchases).
|
||||
MOCK_PAYMENTS: ${MOCK_PAYMENTS:-false}
|
||||
# Stripe purchases for everyone (false: admins only, until the opening;
|
||||
# with a test key always admins only).
|
||||
PURCHASES_OPEN: ${PURCHASES_OPEN:-false}
|
||||
# VAT on the invoices: AAM (alanyi adómentes) or a rate like 27%.
|
||||
INVOICE_VAT: ${INVOICE_VAT:-AAM}
|
||||
# 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.
|
||||
@@ -95,6 +100,11 @@ services:
|
||||
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}
|
||||
# STRIPE_SECRET_KEY and STRIPE_WEBHOOK_SECRET (docs/fizetes.md): with them
|
||||
# packages can be bought (a test key: by admins only).
|
||||
env_file:
|
||||
- path: .env.secrets
|
||||
required: false
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
@@ -109,7 +119,7 @@ services:
|
||||
image: ${REGISTRY_PREFIX:-registry.sagifer.com/sagifer/sorsfonalak}-worker:${TAG:-latest}
|
||||
environment:
|
||||
DATABASE_URL: postgres://sorsfonalak:${POSTGRES_PASSWORD}@postgres:5432/sorsfonalak
|
||||
WORKER_TASKS: email,cleanup
|
||||
WORKER_TASKS: email,cleanup,invoices
|
||||
# SMTP_URL or the SES credentials come from .env.secrets (docs/levelkuldes.md);
|
||||
# listing them here with an empty default would override that file.
|
||||
SES_REGION: ${SES_REGION:-eu-central-1}
|
||||
|
||||
@@ -55,9 +55,19 @@ services:
|
||||
PASSWORD_LOGIN: ${PASSWORD_LOGIN:-false}
|
||||
# Stand-in payment (adds an analysis unit at once) until Stripe is connected.
|
||||
MOCK_PAYMENTS: ${MOCK_PAYMENTS:-true}
|
||||
# Stripe purchases for everyone (false: admins only, until the opening;
|
||||
# with a test key always admins only).
|
||||
PURCHASES_OPEN: ${PURCHASES_OPEN:-false}
|
||||
# VAT on the invoices: AAM (alanyi adómentes) or a rate like 27%.
|
||||
INVOICE_VAT: ${INVOICE_VAT:-AAM}
|
||||
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}
|
||||
# STRIPE_SECRET_KEY / STRIPE_WEBHOOK_SECRET (test keys; docs/fizetes.md).
|
||||
# With them Stripe replaces the stand-in payment.
|
||||
env_file:
|
||||
- path: .env.secrets
|
||||
required: false
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
# Arculat
|
||||
|
||||
- `sorsfonalak-ikon-512.png`: négyzetes ikon (512×512, sötét háttér, teljes kitöltés).
|
||||
- `sorsfonalak-logo-sotet-hatterre.png`: logó átlátszó háttérrel, sötét felületre (1200×300).
|
||||
- `sorsfonalak-logo-vilagos-hatterre.png`: ugyanez világos felületre.
|
||||
|
||||
A jel forrása: `services/frontend/src/app/icon.svg`.
|
||||
|
||||
## Színek
|
||||
|
||||
| Szerep | Szín |
|
||||
|---|---|
|
||||
| Háttér | `#0d1220` |
|
||||
| Panel | `#111729` |
|
||||
| Arany (kiemelés, gombok) | `#d9b46a` |
|
||||
| Arany, világos háttéren | `#a7802f` |
|
||||
| Szöveg sötét háttéren | `#ece6d8` |
|
||||
| Szöveg világos háttéren | `#1b2236` |
|
||||
| Gomb felirata arany gombon | `#141a2c` |
|
||||
|
||||
Stripe (Settings → Branding): Brand color `#0d1220`, Accent color `#d9b46a`, ikon és a sötét háttérre szánt logó.
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 18 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 26 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 26 KiB |
+2
-3
@@ -4,7 +4,7 @@ A katalógus a kódban van: `services/backend/src/packages.rs` (`CATALOG`). Ár-
|
||||
|
||||
## Költség
|
||||
|
||||
Egy részletes képletelemzés és egy kapcsolati elemzés is kb. **$0,21 (≈ 80 Ft)** Opus 5.5-tel, az éves előrejelzés a hosszabb adatsor miatt valamivel több; a rövid összefoglaló kb. $0,01. A fizetési szolgáltató díja kb. 1,5% + 85 Ft tranzakciónként. Az árak bruttók (27% áfa).
|
||||
Egy részletes képletelemzés és egy kapcsolati elemzés is kb. **$0,21 (≈ 80 Ft)** Opus 5.5-tel, az éves előrejelzés a hosszabb adatsor miatt valamivel több; a rövid összefoglaló kb. $0,01. A fizetési szolgáltató díja kb. 1,5% + 85 Ft tranzakciónként. Az árak végső árak: alanyi adómentesek vagyunk (`INVOICE_VAT=AAM`), áfát nem számítunk fel; ha átlépjük az alanyi adómentesség határát, `INVOICE_VAT=27%`, és az árak bruttóként értendők.
|
||||
|
||||
## A lépcső
|
||||
|
||||
@@ -39,7 +39,6 @@ Az éves előrejelzés (2026 novembere óta) a Páros és a Család csomagban mi
|
||||
|
||||
## Későbbre
|
||||
|
||||
- Stripe-bekötés: a `package_orders.source = 'stripe'` már helyet kapott.
|
||||
- Bevezető kedvezmény vagy kupon (pl. az első 100 vásárlónak).
|
||||
- Ajándékba adható csomag (karácsony, Valentin-nap): a Páros és a Család jó ajándék.
|
||||
- Számlázás (NAV Online Számla) a vásárlásokhoz.
|
||||
- Számlázás (NAV Online Számla) a vásárlásokhoz. A fizetés a Stripe-on megy: [fizetes.md](fizetes.md).
|
||||
|
||||
@@ -0,0 +1,80 @@
|
||||
# Fizetés (Stripe)
|
||||
|
||||
A csomagokat a Stripe Checkout fizetési oldalán lehet megvenni. A csomagok neve, tartalma és ára a `services/backend/src/packages.rs`-ben van; minden fizetés ezekkel indul, a Stripe-ban nem kell termékeket felvenni.
|
||||
|
||||
## Menete
|
||||
|
||||
1. A „Megveszem” gomb a `POST /v1/payments/checkout` végpontot hívja (`package`, `return_path`: az oldal, ahonnan indult).
|
||||
2. A backend létrehoz egy Checkout Sessiont (bruttó ár forintban, a csomag neve, a felhasználó e-mail-címe, kötelező számlázási cím), elmenti a `stripe_checkouts` táblába, és visszaadja a fizetési oldal címét.
|
||||
3. Fizetés után a Stripe visszaküld ugyanarra az oldalra `?fizetes=<session id>` paraméterrel (megszakításkor `?fizetes=megszakitva`). A `PaymentReturn` komponens a `GET /v1/payments/checkout/{id}` végpontot kérdezi, amíg a fizetés be nem igazolódik.
|
||||
4. A csomagot a backend akkor adja meg, amikor a Stripe igazolja a fizetést:
|
||||
- a webhook (`POST /api/v1/payments/stripe/webhook`, aláírással ellenőrizve), vagy
|
||||
- ha a webhook még nem jött meg (vagy helyben nincs beállítva), a visszatérő oldal kérdésére a backend maga kérdezi meg a Stripe-ot.
|
||||
|
||||
A session id miatt egy fizetés csak egyszer ír jóvá (`package_orders.source = 'stripe'`).
|
||||
|
||||
## Mit tárolunk
|
||||
|
||||
Bankkártyaadatot soha: a vásárló a Stripe oldalán adja meg, hozzánk nem jut el. A `stripe_checkouts` sorban a fizetés igazolásakor eltároljuk:
|
||||
|
||||
- a Stripe fizetés azonosítóját (`payment_intent`) és a ténylegesen fizetett összeget (`amount_huf`; ha eltér az ártól, hibát naplózunk),
|
||||
- a vevő számlázási adatait (`customer`: a Stripe `customer_details` objektuma: név, e-mail, cím, céges vásárlásnál `business_name` és `tax_ids`, pl. `hu_tin` / `eu_vat`).
|
||||
|
||||
A fizetési oldal kötelezően bekéri a számlázási címet, és felkínálja a céges vásárlást (cégnév, adószám; `tax_id_collection`).
|
||||
|
||||
A sorok a fiók törlése után is megmaradnak (`user_id` → NULL), mert a számviteli törvény 8 évig megőrzést ír elő; ilyenkor csomag már nem jár, de a számla elkészül.
|
||||
|
||||
## Számla
|
||||
|
||||
Fizetéskor a backend egy `invoices` sort is létrehoz a számla minden adatával: a vevő (név, e-mail, ország, irányítószám, város, cím, Billingo-adótípus: `HAS_TAX_NUMBER` / `NO_TAX_NUMBER` / `FOREIGN`, adószám) és a tétel (név, végösszeg, nettó, áfa, áfakód). Az áfakód az `INVOICE_VAT` (a backend `.env`-je): alapból `AAM` (alanyi adómentes: nettó = végösszeg, áfa 0, a számla megjegyzésében „Alanyi adómentes.”), vagy egy kulcs, pl. `27%`. A tétel a törvény szerint azonosítja a szolgáltatást (Áfa tv. 169. § e): megnevezése pl. „Online tartalomszolgáltatás – Páros csomag”, egysége `csomag`, megjegyzése a tartalom („Hozzáférés a sorsfonalak.hu szoftveresen előállított, személyre szabott szöveges tartalmaihoz: 2 képletelemzés, … Digitális tartalom.”; `Package::invoice_item`). Szándékosan nem „asztrológiai”: a szolgáltatás egy weboldal programmal előállított tartalma, nem személyes szakmai tanácsadás. Cégnél a `business_name` és a magyar adószám (`hu_tin`, ennek híján `eu_vat`) kerül a számlára.
|
||||
|
||||
**Teszt módú fizetéshez (`sk_test_…`) nem készül számla**, mert a Billingo számlái valódiak (a NAV-hoz is bekerülnek); a csomagot ilyenkor is megkapja az admin.
|
||||
|
||||
A worker `invoices` feladata (`WORKER_TASKS`, prodon a `worker` konténerben) a Billingo API v3-mal:
|
||||
|
||||
1. létrehozza a partnert (`POST /partners`),
|
||||
2. kiállítja a számlát (`POST /documents`: `type=invoice`, `paid=true`, `electronic=true`, `payment_method=online_bankcard`, bruttó egységár, teljesítés = a fizetés napja magyar idő szerint),
|
||||
3. e-mailben elküldi a vevőnek (`POST /documents/{id}/send`).
|
||||
|
||||
Minden lépés eredményét elmenti a következő előtt, így újrapróbáláskor ott folytatja, ahol abbamaradt, és nem állít ki két számlát. A Billingo teljes válasza a `document` oszlopba kerül (a PDF nem: azt letöltéskor a backend kéri le, `GET /documents/{id}/download`). Hibánál növekvő várakozással újrapróbál (`MAX_INVOICE_ATTEMPTS`, alapból 10, kb. egy nap), utána `failed` lesz, és a `last_error` mondja meg, mi a baj.
|
||||
|
||||
A felhasználó a **Számláim** oldalon (`/szamlak`; a menüpont az első számlával jelenik meg) töltheti le a számláit.
|
||||
|
||||
Beállítás (`.env.secrets`, a backend és a worker is olvassa):
|
||||
|
||||
```
|
||||
BILLINGO_API_KEY=...
|
||||
```
|
||||
|
||||
A számlatömb alapból a fiók első számlatömbje; másikhoz `BILLINGO_BLOCK_ID` a `.env`-ben vagy a `.env.secrets`-ben.
|
||||
|
||||
## Beállítás
|
||||
|
||||
A kulcsok a `.env.secrets` fájlba kerülnek (helyben a repó gyökerében, a szerveren a `/opt/sorsfonalak` mappában), git-be soha:
|
||||
|
||||
```
|
||||
STRIPE_SECRET_KEY=sk_test_...
|
||||
STRIPE_WEBHOOK_SECRET=whsec_...
|
||||
```
|
||||
|
||||
- **A megnyitásig csak az adminok vásárolhatnak** (`PURCHASES_OPEN=false`, az alapértelmezés), a többieknek a gombok „Hamarosan” feliratúak; így senki nem ad meg valódi kártyát egy teszt- vagy félkész beállításnál.
|
||||
- Teszt kulccsal (`sk_test_…`) `PURCHASES_OPEN=true` mellett is csak adminok vásárolhatnak (a Stripe tesztkártyáival senki nem jut csomaghoz). Tesztkártya: `4242 4242 4242 4242`, bármilyen jövőbeli lejárat és CVC.
|
||||
- Élő kulccsal és `PURCHASES_OPEN=true` mellett mindenki vásárolhat (megnyitáskor, a `.env`-ben).
|
||||
- Kulcs nélkül nincs vásárlás (helyben a `MOCK_PAYMENTS=true` próbafizetés működik; a Stripe-kulcs ezt felülírja).
|
||||
|
||||
A Stripe felületén:
|
||||
|
||||
1. **Developers → API keys**: a Secret key → `STRIPE_SECRET_KEY`.
|
||||
2. **Developers → Webhooks → Add endpoint**: `https://sorsfonalak.hu/api/v1/payments/stripe/webhook`, események: `checkout.session.completed` és `checkout.session.async_payment_succeeded`. A Signing secret → `STRIPE_WEBHOOK_SECRET`. Teszt és élő módban külön végpontot kell felvenni, külön titokkal.
|
||||
3. **Settings → Branding**: logó, színek (a fizetési oldal kinézete).
|
||||
4. **Settings → Payment methods**: bankkártya, Apple Pay, Google Pay.
|
||||
|
||||
A kulcsok módosítása után a backendet újra kell indítani (`docker compose up -d backend`).
|
||||
|
||||
Helyben a webhook nem ér el a géphez; nem is kell, mert a visszatérő oldal a Stripe-tól kérdezi le a fizetést. Ha mégis próbálni kell: `stripe listen --forward-to localhost:3001/api/v1/payments/stripe/webhook`.
|
||||
|
||||
## Megnyitás előtt
|
||||
|
||||
- A Stripe-fiók aktiválása (céges adatok, bankszámla), élő kulcsok és élő webhook.
|
||||
- Az első éles számlát nézd át a Billingóban (vevő, adószám, áfa, teljesítési dátum). A Stripe nyugtája nem magyar számla: a Stripe felületén a Customer emails → Successful payments legyen kikapcsolva.
|
||||
- Visszatérítés: egyelőre a Stripe felületén, a csomagot pedig az admin oldalon kell kézzel csökkenteni.
|
||||
@@ -10,6 +10,7 @@ publish.workspace = true
|
||||
db.workspace = true
|
||||
analysis-prompt.workspace = true
|
||||
email-templates.workspace = true
|
||||
hmac.workspace = true
|
||||
horoscope-client.workspace = true
|
||||
service-kit.workspace = true
|
||||
anyhow.workspace = true
|
||||
|
||||
@@ -45,6 +45,19 @@ 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,
|
||||
/// Stripe Checkout, when `STRIPE_SECRET_KEY` is set (it wins over
|
||||
/// `MOCK_PAYMENTS`).
|
||||
pub stripe: Option<StripeConfig>,
|
||||
/// `INVOICE_VAT` (default `AAM`, alanyi adómentes; or e.g. `27%`).
|
||||
pub invoice_vat: crate::invoices::Vat,
|
||||
/// `BILLINGO_API_KEY`: downloading invoices (the worker issues them).
|
||||
pub billingo_api_key: Option<String>,
|
||||
/// `BILLINGO_API_URL` (default `https://api.billingo.hu/v3`).
|
||||
pub billingo_api_url: String,
|
||||
/// `PURCHASES_OPEN` (default `false`): everyone may buy through Stripe.
|
||||
/// Until the opening only admins can (and with a test key always only
|
||||
/// admins), so nobody types a real card into a test or unfinished setup.
|
||||
pub purchases_open: 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.
|
||||
@@ -85,6 +98,34 @@ pub struct Config {
|
||||
pub signup_mode: SignupMode,
|
||||
}
|
||||
|
||||
/// `STRIPE_SECRET_KEY` (`sk_test_…` or `sk_live_…`), `STRIPE_WEBHOOK_SECRET`
|
||||
/// (`whsec_…`, from the webhook endpoint in the Stripe dashboard) and
|
||||
/// `STRIPE_API_URL` (default `https://api.stripe.com`, tests change it).
|
||||
#[derive(Clone)]
|
||||
pub struct StripeConfig {
|
||||
pub secret_key: String,
|
||||
pub webhook_secret: Option<String>,
|
||||
pub api_url: String,
|
||||
}
|
||||
|
||||
impl StripeConfig {
|
||||
/// A test-mode key: no real money moves.
|
||||
pub fn test_mode(&self) -> bool {
|
||||
self.secret_key.starts_with("sk_test_") || self.secret_key.starts_with("rk_test_")
|
||||
}
|
||||
}
|
||||
|
||||
// The keys stay out of logs.
|
||||
impl std::fmt::Debug for StripeConfig {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("StripeConfig")
|
||||
.field("test_mode", &self.test_mode())
|
||||
.field("webhook_secret", &self.webhook_secret.is_some())
|
||||
.field("api_url", &self.api_url)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
fn var(name: &str) -> Option<String> {
|
||||
std::env::var(name).ok().map(|v| v.trim().to_string()).filter(|v| !v.is_empty())
|
||||
}
|
||||
@@ -127,6 +168,25 @@ impl Config {
|
||||
session_ttl_days: parsed("SESSION_TTL_DAYS", 30)?,
|
||||
password_login: parsed("PASSWORD_LOGIN", false)?,
|
||||
mock_payments: parsed("MOCK_PAYMENTS", false)?,
|
||||
stripe: var("STRIPE_SECRET_KEY").map(|secret_key| StripeConfig {
|
||||
secret_key,
|
||||
webhook_secret: var("STRIPE_WEBHOOK_SECRET"),
|
||||
api_url: var("STRIPE_API_URL")
|
||||
.unwrap_or_else(|| "https://api.stripe.com".into())
|
||||
.trim_end_matches('/')
|
||||
.to_string(),
|
||||
}),
|
||||
invoice_vat: match var("INVOICE_VAT") {
|
||||
None => crate::invoices::Vat::Exempt,
|
||||
Some(raw) => crate::invoices::Vat::parse(&raw)
|
||||
.with_context(|| format!("invalid INVOICE_VAT '{raw}': use AAM or a rate like 27%"))?,
|
||||
},
|
||||
billingo_api_key: var("BILLINGO_API_KEY"),
|
||||
billingo_api_url: var("BILLINGO_API_URL")
|
||||
.unwrap_or_else(|| "https://api.billingo.hu/v3".into())
|
||||
.trim_end_matches('/')
|
||||
.to_string(),
|
||||
purchases_open: parsed("PURCHASES_OPEN", false)?,
|
||||
user_invites: parsed("USER_INVITES", false)?,
|
||||
referral_rewards: parsed("REFERRAL_REWARDS", false)?,
|
||||
google_client_ids: list("GOOGLE_CLIENT_IDS"),
|
||||
@@ -166,6 +226,11 @@ impl Config {
|
||||
session_ttl_days: 30,
|
||||
password_login: true,
|
||||
mock_payments: true,
|
||||
stripe: None,
|
||||
invoice_vat: crate::invoices::Vat::Exempt,
|
||||
billingo_api_key: Some("billingo-fake".into()),
|
||||
billingo_api_url: format!("{horoscope_api_url}/billingo"),
|
||||
purchases_open: true,
|
||||
user_invites: true,
|
||||
referral_rewards: true,
|
||||
google_client_ids: vec!["test-client.apps.googleusercontent.com".into()],
|
||||
|
||||
@@ -0,0 +1,182 @@
|
||||
//! Invoices of the Stripe payments. When a payment is confirmed, an invoice
|
||||
//! row is queued with the buyer and the item as they go on the invoice; the
|
||||
//! worker issues it in Billingo (`services/worker/src/invoices.rs`). Users
|
||||
//! download the PDF through the backend, which fetches it from Billingo.
|
||||
|
||||
use serde_json::Value;
|
||||
use sqlx::PgConnection;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::error::ApiError;
|
||||
|
||||
/// The VAT on the invoices (`INVOICE_VAT`): `AAM` (alanyi adómentes, subject
|
||||
/// to the small business exemption: no VAT, net = gross) or a rate like `27%`.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Vat {
|
||||
Exempt,
|
||||
Percent(i64),
|
||||
}
|
||||
|
||||
impl Vat {
|
||||
pub fn parse(raw: &str) -> Option<Self> {
|
||||
match raw.trim() {
|
||||
"AAM" => Some(Vat::Exempt),
|
||||
rate => rate.strip_suffix('%')?.trim().parse().ok().filter(|p| (1..=27).contains(p)).map(Vat::Percent),
|
||||
}
|
||||
}
|
||||
|
||||
/// Billingo's VAT value.
|
||||
pub fn code(self) -> String {
|
||||
match self {
|
||||
Vat::Exempt => "AAM".into(),
|
||||
Vat::Percent(p) => format!("{p}%"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Net and VAT parts of a gross price (rounded to forints, as Billingo does).
|
||||
pub fn split(self, gross: i64) -> (i64, i64) {
|
||||
match self {
|
||||
Vat::Exempt => (gross, 0),
|
||||
Vat::Percent(p) => {
|
||||
let net = (gross * 200 + 100 + p) / (200 + 2 * p);
|
||||
(net, gross - net)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The buyer as invoiced, from Stripe's `customer_details`.
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub struct Buyer {
|
||||
pub name: String,
|
||||
pub email: Option<String>,
|
||||
pub country: String,
|
||||
pub post_code: String,
|
||||
pub city: String,
|
||||
pub address: String,
|
||||
/// Billingo's partner tax type: `HAS_TAX_NUMBER`, `NO_TAX_NUMBER` or `FOREIGN`.
|
||||
pub tax_type: &'static str,
|
||||
pub tax_number: Option<String>,
|
||||
}
|
||||
|
||||
fn text(v: &Value) -> Option<String> {
|
||||
v.as_str().map(str::trim).filter(|s| !s.is_empty()).map(str::to_string)
|
||||
}
|
||||
|
||||
impl Buyer {
|
||||
/// A company ("buying as a business") gives its name and tax id: a
|
||||
/// Hungarian tax number (`hu_tin`) is preferred to an EU VAT number.
|
||||
pub fn from_stripe(details: &Value, fallback_email: Option<&str>) -> Self {
|
||||
let address = &details["address"];
|
||||
let tax_ids = details["tax_ids"].as_array().map(Vec::as_slice).unwrap_or_default();
|
||||
let tax_id = |kind: &str| tax_ids.iter().find(|t| t["type"] == kind).and_then(|t| text(&t["value"]));
|
||||
let tax_number = tax_id("hu_tin").or_else(|| tax_id("eu_vat"));
|
||||
let country = text(&address["country"]).unwrap_or_else(|| "HU".into()).to_uppercase();
|
||||
let tax_type = match (&tax_number, country.as_str()) {
|
||||
(_, c) if c != "HU" => "FOREIGN",
|
||||
(Some(_), _) => "HAS_TAX_NUMBER",
|
||||
(None, _) => "NO_TAX_NUMBER",
|
||||
};
|
||||
let street = [text(&address["line1"]), text(&address["line2"])].into_iter().flatten().collect::<Vec<_>>();
|
||||
Self {
|
||||
name: text(&details["business_name"])
|
||||
.filter(|_| tax_number.is_some())
|
||||
.or_else(|| text(&details["name"]))
|
||||
.unwrap_or_else(|| "Vevő".into()),
|
||||
email: text(&details["email"]).or_else(|| fallback_email.map(str::to_string)),
|
||||
country,
|
||||
post_code: text(&address["postal_code"]).unwrap_or_default(),
|
||||
city: text(&address["city"]).unwrap_or_default(),
|
||||
address: street.join(", "),
|
||||
tax_type,
|
||||
tax_number,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Queues the invoice of a paid checkout, inside the caller's transaction.
|
||||
pub async fn queue(
|
||||
tx: &mut PgConnection,
|
||||
checkout_id: &str,
|
||||
user_id: Option<Uuid>,
|
||||
buyer: &Buyer,
|
||||
(item_name, item_comment): (&str, &str),
|
||||
gross_huf: i64,
|
||||
vat: Vat,
|
||||
) -> Result<Uuid, ApiError> {
|
||||
let id = Uuid::now_v7();
|
||||
let (net, vat_huf) = vat.split(gross_huf);
|
||||
sqlx::query(
|
||||
"INSERT INTO invoices (id, checkout_id, user_id, buyer_name, buyer_email, buyer_country, buyer_post_code, \
|
||||
buyer_city, buyer_address, buyer_tax_type, buyer_tax_number, item_name, gross_huf, net_huf, vat_huf, vat_rate, \
|
||||
item_comment) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17) \
|
||||
ON CONFLICT (checkout_id) DO NOTHING",
|
||||
)
|
||||
.bind(id)
|
||||
.bind(checkout_id)
|
||||
.bind(user_id)
|
||||
.bind(&buyer.name)
|
||||
.bind(&buyer.email)
|
||||
.bind(&buyer.country)
|
||||
.bind(&buyer.post_code)
|
||||
.bind(&buyer.city)
|
||||
.bind(&buyer.address)
|
||||
.bind(buyer.tax_type)
|
||||
.bind(&buyer.tax_number)
|
||||
.bind(item_name)
|
||||
.bind(gross_huf as i32)
|
||||
.bind(net as i32)
|
||||
.bind(vat_huf as i32)
|
||||
.bind(vat.code())
|
||||
.bind(item_comment)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
Ok(id)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use serde_json::json;
|
||||
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn gross_prices_split_into_net_and_vat() {
|
||||
let vat = Vat::parse("27%").unwrap();
|
||||
assert_eq!(vat.split(2000), (1575, 425));
|
||||
assert_eq!(vat.split(6000), (4724, 1276));
|
||||
assert_eq!(vat.split(127), (100, 27));
|
||||
assert_eq!(vat.code(), "27%");
|
||||
// Alanyi adómentes: no VAT at all.
|
||||
assert_eq!(Vat::parse("AAM"), Some(Vat::Exempt));
|
||||
assert_eq!(Vat::Exempt.split(6000), (6000, 0));
|
||||
assert_eq!(Vat::parse("huszonhét"), None);
|
||||
assert_eq!(Vat::parse("99%"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn buyers_from_stripe() {
|
||||
let person = Buyer::from_stripe(
|
||||
&json!({"name": "Kovács Anna", "email": "anna@example.com",
|
||||
"address": {"line1": "Fő utca 1.", "line2": "2/3", "postal_code": "6720", "city": "Szeged", "country": "HU"},
|
||||
"tax_ids": []}),
|
||||
None,
|
||||
);
|
||||
assert_eq!(person.name, "Kovács Anna");
|
||||
assert_eq!(person.address, "Fő utca 1., 2/3");
|
||||
assert_eq!((person.tax_type, person.tax_number), ("NO_TAX_NUMBER", None));
|
||||
|
||||
let company = Buyer::from_stripe(
|
||||
&json!({"name": "Kovács Anna", "business_name": "Csillag Kft.",
|
||||
"address": {"line1": "Kossuth tér 2.", "postal_code": "1055", "city": "Budapest", "country": "HU"},
|
||||
"tax_ids": [{"type": "eu_vat", "value": "HU12345678"}, {"type": "hu_tin", "value": "12345678-1-23"}]}),
|
||||
Some("anna@example.com"),
|
||||
);
|
||||
assert_eq!(company.name, "Csillag Kft.");
|
||||
assert_eq!(company.email.as_deref(), Some("anna@example.com"));
|
||||
assert_eq!((company.tax_type, company.tax_number.as_deref()), ("HAS_TAX_NUMBER", Some("12345678-1-23")));
|
||||
|
||||
let abroad = Buyer::from_stripe(&json!({"name": "Anna", "address": {"country": "at"}}), None);
|
||||
assert_eq!((abroad.country.as_str(), abroad.tax_type), ("AT", "FOREIGN"));
|
||||
}
|
||||
}
|
||||
@@ -13,10 +13,12 @@ mod config;
|
||||
mod credits;
|
||||
mod error;
|
||||
mod google;
|
||||
mod invoices;
|
||||
mod models;
|
||||
mod packages;
|
||||
mod persons;
|
||||
mod routes;
|
||||
mod stripe;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
mod views;
|
||||
@@ -41,6 +43,7 @@ pub struct AppState {
|
||||
pub google: GoogleVerifier,
|
||||
pub login_limiter: LoginLimiter,
|
||||
pub models: models::Catalog,
|
||||
pub stripe: stripe::Client,
|
||||
}
|
||||
|
||||
impl AppState {
|
||||
@@ -50,6 +53,7 @@ impl AppState {
|
||||
google: GoogleVerifier::new(config.google_client_ids.clone(), config.google_jwks_url.clone()),
|
||||
login_limiter: LoginLimiter::new(10, Duration::from_secs(15 * 60)),
|
||||
models: models::Catalog::new(&config.openrouter_models_url),
|
||||
stripe: stripe::Client::default(),
|
||||
db,
|
||||
config,
|
||||
}
|
||||
|
||||
@@ -37,7 +37,7 @@ pub struct Package {
|
||||
pub name: &'static str,
|
||||
pub tagline: &'static str,
|
||||
pub tier: Tier,
|
||||
/// Gross price (27% VAT included).
|
||||
/// The price paid (with VAT if `INVOICE_VAT` is a rate; none under AAM).
|
||||
pub price_huf: i64,
|
||||
pub natal: i64,
|
||||
pub synastry: i64,
|
||||
@@ -186,6 +186,8 @@ pub enum Source {
|
||||
Mock,
|
||||
/// A redeemed promo code.
|
||||
Promo,
|
||||
/// Paid through Stripe Checkout.
|
||||
Stripe,
|
||||
}
|
||||
|
||||
impl Source {
|
||||
@@ -194,11 +196,39 @@ impl Source {
|
||||
Source::Admin => "admin",
|
||||
Source::Mock => "mock",
|
||||
Source::Promo => "promo",
|
||||
Source::Stripe => "stripe",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Package {
|
||||
/// The invoice item: a name that says what the service is (online,
|
||||
/// software-made content; no profession implied), and what the package
|
||||
/// contains (Áfa tv. 169. § e).
|
||||
pub fn invoice_item(&self) -> (String, String) {
|
||||
let name = match self.tier {
|
||||
Tier::Main => format!("Online tartalomszolgáltatás – {} csomag", self.name),
|
||||
Tier::Addon => format!("Online tartalomszolgáltatás – {} kiegészítő", self.name),
|
||||
};
|
||||
let lines: Vec<String> = [
|
||||
(self.natal, "képletelemzés"),
|
||||
(self.synastry, "kapcsolati elemzés"),
|
||||
(self.forecast, "éves előrejelzés"),
|
||||
(self.persons, "további személy felvétele"),
|
||||
(self.questions, "kérdés"),
|
||||
]
|
||||
.into_iter()
|
||||
.filter(|&(n, _)| n > 0)
|
||||
.map(|(n, what)| format!("{n} {what}"))
|
||||
.collect();
|
||||
let comment = format!(
|
||||
"Hozzáférés a sorsfonalak.hu szoftveresen előállított, személyre szabott szöveges tartalmaihoz: {}. \
|
||||
Digitális tartalom.",
|
||||
lines.join(", ")
|
||||
);
|
||||
(name, comment)
|
||||
}
|
||||
|
||||
/// What the package gives, unit by unit.
|
||||
pub fn contents(&self) -> [(Unit, i64); 5] {
|
||||
[
|
||||
@@ -268,7 +298,7 @@ async fn record(
|
||||
let order = Uuid::now_v7();
|
||||
let price = match source {
|
||||
Source::Admin | Source::Promo => 0,
|
||||
Source::Mock => package.price_huf,
|
||||
Source::Mock | Source::Stripe => package.price_huf,
|
||||
};
|
||||
sqlx::query(
|
||||
"INSERT INTO package_orders (id, user_id, package, source, price_huf, note, created_by) \
|
||||
@@ -338,4 +368,21 @@ mod tests {
|
||||
assert!(CATALOG.iter().filter(|p| p.tier == Tier::Main).all(|p| p.questions == QUESTIONS_INCLUDED));
|
||||
assert_eq!(find("addon_questions").unwrap().questions, 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invoice_items_say_what_was_bought() {
|
||||
let (name, comment) = find("couple").unwrap().invoice_item();
|
||||
assert_eq!(name, "Online tartalomszolgáltatás – Páros csomag");
|
||||
assert_eq!(
|
||||
comment,
|
||||
"Hozzáférés a sorsfonalak.hu szoftveresen előállított, személyre szabott szöveges tartalmaihoz: \
|
||||
2 képletelemzés, 1 kapcsolati elemzés, 2 éves előrejelzés, 1 további személy felvétele, 3 kérdés. \
|
||||
Digitális tartalom."
|
||||
);
|
||||
let (name, comment) = find("addon_persons").unwrap().invoice_item();
|
||||
assert_eq!(name, "Online tartalomszolgáltatás – +5 személy kiegészítő");
|
||||
assert!(comment.ends_with("tartalmaihoz: 5 további személy felvétele. Digitális tartalom."), "{comment}");
|
||||
// No profession is implied.
|
||||
assert!(CATALOG.iter().all(|p| !format!("{:?}", p.invoice_item()).to_lowercase().contains("asztrol")));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -35,6 +35,10 @@ pub async fn me(State(state): St, auth: AuthUser) -> ApiResult<Json<Value>> {
|
||||
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?;
|
||||
let (invoices,): (i64,) = sqlx::query_as("SELECT count(*) FROM invoices WHERE user_id = $1")
|
||||
.bind(auth.id())
|
||||
.fetch_one(&mut *conn)
|
||||
.await?;
|
||||
Ok(Json(json!({
|
||||
"user": UserView::from(&auth.user),
|
||||
"providers": providers.into_iter().map(|(p,)| p).collect::<Vec<_>>(),
|
||||
@@ -47,6 +51,8 @@ pub async fn me(State(state): St, auth: AuthUser) -> ApiResult<Json<Value>> {
|
||||
"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 },
|
||||
// The "Számláim" menu shows up with the first invoice.
|
||||
"invoice_count": invoices,
|
||||
})))
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
//! The user's invoices: the list, and the PDF fetched from Billingo on
|
||||
//! download (we keep every invoice detail, but not the PDF itself).
|
||||
|
||||
use std::time::Duration;
|
||||
|
||||
use axum::Json;
|
||||
use axum::extract::{Path, State};
|
||||
use axum::http::{HeaderValue, header};
|
||||
use axum::response::{IntoResponse, Response};
|
||||
use axum_extra::extract::WithRejection;
|
||||
use serde_json::{Value, json};
|
||||
use time::{Date, OffsetDateTime};
|
||||
use uuid::Uuid;
|
||||
|
||||
use super::{IdPath, St};
|
||||
use crate::auth::AuthUser;
|
||||
use crate::error::{ApiError, ApiResult};
|
||||
|
||||
type Row = (Uuid, String, Option<String>, Option<Date>, String, i32, OffsetDateTime);
|
||||
|
||||
/// The user's invoices, newest first. Until Billingo has issued one it is
|
||||
/// shown as being prepared.
|
||||
pub async fn list(State(state): St, auth: AuthUser) -> ApiResult<Json<Value>> {
|
||||
let rows: Vec<Row> = sqlx::query_as(
|
||||
"SELECT id, status, invoice_number, invoice_date, item_name, gross_huf, created_at FROM invoices \
|
||||
WHERE user_id = $1 ORDER BY created_at DESC",
|
||||
)
|
||||
.bind(auth.id())
|
||||
.fetch_all(&state.db)
|
||||
.await?;
|
||||
let invoices: Vec<Value> = rows
|
||||
.into_iter()
|
||||
.map(|(id, status, number, date, item, gross, created_at)| {
|
||||
json!({
|
||||
"id": id,
|
||||
"ready": status == "issued",
|
||||
"invoice_number": number,
|
||||
"invoice_date": date.map(|d| d.to_string()),
|
||||
"item": item,
|
||||
"gross_huf": gross,
|
||||
"paid_at": created_at.format(&time::format_description::well_known::Rfc3339).ok(),
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
Ok(Json(json!({ "invoices": invoices })))
|
||||
}
|
||||
|
||||
/// The invoice's PDF, from Billingo.
|
||||
pub async fn pdf(State(state): St, auth: AuthUser, WithRejection(Path(id), _): IdPath) -> ApiResult<Response> {
|
||||
let row: Option<(i64, Option<String>)> = sqlx::query_as(
|
||||
"SELECT billingo_document_id, invoice_number FROM invoices \
|
||||
WHERE id = $1 AND user_id = $2 AND status = 'issued' AND billingo_document_id IS NOT NULL",
|
||||
)
|
||||
.bind(id)
|
||||
.bind(auth.id())
|
||||
.fetch_optional(&state.db)
|
||||
.await?;
|
||||
let (document, number) = row.ok_or(ApiError::NotFound("invoice"))?;
|
||||
let unavailable = |detail: String| {
|
||||
tracing::error!(error = %detail, invoice = %id, "invoice download failed");
|
||||
ApiError::conflict("invoice_unavailable", "A számla letöltése most nem sikerült. Próbáld újra pár perc múlva.")
|
||||
};
|
||||
let key =
|
||||
state.config.billingo_api_key.as_deref().ok_or_else(|| unavailable("BILLINGO_API_KEY is not set".into()))?;
|
||||
let http = reqwest::Client::builder().timeout(Duration::from_secs(30)).build().expect("static configuration");
|
||||
let res = http
|
||||
.get(format!("{}/documents/{document}/download", state.config.billingo_api_url))
|
||||
.header("X-API-KEY", key)
|
||||
.header("Accept", "application/pdf")
|
||||
.send()
|
||||
.await
|
||||
.map_err(|e| unavailable(e.to_string()))?;
|
||||
let is_pdf = res
|
||||
.headers()
|
||||
.get(header::CONTENT_TYPE)
|
||||
.and_then(|v| v.to_str().ok())
|
||||
.is_some_and(|t| t.starts_with("application/pdf"));
|
||||
if !res.status().is_success() || !is_pdf {
|
||||
let status = res.status();
|
||||
let body = res.text().await.unwrap_or_default();
|
||||
return Err(unavailable(format!("HTTP {status}: {}", body.chars().take(300).collect::<String>())));
|
||||
}
|
||||
let bytes = res.bytes().await.map_err(|e| unavailable(e.to_string()))?;
|
||||
let name: String = number
|
||||
.unwrap_or_else(|| document.to_string())
|
||||
.chars()
|
||||
.map(|c| if c.is_ascii_alphanumeric() || c == '-' { c } else { '-' })
|
||||
.collect();
|
||||
let disposition = HeaderValue::from_str(&format!("attachment; filename=\"szamla-{name}.pdf\""))
|
||||
.unwrap_or_else(|_| HeaderValue::from_static("attachment; filename=\"szamla.pdf\""));
|
||||
Ok((
|
||||
[
|
||||
(header::CONTENT_TYPE, HeaderValue::from_static("application/pdf")),
|
||||
(header::CONTENT_DISPOSITION, disposition),
|
||||
(header::CACHE_CONTROL, HeaderValue::from_static("private, no-store")),
|
||||
],
|
||||
bytes,
|
||||
)
|
||||
.into_response())
|
||||
}
|
||||
@@ -13,6 +13,7 @@ mod charts;
|
||||
mod errors;
|
||||
mod forecasts;
|
||||
mod invitations;
|
||||
mod invoices_user;
|
||||
mod jobs;
|
||||
mod models;
|
||||
mod payments;
|
||||
@@ -77,6 +78,11 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/me/export", get(account::export))
|
||||
.route("/v1/credits", get(account::credits))
|
||||
.route("/v1/payments/mock", post(payments::mock))
|
||||
.route("/v1/payments/checkout", post(payments::checkout))
|
||||
.route("/v1/payments/checkout/{id}", get(payments::checkout_status))
|
||||
.route("/v1/payments/stripe/webhook", post(payments::stripe_webhook))
|
||||
.route("/v1/invoices", get(invoices_user::list))
|
||||
.route("/v1/invoices/{id}/pdf", get(invoices_user::pdf))
|
||||
// charts
|
||||
.route("/v1/charts", get(charts::list).post(charts::create))
|
||||
.route("/v1/charts/{id}", get(charts::get_one).patch(charts::update).delete(charts::remove))
|
||||
@@ -161,7 +167,14 @@ async fn public_config(State(state): St) -> Json<Value> {
|
||||
"google_login": { "enabled": state.google.enabled(), "client_id": c.google_client_ids.first() },
|
||||
"locales": c.supported_locales,
|
||||
"password_login": c.password_login,
|
||||
"mock_payments": c.mock_payments,
|
||||
"mock_payments": payments::method(c) == Some("mock"),
|
||||
// "stripe", "mock" or null; Stripe purchases are for admins only
|
||||
// until PURCHASES_OPEN (and always with a test key).
|
||||
"payments": payments::method(c),
|
||||
"payments_admins_only": payments::admins_only(c),
|
||||
"payments_test": c.stripe.as_ref().is_some_and(|s| s.test_mode()),
|
||||
// "AAM" (alanyi adómentes: the prices carry no VAT) or a rate like "27%".
|
||||
"vat": c.invoice_vat.code(),
|
||||
"user_invites": c.user_invites,
|
||||
"referral_rewards": c.referral_rewards,
|
||||
"signup_mode": c.signup_mode.as_str(),
|
||||
|
||||
@@ -1,19 +1,27 @@
|
||||
//! Packages and payments. Until Stripe is connected, `MOCK_PAYMENTS=true`
|
||||
//! turns on a stand-in: "paying" grants the package right away, so the paid
|
||||
//! flow can be used end to end.
|
||||
//! Packages and payments. With `STRIPE_SECRET_KEY` a package is paid on
|
||||
//! Stripe's hosted Checkout page and granted when Stripe confirms the payment
|
||||
//! (webhook, or the return page asking). Without it `MOCK_PAYMENTS=true`
|
||||
//! turns on a stand-in: "paying" grants the package right away.
|
||||
|
||||
use axum::Json;
|
||||
use axum::extract::State;
|
||||
use axum::body::Bytes;
|
||||
use axum::extract::{Path, State};
|
||||
use axum::http::HeaderMap;
|
||||
use axum_extra::extract::WithRejection;
|
||||
use db::Role;
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
use time::OffsetDateTime;
|
||||
use uuid::Uuid;
|
||||
|
||||
use super::{Body, St};
|
||||
use crate::AppState;
|
||||
use crate::auth::AuthUser;
|
||||
use crate::config::StripeConfig;
|
||||
use crate::credits::{self, Unit};
|
||||
use crate::error::{ApiError, ApiResult};
|
||||
use crate::packages::{self, CATALOG, Source};
|
||||
use crate::persons;
|
||||
use crate::{invoices, persons, stripe};
|
||||
|
||||
/// The package catalog (public).
|
||||
pub async fn catalog() -> Json<Value> {
|
||||
@@ -46,7 +54,7 @@ pub async fn mock(
|
||||
auth: AuthUser,
|
||||
WithRejection(Json(req), _): Body<MockPayment>,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
if !state.config.mock_payments {
|
||||
if !state.config.mock_payments || state.config.stripe.is_some() {
|
||||
return Err(ApiError::NotFound("payment method"));
|
||||
}
|
||||
let id = match (req.package.as_deref(), req.unit) {
|
||||
@@ -65,3 +73,207 @@ pub async fn mock(
|
||||
tracing::info!(user = %auth.id(), package = package.id, "mock payment");
|
||||
Ok(Json(holdings(&state, &auth).await?))
|
||||
}
|
||||
|
||||
/// How the frontend should offer purchases: `"stripe"`, `"mock"` or `None`
|
||||
/// (no purchases).
|
||||
pub fn method(config: &crate::config::Config) -> Option<&'static str> {
|
||||
match (&config.stripe, config.mock_payments) {
|
||||
(Some(_), _) => Some("stripe"),
|
||||
(None, true) => Some("mock"),
|
||||
(None, false) => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Only admins can buy through Stripe: until purchases open, and always with a
|
||||
/// test key (nobody gets packages with Stripe's test cards, nobody types a
|
||||
/// real card into a test page).
|
||||
pub fn admins_only(config: &crate::config::Config) -> bool {
|
||||
!config.purchases_open || config.stripe.as_ref().is_some_and(StripeConfig::test_mode)
|
||||
}
|
||||
|
||||
/// Stripe, if this user may pay through it.
|
||||
fn stripe_for<'a>(state: &'a AppState, auth: &AuthUser) -> Result<&'a StripeConfig, ApiError> {
|
||||
let config = state.config.stripe.as_ref().ok_or(ApiError::NotFound("payment method"))?;
|
||||
if admins_only(&state.config) && !auth.user.has_role(Role::Admin) {
|
||||
return Err(ApiError::Forbidden("purchases are being tested; they open soon".into()));
|
||||
}
|
||||
Ok(config)
|
||||
}
|
||||
|
||||
/// The page to come back to after paying: a plain path of this site, without
|
||||
/// its query (anything else: the packages page).
|
||||
fn return_path(path: Option<&str>) -> String {
|
||||
let path = path.unwrap_or("").split(['?', '#']).next().unwrap_or("");
|
||||
let plain = path.starts_with('/')
|
||||
&& !path.starts_with("//")
|
||||
&& path.len() <= 200
|
||||
&& path.chars().all(|c| c.is_ascii_alphanumeric() || "/-_.".contains(c));
|
||||
if plain { path.to_string() } else { "/csomagok".to_string() }
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct CheckoutRequest {
|
||||
package: String,
|
||||
/// The page the purchase started on (default: the packages page).
|
||||
return_path: Option<String>,
|
||||
}
|
||||
|
||||
/// Starts paying for a package: returns the address of Stripe's payment page.
|
||||
pub async fn checkout(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(Json(req), _): Body<CheckoutRequest>,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let config = stripe_for(&state, &auth)?;
|
||||
let package = packages::find(&req.package).ok_or(ApiError::NotFound("package"))?;
|
||||
let back = format!("{}{}", state.config.public_base_url, return_path(req.return_path.as_deref()));
|
||||
let field = |k: &str, v: &str| (k.to_string(), v.to_string());
|
||||
let form = vec![
|
||||
field("mode", "payment"),
|
||||
field("locale", "hu"),
|
||||
field("client_reference_id", &auth.id().to_string()),
|
||||
field("customer_email", &auth.user.email),
|
||||
// Name and address go on the invoice; a company also gives its name
|
||||
// and tax number ("I'm buying as a business").
|
||||
field("billing_address_collection", "required"),
|
||||
field("tax_id_collection[enabled]", "true"),
|
||||
field("customer_creation", "always"),
|
||||
field("line_items[0][quantity]", "1"),
|
||||
field("line_items[0][price_data][currency]", "huf"),
|
||||
// Stripe counts forints in fillér.
|
||||
field("line_items[0][price_data][unit_amount]", &(package.price_huf * 100).to_string()),
|
||||
field("line_items[0][price_data][product_data][name]", &format!("Sorsfonalak – {}", package.name)),
|
||||
field("line_items[0][price_data][product_data][description]", package.tagline),
|
||||
field("metadata[package]", package.id),
|
||||
field("metadata[user_id]", &auth.id().to_string()),
|
||||
field("payment_intent_data[description]", &format!("Sorsfonalak – {}", package.name)),
|
||||
field("payment_intent_data[metadata][package]", package.id),
|
||||
field("success_url", &format!("{back}?fizetes={{CHECKOUT_SESSION_ID}}")),
|
||||
field("cancel_url", &format!("{back}?fizetes=megszakitva")),
|
||||
];
|
||||
let session = state.stripe.create_session(config, &form).await?;
|
||||
let url = session.url.ok_or_else(|| ApiError::Internal(format!("checkout session {} has no url", session.id)))?;
|
||||
sqlx::query("INSERT INTO stripe_checkouts (id, user_id, package, price_huf, live) VALUES ($1, $2, $3, $4, $5)")
|
||||
.bind(&session.id)
|
||||
.bind(auth.id())
|
||||
.bind(package.id)
|
||||
.bind(package.price_huf as i32)
|
||||
.bind(!config.test_mode())
|
||||
.execute(&state.db)
|
||||
.await?;
|
||||
tracing::info!(user = %auth.id(), package = package.id, session = %session.id, "checkout started");
|
||||
Ok(Json(json!({ "url": url })))
|
||||
}
|
||||
|
||||
/// Records a paid session (what was charged, the buyer's billing details),
|
||||
/// grants its package and queues the invoice, once. `false`: not our session.
|
||||
async fn complete(state: &AppState, session: &stripe::Session) -> Result<bool, ApiError> {
|
||||
let mut tx = state.db.begin().await?;
|
||||
type Checkout = (Option<Uuid>, String, i32, bool, Option<OffsetDateTime>);
|
||||
let row: Option<Checkout> = sqlx::query_as(
|
||||
"SELECT user_id, package, price_huf, live, completed_at FROM stripe_checkouts WHERE id = $1 FOR UPDATE",
|
||||
)
|
||||
.bind(&session.id)
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?;
|
||||
let Some((user_id, package_id, price_huf, live, completed_at)) = row else { return Ok(false) };
|
||||
if completed_at.is_some() {
|
||||
return Ok(true);
|
||||
}
|
||||
let amount_huf = session.amount_total.map(|minor| minor / 100);
|
||||
if amount_huf != Some(i64::from(price_huf)) || session.currency.as_deref() != Some("huf") {
|
||||
tracing::error!(session = %session.id, ?amount_huf, currency = ?session.currency, price_huf, "paid amount differs from the price");
|
||||
}
|
||||
let package =
|
||||
packages::find(&package_id).ok_or_else(|| ApiError::Internal(format!("unknown package {package_id}")))?;
|
||||
// A deleted account still gets its invoice, but no package.
|
||||
let order = match user_id {
|
||||
Some(user_id) => {
|
||||
let note = format!("Stripe {}", session.id);
|
||||
Some(packages::grant(&mut tx, user_id, package, Source::Stripe, Some(user_id), Some(¬e)).await?)
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
sqlx::query(
|
||||
"UPDATE stripe_checkouts SET completed_at = now(), order_id = $2, payment_intent = $3, amount_huf = $4, \
|
||||
customer = $5 WHERE id = $1",
|
||||
)
|
||||
.bind(&session.id)
|
||||
.bind(order)
|
||||
.bind(&session.payment_intent)
|
||||
.bind(amount_huf.map(|a| a as i32))
|
||||
.bind(&session.customer_details)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
// A test payment gets no invoice: Billingo's invoices are real (reported
|
||||
// to the tax authority).
|
||||
if live {
|
||||
let buyer = invoices::Buyer::from_stripe(session.customer_details.as_ref().unwrap_or(&Value::Null), None);
|
||||
let (item, comment) = package.invoice_item();
|
||||
let gross = amount_huf.unwrap_or(i64::from(price_huf));
|
||||
invoices::queue(&mut tx, &session.id, user_id, &buyer, (&item, &comment), gross, state.config.invoice_vat)
|
||||
.await?;
|
||||
}
|
||||
tx.commit().await?;
|
||||
tracing::info!(user = ?user_id, package = %package_id, session = %session.id, "package paid");
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
/// Where a payment stands (the return page asks until it is paid). If the
|
||||
/// webhook has not arrived yet, Stripe is asked directly.
|
||||
pub async fn checkout_status(
|
||||
State(state): St,
|
||||
auth: AuthUser,
|
||||
WithRejection(Path(id), _): WithRejection<Path<String>, ApiError>,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let row: Option<(String, Option<OffsetDateTime>)> =
|
||||
sqlx::query_as("SELECT package, completed_at FROM stripe_checkouts WHERE id = $1 AND user_id = $2")
|
||||
.bind(&id)
|
||||
.bind(auth.id())
|
||||
.fetch_optional(&state.db)
|
||||
.await?;
|
||||
let (package_id, completed_at) = row.ok_or(ApiError::NotFound("payment"))?;
|
||||
let mut status = if completed_at.is_some() { "paid" } else { "pending" };
|
||||
if let (None, Some(config)) = (completed_at, &state.config.stripe) {
|
||||
let session = state.stripe.get_session(config, &id).await?;
|
||||
if session.paid() {
|
||||
complete(&state, &session).await?;
|
||||
status = "paid";
|
||||
} else if session.status.as_deref() == Some("expired") {
|
||||
status = "expired";
|
||||
}
|
||||
}
|
||||
Ok(Json(json!({
|
||||
"status": status,
|
||||
"package": package_id,
|
||||
"name": packages::find(&package_id).map(|p| p.name),
|
||||
})))
|
||||
}
|
||||
|
||||
/// Stripe's webhook (Developers → Webhooks; event `checkout.session.completed`,
|
||||
/// for delayed methods also `checkout.session.async_payment_succeeded`).
|
||||
pub async fn stripe_webhook(State(state): St, headers: HeaderMap, body: Bytes) -> ApiResult<Json<Value>> {
|
||||
let secret = state
|
||||
.config
|
||||
.stripe
|
||||
.as_ref()
|
||||
.and_then(|c| c.webhook_secret.as_deref())
|
||||
.ok_or(ApiError::NotFound("payment method"))?;
|
||||
let signature = headers.get("stripe-signature").and_then(|v| v.to_str().ok()).unwrap_or("");
|
||||
let now = OffsetDateTime::now_utc().unix_timestamp();
|
||||
if !stripe::verify_signature(secret, signature, &body, now) {
|
||||
tracing::warn!("stripe webhook with a bad signature");
|
||||
return Err(ApiError::BadRequest("invalid signature".into()));
|
||||
}
|
||||
let mut event: Value = serde_json::from_slice(&body).map_err(|e| ApiError::BadRequest(e.to_string()))?;
|
||||
let kind = event["type"].as_str().unwrap_or_default();
|
||||
if matches!(kind, "checkout.session.completed" | "checkout.session.async_payment_succeeded") {
|
||||
let session: stripe::Session = serde_json::from_value(event["data"]["object"].take())
|
||||
.map_err(|e| ApiError::BadRequest(format!("checkout session: {e}")))?;
|
||||
if session.paid() && !complete(&state, &session).await? {
|
||||
tracing::warn!(session = %session.id, "stripe webhook for a session we did not start");
|
||||
}
|
||||
}
|
||||
Ok(Json(json!({ "received": true })))
|
||||
}
|
||||
|
||||
@@ -0,0 +1,169 @@
|
||||
//! The little of Stripe's API we use: Checkout Sessions (a hosted payment
|
||||
//! page for one package) and webhook signature checking. The package catalog
|
||||
//! stays in `packages.rs`; each session carries its name and price, so no
|
||||
//! products have to be kept in the Stripe dashboard.
|
||||
|
||||
use std::time::Duration;
|
||||
|
||||
use hmac::{Hmac, Mac};
|
||||
use serde::Deserialize;
|
||||
use serde_json::Value;
|
||||
use sha2::Sha256;
|
||||
|
||||
use crate::config::StripeConfig;
|
||||
use crate::error::ApiError;
|
||||
|
||||
/// How old a webhook signature may be (Stripe's own libraries use 5 minutes).
|
||||
const SIGNATURE_TOLERANCE: i64 = 300;
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub struct Session {
|
||||
pub id: String,
|
||||
/// The payment page (only while the session is open).
|
||||
pub url: Option<String>,
|
||||
/// `paid`, `unpaid` or `no_payment_required`.
|
||||
pub payment_status: String,
|
||||
/// `open`, `complete` or `expired`.
|
||||
pub status: Option<String>,
|
||||
/// In the smallest unit (fillér for forints).
|
||||
#[serde(default)]
|
||||
pub amount_total: Option<i64>,
|
||||
#[serde(default)]
|
||||
pub currency: Option<String>,
|
||||
/// The PaymentIntent's id.
|
||||
#[serde(default)]
|
||||
pub payment_intent: Option<String>,
|
||||
/// Name, e-mail, billing address; for a company its name and tax ids.
|
||||
#[serde(default)]
|
||||
pub customer_details: Option<Value>,
|
||||
}
|
||||
|
||||
impl Session {
|
||||
pub fn paid(&self) -> bool {
|
||||
self.payment_status == "paid"
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Client {
|
||||
http: reqwest::Client,
|
||||
}
|
||||
|
||||
impl Default for Client {
|
||||
fn default() -> Self {
|
||||
let http = reqwest::Client::builder().timeout(Duration::from_secs(20)).build().expect("static configuration");
|
||||
Self { http }
|
||||
}
|
||||
}
|
||||
|
||||
/// What the user sees when Stripe cannot be reached.
|
||||
fn unavailable(detail: String) -> ApiError {
|
||||
tracing::error!(error = %detail, "stripe request failed");
|
||||
ApiError::Limited {
|
||||
code: "payment_unavailable",
|
||||
message: "A fizetési oldal most nem érhető el. Próbáld újra pár perc múlva.".into(),
|
||||
}
|
||||
}
|
||||
|
||||
impl Client {
|
||||
/// Creates a Checkout Session from form fields (Stripe's API takes
|
||||
/// `application/x-www-form-urlencoded` with `a[b][c]` keys).
|
||||
pub async fn create_session(&self, config: &StripeConfig, form: &[(String, String)]) -> Result<Session, ApiError> {
|
||||
let res = self
|
||||
.http
|
||||
.post(format!("{}/v1/checkout/sessions", config.api_url))
|
||||
.bearer_auth(&config.secret_key)
|
||||
.form(form)
|
||||
.send()
|
||||
.await
|
||||
.map_err(|e| unavailable(e.to_string()))?;
|
||||
Self::session(res).await
|
||||
}
|
||||
|
||||
pub async fn get_session(&self, config: &StripeConfig, id: &str) -> Result<Session, ApiError> {
|
||||
let res = self
|
||||
.http
|
||||
.get(format!("{}/v1/checkout/sessions/{id}", config.api_url))
|
||||
.bearer_auth(&config.secret_key)
|
||||
.send()
|
||||
.await
|
||||
.map_err(|e| unavailable(e.to_string()))?;
|
||||
Self::session(res).await
|
||||
}
|
||||
|
||||
async fn session(res: reqwest::Response) -> Result<Session, ApiError> {
|
||||
let status = res.status();
|
||||
if !status.is_success() {
|
||||
let body = res.text().await.unwrap_or_default();
|
||||
return Err(unavailable(format!("HTTP {status}: {}", body.chars().take(500).collect::<String>())));
|
||||
}
|
||||
res.json().await.map_err(|e| unavailable(format!("unexpected response: {e}")))
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks a `Stripe-Signature` header (`t=…,v1=…[,v1=…]`): an HMAC-SHA256 of
|
||||
/// `"{t}.{body}"` with the endpoint's signing secret, at most five minutes old.
|
||||
pub fn verify_signature(secret: &str, header: &str, body: &[u8], now: i64) -> bool {
|
||||
let mut timestamp = None;
|
||||
let mut signatures = Vec::new();
|
||||
for part in header.split(',') {
|
||||
match part.trim().split_once('=') {
|
||||
Some(("t", v)) => timestamp = v.parse::<i64>().ok(),
|
||||
Some(("v1", v)) => signatures.push(v),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
let Some(timestamp) = timestamp else { return false };
|
||||
if (now - timestamp).abs() > SIGNATURE_TOLERANCE {
|
||||
return false;
|
||||
}
|
||||
let mut mac = Hmac::<Sha256>::new_from_slice(secret.as_bytes()).expect("HMAC takes any key length");
|
||||
mac.update(timestamp.to_string().as_bytes());
|
||||
mac.update(b".");
|
||||
mac.update(body);
|
||||
let expected = mac.finalize().into_bytes();
|
||||
signatures.iter().any(|s| decode_hex(s).is_some_and(|sig| constant_time_eq(&sig, &expected)))
|
||||
}
|
||||
|
||||
/// The signature header for a body, as Stripe would send it (tests).
|
||||
#[cfg(test)]
|
||||
pub fn sign(secret: &str, body: &[u8], timestamp: i64) -> String {
|
||||
let mut mac = Hmac::<Sha256>::new_from_slice(secret.as_bytes()).unwrap();
|
||||
mac.update(format!("{timestamp}.").as_bytes());
|
||||
mac.update(body);
|
||||
let hex: String = mac.finalize().into_bytes().iter().map(|b| format!("{b:02x}")).collect();
|
||||
format!("t={timestamp},v1={hex}")
|
||||
}
|
||||
|
||||
fn decode_hex(s: &str) -> Option<Vec<u8>> {
|
||||
if !s.len().is_multiple_of(2) {
|
||||
return None;
|
||||
}
|
||||
(0..s.len()).step_by(2).map(|i| u8::from_str_radix(s.get(i..i + 2)?, 16).ok()).collect()
|
||||
}
|
||||
|
||||
fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
|
||||
a.len() == b.len() && a.iter().zip(b).fold(0u8, |acc, (x, y)| acc | (x ^ y)) == 0
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn signatures_are_checked() {
|
||||
let body = br#"{"id":"evt_1"}"#;
|
||||
let now = 1_800_000_000;
|
||||
let header = sign("whsec_test", body, now);
|
||||
assert!(verify_signature("whsec_test", &header, body, now));
|
||||
assert!(verify_signature("whsec_test", &header, body, now + 299));
|
||||
// Another secret, a changed body, an old or missing timestamp.
|
||||
assert!(!verify_signature("whsec_other", &header, body, now));
|
||||
assert!(!verify_signature("whsec_test", &header, br#"{"id":"evt_2"}"#, now));
|
||||
assert!(!verify_signature("whsec_test", &header, body, now + 301));
|
||||
assert!(!verify_signature("whsec_test", header.split_once(',').unwrap().1, body, now));
|
||||
// One good signature among others (during a secret rotation) is enough.
|
||||
let rotated = format!("{header},v1=00ff");
|
||||
assert!(verify_signature("whsec_test", &rotated, body, now));
|
||||
assert!(!verify_signature("whsec_test", "t=1800000000,v1=zz", body, now));
|
||||
}
|
||||
}
|
||||
@@ -111,9 +111,69 @@ async fn fake_openrouter_models() -> Json<Value> {
|
||||
]}))
|
||||
}
|
||||
|
||||
/// Checkout sessions the fake Stripe created: form fields and whether paid.
|
||||
type FakeSessions = std::sync::Mutex<std::collections::HashMap<String, (Vec<(String, String)>, bool)>>;
|
||||
static STRIPE_SESSIONS: std::sync::LazyLock<FakeSessions> = std::sync::LazyLock::new(Default::default);
|
||||
static STRIPE_IDS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
|
||||
|
||||
fn stripe_form(id: &str, key: &str) -> Option<String> {
|
||||
let sessions = STRIPE_SESSIONS.lock().unwrap();
|
||||
sessions.get(id)?.0.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
|
||||
}
|
||||
|
||||
fn stripe_pay(id: &str) {
|
||||
STRIPE_SESSIONS.lock().unwrap().get_mut(id).unwrap().1 = true;
|
||||
}
|
||||
|
||||
async fn fake_stripe_create(
|
||||
headers: HeaderMap,
|
||||
axum::Form(form): axum::Form<Vec<(String, String)>>,
|
||||
) -> (StatusCode, Json<Value>) {
|
||||
if headers.get("authorization").and_then(|v| v.to_str().ok()) != Some("Bearer sk_live_fake") {
|
||||
return (StatusCode::UNAUTHORIZED, Json(json!({"error": {"message": "bad key"}})));
|
||||
}
|
||||
let id = format!("cs_fake_{}", STRIPE_IDS.fetch_add(1, std::sync::atomic::Ordering::Relaxed));
|
||||
STRIPE_SESSIONS.lock().unwrap().insert(id.clone(), (form, false));
|
||||
(
|
||||
StatusCode::OK,
|
||||
Json(
|
||||
json!({"id": id, "url": format!("https://checkout.stripe.test/{id}"), "payment_status": "unpaid", "status": "open"}),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
async fn fake_stripe_get(axum::extract::Path(id): axum::extract::Path<String>) -> (StatusCode, Json<Value>) {
|
||||
match STRIPE_SESSIONS.lock().unwrap().get(&id) {
|
||||
Some((_, paid)) => (
|
||||
StatusCode::OK,
|
||||
Json(json!({"id": id, "url": null,
|
||||
"payment_status": if *paid { "paid" } else { "unpaid" },
|
||||
"status": if *paid { "complete" } else { "open" },
|
||||
"amount_total": 200000, "currency": "huf", "payment_intent": "pi_fake",
|
||||
"customer_details": {"name": "Anna Teszt", "email": "anna@example.com",
|
||||
"address": {"city": "Szeged", "country": "HU"}, "tax_ids": []}})),
|
||||
),
|
||||
None => (StatusCode::NOT_FOUND, Json(json!({"error": {"message": "no such session"}}))),
|
||||
}
|
||||
}
|
||||
|
||||
async fn fake_billingo_pdf(
|
||||
headers: HeaderMap,
|
||||
axum::extract::Path(id): axum::extract::Path<i64>,
|
||||
) -> axum::response::Response {
|
||||
use axum::response::IntoResponse;
|
||||
if headers.get("x-api-key").and_then(|v| v.to_str().ok()) != Some("billingo-fake") || id != 777 {
|
||||
return (StatusCode::NOT_FOUND, Json(json!({"error": {"message": "no such document"}}))).into_response();
|
||||
}
|
||||
([("content-type", "application/pdf")], "%PDF-1.4 fake").into_response()
|
||||
}
|
||||
|
||||
async fn fake_services() -> String {
|
||||
let app = Router::new()
|
||||
.route("/billingo/documents/{id}/download", get(fake_billingo_pdf))
|
||||
.route("/openrouter/models", get(fake_openrouter_models))
|
||||
.route("/v1/checkout/sessions", post(fake_stripe_create))
|
||||
.route("/v1/checkout/sessions/{id}", get(fake_stripe_get))
|
||||
.route("/v1/natal", post(fake_natal))
|
||||
.route("/v1/synastry", post(fake_synastry))
|
||||
.route("/v1/forecast", post(fake_forecast))
|
||||
@@ -782,8 +842,10 @@ async fn export_and_delete_account(pool: PgPool) {
|
||||
/// config and catalog, shared links, invitation pages, the waitlist and
|
||||
/// unsubscribing. Every other route (charts, calculations, analyses) needs a
|
||||
/// logged-in user, so other apps cannot use them.
|
||||
const PUBLIC_ROUTES: [&str; 15] = [
|
||||
const PUBLIC_ROUTES: [&str; 16] = [
|
||||
"/healthz",
|
||||
// Stripe calls it; the signature proves it.
|
||||
"/v1/payments/stripe/webhook",
|
||||
"/v1/config",
|
||||
"/v1/packages",
|
||||
"/v1/auth/register",
|
||||
@@ -2207,3 +2269,276 @@ async fn a_new_user_from_a_shared_link_earns_an_analysis(pool: PgPool) {
|
||||
.unwrap();
|
||||
assert_eq!(count, 0);
|
||||
}
|
||||
|
||||
fn with_stripe(config: &mut Config, key: &str) {
|
||||
config.stripe = Some(crate::config::StripeConfig {
|
||||
secret_key: key.into(),
|
||||
webhook_secret: Some("whsec_fake".into()),
|
||||
api_url: config.horoscope_api_url.clone(),
|
||||
});
|
||||
}
|
||||
|
||||
async fn stripe_orders(pool: &PgPool, email: &str) -> Vec<(String, i32)> {
|
||||
sqlx::query_as(
|
||||
"SELECT o.package, o.price_huf FROM package_orders o JOIN users u ON u.id = o.user_id \
|
||||
WHERE u.email = $1 AND o.source = 'stripe' ORDER BY o.created_at",
|
||||
)
|
||||
.bind(email)
|
||||
.fetch_all(pool)
|
||||
.await
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn stripe_checkout_grants_the_paid_package_once(pool: PgPool) {
|
||||
let app = TestApp::with_config(pool, |c| with_stripe(c, "sk_live_fake")).await;
|
||||
let r = app.get("/v1/config", None).await;
|
||||
assert_eq!(r.body["payments"], "stripe");
|
||||
assert_eq!(r.body["payments_test"], false);
|
||||
assert_eq!(r.body["vat"], "AAM");
|
||||
// Stripe replaces the stand-in payment.
|
||||
assert_eq!(r.body["mock_payments"], false);
|
||||
let anna = app.register("anna@example.com", "Anna").await;
|
||||
let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "couple"})).await;
|
||||
assert_eq!(r.status, StatusCode::NOT_FOUND);
|
||||
|
||||
let r = app.post("/v1/payments/checkout", Some(&anna), json!({"package": "nincs"})).await;
|
||||
assert_eq!(r.status, StatusCode::NOT_FOUND);
|
||||
let r = app
|
||||
.post("/v1/payments/checkout", Some(&anna), json!({"package": "couple", "return_path": "/kepletek/abc?x=1"}))
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
|
||||
let url = r.body["url"].as_str().unwrap();
|
||||
let id = url.rsplit('/').next().unwrap().to_string();
|
||||
assert_eq!(stripe_form(&id, "line_items[0][price_data][currency]").as_deref(), Some("huf"));
|
||||
assert_eq!(stripe_form(&id, "line_items[0][price_data][unit_amount]").as_deref(), Some("600000"));
|
||||
assert_eq!(
|
||||
stripe_form(&id, "line_items[0][price_data][product_data][name]").as_deref(),
|
||||
Some("Sorsfonalak – Páros")
|
||||
);
|
||||
assert_eq!(stripe_form(&id, "customer_email").as_deref(), Some("anna@example.com"));
|
||||
assert_eq!(stripe_form(&id, "tax_id_collection[enabled]").as_deref(), Some("true"));
|
||||
assert_eq!(stripe_form(&id, "billing_address_collection").as_deref(), Some("required"));
|
||||
assert_eq!(
|
||||
stripe_form(&id, "success_url").as_deref(),
|
||||
Some("https://sorsfonalak.test/kepletek/abc?fizetes={CHECKOUT_SESSION_ID}")
|
||||
);
|
||||
// Only paths of this site to come back to.
|
||||
let r = app
|
||||
.post("/v1/payments/checkout", Some(&anna), json!({"package": "single", "return_path": "//evil.example/x"}))
|
||||
.await;
|
||||
let other = r.body["url"].as_str().unwrap().rsplit('/').next().unwrap().to_string();
|
||||
assert_eq!(
|
||||
stripe_form(&other, "cancel_url").as_deref(),
|
||||
Some("https://sorsfonalak.test/csomagok?fizetes=megszakitva")
|
||||
);
|
||||
|
||||
// Not paid yet: nothing granted.
|
||||
let r = app.get(&format!("/v1/payments/checkout/{id}"), Some(&anna)).await;
|
||||
assert_eq!(r.body["status"], "pending", "{}", r.body);
|
||||
assert!(stripe_orders(&app.pool, "anna@example.com").await.is_empty());
|
||||
// Someone else's payment is not found.
|
||||
let bela = app.register("bela@example.com", "Béla").await;
|
||||
let r = app.get(&format!("/v1/payments/checkout/{id}"), Some(&bela)).await;
|
||||
assert_eq!(r.status, StatusCode::NOT_FOUND);
|
||||
|
||||
// The webhook: a bad signature is refused, a good one grants the package,
|
||||
// and Stripe's retries do not grant it again.
|
||||
let event = json!({"id": "evt_1", "type": "checkout.session.completed",
|
||||
"data": {"object": {"id": id, "payment_status": "paid", "status": "complete",
|
||||
"amount_total": 600000, "currency": "huf", "payment_intent": "pi_1",
|
||||
"customer_details": {"name": "Kovács Anna", "email": "anna@example.com",
|
||||
"business_name": "Csillag Kft.",
|
||||
"address": {"line1": "Fő utca 1.", "city": "Szeged", "postal_code": "6720", "country": "HU"},
|
||||
"tax_ids": [{"type": "hu_tin", "value": "12345678-1-23"}]}}}});
|
||||
let body = event.to_string();
|
||||
let now = time::OffsetDateTime::now_utc().unix_timestamp();
|
||||
let bad = crate::stripe::sign("whsec_other", body.as_bytes(), now);
|
||||
let r = app
|
||||
.call_with("POST", "/v1/payments/stripe/webhook", None, Some(event.clone()), &[("stripe-signature", &bad)])
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::BAD_REQUEST);
|
||||
assert!(stripe_orders(&app.pool, "anna@example.com").await.is_empty());
|
||||
let good = crate::stripe::sign("whsec_fake", body.as_bytes(), now);
|
||||
for _ in 0..2 {
|
||||
let r = app
|
||||
.call_with("POST", "/v1/payments/stripe/webhook", None, Some(event.clone()), &[("stripe-signature", &good)])
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
|
||||
}
|
||||
assert_eq!(stripe_orders(&app.pool, "anna@example.com").await, vec![("couple".to_string(), 6000)]);
|
||||
// What the invoice needs is kept, and the invoice is queued.
|
||||
let (intent, amount, customer): (String, i32, Value) =
|
||||
sqlx::query_as("SELECT payment_intent, amount_huf, customer FROM stripe_checkouts WHERE id = $1")
|
||||
.bind(&id)
|
||||
.fetch_one(&app.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!((intent.as_str(), amount), ("pi_1", 6000));
|
||||
assert_eq!(customer["tax_ids"][0]["value"], "12345678-1-23");
|
||||
#[derive(sqlx::FromRow, Debug)]
|
||||
struct Queued {
|
||||
status: String,
|
||||
buyer_name: String,
|
||||
buyer_address: String,
|
||||
buyer_post_code: String,
|
||||
buyer_tax_type: String,
|
||||
buyer_tax_number: Option<String>,
|
||||
item_name: String,
|
||||
gross_huf: i32,
|
||||
net_huf: i32,
|
||||
vat_huf: i32,
|
||||
}
|
||||
let invoice: Queued = sqlx::query_as(
|
||||
"SELECT status, buyer_name, buyer_address, buyer_post_code, buyer_tax_type, buyer_tax_number, item_name, \
|
||||
gross_huf, net_huf, vat_huf FROM invoices WHERE checkout_id = $1",
|
||||
)
|
||||
.bind(&id)
|
||||
.fetch_one(&app.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(invoice.status, "pending");
|
||||
assert_eq!((invoice.buyer_name.as_str(), invoice.buyer_address.as_str()), ("Csillag Kft.", "Fő utca 1."));
|
||||
assert_eq!(invoice.buyer_post_code, "6720");
|
||||
assert_eq!(
|
||||
(invoice.buyer_tax_type.as_str(), invoice.buyer_tax_number.as_deref()),
|
||||
("HAS_TAX_NUMBER", Some("12345678-1-23"))
|
||||
);
|
||||
assert_eq!(invoice.item_name, "Online tartalomszolgáltatás – Páros csomag");
|
||||
// Alanyi adómentes (the default): no VAT.
|
||||
assert_eq!((invoice.gross_huf, invoice.net_huf, invoice.vat_huf), (6000, 6000, 0));
|
||||
|
||||
// The user's invoices: being prepared until Billingo issues it, then the
|
||||
// PDF comes from Billingo.
|
||||
let r = app.get("/v1/invoices", Some(&anna)).await;
|
||||
assert_eq!(r.body["invoices"].as_array().unwrap().len(), 1);
|
||||
assert_eq!(app.get("/v1/me", Some(&anna)).await.body["invoice_count"], 1);
|
||||
assert_eq!(r.body["invoices"][0]["ready"], false);
|
||||
let invoice_id = r.body["invoices"][0]["id"].as_str().unwrap().to_string();
|
||||
let r = app.get(&format!("/v1/invoices/{invoice_id}/pdf"), Some(&anna)).await;
|
||||
assert_eq!(r.status, StatusCode::NOT_FOUND);
|
||||
sqlx::query(
|
||||
"UPDATE invoices SET status = 'issued', billingo_document_id = 777, invoice_number = 'SF-2026/1', \
|
||||
invoice_date = '2026-11-20' WHERE id = $1::uuid",
|
||||
)
|
||||
.bind(&invoice_id)
|
||||
.execute(&app.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let r = app.get("/v1/invoices", Some(&anna)).await;
|
||||
assert_eq!(
|
||||
(&r.body["invoices"][0]["ready"], &r.body["invoices"][0]["invoice_number"]),
|
||||
(&json!(true), &json!("SF-2026/1"))
|
||||
);
|
||||
let req = Request::builder()
|
||||
.uri(format!("/v1/invoices/{invoice_id}/pdf"))
|
||||
.header("authorization", format!("Bearer {anna}"))
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.router.clone().oneshot(req).await.unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
assert_eq!(resp.headers()["content-type"], "application/pdf");
|
||||
assert_eq!(resp.headers()["content-disposition"], "attachment; filename=\"szamla-SF-2026-1.pdf\"");
|
||||
assert!(resp.into_body().collect().await.unwrap().to_bytes().starts_with(b"%PDF"));
|
||||
// Nobody else's.
|
||||
let r = app.get(&format!("/v1/invoices/{invoice_id}/pdf"), Some(&bela)).await;
|
||||
assert_eq!(r.status, StatusCode::NOT_FOUND);
|
||||
assert_eq!(app.get("/v1/invoices", Some(&bela)).await.body["invoices"], json!([]));
|
||||
let r = app.get(&format!("/v1/payments/checkout/{id}"), Some(&anna)).await;
|
||||
assert_eq!(r.body["status"], "paid");
|
||||
assert_eq!(r.body["name"], "Páros");
|
||||
let r = app.get("/v1/me", Some(&anna)).await;
|
||||
assert_eq!(r.status, StatusCode::OK);
|
||||
|
||||
// A session we did not start is ignored.
|
||||
let stray = json!({"type": "checkout.session.completed", "data": {"object": {"id": "cs_unknown", "payment_status": "paid"}}});
|
||||
let sig = crate::stripe::sign("whsec_fake", stray.to_string().as_bytes(), now);
|
||||
let r =
|
||||
app.call_with("POST", "/v1/payments/stripe/webhook", None, Some(stray), &[("stripe-signature", &sig)]).await;
|
||||
assert_eq!(r.status, StatusCode::OK);
|
||||
|
||||
// Without the webhook (late or not set up) the return page asks Stripe.
|
||||
stripe_pay(&other);
|
||||
let r = app.get(&format!("/v1/payments/checkout/{other}"), Some(&anna)).await;
|
||||
assert_eq!(r.body["status"], "paid", "{}", r.body);
|
||||
let r = app.get(&format!("/v1/payments/checkout/{other}"), Some(&anna)).await;
|
||||
assert_eq!(r.body["status"], "paid");
|
||||
assert_eq!(
|
||||
stripe_orders(&app.pool, "anna@example.com").await,
|
||||
vec![("couple".to_string(), 6000), ("single".to_string(), 2000)]
|
||||
);
|
||||
let (name, tax_type): (String, String) =
|
||||
sqlx::query_as("SELECT buyer_name, buyer_tax_type FROM invoices WHERE checkout_id = $1")
|
||||
.bind(&other)
|
||||
.fetch_one(&app.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!((name.as_str(), tax_type.as_str()), ("Anna Teszt", "NO_TAX_NUMBER"));
|
||||
|
||||
// A test payment grants the package but gets no invoice (Billingo's are real).
|
||||
sqlx::query(
|
||||
"INSERT INTO stripe_checkouts (id, user_id, package, price_huf, live) \
|
||||
SELECT 'cs_test_1', id, 'single', 2000, false FROM users WHERE email = 'anna@example.com'",
|
||||
)
|
||||
.execute(&app.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let test = json!({"type": "checkout.session.completed",
|
||||
"data": {"object": {"id": "cs_test_1", "payment_status": "paid", "amount_total": 200000, "currency": "huf"}}});
|
||||
let sig = crate::stripe::sign("whsec_fake", test.to_string().as_bytes(), now);
|
||||
let r = app.call_with("POST", "/v1/payments/stripe/webhook", None, Some(test), &[("stripe-signature", &sig)]).await;
|
||||
assert_eq!(r.status, StatusCode::OK);
|
||||
assert_eq!(stripe_orders(&app.pool, "anna@example.com").await.len(), 3);
|
||||
let (invoices,): (i64,) = sqlx::query_as("SELECT count(*) FROM invoices WHERE checkout_id = 'cs_test_1'")
|
||||
.fetch_one(&app.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(invoices, 0);
|
||||
|
||||
// Deleting the account keeps the payments (accounting law).
|
||||
let r = app.call("DELETE", "/v1/me", Some(&anna), Some(json!({"confirm": "DELETE"}))).await;
|
||||
assert!(r.status.is_success(), "{}", r.body);
|
||||
let (kept,): (i64,) = sqlx::query_as(
|
||||
"SELECT count(*) FROM stripe_checkouts WHERE user_id IS NULL AND completed_at IS NOT NULL AND live",
|
||||
)
|
||||
.fetch_one(&app.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(kept, 2);
|
||||
let (kept,): (i64,) =
|
||||
sqlx::query_as("SELECT count(*) FROM invoices WHERE user_id IS NULL").fetch_one(&app.pool).await.unwrap();
|
||||
assert_eq!(kept, 2);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn stripe_test_mode_is_for_admins_only(pool: PgPool) {
|
||||
let app = TestApp::with_config(pool, |c| with_stripe(c, "sk_test_fake")).await;
|
||||
let r = app.get("/v1/config", None).await;
|
||||
assert_eq!(r.body["payments"], "stripe");
|
||||
assert_eq!(r.body["payments_test"], true);
|
||||
assert_eq!(r.body["payments_admins_only"], true);
|
||||
let anna = app.register("anna@example.com", "Anna").await;
|
||||
let r = app.post("/v1/payments/checkout", Some(&anna), json!({"package": "single"})).await;
|
||||
assert_eq!(r.status, StatusCode::FORBIDDEN);
|
||||
// The admin gets as far as Stripe (the fake one only knows the live key).
|
||||
let admin = app.register("admin@example.com", "Admin").await;
|
||||
let r = app.post("/v1/payments/checkout", Some(&admin), json!({"package": "single"})).await;
|
||||
assert_eq!(r.body["error"]["code"], "payment_unavailable", "{}", r.body);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn stripe_purchases_wait_for_the_opening(pool: PgPool) {
|
||||
let app = TestApp::with_config(pool, |c| {
|
||||
with_stripe(c, "sk_live_fake");
|
||||
c.purchases_open = false;
|
||||
})
|
||||
.await;
|
||||
let r = app.get("/v1/config", None).await;
|
||||
assert_eq!((&r.body["payments_test"], &r.body["payments_admins_only"]), (&json!(false), &json!(true)));
|
||||
let anna = app.register("anna@example.com", "Anna").await;
|
||||
let r = app.post("/v1/payments/checkout", Some(&anna), json!({"package": "single"})).await;
|
||||
assert_eq!(r.status, StatusCode::FORBIDDEN);
|
||||
let admin = app.register("admin@example.com", "Admin").await;
|
||||
let r = app.post("/v1/payments/checkout", Some(&admin), json!({"package": "single"})).await;
|
||||
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
|
||||
}
|
||||
|
||||
@@ -86,6 +86,14 @@ export default async function PrivacyPage() {
|
||||
<td>A megvásárolt szolgáltatás nyújtása, elszámolás</td>
|
||||
<td>Szerződés teljesítése; számviteli kötelezettség (6. cikk (1) c)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>
|
||||
Fizetéseid adatai: a Stripe fizetési azonosítója, a fizetett összeg, a számlázási neved, címed és
|
||||
e-mail-címed, céges vásárlásnál a cégnév és az adószám
|
||||
</td>
|
||||
<td>A fizetés igazolása, a számla kiállítása</td>
|
||||
<td>Szerződés teljesítése; számviteli kötelezettség (6. cikk (1) c)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Meghívott e-mail-címe, a meghívó neve és személyes üzenete</td>
|
||||
<td>A meghívó elküldése; amíg az oldal zártkörű, csak meghívottak regisztrálhatnak</td>
|
||||
@@ -110,8 +118,10 @@ export default async function PrivacyPage() {
|
||||
</table>
|
||||
</div>
|
||||
<p>
|
||||
Bankkártyaadatot nem kezelünk és nem tárolunk; a fizetést, amikor elindul, külső fizetési szolgáltató
|
||||
végzi, akinek a neve itt lesz feltüntetve.
|
||||
<strong>Bankkártyaadatot nem kezelünk és nem tárolunk.</strong> A fizetés a Stripe biztonságos fizetési
|
||||
oldalán történik: a kártyaadataidat közvetlenül a Stripe-nak adod meg, hozzánk nem jutnak el. A Stripe-tól
|
||||
csak a fizetés azonosítóját, összegét és a számlázási adataidat kapjuk meg. Ezeket a fiókod törlése után is
|
||||
megőrizzük a számviteli törvény szerinti ideig (8 évig).
|
||||
</p>
|
||||
</section>
|
||||
|
||||
@@ -198,6 +208,14 @@ export default async function PrivacyPage() {
|
||||
<strong>Amazon Web Services EMEA SARL</strong> (Amazon SES) – a rendszerlevelek és a meghívók kézbesítése;
|
||||
az Európai Unióban (Frankfurt).
|
||||
</li>
|
||||
<li>
|
||||
<strong>Stripe Payments Europe, Ltd.</strong> (Írország) – a bankkártyás fizetés lebonyolítása és a
|
||||
visszaélések kiszűrése; a kártyaadatokat csak a Stripe kezeli.
|
||||
</li>
|
||||
<li>
|
||||
<strong>Billingo Technologies Zrt.</strong> (Billingo) – a számlák kiállítása, megküldése és megőrzése; a
|
||||
számlázási adataidat (név, cím, e-mail-cím, céges vásárlásnál cégnév és adószám) kapja meg.
|
||||
</li>
|
||||
<li>
|
||||
<strong>OpenRouter, Inc.</strong> és az általa elért mesterségesintelligencia-szolgáltatók – az elemzések
|
||||
megírása, kizárólag a 4. pontban leírt csillagászati adatokból (személyes adat nem jut el hozzájuk).
|
||||
|
||||
@@ -6,7 +6,16 @@ import type { NextRequest } from "next/server";
|
||||
import { BACKEND_URL } from "@/lib/server";
|
||||
import { SHARES_TAG } from "@/lib/share";
|
||||
|
||||
const REQUEST_HEADERS = ["accept", "accept-language", "authorization", "content-type", "cookie", "user-agent"];
|
||||
// stripe-signature: Stripe's webhook (the body is passed on byte for byte).
|
||||
const REQUEST_HEADERS = [
|
||||
"accept",
|
||||
"accept-language",
|
||||
"authorization",
|
||||
"content-type",
|
||||
"cookie",
|
||||
"stripe-signature",
|
||||
"user-agent",
|
||||
];
|
||||
// Hop-by-hop or re-computed by the runtime.
|
||||
const SKIP_RESPONSE_HEADERS = new Set(["connection", "content-encoding", "content-length", "set-cookie", "transfer-encoding"]);
|
||||
|
||||
|
||||
@@ -1,14 +1,20 @@
|
||||
import type { Metadata } from "next";
|
||||
import Link from "next/link";
|
||||
|
||||
import { AiNote } from "@/components/AiNote";
|
||||
import { PackageCards } from "@/components/PackageCards";
|
||||
import { RedeemCode } from "@/components/RedeemCode";
|
||||
import { payMethod } from "@/lib/payments";
|
||||
import { backendGet, requireMe } from "@/lib/server";
|
||||
import type { Package, PublicConfig } from "@/lib/types";
|
||||
|
||||
export const metadata: Metadata = { title: "Csomagok" };
|
||||
|
||||
const FAQ: [string, string][] = [
|
||||
[
|
||||
"Biztonságos a fizetés?",
|
||||
"Igen. A fizetés a Stripe biztonságos fizetési oldalán történik, bankkártyával, Apple Payjel vagy Google Payjel. A kártyaadataidat közvetlenül a Stripe-nak adod meg: hozzánk nem jutnak el, és nem is tároljuk őket. Cégként is vásárolhatsz, ilyenkor a cégnevet és az adószámot is megadhatod a számlához.",
|
||||
],
|
||||
[
|
||||
"Lejárnak a megvett elemzések?",
|
||||
"Nem. A csomagokban kapott elemzések és személyhelyek addig megmaradnak, amíg fel nem használod őket.",
|
||||
@@ -39,7 +45,7 @@ export default async function PackagesPage() {
|
||||
backendGet<PublicConfig>("/v1/config"),
|
||||
]);
|
||||
const packages = catalog?.packages ?? [];
|
||||
const canPay = config?.mock_payments ?? false;
|
||||
const canPay = payMethod(config, me);
|
||||
const left = me.analyses_left;
|
||||
const slots = me.persons;
|
||||
|
||||
@@ -79,6 +85,12 @@ export default async function PackagesPage() {
|
||||
<RedeemCode />
|
||||
</section>
|
||||
|
||||
{me.invoice_count > 0 && (
|
||||
<p className="hint">
|
||||
A korábbi vásárlásaid számlái: <Link href="/szamlak">Számláim →</Link>
|
||||
</p>
|
||||
)}
|
||||
|
||||
<PackageCards packages={packages} canPay={canPay} />
|
||||
|
||||
<section className="field" aria-labelledby="addon-title" style={{ gap: 12 }}>
|
||||
@@ -102,7 +114,11 @@ export default async function PackagesPage() {
|
||||
</div>
|
||||
))}
|
||||
</dl>
|
||||
<p className="hint">Az árak bruttó árak, az áfát tartalmazzák.</p>
|
||||
<p className="hint">
|
||||
{config?.vat === "AAM" || !config
|
||||
? "Az árak végső árak: alanyi adómentesek vagyunk, áfát nem számítunk fel."
|
||||
: `Az árak bruttó árak, a ${config.vat} áfát tartalmazzák.`}
|
||||
</p>
|
||||
</section>
|
||||
</main>
|
||||
);
|
||||
|
||||
@@ -92,7 +92,19 @@ p { margin: 0; }
|
||||
border: 1px solid var(--line-2); background: var(--panel-2); color: var(--ink);
|
||||
font: 400 15px var(--font-body);
|
||||
}
|
||||
select.inp { padding-right: 32px; text-overflow: ellipsis; }
|
||||
/* Our own chevron, so the text starts where it does in the other fields */
|
||||
select.inp {
|
||||
appearance: none; -webkit-appearance: none; cursor: pointer; text-overflow: ellipsis;
|
||||
padding: 0 42px 0 14px;
|
||||
background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath d='M4 6l4 4 4-4' fill='none' stroke='%23a3abc0' stroke-width='1.8' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E");
|
||||
background-repeat: no-repeat; background-position: right 14px center; background-size: 16px;
|
||||
}
|
||||
select.inp:focus { background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath d='M4 6l4 4 4-4' fill='none' stroke='%23d9b46a' stroke-width='1.8' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E"); }
|
||||
select.inp option { background: var(--panel-2); color: var(--ink); }
|
||||
/* Multi-line fields: room above and below the text too */
|
||||
textarea.inp { padding: 12px 14px; line-height: 1.55; min-height: 96px; resize: vertical; }
|
||||
/* A button beside input fields is as tall as they are */
|
||||
.row > .btn:not(.btn-sm), .redeem-row > .btn { min-height: 48px; }
|
||||
.inp::placeholder { color: #8a93ab; }
|
||||
.inp:focus { outline: none; border-color: var(--gold); box-shadow: 0 0 0 3px rgba(217, 180, 106, 0.25); }
|
||||
.inp:disabled { opacity: 0.55; }
|
||||
@@ -932,3 +944,23 @@ a.pair-row:hover strong { color: var(--gold); }
|
||||
.lp-partner:hover { opacity: 1; }
|
||||
.lp-partners .hint + .lp-partner { margin-right: 18px; }
|
||||
.lp-partners .lp-partner:last-child { margin-right: 0; }
|
||||
|
||||
/* Chart page: below the wheel and the summary, the facts and the next steps side by side */
|
||||
.chart-extras { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(300px, 100%), 1fr)); gap: 16px; align-items: stretch; }
|
||||
.chart-extras > .card { margin: 0; }
|
||||
|
||||
/* Back from Stripe: the payment's result at the bottom of the screen. */
|
||||
.pay-return { position: fixed; left: 50%; bottom: 20px; transform: translateX(-50%); z-index: 60; width: min(560px, calc(100% - 32px)); }
|
||||
.pay-return .msg {
|
||||
display: flex; align-items: center; justify-content: space-between; gap: 12px; margin: 0; padding: 14px 16px;
|
||||
background: var(--panel-2); border: 1px solid var(--line); border-radius: 14px; box-shadow: 0 12px 40px rgba(0, 0, 0, 0.45);
|
||||
}
|
||||
.pay-return .msg-ok { border-color: color-mix(in srgb, var(--ok) 55%, var(--line)); }
|
||||
.pay-return .msg-error { border-color: color-mix(in srgb, var(--danger) 55%, var(--line)); }
|
||||
|
||||
/* Számláim */
|
||||
.invoice-table th.num, .invoice-table td.num { text-align: right; }
|
||||
.invoice-table td.act { text-align: right; white-space: nowrap; }
|
||||
@media (max-width: 640px) {
|
||||
.invoice-table th:nth-child(3), .invoice-table td:nth-child(3) { display: none; }
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ import { ChartWheel } from "@/components/ChartWheel";
|
||||
import { DetailedAnalysis } from "@/components/DetailedAnalysis";
|
||||
import { ForecastKeys, ForecastTimeline, ForecastTransits, longDay } from "@/components/ForecastViews";
|
||||
import { Tabs } from "@/components/Tabs";
|
||||
import { payMethod } from "@/lib/payments";
|
||||
import { backendGet, requireMe } from "@/lib/server";
|
||||
import type { Analysis, Chart, ForecastDetail, ForecastList, PublicConfig } from "@/lib/types";
|
||||
|
||||
@@ -134,7 +135,7 @@ export default async function ForecastPage({
|
||||
initial={detailed}
|
||||
left={me.analyses_left.forecast}
|
||||
isAdmin={me.user.roles.includes("admin")}
|
||||
canPay={config?.mock_payments ?? false}
|
||||
canPay={payMethod(config, me)}
|
||||
questionsLeft={me.analyses_left.question ?? 0}
|
||||
/>
|
||||
),
|
||||
|
||||
@@ -10,6 +10,7 @@ import { ChartWheel, WheelLegend } from "@/components/ChartWheel";
|
||||
import { CompareButton } from "@/components/CompareButton";
|
||||
import { Tabs } from "@/components/Tabs";
|
||||
import { ASPECTS, ELEMENTS, MODALITIES, MOON_PHASES, countryName, formatBirthDate, pointName } from "@/lib/astro";
|
||||
import { payMethod } from "@/lib/payments";
|
||||
import { backendGet, requireMe } from "@/lib/server";
|
||||
import type { Analysis, Chart, ChartListItem, PublicConfig } from "@/lib/types";
|
||||
|
||||
@@ -82,87 +83,90 @@ export default async function ChartPage({ params }: { params: Promise<{ id: stri
|
||||
referralsLeft={me.referral_rewards.limit - me.referral_rewards.earned}
|
||||
/>
|
||||
<BigThree chart={chart} />
|
||||
{(elements || modalities || phase) && (
|
||||
<div className="card" style={{ gap: 12 }}>
|
||||
<dl className="facts">
|
||||
{elements && (
|
||||
<>
|
||||
<dt>Elemek</dt>
|
||||
<dd>
|
||||
{Object.entries(elements)
|
||||
.map(([k, v]) => `${ELEMENTS[k] ?? k} ${v.count}`)
|
||||
.join(" · ")}
|
||||
</dd>
|
||||
</>
|
||||
)}
|
||||
{modalities && (
|
||||
<>
|
||||
<dt>Minőségek</dt>
|
||||
<dd>
|
||||
{Object.entries(modalities)
|
||||
.map(([k, v]) => `${MODALITIES[k] ?? k} ${v.count}`)
|
||||
.join(" · ")}
|
||||
</dd>
|
||||
</>
|
||||
)}
|
||||
{phase && (
|
||||
<>
|
||||
<dt>Holdfázis</dt>
|
||||
<dd>
|
||||
{MOON_PHASES[phase.phase] ?? phase.phase}, {Math.round(phase.illumination * 100)}%
|
||||
</dd>
|
||||
</>
|
||||
)}
|
||||
</dl>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<section className="chart-extras" aria-label="A képlet összegzése és továbblépés">
|
||||
{(elements || modalities || phase) && (
|
||||
<div className="card" style={{ gap: 12 }}>
|
||||
<dl className="facts">
|
||||
{elements && (
|
||||
<p className="hint">
|
||||
Az elemek és minőségek a tíz bolygóból számolva:{" "}
|
||||
{Object.entries(elements)
|
||||
.filter(([, v]) => v.count > 0)
|
||||
.map(([k, v]) => `${ELEMENTS[k] ?? k}: ${v.points.map(pointName).join(", ")}`)
|
||||
.join("; ")}
|
||||
.
|
||||
</p>
|
||||
<>
|
||||
<dt>Elemek</dt>
|
||||
<dd>
|
||||
{Object.entries(elements)
|
||||
.map(([k, v]) => `${ELEMENTS[k] ?? k} ${v.count}`)
|
||||
.join(" · ")}
|
||||
</dd>
|
||||
</>
|
||||
)}
|
||||
{modalities && (
|
||||
<>
|
||||
<dt>Minőségek</dt>
|
||||
<dd>
|
||||
{Object.entries(modalities)
|
||||
.map(([k, v]) => `${MODALITIES[k] ?? k} ${v.count}`)
|
||||
.join(" · ")}
|
||||
</dd>
|
||||
</>
|
||||
)}
|
||||
{phase && (
|
||||
<>
|
||||
<dt>Holdfázis</dt>
|
||||
<dd>
|
||||
{MOON_PHASES[phase.phase] ?? phase.phase}, {Math.round(phase.illumination * 100)}%
|
||||
</dd>
|
||||
</>
|
||||
)}
|
||||
</dl>
|
||||
{elements && (
|
||||
<p className="hint">
|
||||
Az elemek és minőségek a tíz bolygóból számolva:{" "}
|
||||
{Object.entries(elements)
|
||||
.filter(([, v]) => v.count > 0)
|
||||
.map(([k, v]) => `${ELEMENTS[k] ?? k}: ${v.points.map(pointName).join(", ")}`)
|
||||
.join("; ")}
|
||||
.
|
||||
</p>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
<Link href={`/kepletek/${chart.id}/elorejelzes`} className="card persons-tile">
|
||||
<span className="eyebrow">Éves előrejelzés</span>
|
||||
<strong>{chart.is_primary ? "Mit hoz az éved?" : `Mit hoz ${chart.label} éve?`}</strong>
|
||||
<span className="muted">
|
||||
Szolár képlet, tranzitok pontos dátumokkal, progresszió: egy év születésnaptól születésnapig.
|
||||
</span>
|
||||
<span className="persons-tile-arrow" aria-hidden="true">
|
||||
→
|
||||
</span>
|
||||
</Link>
|
||||
{!chart.is_primary && own && (
|
||||
<div className="card compare-tile">
|
||||
<span className="eyebrow">Összevetés</span>
|
||||
<strong>Te és {chart.label}</strong>
|
||||
<span className="muted">Két képlet egy körön: mi vonz, hol súrlódtok, és mit ad a kapcsolat.</span>
|
||||
<div className="form-actions">
|
||||
<CompareButton chart1={own.id} chart2={chart.id} label="Összevetés velem" className="btn" />
|
||||
</div>
|
||||
)}
|
||||
<Link href={`/kepletek/${chart.id}/elorejelzes`} className="card persons-tile">
|
||||
<span className="eyebrow">Éves előrejelzés</span>
|
||||
<strong>{chart.is_primary ? "Mit hoz az éved?" : `Mit hoz ${chart.label} éve?`}</strong>
|
||||
</div>
|
||||
)}
|
||||
{chart.is_primary && (
|
||||
<Link href="/szemelyek" className="card persons-tile">
|
||||
<span className="eyebrow">Személyek</span>
|
||||
<strong>
|
||||
{persons.length > 0 ? `${persons.length} felvett személy` : "Társad, családod képlete"}
|
||||
</strong>
|
||||
<span className="muted">
|
||||
Szolár képlet, tranzitok pontos dátumokkal, progresszió: egy év születésnaptól születésnapig.
|
||||
{persons.length > 0
|
||||
? persons.slice(0, 3).map((p) => p.label).join(", ") + (persons.length > 3 ? "…" : "")
|
||||
: "Vedd fel őket, és nézd meg az ő képletüket és elemzésüket is."}
|
||||
</span>
|
||||
<span className="persons-tile-arrow" aria-hidden="true">
|
||||
→
|
||||
</span>
|
||||
</Link>
|
||||
{!chart.is_primary && own && (
|
||||
<div className="card compare-tile">
|
||||
<span className="eyebrow">Összevetés</span>
|
||||
<strong>Te és {chart.label}</strong>
|
||||
<span className="muted">Két képlet egy körön: mi vonz, hol súrlódtok, és mit ad a kapcsolat.</span>
|
||||
<div className="form-actions">
|
||||
<CompareButton chart1={own.id} chart2={chart.id} label="Összevetés velem" className="btn" />
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
{chart.is_primary && (
|
||||
<Link href="/szemelyek" className="card persons-tile">
|
||||
<span className="eyebrow">Személyek</span>
|
||||
<strong>
|
||||
{persons.length > 0 ? `${persons.length} felvett személy` : "Társad, családod képlete"}
|
||||
</strong>
|
||||
<span className="muted">
|
||||
{persons.length > 0
|
||||
? persons.slice(0, 3).map((p) => p.label).join(", ") + (persons.length > 3 ? "…" : "")
|
||||
: "Vedd fel őket, és nézd meg az ő képletüket és elemzésüket is."}
|
||||
</span>
|
||||
<span className="persons-tile-arrow" aria-hidden="true">
|
||||
→
|
||||
</span>
|
||||
</Link>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
</section>
|
||||
|
||||
<section className="card chart-tabs" aria-label="Elemzés és táblázatok">
|
||||
@@ -178,7 +182,7 @@ export default async function ChartPage({ params }: { params: Promise<{ id: stri
|
||||
initial={detailed}
|
||||
left={me.analyses_left.natal}
|
||||
isAdmin={me.user.roles.includes("admin")}
|
||||
canPay={config?.mock_payments ?? false}
|
||||
canPay={payMethod(config, me)}
|
||||
questionsLeft={me.analyses_left.question ?? 0}
|
||||
/>
|
||||
),
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
import type { Metadata } from "next";
|
||||
import { Cormorant_Garamond, Inter } from "next/font/google";
|
||||
import { Suspense } from "react";
|
||||
|
||||
import { PaymentReturn } from "@/components/PaymentReturn";
|
||||
import { SiteHeader } from "@/components/SiteHeader";
|
||||
import { getMe } from "@/lib/server";
|
||||
|
||||
@@ -25,6 +27,11 @@ export default async function RootLayout({ children }: { children: React.ReactNo
|
||||
<body>
|
||||
{me && <SiteHeader me={me} />}
|
||||
{children}
|
||||
{me && (
|
||||
<Suspense fallback={null}>
|
||||
<PaymentReturn />
|
||||
</Suspense>
|
||||
)}
|
||||
</body>
|
||||
</html>
|
||||
);
|
||||
|
||||
@@ -8,6 +8,7 @@ import { CompositeTables, CrossGrid, HouseOverlays, InterAspectList, NatureBar }
|
||||
import { SynastryLegend, SynastryWheel } from "@/components/SynastryWheel";
|
||||
import { Tabs } from "@/components/Tabs";
|
||||
import { ASPECTS, formatBirthDate } from "@/lib/astro";
|
||||
import { payMethod } from "@/lib/payments";
|
||||
import { backendGet, requireMe } from "@/lib/server";
|
||||
import { sideName, sideTimeKnown } from "@/lib/synastry";
|
||||
import type { Analysis, ChartListItem, PublicConfig, Synastry, SynastrySide } from "@/lib/types";
|
||||
@@ -127,7 +128,7 @@ export default async function ComparisonPage({ params }: { params: Promise<{ id:
|
||||
initial={detailed}
|
||||
left={me.analyses_left.synastry}
|
||||
isAdmin={me.user.roles.includes("admin")}
|
||||
canPay={config?.mock_payments ?? false}
|
||||
canPay={payMethod(config, me)}
|
||||
note={`Az elemzésben az első fél: ${name1}, a második fél: ${name2}.`}
|
||||
questionsLeft={me.analyses_left.question ?? 0}
|
||||
/>
|
||||
|
||||
@@ -33,6 +33,11 @@ const DATA: [string, string, string][] = [
|
||||
"Providing the purchased service, accounting",
|
||||
"Performance of a contract; legal obligation (Art. 6(1)(c))",
|
||||
],
|
||||
[
|
||||
"Your payments: Stripe's payment ID, the amount paid, your billing name, address and e-mail address, and for a company purchase the company name and tax number",
|
||||
"Proof of payment, issuing the invoice",
|
||||
"Performance of a contract; legal obligation (Art. 6(1)(c))",
|
||||
],
|
||||
[
|
||||
"An invitee's e-mail address, the inviter's name and personal message",
|
||||
"Sending the invitation; while the site is invitation-only, only invitees can sign up",
|
||||
@@ -113,8 +118,10 @@ export default async function PrivacyPolicyPage() {
|
||||
</table>
|
||||
</div>
|
||||
<p>
|
||||
We do not process or store card details; payments, once available, will be handled by an external payment
|
||||
provider, named here.
|
||||
<strong>We do not process or store card details.</strong> Payments are made on Stripe's secure payment
|
||||
page: you give your card details directly to Stripe, and they never reach us. From Stripe we only receive
|
||||
the payment's ID, the amount and your billing details, which we keep for the period required by
|
||||
accounting law (8 years), even after your account is deleted.
|
||||
</p>
|
||||
</section>
|
||||
|
||||
@@ -200,6 +207,14 @@ export default async function PrivacyPolicyPage() {
|
||||
<strong>Amazon Web Services EMEA SARL</strong> (Amazon SES): delivering service e-mails and invitations; in
|
||||
the European Union (Frankfurt).
|
||||
</li>
|
||||
<li>
|
||||
<strong>Stripe Payments Europe, Ltd.</strong> (Ireland): processing card payments and preventing fraud;
|
||||
only Stripe handles card details.
|
||||
</li>
|
||||
<li>
|
||||
<strong>Billingo Technologies Zrt.</strong> (Billingo): issuing, sending and keeping the invoices; it
|
||||
receives your billing details (name, address, e-mail address, and for a company its name and tax number).
|
||||
</li>
|
||||
<li>
|
||||
<strong>OpenRouter, Inc.</strong> and the artificial intelligence providers it reaches: writing the readings,
|
||||
only from the astronomical data described in section 4 (no personal data reaches them).
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
import type { MetadataRoute } from "next";
|
||||
|
||||
import { siteUrl } from "@/lib/share";
|
||||
|
||||
// AI crawlers that train models or answer from the site: they load pages
|
||||
// far more often than visitors do. Link preview robots (Facebook, Messenger,
|
||||
// Slack, WhatsApp, X, LinkedIn) stay allowed, they make the shared links work.
|
||||
@@ -38,12 +40,13 @@ const AI_CRAWLERS = [
|
||||
"Scrapy",
|
||||
];
|
||||
|
||||
export default function robots(): MetadataRoute.Robots {
|
||||
export default async function robots(): Promise<MetadataRoute.Robots> {
|
||||
return {
|
||||
sitemap: `${await siteUrl()}/sitemap.xml`,
|
||||
rules: [
|
||||
{ userAgent: AI_CRAWLERS, disallow: "/" },
|
||||
// Logged-in pages redirect anyway; shared links carry noindex.
|
||||
{ userAgent: "*", allow: "/", disallow: ["/api/", "/admin", "/profil", "/kepletek", "/osszevetesek", "/szemelyek"] },
|
||||
{ userAgent: "*", allow: "/", disallow: ["/api/", "/admin", "/profil", "/kepletek", "/osszevetesek", "/szemelyek", "/szamlak"] },
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
import type { MetadataRoute } from "next";
|
||||
|
||||
import { siteUrl } from "@/lib/share";
|
||||
|
||||
/** The public pages for search engines; everything else needs a login. */
|
||||
export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
|
||||
const base = await siteUrl();
|
||||
const privacy = { languages: { hu: `${base}/adatvedelem`, en: `${base}/privacy` } };
|
||||
return [
|
||||
{ url: `${base}/`, changeFrequency: "weekly", priority: 1 },
|
||||
{ url: `${base}/pelda`, changeFrequency: "monthly", priority: 0.8 },
|
||||
{ url: `${base}/adatvedelem`, changeFrequency: "yearly", priority: 0.2, alternates: privacy },
|
||||
{ url: `${base}/privacy`, changeFrequency: "yearly", priority: 0.2, alternates: privacy },
|
||||
];
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
import type { Metadata } from "next";
|
||||
import Link from "next/link";
|
||||
|
||||
import { backendGet, requireMe } from "@/lib/server";
|
||||
import type { Invoice } from "@/lib/types";
|
||||
|
||||
export const metadata: Metadata = { title: "Számláim" };
|
||||
|
||||
const huf = (n: number) => `${n.toLocaleString("hu-HU")} Ft`;
|
||||
const day = (iso: string) => new Date(iso).toLocaleDateString("hu-HU", { timeZone: "Europe/Budapest" });
|
||||
|
||||
/** The invoices of the user's purchases, with the PDF to download. */
|
||||
export default async function InvoicesPage() {
|
||||
await requireMe("/szamlak");
|
||||
const invoices = (await backendGet<{ invoices: Invoice[] }>("/v1/invoices"))?.invoices ?? [];
|
||||
|
||||
return (
|
||||
<main className="page" style={{ maxWidth: 900 }}>
|
||||
<div className="page-head">
|
||||
<h1>Számláim</h1>
|
||||
<p className="muted">
|
||||
A vásárlásaid számlái. A számlát e-mailben is elküldjük a fizetéskor megadott címre; itt bármikor újra
|
||||
letöltheted.
|
||||
</p>
|
||||
</div>
|
||||
|
||||
{invoices.length === 0 ? (
|
||||
<section className="card">
|
||||
<p className="muted">
|
||||
Még nincs számlád. Ha csomagot vásárolsz, a számlája itt jelenik meg. <Link href="/csomagok">Csomagok →</Link>
|
||||
</p>
|
||||
</section>
|
||||
) : (
|
||||
<section className="card">
|
||||
<div className="table-wrap">
|
||||
<table className="invoice-table">
|
||||
<thead>
|
||||
<tr>
|
||||
<th>Dátum</th>
|
||||
<th>Számlaszám</th>
|
||||
<th>Tétel</th>
|
||||
<th className="num">Összeg</th>
|
||||
<th>
|
||||
<span className="sr-only">Letöltés</span>
|
||||
</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{invoices.map((inv) => (
|
||||
<tr key={inv.id}>
|
||||
<td>{day(inv.invoice_date ?? inv.paid_at)}</td>
|
||||
<td>{inv.invoice_number ?? "–"}</td>
|
||||
<td>{inv.item}</td>
|
||||
<td className="num">{huf(inv.gross_huf)}</td>
|
||||
<td className="act">
|
||||
{inv.ready ? (
|
||||
<a className="btn btn-sm" href={`/api/v1/invoices/${inv.id}/pdf`} download>
|
||||
PDF letöltése
|
||||
</a>
|
||||
) : (
|
||||
<span className="hint">Készül…</span>
|
||||
)}
|
||||
</td>
|
||||
</tr>
|
||||
))}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
<p className="hint">
|
||||
A számlákat a Billingo állítja ki. Ha egy számla adatai hibásak (például a cégnév vagy az adószám), írj nekünk,
|
||||
és helyesbítjük.
|
||||
</p>
|
||||
</section>
|
||||
)}
|
||||
</main>
|
||||
);
|
||||
}
|
||||
@@ -5,6 +5,7 @@ import { ChartCard } from "@/components/ChartCard";
|
||||
import { PersonActions } from "@/components/PersonActions";
|
||||
import { PendingInvites } from "@/components/PendingInvites";
|
||||
import { PersonPacks } from "@/components/PersonPacks";
|
||||
import { payMethod } from "@/lib/payments";
|
||||
import { backendGet, requireMe } from "@/lib/server";
|
||||
import type { ChartListItem, PublicConfig } from "@/lib/types";
|
||||
|
||||
@@ -102,7 +103,7 @@ export default async function PersonsPage() {
|
||||
? "Elfogytak a helyeid. Újabb személyhez válassz csomagot."
|
||||
: "A felvett személyek képletét és elemzéseit itt éred el. Egy törölt személy helye nem szabadul fel."}
|
||||
</p>
|
||||
<PersonPacks canPay={config?.mock_payments ?? false} />
|
||||
<PersonPacks canPay={payMethod(config, me)} />
|
||||
</section>
|
||||
)}
|
||||
</main>
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
import type { Metadata } from "next";
|
||||
|
||||
import { PersonPacks } from "@/components/PersonPacks";
|
||||
import { payMethod } from "@/lib/payments";
|
||||
import { backendGet, requireMe } from "@/lib/server";
|
||||
import type { PublicConfig } from "@/lib/types";
|
||||
|
||||
@@ -31,7 +32,7 @@ export default async function NewPersonPage() {
|
||||
full={
|
||||
<>
|
||||
<p className="muted">Elfogytak a helyeid. Újabb személyhez válassz csomagot, vagy hívd meg.</p>
|
||||
<PersonPacks canPay={config?.mock_payments ?? false} />
|
||||
<PersonPacks canPay={payMethod(config, me)} />
|
||||
</>
|
||||
}
|
||||
/>
|
||||
|
||||
@@ -4,7 +4,7 @@ import Link from "next/link";
|
||||
import { useCallback, useEffect, useState } from "react";
|
||||
|
||||
import { api, ApiError, errorText } from "@/lib/api";
|
||||
import type { Question, UnitBalance } from "@/lib/types";
|
||||
import type { PayMethod, Question, UnitBalance } from "@/lib/types";
|
||||
|
||||
import { AnalysisLoading } from "./AnalysisLoading";
|
||||
import { PackageChooser } from "./PackageCards";
|
||||
@@ -49,7 +49,7 @@ export function AnalysisQuestions({
|
||||
analysisId: string;
|
||||
left: number;
|
||||
isAdmin: boolean;
|
||||
canPay: boolean;
|
||||
canPay: PayMethod | null;
|
||||
/** What the analysis is about: the heading and the example question follow it. */
|
||||
about: "natal" | "synastry" | "forecast";
|
||||
}) {
|
||||
|
||||
@@ -4,7 +4,7 @@ import Link from "next/link";
|
||||
import { useEffect, useState } from "react";
|
||||
|
||||
import { api, errorText } from "@/lib/api";
|
||||
import type { Analysis } from "@/lib/types";
|
||||
import type { Analysis, PayMethod } from "@/lib/types";
|
||||
|
||||
import { AI_SHORT } from "./AiNote";
|
||||
import { AnalysisLoading } from "./AnalysisLoading";
|
||||
@@ -96,8 +96,8 @@ export function DetailedAnalysis({
|
||||
initial: Analysis | null;
|
||||
left: number;
|
||||
isAdmin: boolean;
|
||||
/** The stand-in payment is on (MOCK_PAYMENTS). */
|
||||
canPay: boolean;
|
||||
/** How the user can buy a package (null: purchases are off). */
|
||||
canPay: PayMethod | null;
|
||||
/** Shown above a finished analysis (e.g. who is the first and the second person). */
|
||||
note?: string;
|
||||
/** Questions left; given where questions can be asked. */
|
||||
@@ -245,7 +245,11 @@ export function DetailedAnalysis({
|
||||
step === "pay" ? (
|
||||
<div className="pay-box">
|
||||
<p className="pay-lead">
|
||||
Válassz csomagot. A vásárlás után az elemzés azonnal elindul, a maradék elemzések pedig nem járnak le.
|
||||
Válassz csomagot.{" "}
|
||||
{canPay === "mock"
|
||||
? "A vásárlás után az elemzés azonnal elindul"
|
||||
: "A fizetés után visszajössz ide, és rögtön elindíthatod az elemzést"}
|
||||
, a maradék elemzések pedig nem járnak le.
|
||||
</p>
|
||||
<PackageChooser ids={t.packages} canPay={canPay} onBought={start} />
|
||||
<div className="form-actions">
|
||||
|
||||
@@ -5,7 +5,7 @@ import { useRouter } from "next/navigation";
|
||||
import { useEffect, useState } from "react";
|
||||
|
||||
import { api, errorText } from "@/lib/api";
|
||||
import type { Package } from "@/lib/types";
|
||||
import type { Package, PayMethod } from "@/lib/types";
|
||||
|
||||
export const huf = (n: number) => `${n.toLocaleString("hu-HU")} Ft`;
|
||||
|
||||
@@ -22,8 +22,9 @@ export function contents(p: Package): string[] {
|
||||
|
||||
/**
|
||||
* Package cards with a buy button. Bigger packages show what they save and
|
||||
* how little more they cost than the previous one. Until Stripe is connected
|
||||
* the payment is a stand-in (MOCK_PAYMENTS) that grants the package at once.
|
||||
* how little more they cost than the previous one. With Stripe the button
|
||||
* goes to Stripe's payment page and comes back to this page (PaymentReturn
|
||||
* shows the result); the stand-in payment (MOCK_PAYMENTS) grants at once.
|
||||
*/
|
||||
export function PackageCards({
|
||||
packages,
|
||||
@@ -35,15 +36,24 @@ export function PackageCards({
|
||||
packages: Package[];
|
||||
/** Which packages, in this order (default: the main ladder). */
|
||||
ids?: string[];
|
||||
canPay: boolean;
|
||||
/** How the user can pay (null: purchases are off, the buttons say "soon"). */
|
||||
canPay: PayMethod | null;
|
||||
compact?: boolean;
|
||||
/** After a purchase (default: reload the page data). */
|
||||
/** After a stand-in purchase (default: reload the page data). */
|
||||
onBought?: (p: Package) => Promise<void> | void;
|
||||
}) {
|
||||
const router = useRouter();
|
||||
const [busy, setBusy] = useState<string | null>(null);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [done, setDone] = useState<string | null>(null);
|
||||
// Back from Stripe's page (the browser may restore this page as it was).
|
||||
useEffect(() => {
|
||||
const reset = (e: PageTransitionEvent) => {
|
||||
if (e.persisted) setBusy(null);
|
||||
};
|
||||
window.addEventListener("pageshow", reset);
|
||||
return () => window.removeEventListener("pageshow", reset);
|
||||
}, []);
|
||||
const shown = ids
|
||||
? ids.map((id) => packages.find((p) => p.id === id)).filter((p): p is Package => p !== undefined)
|
||||
: packages.filter((p) => p.tier === "main");
|
||||
@@ -53,15 +63,22 @@ export function PackageCards({
|
||||
setError(null);
|
||||
setDone(null);
|
||||
try {
|
||||
if (canPay === "stripe" || canPay === "stripe_test") {
|
||||
const { url } = await api<{ url: string }>("/payments/checkout", {
|
||||
body: { package: p.id, return_path: window.location.pathname },
|
||||
});
|
||||
window.location.assign(url);
|
||||
return;
|
||||
}
|
||||
await api("/payments/mock", { body: { package: p.id } });
|
||||
if (onBought) await onBought(p);
|
||||
else {
|
||||
setDone(p.name);
|
||||
router.refresh();
|
||||
}
|
||||
setBusy(null);
|
||||
} catch (e) {
|
||||
setError(errorText(e));
|
||||
} finally {
|
||||
setBusy(null);
|
||||
}
|
||||
}
|
||||
@@ -110,7 +127,7 @@ export function PackageCards({
|
||||
onClick={() => buy(p)}
|
||||
disabled={busy !== null}
|
||||
>
|
||||
{busy === p.id ? "Fizetés…" : "Megveszem"}
|
||||
{busy === p.id ? (canPay === "mock" ? "Fizetés…" : "Átirányítás…") : "Megveszem"}
|
||||
</button>
|
||||
) : (
|
||||
<button type="button" className="btn" disabled>
|
||||
@@ -131,7 +148,19 @@ export function PackageCards({
|
||||
A(z) {done} csomag jóváírva.
|
||||
</p>
|
||||
)}
|
||||
{canPay && <p className="hint">Tesztüzem: a fizetés még nincs bekötve, a gomb nem terhel semmit.</p>}
|
||||
{canPay === "mock" && <p className="hint">Tesztüzem: a fizetés még nincs bekötve, a gomb nem terhel semmit.</p>}
|
||||
{(canPay === "stripe" || canPay === "stripe_test") && (
|
||||
<p className="hint">
|
||||
<span aria-hidden="true">🔒</span> A fizetés a Stripe biztonságos oldalán történik (bankkártya, Apple Pay,
|
||||
Google Pay). A kártyaadataidat közvetlenül a Stripe-nak adod meg: mi nem látjuk és nem tároljuk őket.
|
||||
</p>
|
||||
)}
|
||||
{canPay === "stripe_test" && (
|
||||
<p className="hint">
|
||||
Stripe tesztmód (csak adminoknak látszik): kártyaszám 4242 4242 4242 4242, bármilyen jövőbeli lejárat és CVC.
|
||||
Valódi pénz nem mozdul.
|
||||
</p>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -154,7 +183,7 @@ export function PackageChooser({
|
||||
onBought,
|
||||
}: {
|
||||
ids: string[];
|
||||
canPay: boolean;
|
||||
canPay: PayMethod | null;
|
||||
onBought?: (p: Package) => Promise<void> | void;
|
||||
}) {
|
||||
const packages = usePackages();
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
"use client";
|
||||
|
||||
import { usePathname, useRouter, useSearchParams } from "next/navigation";
|
||||
import { useEffect, useState } from "react";
|
||||
|
||||
import { api, errorText } from "@/lib/api";
|
||||
|
||||
type Notice = { kind: "wait" | "ok" | "info" | "error"; text: string };
|
||||
|
||||
const POLLS = 20;
|
||||
const POLL_MS = 2000;
|
||||
|
||||
/**
|
||||
* Back from Stripe's payment page (`?fizetes=<session>` or
|
||||
* `?fizetes=megszakitva`): waits until the payment is confirmed, then shows
|
||||
* it and reloads the page data. Lives in the layout, so it works on every
|
||||
* page a purchase can start from.
|
||||
*/
|
||||
export function PaymentReturn() {
|
||||
const params = useSearchParams();
|
||||
const pathname = usePathname();
|
||||
const router = useRouter();
|
||||
const value = params.get("fizetes");
|
||||
const [notice, setNotice] = useState<Notice | null>(null);
|
||||
|
||||
useEffect(() => {
|
||||
if (!value) return;
|
||||
// A reload should not show it again.
|
||||
const clean = () => {
|
||||
const rest = new URLSearchParams(window.location.search);
|
||||
rest.delete("fizetes");
|
||||
router.replace(rest.size ? `${pathname}?${rest}` : pathname, { scroll: false });
|
||||
};
|
||||
if (value === "megszakitva") {
|
||||
setNotice({ kind: "info", text: "A fizetés megszakadt, nem terheltünk semmit." });
|
||||
clean();
|
||||
return;
|
||||
}
|
||||
let stopped = false;
|
||||
setNotice({ kind: "wait", text: "A fizetés visszaigazolására várunk…" });
|
||||
(async () => {
|
||||
for (let i = 0; i < POLLS && !stopped; i++) {
|
||||
try {
|
||||
const r = await api<{ status: string; name: string | null }>(
|
||||
`/payments/checkout/${encodeURIComponent(value)}`,
|
||||
);
|
||||
if (stopped) return;
|
||||
if (r.status === "paid") {
|
||||
setNotice({ kind: "ok", text: `Köszönjük! Jóváírtuk: ${r.name ?? "a csomagod"}.` });
|
||||
clean();
|
||||
router.refresh();
|
||||
return;
|
||||
}
|
||||
if (r.status === "expired") {
|
||||
setNotice({ kind: "info", text: "A fizetési oldal lejárt, nem terheltünk semmit." });
|
||||
clean();
|
||||
return;
|
||||
}
|
||||
} catch (e) {
|
||||
if (!stopped) setNotice({ kind: "error", text: errorText(e) });
|
||||
return;
|
||||
}
|
||||
await new Promise((resolve) => setTimeout(resolve, POLL_MS));
|
||||
}
|
||||
if (!stopped)
|
||||
setNotice({
|
||||
kind: "error",
|
||||
text: "A Stripe még nem igazolta vissza a fizetést. Pár perc múlva frissítsd az oldalt: ha a pénz levonódott, a csomag megérkezik.",
|
||||
});
|
||||
})();
|
||||
return () => {
|
||||
stopped = true;
|
||||
};
|
||||
}, [value, pathname, router]);
|
||||
|
||||
if (!notice) return null;
|
||||
const cls = notice.kind === "ok" ? "msg msg-ok" : notice.kind === "error" ? "msg msg-error" : "msg";
|
||||
return (
|
||||
<div className="pay-return" role={notice.kind === "error" ? "alert" : "status"}>
|
||||
<p className={cls}>
|
||||
<span>{notice.text}</span>
|
||||
{notice.kind !== "wait" && (
|
||||
<button type="button" className="btn btn-sm btn-ghost" onClick={() => setNotice(null)} aria-label="Bezárás">
|
||||
×
|
||||
</button>
|
||||
)}
|
||||
</p>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -1,8 +1,10 @@
|
||||
"use client";
|
||||
|
||||
import type { PayMethod } from "@/lib/types";
|
||||
|
||||
import { PackageChooser } from "./PackageCards";
|
||||
|
||||
/** Packages that give more persons: a few more, or the family package. */
|
||||
export function PersonPacks({ canPay }: { canPay: boolean }) {
|
||||
export function PersonPacks({ canPay }: { canPay: PayMethod | null }) {
|
||||
return <PackageChooser ids={["addon_persons", "family"]} canPay={canPay} />;
|
||||
}
|
||||
|
||||
@@ -90,6 +90,7 @@ export function SiteHeader({ me }: { me: Me }) {
|
||||
{ href: "/szemelyek", label: "Személyek" },
|
||||
{ href: "/osszevetesek", label: "Összevetések" },
|
||||
{ href: "/csomagok", label: "Csomagok" },
|
||||
...(me.invoice_count > 0 ? [{ href: "/szamlak", label: "Számláim" }] : []),
|
||||
{ href: "/profil", label: "Profil" },
|
||||
];
|
||||
if (me.user.roles.includes("admin")) links.push({ href: "/admin", label: "Admin" });
|
||||
|
||||
@@ -15,5 +15,5 @@ export function operatorDetails(): string | null {
|
||||
return parts.length > 0 ? parts.join(", ") : null;
|
||||
}
|
||||
|
||||
export const PRIVACY_UPDATED = "2026. november 19.";
|
||||
export const PRIVACY_UPDATED_EN = "19 November 2026";
|
||||
export const PRIVACY_UPDATED = "2026. november 20.";
|
||||
export const PRIVACY_UPDATED_EN = "20 November 2026";
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
import type { Me, PayMethod, PublicConfig } from "./types";
|
||||
|
||||
/**
|
||||
* How this user can buy packages. Until purchases open (and with a Stripe
|
||||
* test key) only admins can; everyone else sees "soon".
|
||||
*/
|
||||
export function payMethod(config: PublicConfig | null | undefined, me: Me): PayMethod | null {
|
||||
if (config?.payments === "mock") return "mock";
|
||||
if (config?.payments !== "stripe") return null;
|
||||
if (config.payments_admins_only && !me.user.roles.includes("admin")) return null;
|
||||
return config.payments_test ? "stripe_test" : "stripe";
|
||||
}
|
||||
@@ -23,6 +23,8 @@ export interface Me {
|
||||
package: { id: string; name: string; since: string } | null;
|
||||
/** The free question for a shared link is used up (once per user). */
|
||||
share_reward_granted: boolean;
|
||||
/** Invoices of the user's payments (the "Számláim" menu shows from the first). */
|
||||
invoice_count: number;
|
||||
/** Natal analyses earned by bringing new users through shared links. */
|
||||
referral_rewards: { earned: number; limit: number };
|
||||
}
|
||||
@@ -92,6 +94,14 @@ export interface PublicConfig {
|
||||
password_login: boolean;
|
||||
password_min_length: number;
|
||||
mock_payments: boolean;
|
||||
/** How packages are paid: Stripe Checkout, the stand-in, or not at all. */
|
||||
payments: "stripe" | "mock" | null;
|
||||
/** Only admins can buy through Stripe (until the opening, and with a test key). */
|
||||
payments_admins_only: boolean;
|
||||
/** Stripe has a test key (test cards work, no real money). */
|
||||
payments_test: boolean;
|
||||
/** "AAM": alanyi adómentes, the prices carry no VAT; otherwise the rate, e.g. "27%". */
|
||||
vat: string;
|
||||
/** "invite": new accounts need an invitation. */
|
||||
signup_mode: "invite" | "open";
|
||||
/** Users may invite others (off until the launch; admins always may). */
|
||||
@@ -573,3 +583,17 @@ export interface PersonInviteLanding {
|
||||
status: "pending" | "accepted" | "expired";
|
||||
expires_at: string;
|
||||
}
|
||||
|
||||
/** How this user can buy a package; `null`: purchases are off. */
|
||||
export type PayMethod = "stripe" | "stripe_test" | "mock";
|
||||
|
||||
export interface Invoice {
|
||||
id: string;
|
||||
/** Issued in Billingo: the PDF can be downloaded. */
|
||||
ready: boolean;
|
||||
invoice_number: string | null;
|
||||
invoice_date: string | null;
|
||||
item: string;
|
||||
gross_huf: number;
|
||||
paid_at: string;
|
||||
}
|
||||
|
||||
@@ -14,22 +14,26 @@ pub struct Tasks {
|
||||
pub cleanup: bool,
|
||||
/// Writing the analyses and answers with the LLM (both lanes).
|
||||
pub analyses: bool,
|
||||
/// Issuing the invoices of the payments in Billingo.
|
||||
pub invoices: bool,
|
||||
}
|
||||
|
||||
impl Tasks {
|
||||
pub const ALL: Tasks = Tasks { email: true, cleanup: true, analyses: true };
|
||||
pub const ALL: Tasks = Tasks { email: true, cleanup: true, analyses: true, invoices: true };
|
||||
const NONE: Tasks = Tasks { email: false, cleanup: false, analyses: false, invoices: false };
|
||||
|
||||
pub fn parse(raw: &str) -> anyhow::Result<Self> {
|
||||
let mut tasks = Tasks { email: false, cleanup: false, analyses: false };
|
||||
let mut tasks = Self::NONE;
|
||||
for name in raw.split(',').map(str::trim).filter(|n| !n.is_empty()) {
|
||||
match name {
|
||||
"email" => tasks.email = true,
|
||||
"cleanup" => tasks.cleanup = true,
|
||||
"analyses" => tasks.analyses = true,
|
||||
other => anyhow::bail!("unknown task '{other}' in WORKER_TASKS (email, cleanup, analyses)"),
|
||||
"invoices" => tasks.invoices = true,
|
||||
other => anyhow::bail!("unknown task '{other}' in WORKER_TASKS (email, cleanup, analyses, invoices)"),
|
||||
}
|
||||
}
|
||||
anyhow::ensure!(tasks != Tasks { email: false, cleanup: false, analyses: false }, "WORKER_TASKS names no task");
|
||||
anyhow::ensure!(tasks != Self::NONE, "WORKER_TASKS names no task");
|
||||
Ok(tasks)
|
||||
}
|
||||
}
|
||||
@@ -61,6 +65,15 @@ pub struct Config {
|
||||
pub quick_concurrency: usize,
|
||||
/// After this many failed attempts an analysis fails and is refunded.
|
||||
pub max_analysis_attempts: i32,
|
||||
/// `BILLINGO_API_KEY`; unset: invoices stay pending.
|
||||
pub billingo_api_key: Option<String>,
|
||||
/// `BILLINGO_API_URL` (default `https://api.billingo.hu/v3`).
|
||||
pub billingo_api_url: String,
|
||||
/// `BILLINGO_BLOCK_ID`: the invoice pad (default: the account's first one).
|
||||
pub billingo_block_id: Option<i64>,
|
||||
/// `MAX_INVOICE_ATTEMPTS` (default 10, about a day with the backoff):
|
||||
/// then the invoice is marked failed for an admin.
|
||||
pub max_invoice_attempts: i32,
|
||||
}
|
||||
|
||||
fn var(name: &str) -> Option<String> {
|
||||
@@ -103,6 +116,13 @@ impl Config {
|
||||
analysis_concurrency: parsed("ANALYSIS_CONCURRENCY", 4)?,
|
||||
quick_concurrency: parsed("QUICK_CONCURRENCY", 2)?,
|
||||
max_analysis_attempts: parsed("MAX_ANALYSIS_ATTEMPTS", 3)?,
|
||||
billingo_api_key: var("BILLINGO_API_KEY"),
|
||||
billingo_api_url: var("BILLINGO_API_URL").unwrap_or_else(|| crate::invoices::DEFAULT_BASE_URL.into()),
|
||||
billingo_block_id: var("BILLINGO_BLOCK_ID")
|
||||
.map(|v| v.parse())
|
||||
.transpose()
|
||||
.context("invalid BILLINGO_BLOCK_ID")?,
|
||||
max_invoice_attempts: parsed("MAX_INVOICE_ATTEMPTS", 10)?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,500 @@
|
||||
//! Issuing the invoices of the Stripe payments in Billingo (API v3).
|
||||
//!
|
||||
//! The backend queues one `invoices` row per paid checkout, with the buyer and
|
||||
//! the item as they go on the invoice. This job takes the due rows and, step
|
||||
//! by step, creates the Billingo partner, the invoice (paid by card,
|
||||
//! electronic) and e-mails it to the buyer. Each step's result is saved before
|
||||
//! the next one, so a retry continues where it stopped and never issues a
|
||||
//! second invoice. Billingo's whole answer is kept; the PDF is not (the
|
||||
//! backend fetches it when the user downloads it).
|
||||
|
||||
use std::time::Duration;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use sqlx::PgPool;
|
||||
use time::{Date, Month, OffsetDateTime, UtcOffset, Weekday};
|
||||
use tokio::sync::{Mutex, watch};
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::email::backoff;
|
||||
|
||||
pub const DEFAULT_BASE_URL: &str = "https://api.billingo.hu/v3";
|
||||
/// How long a claimed invoice is left alone (a crashed worker's row comes back).
|
||||
const LEASE: &str = "10 minutes";
|
||||
|
||||
pub struct Billingo {
|
||||
http: reqwest::Client,
|
||||
base: String,
|
||||
key: String,
|
||||
/// The invoice pad (`BILLINGO_BLOCK_ID`, or the account's first invoice pad).
|
||||
block: Mutex<Option<i64>>,
|
||||
}
|
||||
|
||||
impl Billingo {
|
||||
pub fn new(base: &str, key: &str, block: Option<i64>) -> Self {
|
||||
let http = reqwest::Client::builder().timeout(Duration::from_secs(30)).build().expect("static configuration");
|
||||
Self { http, base: base.trim_end_matches('/').to_owned(), key: key.to_owned(), block: Mutex::new(block) }
|
||||
}
|
||||
|
||||
async fn call(&self, method: reqwest::Method, path: &str, body: Option<&Value>) -> Result<Value, String> {
|
||||
let mut req = self
|
||||
.http
|
||||
.request(method.clone(), format!("{}{path}", self.base))
|
||||
.header("X-API-KEY", &self.key)
|
||||
.header("Accept", "application/json");
|
||||
if let Some(body) = body {
|
||||
req = req.json(body);
|
||||
}
|
||||
let res = req.send().await.map_err(|e| format!("{method} {path}: {e}"))?;
|
||||
let status = res.status();
|
||||
let text = res.text().await.unwrap_or_default();
|
||||
if !status.is_success() {
|
||||
return Err(format!("{method} {path}: HTTP {status}: {}", text.chars().take(500).collect::<String>()));
|
||||
}
|
||||
if text.trim().is_empty() {
|
||||
return Ok(Value::Null);
|
||||
}
|
||||
serde_json::from_str(&text).map_err(|e| format!("{method} {path}: not JSON: {e}"))
|
||||
}
|
||||
|
||||
async fn block(&self) -> Result<i64, String> {
|
||||
let mut block = self.block.lock().await;
|
||||
if let Some(id) = *block {
|
||||
return Ok(id);
|
||||
}
|
||||
let list = self.call(reqwest::Method::GET, "/document-blocks?type=invoice&per_page=100", None).await?;
|
||||
let id = list["data"]
|
||||
.as_array()
|
||||
.and_then(|pads| pads.iter().find(|p| p["type"] == "invoice" || p["type"].is_null()))
|
||||
.and_then(|p| p["id"].as_i64())
|
||||
.ok_or("Billingo has no invoice pad (document block); set BILLINGO_BLOCK_ID")?;
|
||||
*block = Some(id);
|
||||
Ok(id)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(sqlx::FromRow)]
|
||||
struct Due {
|
||||
id: Uuid,
|
||||
attempts: i32,
|
||||
buyer_name: String,
|
||||
buyer_email: Option<String>,
|
||||
buyer_country: String,
|
||||
buyer_post_code: String,
|
||||
buyer_city: String,
|
||||
buyer_address: String,
|
||||
buyer_tax_type: String,
|
||||
buyer_tax_number: Option<String>,
|
||||
item_name: String,
|
||||
item_comment: Option<String>,
|
||||
item_unit: String,
|
||||
gross_huf: i32,
|
||||
vat_rate: String,
|
||||
payment_method: String,
|
||||
billingo_partner_id: Option<i64>,
|
||||
billingo_document_id: Option<i64>,
|
||||
sent_at: Option<OffsetDateTime>,
|
||||
paid_at: OffsetDateTime,
|
||||
}
|
||||
|
||||
/// The date in Hungary (CET, CEST from the last Sunday of March to the last
|
||||
/// Sunday of October, 01:00 UTC): the invoice's fulfilment date.
|
||||
pub fn hungarian_date(t: OffsetDateTime) -> Date {
|
||||
let last_sunday = |month| {
|
||||
let mut d = Date::from_calendar_date(t.year(), month, 31).expect("March and October have 31 days");
|
||||
while d.weekday() != Weekday::Sunday {
|
||||
d = d.previous_day().expect("not the first day");
|
||||
}
|
||||
d.with_hms(1, 0, 0).expect("valid time").assume_utc()
|
||||
};
|
||||
let summer = t >= last_sunday(Month::March) && t < last_sunday(Month::October);
|
||||
t.to_offset(UtcOffset::from_hms(if summer { 2 } else { 1 }, 0, 0).expect("valid offset")).date()
|
||||
}
|
||||
|
||||
/// A `YYYY-MM-DD…` value of Billingo's answer.
|
||||
fn date(v: &Value) -> Option<Date> {
|
||||
let s = v.as_str()?.get(..10)?;
|
||||
let mut parts = s.split('-');
|
||||
let year = parts.next()?.parse().ok()?;
|
||||
let month = Month::try_from(parts.next()?.parse::<u8>().ok()?).ok()?;
|
||||
Date::from_calendar_date(year, month, parts.next()?.parse().ok()?).ok()
|
||||
}
|
||||
|
||||
/// Issues the due invoices; returns how many were finished.
|
||||
pub async fn run_once(db: &PgPool, billingo: &Billingo, max_attempts: i32) -> Result<usize, sqlx::Error> {
|
||||
let mut done = 0;
|
||||
loop {
|
||||
let due: Option<Due> = sqlx::query_as(&format!(
|
||||
"UPDATE invoices i SET attempts = i.attempts + 1, next_attempt_at = now() + interval '{LEASE}' \
|
||||
FROM stripe_checkouts c \
|
||||
WHERE c.id = i.checkout_id AND i.id = (SELECT id FROM invoices WHERE status = 'pending' \
|
||||
AND next_attempt_at <= now() ORDER BY next_attempt_at FOR UPDATE SKIP LOCKED LIMIT 1) \
|
||||
RETURNING i.id, i.attempts, i.buyer_name, i.buyer_email, i.buyer_country, i.buyer_post_code, \
|
||||
i.buyer_city, i.buyer_address, i.buyer_tax_type, i.buyer_tax_number, i.item_name, i.item_comment, i.item_unit, i.gross_huf, \
|
||||
i.vat_rate, i.payment_method, i.billingo_partner_id, i.billingo_document_id, i.sent_at, \
|
||||
coalesce(c.completed_at, i.created_at) AS paid_at"
|
||||
))
|
||||
.fetch_optional(db)
|
||||
.await?;
|
||||
let Some(due) = due else { return Ok(done) };
|
||||
match issue(db, billingo, &due).await {
|
||||
Ok(number) => {
|
||||
tracing::info!(invoice = %due.id, number = %number, "invoice issued");
|
||||
done += 1;
|
||||
}
|
||||
Err(Failure::Db(e)) => return Err(e),
|
||||
Err(Failure::Billingo(error)) if due.attempts >= max_attempts => {
|
||||
tracing::error!(invoice = %due.id, %error, "invoice failed; an admin has to look at it");
|
||||
sqlx::query("UPDATE invoices SET status = 'failed', last_error = $2 WHERE id = $1")
|
||||
.bind(due.id)
|
||||
.bind(&error)
|
||||
.execute(db)
|
||||
.await?;
|
||||
done += 1;
|
||||
}
|
||||
Err(Failure::Billingo(error)) => {
|
||||
let wait = backoff(due.attempts);
|
||||
tracing::warn!(invoice = %due.id, %error, retry_in = ?wait, "invoice not issued yet");
|
||||
sqlx::query(
|
||||
"UPDATE invoices SET last_error = $2, next_attempt_at = now() + make_interval(secs => $3) \
|
||||
WHERE id = $1",
|
||||
)
|
||||
.bind(due.id)
|
||||
.bind(&error)
|
||||
.bind(wait.as_secs_f64())
|
||||
.execute(db)
|
||||
.await?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
enum Failure {
|
||||
Billingo(String),
|
||||
Db(sqlx::Error),
|
||||
}
|
||||
|
||||
impl From<sqlx::Error> for Failure {
|
||||
fn from(e: sqlx::Error) -> Self {
|
||||
Failure::Db(e)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<String> for Failure {
|
||||
fn from(e: String) -> Self {
|
||||
Failure::Billingo(e)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<&str> for Failure {
|
||||
fn from(e: &str) -> Self {
|
||||
Failure::Billingo(e.to_owned())
|
||||
}
|
||||
}
|
||||
|
||||
/// Partner, invoice, e-mail: whatever is still missing. Returns the number.
|
||||
async fn issue(db: &PgPool, billingo: &Billingo, due: &Due) -> Result<String, Failure> {
|
||||
use reqwest::Method;
|
||||
|
||||
let partner = match due.billingo_partner_id {
|
||||
Some(id) => id,
|
||||
None => {
|
||||
let body = json!({
|
||||
"name": due.buyer_name,
|
||||
"address": {
|
||||
"country_code": due.buyer_country,
|
||||
"post_code": due.buyer_post_code,
|
||||
"city": due.buyer_city,
|
||||
"address": due.buyer_address,
|
||||
},
|
||||
"emails": due.buyer_email.iter().collect::<Vec<_>>(),
|
||||
"taxcode": due.buyer_tax_number.clone().unwrap_or_default(),
|
||||
"tax_type": due.buyer_tax_type,
|
||||
});
|
||||
let partner = billingo.call(Method::POST, "/partners", Some(&body)).await?;
|
||||
let id = partner["id"].as_i64().ok_or("Billingo partner without id")?;
|
||||
sqlx::query("UPDATE invoices SET billingo_partner_id = $2 WHERE id = $1")
|
||||
.bind(due.id)
|
||||
.bind(id)
|
||||
.execute(db)
|
||||
.await?;
|
||||
id
|
||||
}
|
||||
};
|
||||
|
||||
let document = match due.billingo_document_id {
|
||||
Some(id) => id,
|
||||
None => {
|
||||
let day = hungarian_date(due.paid_at).to_string();
|
||||
let body = json!({
|
||||
"partner_id": partner,
|
||||
"block_id": billingo.block().await?,
|
||||
"type": "invoice",
|
||||
"fulfillment_date": day,
|
||||
"due_date": day,
|
||||
"payment_method": due.payment_method,
|
||||
"language": "hu",
|
||||
"currency": "HUF",
|
||||
"electronic": true,
|
||||
"paid": true,
|
||||
"items": [{
|
||||
"name": due.item_name,
|
||||
"unit_price": due.gross_huf,
|
||||
"unit_price_type": "gross",
|
||||
"quantity": 1,
|
||||
"unit": due.item_unit,
|
||||
"vat": due.vat_rate,
|
||||
"comment": due.item_comment.clone().unwrap_or_default(),
|
||||
}],
|
||||
"comment": if due.vat_rate == "AAM" {
|
||||
"Bankkártyával kifizetve (Stripe). Alanyi adómentes."
|
||||
} else {
|
||||
"Bankkártyával kifizetve (Stripe)."
|
||||
},
|
||||
});
|
||||
let doc = billingo.call(Method::POST, "/documents", Some(&body)).await?;
|
||||
let id = doc["id"].as_i64().ok_or("Billingo invoice without id")?;
|
||||
let item = &doc["items"][0];
|
||||
sqlx::query(
|
||||
"UPDATE invoices SET billingo_document_id = $2, invoice_number = $3, invoice_date = $4, \
|
||||
fulfillment_date = $5, due_date = $6, document = $7, \
|
||||
net_huf = coalesce($8, net_huf), vat_huf = coalesce($9, vat_huf) WHERE id = $1",
|
||||
)
|
||||
.bind(due.id)
|
||||
.bind(id)
|
||||
.bind(doc["invoice_number"].as_str())
|
||||
.bind(date(&doc["invoice_date"]))
|
||||
.bind(date(&doc["fulfillment_date"]))
|
||||
.bind(date(&doc["due_date"]))
|
||||
.bind(&doc)
|
||||
.bind(item["net_amount"].as_f64().map(|n| n.round() as i32))
|
||||
.bind(item["vat_amount"].as_f64().map(|n| n.round() as i32))
|
||||
.execute(db)
|
||||
.await?;
|
||||
id
|
||||
}
|
||||
};
|
||||
|
||||
if due.sent_at.is_none()
|
||||
&& let Some(email) = &due.buyer_email
|
||||
{
|
||||
let body = json!({ "emails": [email] });
|
||||
billingo.call(Method::POST, &format!("/documents/{document}/send"), Some(&body)).await?;
|
||||
sqlx::query("UPDATE invoices SET sent_at = now() WHERE id = $1").bind(due.id).execute(db).await?;
|
||||
}
|
||||
|
||||
let (number,): (Option<String>,) = sqlx::query_as(
|
||||
"UPDATE invoices SET status = 'issued', issued_at = now(), last_error = NULL WHERE id = $1 \
|
||||
RETURNING invoice_number",
|
||||
)
|
||||
.bind(due.id)
|
||||
.fetch_one(db)
|
||||
.await?;
|
||||
Ok(number.unwrap_or_default())
|
||||
}
|
||||
|
||||
pub async fn run(db: PgPool, billingo: Billingo, max_attempts: i32, interval: Duration, stop: watch::Receiver<bool>) {
|
||||
loop {
|
||||
if let Err(e) = run_once(&db, &billingo, max_attempts).await {
|
||||
tracing::error!(error = %e, "invoices");
|
||||
}
|
||||
tokio::select! {
|
||||
() = tokio::time::sleep(interval) => {}
|
||||
() = crate::stopped(stop.clone()) => break,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
use super::*;
|
||||
use axum::extract::{Path, State};
|
||||
use axum::http::StatusCode;
|
||||
use axum::routing::{get, post};
|
||||
use axum::{Json, Router};
|
||||
|
||||
fn at(s: &str) -> OffsetDateTime {
|
||||
OffsetDateTime::parse(s, &time::format_description::well_known::Rfc3339).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fulfilment_dates_are_hungarian() {
|
||||
// 23:30 UTC is already the next day in Budapest, in winter and summer.
|
||||
assert_eq!(hungarian_date(at("2026-11-20T23:30:00Z")).to_string(), "2026-11-21");
|
||||
assert_eq!(hungarian_date(at("2026-11-20T22:59:00Z")).to_string(), "2026-11-20");
|
||||
assert_eq!(hungarian_date(at("2026-07-01T22:30:00Z")).to_string(), "2026-07-02");
|
||||
assert_eq!(hungarian_date(at("2026-07-01T21:59:00Z")).to_string(), "2026-07-01");
|
||||
assert_eq!(date(&json!("2026-11-21T00:00:00+01:00")).unwrap().to_string(), "2026-11-21");
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Fake {
|
||||
requests: std::sync::Mutex<Vec<(String, Value)>>,
|
||||
documents: AtomicUsize,
|
||||
/// Sending fails this many times first.
|
||||
send_failures: AtomicUsize,
|
||||
/// Partners are refused (a permanent error).
|
||||
refuse_partners: std::sync::atomic::AtomicBool,
|
||||
}
|
||||
|
||||
async fn fake_billingo(fake: Arc<Fake>) -> String {
|
||||
async fn blocks(State(f): State<Arc<Fake>>) -> Json<Value> {
|
||||
f.requests.lock().unwrap().push(("blocks".into(), Value::Null));
|
||||
Json(json!({"data": [{"id": 5, "name": "Számlák", "type": "invoice"}], "total": 1}))
|
||||
}
|
||||
async fn partner(State(f): State<Arc<Fake>>, Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
|
||||
f.requests.lock().unwrap().push(("partner".into(), body.clone()));
|
||||
if f.refuse_partners.load(Ordering::SeqCst) {
|
||||
return (StatusCode::UNPROCESSABLE_ENTITY, Json(json!({"message": "invalid tax code"})));
|
||||
}
|
||||
(StatusCode::CREATED, Json(json!({"id": 42, "name": body["name"]})))
|
||||
}
|
||||
async fn document(State(f): State<Arc<Fake>>, Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
|
||||
f.requests.lock().unwrap().push(("document".into(), body.clone()));
|
||||
let n = f.documents.fetch_add(1, Ordering::SeqCst) + 1;
|
||||
(
|
||||
StatusCode::CREATED,
|
||||
Json(json!({"id": 900 + n, "invoice_number": format!("SF-2026-{n}"), "invoice_date": "2026-11-20",
|
||||
"fulfillment_date": body["fulfillment_date"], "due_date": body["due_date"],
|
||||
"gross_total": 6000.0,
|
||||
"items": [{"name": "x", "net_amount": 6000.0, "vat_amount": 0.0, "gross_amount": 6000.0}]})),
|
||||
)
|
||||
}
|
||||
async fn send(
|
||||
State(f): State<Arc<Fake>>,
|
||||
Path(id): Path<i64>,
|
||||
Json(body): Json<Value>,
|
||||
) -> (StatusCode, Json<Value>) {
|
||||
f.requests.lock().unwrap().push((format!("send {id}"), body.clone()));
|
||||
if f.send_failures.load(Ordering::SeqCst) > 0 {
|
||||
f.send_failures.fetch_sub(1, Ordering::SeqCst);
|
||||
return (StatusCode::INTERNAL_SERVER_ERROR, Json(json!({"error": "mail down"})));
|
||||
}
|
||||
(StatusCode::OK, Json(body))
|
||||
}
|
||||
let app = Router::new()
|
||||
.route("/document-blocks", get(blocks))
|
||||
.route("/partners", post(partner))
|
||||
.route("/documents", post(document))
|
||||
.route("/documents/{id}/send", post(send))
|
||||
.with_state(fake);
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let addr = listener.local_addr().unwrap();
|
||||
tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
|
||||
format!("http://{addr}")
|
||||
}
|
||||
|
||||
async fn paid(db: &PgPool, tax: Option<&str>) -> Uuid {
|
||||
let checkout = format!("cs_{}", Uuid::now_v7());
|
||||
sqlx::query(
|
||||
"INSERT INTO stripe_checkouts (id, package, price_huf, live, completed_at) \
|
||||
VALUES ($1, 'couple', 6000, false, '2026-11-20T23:30:00Z')",
|
||||
)
|
||||
.bind(&checkout)
|
||||
.execute(db)
|
||||
.await
|
||||
.unwrap();
|
||||
let id = Uuid::now_v7();
|
||||
sqlx::query(
|
||||
"INSERT INTO invoices (id, checkout_id, buyer_name, buyer_email, buyer_country, buyer_post_code, \
|
||||
buyer_city, buyer_address, buyer_tax_type, buyer_tax_number, item_name, gross_huf, net_huf, vat_huf) \
|
||||
VALUES ($1, $2, 'Csillag Kft.', 'anna@example.com', 'HU', '6720', 'Szeged', 'Fő utca 1.', $3, $4, \
|
||||
'Online tartalomszolgáltatás – Páros csomag', 6000, 6000, 0)",
|
||||
)
|
||||
.bind(id)
|
||||
.bind(&checkout)
|
||||
.bind(if tax.is_some() { "HAS_TAX_NUMBER" } else { "NO_TAX_NUMBER" })
|
||||
.bind(tax)
|
||||
.execute(db)
|
||||
.await
|
||||
.unwrap();
|
||||
id
|
||||
}
|
||||
|
||||
async fn state(db: &PgPool, id: Uuid) -> (String, Option<String>, Option<i64>, bool, i32) {
|
||||
sqlx::query_as(
|
||||
"SELECT status, invoice_number, billingo_document_id, sent_at IS NOT NULL, attempts FROM invoices \
|
||||
WHERE id = $1",
|
||||
)
|
||||
.bind(id)
|
||||
.fetch_one(db)
|
||||
.await
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn invoices_are_issued_and_sent_once(db: PgPool) {
|
||||
let fake = Arc::new(Fake::default());
|
||||
let billingo = Billingo::new(&fake_billingo(fake.clone()).await, "key", None);
|
||||
let id = paid(&db, Some("12345678-1-23")).await;
|
||||
fake.send_failures.store(1, Ordering::SeqCst);
|
||||
|
||||
// The invoice is made, but the e-mail fails: it is retried later.
|
||||
assert_eq!(run_once(&db, &billingo, 5).await.unwrap(), 0);
|
||||
let (status, number, document, sent, attempts) = state(&db, id).await;
|
||||
assert_eq!(
|
||||
(status.as_str(), number.as_deref(), document, sent, attempts),
|
||||
("pending", Some("SF-2026-1"), Some(901), false, 1)
|
||||
);
|
||||
{
|
||||
let requests = fake.requests.lock().unwrap();
|
||||
let partner = &requests.iter().find(|(k, _)| k == "partner").unwrap().1;
|
||||
assert_eq!(partner["taxcode"], "12345678-1-23");
|
||||
assert_eq!(partner["tax_type"], "HAS_TAX_NUMBER");
|
||||
assert_eq!(partner["address"]["post_code"], "6720");
|
||||
let doc = &requests.iter().find(|(k, _)| k == "document").unwrap().1;
|
||||
assert_eq!((&doc["partner_id"], &doc["block_id"]), (&json!(42), &json!(5)));
|
||||
assert_eq!(
|
||||
(&doc["paid"], &doc["payment_method"], &doc["currency"]),
|
||||
(&json!(true), &json!("online_bankcard"), &json!("HUF"))
|
||||
);
|
||||
assert_eq!(doc["items"][0]["unit_price"], 6000);
|
||||
assert_eq!(
|
||||
(&doc["items"][0]["name"], &doc["items"][0]["unit"]),
|
||||
(&json!("Online tartalomszolgáltatás – Páros csomag"), &json!("csomag"))
|
||||
);
|
||||
assert_eq!(
|
||||
(&doc["items"][0]["unit_price_type"], &doc["items"][0]["vat"]),
|
||||
(&json!("gross"), &json!("AAM"))
|
||||
);
|
||||
// Paid at 00:30 in Budapest.
|
||||
assert_eq!(doc["fulfillment_date"], "2026-11-21");
|
||||
}
|
||||
// Not before its time.
|
||||
assert_eq!(run_once(&db, &billingo, 5).await.unwrap(), 0);
|
||||
sqlx::query("UPDATE invoices SET next_attempt_at = now()").execute(&db).await.unwrap();
|
||||
assert_eq!(run_once(&db, &billingo, 5).await.unwrap(), 1);
|
||||
let (status, _, _, sent, _) = state(&db, id).await;
|
||||
assert_eq!((status.as_str(), sent), ("issued", true));
|
||||
// One partner and one invoice, even with the retry.
|
||||
assert_eq!(fake.documents.load(Ordering::SeqCst), 1);
|
||||
let (net, vat, kept): (i32, i32, Value) =
|
||||
sqlx::query_as("SELECT net_huf, vat_huf, document FROM invoices WHERE id = $1")
|
||||
.bind(id)
|
||||
.fetch_one(&db)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!((net, vat, &kept["invoice_number"]), (6000, 0, &json!("SF-2026-1")));
|
||||
assert_eq!(run_once(&db, &billingo, 5).await.unwrap(), 0);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn invoices_fail_after_the_last_attempt(db: PgPool) {
|
||||
let fake = Arc::new(Fake::default());
|
||||
fake.refuse_partners.store(true, Ordering::SeqCst);
|
||||
let billingo = Billingo::new(&fake_billingo(fake.clone()).await, "key", Some(7));
|
||||
let id = paid(&db, None).await;
|
||||
run_once(&db, &billingo, 2).await.unwrap();
|
||||
sqlx::query("UPDATE invoices SET next_attempt_at = now()").execute(&db).await.unwrap();
|
||||
assert_eq!(run_once(&db, &billingo, 2).await.unwrap(), 1);
|
||||
let (status, ..) = state(&db, id).await;
|
||||
assert_eq!(status, "failed");
|
||||
let (error,): (String,) =
|
||||
sqlx::query_as("SELECT last_error FROM invoices WHERE id = $1").bind(id).fetch_one(&db).await.unwrap();
|
||||
assert!(error.contains("422") && error.contains("invalid tax code"), "{error}");
|
||||
assert_eq!(fake.documents.load(Ordering::SeqCst), 0);
|
||||
}
|
||||
}
|
||||
@@ -4,6 +4,7 @@
|
||||
//! * e-mail delivery from `email_outbox` over SMTP (Mailpit in development)
|
||||
//! * hourly cleanup of expired sessions, tokens, invites and old e-mails
|
||||
//! * writing the requested text analyses with an LLM (OpenRouter)
|
||||
//! * issuing the invoices of the payments in Billingo
|
||||
//!
|
||||
//! `WORKER_TASKS` (e.g. `email,cleanup` or `analyses`) picks the jobs of one
|
||||
//! process, so they can run in separate containers; all of them by default.
|
||||
@@ -18,6 +19,7 @@ mod cleanup;
|
||||
mod compare;
|
||||
mod config;
|
||||
mod email;
|
||||
mod invoices;
|
||||
mod ses;
|
||||
mod templates {
|
||||
pub use email_templates::*;
|
||||
@@ -95,7 +97,13 @@ async fn main() -> anyhow::Result<()> {
|
||||
let (stop_tx, stop) = watch::channel(false);
|
||||
let mut jobs = tokio::task::JoinSet::new();
|
||||
let tasks = config.tasks;
|
||||
tracing::info!(email = tasks.email, cleanup = tasks.cleanup, analyses = tasks.analyses, "worker tasks");
|
||||
tracing::info!(
|
||||
email = tasks.email,
|
||||
cleanup = tasks.cleanup,
|
||||
analyses = tasks.analyses,
|
||||
invoices = tasks.invoices,
|
||||
"worker tasks"
|
||||
);
|
||||
match &config.smtp_url {
|
||||
_ if !tasks.email => {}
|
||||
Some(url) => {
|
||||
@@ -125,6 +133,21 @@ async fn main() -> anyhow::Result<()> {
|
||||
if tasks.cleanup {
|
||||
jobs.spawn(cleanup::run(pool.clone(), stop.clone()));
|
||||
}
|
||||
match &config.billingo_api_key {
|
||||
_ if !tasks.invoices => {}
|
||||
Some(key) => {
|
||||
let billingo = invoices::Billingo::new(&config.billingo_api_url, key, config.billingo_block_id);
|
||||
tracing::info!("invoicing enabled (Billingo)");
|
||||
jobs.spawn(invoices::run(
|
||||
pool.clone(),
|
||||
billingo,
|
||||
config.max_invoice_attempts,
|
||||
config.poll_interval,
|
||||
stop.clone(),
|
||||
));
|
||||
}
|
||||
None => tracing::warn!("BILLINGO_API_KEY is not set: invoices stay pending"),
|
||||
}
|
||||
|
||||
let app = Router::new().route("/healthz", get(healthz)).with_state(pool);
|
||||
let listener = tokio::net::TcpListener::bind(addr).await.with_context(|| format!("binding {addr}"))?;
|
||||
|
||||
@@ -227,8 +227,12 @@ async fn cleanup_removes_only_expired_data(db: PgPool) {
|
||||
fn worker_tasks_are_chosen_by_name() {
|
||||
use crate::config::Tasks;
|
||||
let mail = Tasks::parse("email, cleanup").unwrap();
|
||||
assert_eq!(mail, Tasks { email: true, cleanup: true, analyses: false });
|
||||
assert_eq!(Tasks::parse("analyses").unwrap(), Tasks { email: false, cleanup: false, analyses: true });
|
||||
assert_eq!(mail, Tasks { email: true, cleanup: true, analyses: false, invoices: false });
|
||||
assert_eq!(
|
||||
Tasks::parse("analyses").unwrap(),
|
||||
Tasks { email: false, cleanup: false, analyses: true, invoices: false }
|
||||
);
|
||||
assert!(Tasks::parse("email,invoices").unwrap().invoices);
|
||||
assert!(Tasks::parse("emails").is_err());
|
||||
assert!(Tasks::parse(" , ").is_err());
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user