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
+146
View File
@@ -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<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,
}
}
}
/// 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<Uuid>,
buyer: &Buyer,
item_name: &str,
gross_huf: i64,
) -> Result<Uuid, ApiError> {
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"));
}
}