Compare commits

..
Author SHA1 Message Date
fecoandClaude Opus 5.5 ba11eda64c Merge main into prod: invoice fixes
CI / test (push) Successful in 1m28s
CI / build (push) Successful in 19s
CI / deploy (push) Successful in 34s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-20 08:56:08 +00:00
fecoandClaude Opus 5.5 e4905ec5f1 Invoice items: online content service, not astrology
CI / test (push) Successful in 1m32s
CI / build (push) Successful in 4m58s
CI / deploy (push) Skipped
The item reads e.g. 'Online tartalomszolgáltatás – Páros csomag', with
access to the site's software-made, personalised texts as its comment:
no profession is implied.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-20 08:55:55 +00:00
fecoandClaude Opus 5.5 f578e84b3f Invoice items say what the service is
CI / test (push) Successful in 1m32s
CI / build (push) Successful in 5m50s
CI / deploy (push) Skipped
'Sorsfonalak – Páros' does not identify the service, as the VAT act
(169. § e) asks. The item is now e.g. 'Asztrológiai elemzéscsomag –
Páros', unit 'csomag', with the package's contents as its comment.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-20 08:34:08 +00:00
fecoandClaude Opus 5.5 76bc965537 No invoice for test payments
CI / test (push) Successful in 1m28s
CI / build (push) Successful in 6m16s
CI / deploy (push) Skipped
Billingo's invoices are real (reported to the tax authority), so a
payment made with a Stripe test key grants the package but queues no
invoice.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-20 08:30:54 +00:00
fecoandClaude Opus 5.5 174ec31351 Merge main into prod: migration fix (site down)
CI / test (push) Successful in 1m28s
CI / build (push) Successful in 21s
CI / deploy (push) Successful in 33s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-20 08:18:56 +00:00
fecoandClaude Opus 5.5 184f19e1f2 Migrations: restore 0027 as applied in production, the rest in 0028
CI / test (push) Successful in 1m28s
CI / build (push) Successful in 5m7s
CI / deploy (push) Skipped
0027 had already run in production in its first form; changing it made
the backend refuse to start. It is back as it was, and the payment
details and the invoices table come in 0028.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-20 08:18:44 +00:00
fecoandClaude Opus 5.5 27ecdf386e Merge main into prod
CI / test (push) Successful in 1m29s
CI / build (push) Successful in 2m2s
CI / deploy (push) Failing after 34s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-20 08:05:38 +00:00
fecoandClaude Opus 5.5 4338a35202 Invoices: alanyi adómentes (AAM) by default
CI / test (push) Successful in 1m29s
CI / build (push) Successful in 5m57s
CI / deploy (push) Skipped
INVOICE_VAT picks the VAT of the invoices: AAM (no VAT, net = gross, the
invoice says so) or a rate like 27% once the exemption limit is passed.
The packages page tells which.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-20 08:03:04 +00:00
fecoandClaude Opus 5.5 2a0830fda0 Invoices: issued in Billingo by the worker, downloadable on Számláim
CI / test (push) Successful in 1m29s
CI / build (push) Successful in 9m7s
CI / deploy (push) Skipped
A paid checkout queues an invoice row with every invoice detail (buyer,
tax type and number, item, net, VAT, gross). The worker's new 'invoices'
task creates the Billingo partner and the paid card invoice and e-mails
it (API v3), saving each step so a retry never issues a second invoice,
and keeps Billingo's whole answer; the PDF is fetched from Billingo when
the user downloads it from the new Számláim page (in the menu once there
is an invoice). Payments and invoices outlive a deleted account.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-20 07:52:34 +00:00
fecoandClaude Opus 5.5 e530e78c54 Stripe: company purchases, payment details kept for the invoice
CI / test (push) Successful in 1m25s
CI / build (push) Successful in 5m20s
CI / deploy (push) Skipped
The checkout offers buying as a company (name, tax number). A confirmed
payment keeps Stripe's payment id, the amount charged and the buyer's
billing details, and queues the invoice for a background job (Billingo,
once the company exists). Payments outlive a deleted account for the
accounting law's 8 years. The package cards, the FAQ and the privacy
policy say that card details go to Stripe only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-20 07:26:03 +00:00
31 changed files with 1394 additions and 52 deletions
@@ -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
View File
@@ -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=...`, a levélküldés adatai, és ha van, `STRIPE_SECRET_KEY` / `STRIPE_WEBHOOK_SECRET` (`docs/fizetes.md`).
- `.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)
+3 -1
View File
@@ -91,6 +91,8 @@ services:
# 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.
@@ -117,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}
+2
View File
@@ -58,6 +58,8 @@ services:
# 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}
+1 -1
View File
@@ -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ő
+36 -1
View File
@@ -13,6 +13,41 @@ A csomagokat a Stripe Checkout fizetési oldalán lehet megvenni. A csomagok nev
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:
@@ -41,5 +76,5 @@ Helyben a webhook nem ér el a géphez; nem is kell, mert a visszatérő oldal a
## Megnyitás előtt
- A Stripe-fiók aktiválása (céges adatok, bankszámla), élő kulcsok és élő webhook.
- Számla: Billingo API-val, minden sikeres fizetés után (a vásárló neve és címe a Checkoutból jön). A Stripe nyugtája nem magyar számla.
- 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.
+19
View File
@@ -48,6 +48,12 @@ pub struct Config {
/// 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.
@@ -170,6 +176,16 @@ impl Config {
.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)?,
@@ -211,6 +227,9 @@ impl Config {
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,
+182
View File
@@ -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"));
}
}
+1
View File
@@ -13,6 +13,7 @@ mod config;
mod credits;
mod error;
mod google;
mod invoices;
mod models;
mod packages;
mod persons;
+45 -1
View File
@@ -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,
@@ -202,6 +202,33 @@ impl Source {
}
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] {
[
@@ -341,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")));
}
}
+6
View File
@@ -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())
}
+5
View File
@@ -13,6 +13,7 @@ mod charts;
mod errors;
mod forecasts;
mod invitations;
mod invoices_user;
mod jobs;
mod models;
mod payments;
@@ -80,6 +81,8 @@ pub fn router(state: Arc<AppState>) -> Router {
.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))
@@ -170,6 +173,8 @@ async fn public_config(State(state): St) -> Json<Value> {
"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(),
+56 -27
View File
@@ -21,7 +21,7 @@ use crate::config::StripeConfig;
use crate::credits::{self, Unit};
use crate::error::{ApiError, ApiResult};
use crate::packages::{self, CATALOG, Source};
use crate::{persons, stripe};
use crate::{invoices, persons, stripe};
/// The package catalog (public).
pub async fn catalog() -> Json<Value> {
@@ -134,8 +134,11 @@ pub async fn checkout(
field("locale", "hu"),
field("client_reference_id", &auth.id().to_string()),
field("customer_email", &auth.user.email),
// Name and address go on the invoice.
// 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.
@@ -163,29 +166,57 @@ pub async fn checkout(
Ok(Json(json!({ "url": url })))
}
/// Grants the package of a paid session, once. `false`: not our session.
async fn complete(state: &AppState, session_id: &str) -> Result<bool, ApiError> {
/// 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?;
let row: Option<(Uuid, String, Option<OffsetDateTime>)> =
sqlx::query_as("SELECT user_id, package, completed_at FROM stripe_checkouts WHERE id = $1 FOR UPDATE")
.bind(session_id)
.fetch_optional(&mut *tx)
.await?;
let Some((user_id, package_id, completed_at)) = row else { return Ok(false) };
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}")))?;
let note = format!("Stripe {session_id}");
let order = packages::grant(&mut tx, user_id, package, Source::Stripe, Some(user_id), Some(&note)).await?;
sqlx::query("UPDATE stripe_checkouts SET completed_at = now(), order_id = $2 WHERE id = $1")
.bind(session_id)
.bind(order)
.execute(&mut *tx)
.await?;
// 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(&note)).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");
tracing::info!(user = ?user_id, package = %package_id, session = %session.id, "package paid");
Ok(true)
}
@@ -207,7 +238,7 @@ pub async fn checkout_status(
if let (None, Some(config)) = (completed_at, &state.config.stripe) {
let session = state.stripe.get_session(config, &id).await?;
if session.paid() {
complete(&state, &id).await?;
complete(&state, &session).await?;
status = "paid";
} else if session.status.as_deref() == Some("expired") {
status = "expired";
@@ -235,15 +266,13 @@ pub async fn stripe_webhook(State(state): St, headers: HeaderMap, body: Bytes) -
tracing::warn!("stripe webhook with a bad signature");
return Err(ApiError::BadRequest("invalid signature".into()));
}
let event: Value = serde_json::from_slice(&body).map_err(|e| ApiError::BadRequest(e.to_string()))?;
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();
let session = &event["data"]["object"];
if matches!(kind, "checkout.session.completed" | "checkout.session.async_payment_succeeded")
&& session["payment_status"] == "paid"
{
let id = session["id"].as_str().unwrap_or_default();
if !complete(&state, id).await? {
tracing::warn!(session = id, "stripe webhook for a session we did not start");
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 })))
+12
View File
@@ -7,6 +7,7 @@ use std::time::Duration;
use hmac::{Hmac, Mac};
use serde::Deserialize;
use serde_json::Value;
use sha2::Sha256;
use crate::config::StripeConfig;
@@ -24,6 +25,17 @@ pub struct Session {
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 {
+143 -2
View File
@@ -148,14 +148,29 @@ async fn fake_stripe_get(axum::extract::Path(id): axum::extract::Path<String>) -
StatusCode::OK,
Json(json!({"id": id, "url": null,
"payment_status": if *paid { "paid" } else { "unpaid" },
"status": if *paid { "complete" } else { "open" }})),
"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))
@@ -2280,6 +2295,7 @@ async fn stripe_checkout_grants_the_paid_package_once(pool: PgPool) {
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;
@@ -2301,6 +2317,8 @@ async fn stripe_checkout_grants_the_paid_package_once(pool: PgPool) {
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}")
@@ -2327,7 +2345,12 @@ async fn stripe_checkout_grants_the_paid_package_once(pool: PgPool) {
// 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"}}});
"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);
@@ -2344,6 +2367,83 @@ async fn stripe_checkout_grants_the_paid_package_once(pool: PgPool) {
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");
@@ -2367,6 +2467,47 @@ async fn stripe_checkout_grants_the_paid_package_once(pool: PgPool) {
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")]
+20 -2
View File
@@ -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).
+16 -1
View File
@@ -1,4 +1,5 @@
import type { Metadata } from "next";
import Link from "next/link";
import { AiNote } from "@/components/AiNote";
import { PackageCards } from "@/components/PackageCards";
@@ -10,6 +11,10 @@ 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.",
@@ -80,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 }}>
@@ -103,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>
);
+7
View File
@@ -957,3 +957,10 @@ a.pair-row:hover strong { color: var(--gold); }
}
.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; }
}
+17 -2
View File
@@ -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&apos;s secure payment
page: you give your card details directly to Stripe, and they never reach us. From Stripe we only receive
the payment&apos;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 -1
View File
@@ -46,7 +46,7 @@ export default async function robots(): Promise<MetadataRoute.Robots> {
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,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>
);
}
@@ -149,10 +149,10 @@ export function PackageCards({
</p>
)}
{canPay === "mock" && <p className="hint">Tesztüzem: a fizetés még nincs bekötve, a gomb nem terhel semmit.</p>}
{canPay === "stripe" && !compact && (
{(canPay === "stripe" || canPay === "stripe_test") && (
<p className="hint">
A fizetés a Stripe biztonságos oldalán történik (bankkártya, Apple Pay, Google Pay); a kártyaadataidat mi nem
látjuk.
<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" && (
@@ -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" });
+2 -2
View File
@@ -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";
+15
View File
@@ -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 };
}
@@ -98,6 +100,8 @@ export interface PublicConfig {
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). */
@@ -582,3 +586,14 @@ export interface PersonInviteLanding {
/** 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;
}
+24 -4
View File
@@ -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)?,
})
}
}
+500
View File
@@ -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);
}
}
+24 -1
View File
@@ -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}"))?;
+6 -2
View File
@@ -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());
}