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
This commit is contained in:
feco
2026-11-20 07:52:34 +00:00
co-authored by Claude Opus 5.5
parent e530e78c54
commit 2a0830fda0
24 changed files with 1090 additions and 35 deletions
+88 -8
View File
@@ -157,8 +157,20 @@ async fn fake_stripe_get(axum::extract::Path(id): axum::extract::Path<String>) -
}
}
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))
@@ -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<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!((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")]