diff --git a/crates/db/migrations/0027_stripe_checkouts.sql b/crates/db/migrations/0027_stripe_checkouts.sql index 40212d4..c26c0ff 100644 --- a/crates/db/migrations/0027_stripe_checkouts.sql +++ b/crates/db/migrations/0027_stripe_checkouts.sql @@ -19,17 +19,55 @@ CREATE TABLE stripe_checkouts ( payment_intent text, -- What Stripe charged, in forints. amount_huf integer, - -- Stripe's customer_details: name, e-mail, address, and for a company - -- its name and tax ids. - customer jsonb, - -- The invoice (a background job issues it): pending → issued, or failed - -- after retries (an admin looks at it). - invoice_status text CHECK (invoice_status IN ('pending', 'issued', 'failed')), - invoice_attempts integer NOT NULL DEFAULT 0, - invoice_error text, - invoice_number text, - invoiced_at timestamptz + -- Stripe's customer_details as it came: name, e-mail, address, and for a + -- company its name and tax ids. + customer jsonb ); CREATE INDEX stripe_checkouts_user_idx ON stripe_checkouts (user_id, created_at DESC); -CREATE INDEX stripe_checkouts_invoice_idx ON stripe_checkouts (completed_at) WHERE invoice_status = 'pending'; + +-- One invoice per paid checkout, issued in Billingo by the worker. 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, gross price with 27% VAT. + 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 '27%', + 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'; diff --git a/deploy/README.md b/deploy/README.md index f871589..ae4ad03 100644 --- a/deploy/README.md +++ b/deploy/README.md @@ -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) diff --git a/deploy/docker-compose.yml b/deploy/docker-compose.yml index 20d4a33..4f730fe 100644 --- a/deploy/docker-compose.yml +++ b/deploy/docker-compose.yml @@ -117,7 +117,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} diff --git a/docs/fizetes.md b/docs/fizetes.md index 49dcf92..0b7cc27 100644 --- a/docs/fizetes.md +++ b/docs/fizetes.md @@ -26,7 +26,25 @@ A sorok a fiók törlése után is megmaradnak (`user_id` → NULL), mert a szá ## Számla -Minden igazolt fizetés `invoice_status = 'pending'` állapotba kerül: ez a számlázási sor. A számlát egy háttérfeladat (worker) állítja ki a Billingo API-val, újrapróbálással (`invoice_attempts`, `invoice_error`), siker után `issued` + `invoice_number`, végleges hiba után `failed` (admin nézi meg). A Billingo-rész a cég és a Billingo-fiók után készül el; addig a sorok `pending` állapotban várnak. +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, bruttó, nettó, áfa, 27%). 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. + +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 @@ -56,5 +74,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: a worker Billingo-feladata (lásd fent). A Stripe nyugtája nem magyar számla: a Stripe felületén a Customer emails → Successful payments legyen kikapcsolva. +- 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. diff --git a/services/backend/src/config.rs b/services/backend/src/config.rs index 996ed3b..49163c4 100644 --- a/services/backend/src/config.rs +++ b/services/backend/src/config.rs @@ -48,6 +48,10 @@ pub struct Config { /// Stripe Checkout, when `STRIPE_SECRET_KEY` is set (it wins over /// `MOCK_PAYMENTS`). pub stripe: Option, + /// `BILLINGO_API_KEY`: downloading invoices (the worker issues them). + pub billingo_api_key: Option, + /// `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 +174,11 @@ impl Config { .trim_end_matches('/') .to_string(), }), + 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 +220,8 @@ impl Config { password_login: true, mock_payments: true, stripe: None, + billingo_api_key: Some("billingo-fake".into()), + billingo_api_url: format!("{horoscope_api_url}/billingo"), purchases_open: true, user_invites: true, referral_rewards: true, diff --git a/services/backend/src/invoices.rs b/services/backend/src/invoices.rs new file mode 100644 index 0000000..66bf59f --- /dev/null +++ b/services/backend/src/invoices.rs @@ -0,0 +1,146 @@ +//! 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; + +/// VAT of every package, in percent. +pub const VAT_PERCENT: i64 = 27; + +/// The buyer as invoiced, from Stripe's `customer_details`. +#[derive(Debug, PartialEq, Eq)] +pub struct Buyer { + pub name: String, + pub email: Option, + 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, +} + +fn text(v: &Value) -> Option { + 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::>(); + 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, + } + } +} + +/// Net and VAT parts of a gross price (rounded to forints, as Billingo does). +pub fn split_gross(gross: i64) -> (i64, i64) { + let net = (gross * 200 + 100 + VAT_PERCENT) / (200 + 2 * VAT_PERCENT); + (net, gross - net) +} + +/// 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, + buyer: &Buyer, + item_name: &str, + gross_huf: i64, +) -> Result { + let id = Uuid::now_v7(); + let (net, vat) = split_gross(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) \ + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16) \ + 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 as i32) + .bind(format!("{VAT_PERCENT}%")) + .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() { + assert_eq!(split_gross(2000), (1575, 425)); + assert_eq!(split_gross(6000), (4724, 1276)); + assert_eq!(split_gross(127), (100, 27)); + } + + #[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")); + } +} diff --git a/services/backend/src/main.rs b/services/backend/src/main.rs index 56cf9e3..c0989bc 100644 --- a/services/backend/src/main.rs +++ b/services/backend/src/main.rs @@ -13,6 +13,7 @@ mod config; mod credits; mod error; mod google; +mod invoices; mod models; mod packages; mod persons; diff --git a/services/backend/src/routes/account.rs b/services/backend/src/routes/account.rs index 46951f3..17c0b6d 100644 --- a/services/backend/src/routes/account.rs +++ b/services/backend/src/routes/account.rs @@ -35,6 +35,10 @@ pub async fn me(State(state): St, auth: AuthUser) -> ApiResult> { 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::>(), @@ -47,6 +51,8 @@ pub async fn me(State(state): St, auth: AuthUser) -> ApiResult> { "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, }))) } diff --git a/services/backend/src/routes/invoices_user.rs b/services/backend/src/routes/invoices_user.rs new file mode 100644 index 0000000..203bf26 --- /dev/null +++ b/services/backend/src/routes/invoices_user.rs @@ -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, Option, 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> { + let rows: Vec = 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 = 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 { + let row: Option<(i64, Option)> = 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::()))); + } + 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()) +} diff --git a/services/backend/src/routes/mod.rs b/services/backend/src/routes/mod.rs index f6a4fb1..fe3558d 100644 --- a/services/backend/src/routes/mod.rs +++ b/services/backend/src/routes/mod.rs @@ -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) -> 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)) diff --git a/services/backend/src/routes/payments.rs b/services/backend/src/routes/payments.rs index cfebe0a..79d76b0 100644 --- a/services/backend/src/routes/payments.rs +++ b/services/backend/src/routes/payments.rs @@ -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 { @@ -184,11 +184,11 @@ async fn complete(state: &AppState, session: &stripe::Session) -> Result { - let package = packages::find(&package_id) - .ok_or_else(|| ApiError::Internal(format!("unknown package {package_id}")))?; let note = format!("Stripe {}", session.id); Some(packages::grant(&mut tx, user_id, package, Source::Stripe, Some(user_id), Some(¬e)).await?) } @@ -196,7 +196,7 @@ async fn complete(state: &AppState, session: &stripe::Session) -> Result Result) - } } +async fn fake_billingo_pdf( + headers: HeaderMap, + axum::extract::Path(id): axum::extract::Path, +) -> 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)) @@ -2355,16 +2367,81 @@ async fn stripe_checkout_grants_the_paid_package_once(pool: PgPool) { } 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, invoice): (String, i32, Value, String) = sqlx::query_as( - "SELECT payment_intent, amount_huf, customer, invoice_status FROM stripe_checkouts WHERE id = $1", + 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, + 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!((intent.as_str(), amount, invoice.as_str()), ("pi_1", 6000, "pending")); - assert_eq!(customer["tax_ids"][0]["value"], "12345678-1-23"); - assert_eq!(customer["address"]["postal_code"], "6720"); + 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, "Sorsfonalak – Páros"); + assert_eq!((invoice.gross_huf, invoice.net_huf, invoice.vat_huf), (6000, 4724, 1276)); + + // 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"); @@ -2388,13 +2465,13 @@ 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, invoice): (String, String) = - sqlx::query_as("SELECT customer->>'name', invoice_status FROM stripe_checkouts WHERE id = $1") + 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(), invoice.as_str()), ("Anna Teszt", "pending")); + assert_eq!((name.as_str(), tax_type.as_str()), ("Anna Teszt", "NO_TAX_NUMBER")); // Deleting the account keeps the payments (accounting law). let r = app.call("DELETE", "/v1/me", Some(&anna), Some(json!({"confirm": "DELETE"}))).await; @@ -2405,6 +2482,9 @@ async fn stripe_checkout_grants_the_paid_package_once(pool: PgPool) { .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")] diff --git a/services/frontend/src/app/adatvedelem/page.tsx b/services/frontend/src/app/adatvedelem/page.tsx index 6c399d3..051249b 100644 --- a/services/frontend/src/app/adatvedelem/page.tsx +++ b/services/frontend/src/app/adatvedelem/page.tsx @@ -212,6 +212,10 @@ export default async function PrivacyPage() { Stripe Payments Europe, Ltd. (Í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. +
  • + Billingo Technologies Zrt. (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. +
  • OpenRouter, Inc. é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). diff --git a/services/frontend/src/app/csomagok/page.tsx b/services/frontend/src/app/csomagok/page.tsx index 4a62180..0238e33 100644 --- a/services/frontend/src/app/csomagok/page.tsx +++ b/services/frontend/src/app/csomagok/page.tsx @@ -1,4 +1,5 @@ import type { Metadata } from "next"; +import Link from "next/link"; import { AiNote } from "@/components/AiNote"; import { PackageCards } from "@/components/PackageCards"; @@ -84,6 +85,12 @@ export default async function PackagesPage() { + {me.invoice_count > 0 && ( +

    + A korábbi vásárlásaid számlái: Számláim → +

    + )} +
    diff --git a/services/frontend/src/app/globals.css b/services/frontend/src/app/globals.css index 0770685..dbe7f75 100644 --- a/services/frontend/src/app/globals.css +++ b/services/frontend/src/app/globals.css @@ -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; } +} diff --git a/services/frontend/src/app/privacy/page.tsx b/services/frontend/src/app/privacy/page.tsx index 7571f0e..4927c32 100644 --- a/services/frontend/src/app/privacy/page.tsx +++ b/services/frontend/src/app/privacy/page.tsx @@ -211,6 +211,10 @@ export default async function PrivacyPolicyPage() { Stripe Payments Europe, Ltd. (Ireland): processing card payments and preventing fraud; only Stripe handles card details.
  • +
  • + Billingo Technologies Zrt. (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). +
  • OpenRouter, Inc. and the artificial intelligence providers it reaches: writing the readings, only from the astronomical data described in section 4 (no personal data reaches them). diff --git a/services/frontend/src/app/robots.ts b/services/frontend/src/app/robots.ts index ed6d5f6..c8348ac 100644 --- a/services/frontend/src/app/robots.ts +++ b/services/frontend/src/app/robots.ts @@ -46,7 +46,7 @@ export default async function robots(): Promise { 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"] }, ], }; } diff --git a/services/frontend/src/app/szamlak/page.tsx b/services/frontend/src/app/szamlak/page.tsx new file mode 100644 index 0000000..14b542c --- /dev/null +++ b/services/frontend/src/app/szamlak/page.tsx @@ -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 ( +
    +
    +

    Számláim

    +

    + 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. +

    +
    + + {invoices.length === 0 ? ( +
    +

    + Még nincs számlád. Ha csomagot vásárolsz, a számlája itt jelenik meg. Csomagok → +

    +
    + ) : ( +
    +
    + + + + + + + + + + + + {invoices.map((inv) => ( + + + + + + + + ))} + +
    DátumSzámlaszámTételÖsszeg + Letöltés +
    {day(inv.invoice_date ?? inv.paid_at)}{inv.invoice_number ?? "–"}{inv.item}{huf(inv.gross_huf)} + {inv.ready ? ( + + PDF letöltése + + ) : ( + Készül… + )} +
    +
    +

    + 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. +

    +
    + )} +
    + ); +} diff --git a/services/frontend/src/components/SiteHeader.tsx b/services/frontend/src/components/SiteHeader.tsx index 34ed12a..86d1a63 100644 --- a/services/frontend/src/components/SiteHeader.tsx +++ b/services/frontend/src/components/SiteHeader.tsx @@ -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" }); diff --git a/services/frontend/src/lib/types.ts b/services/frontend/src/lib/types.ts index bb1559b..19ca01e 100644 --- a/services/frontend/src/lib/types.ts +++ b/services/frontend/src/lib/types.ts @@ -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 }; } @@ -582,3 +584,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; +} diff --git a/services/worker/src/config.rs b/services/worker/src/config.rs index 27030cb..30caa2a 100644 --- a/services/worker/src/config.rs +++ b/services/worker/src/config.rs @@ -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 { - 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, + /// `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, + /// `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 { @@ -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)?, }) } } diff --git a/services/worker/src/invoices.rs b/services/worker/src/invoices.rs new file mode 100644 index 0000000..5fc8300 --- /dev/null +++ b/services/worker/src/invoices.rs @@ -0,0 +1,489 @@ +//! 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>, +} + +impl Billingo { + pub fn new(base: &str, key: &str, block: Option) -> 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 { + 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::())); + } + 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 { + 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, + buyer_country: String, + buyer_post_code: String, + buyer_city: String, + buyer_address: String, + buyer_tax_type: String, + buyer_tax_number: Option, + item_name: String, + gross_huf: i32, + vat_rate: String, + payment_method: String, + billingo_partner_id: Option, + billingo_document_id: Option, + sent_at: Option, + 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 { + 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::().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 { + let mut done = 0; + loop { + let due: Option = 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.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 for Failure { + fn from(e: sqlx::Error) -> Self { + Failure::Db(e) + } +} + +impl From 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 { + 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::>(), + "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": "db", + "vat": due.vat_rate, + }], + "comment": "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,) = 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) { + 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>, + 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) -> String { + async fn blocks(State(f): State>) -> Json { + 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>, Json(body): Json) -> (StatusCode, Json) { + 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>, Json(body): Json) -> (StatusCode, Json) { + 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": 4724.41, "vat_amount": 1275.59, "gross_amount": 6000.0}]})), + ) + } + async fn send( + State(f): State>, + Path(id): Path, + Json(body): Json, + ) -> (StatusCode, Json) { + 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, \ + 'Sorsfonalak – Páros', 6000, 4724, 1276)", + ) + .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, Option, 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]["unit_price_type"], &doc["items"][0]["vat"]), + (&json!("gross"), &json!("27%")) + ); + // 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"]), (4724, 1276, &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); + } +} diff --git a/services/worker/src/main.rs b/services/worker/src/main.rs index 9594684..506febe 100644 --- a/services/worker/src/main.rs +++ b/services/worker/src/main.rs @@ -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}"))?; diff --git a/services/worker/src/tests.rs b/services/worker/src/tests.rs index 7581279..90e4504 100644 --- a/services/worker/src/tests.rs +++ b/services/worker/src/tests.rs @@ -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()); }