Files
sorsfonalak/services/backend/src/invoices.rs
T

195 lines
7.4 KiB
Rust
Raw Normal View History

//! 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. A
/// Hungarian company with only an EU VAT number (`HU12345678`) is invoiced
/// without a tax type number: Billingo takes only the full domestic
/// number (`12345678-1-23`) for HAS_TAX_NUMBER; the EU number still goes
/// on the invoice, in its comment (the worker adds it).
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(_), _) if tax_id("hu_tin").is_some() => "HAS_TAX_NUMBER",
_ => "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,
2026-11-20 08:34:08 +00:00
(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, \
2026-11-20 08:34:08 +00:00
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())
2026-11-20 08:34:08 +00:00
.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 eu_only = Buyer::from_stripe(
&json!({"name": "Kovács Anna", "business_name": "Csillag Kft.", "address": {"country": "HU"},
"tax_ids": [{"type": "eu_vat", "value": "HU12345678"}]}),
None,
);
assert_eq!(eu_only.name, "Csillag Kft.");
assert_eq!((eu_only.tax_type, eu_only.tax_number.as_deref()), ("NO_TAX_NUMBER", Some("HU12345678")));
let abroad = Buyer::from_stripe(&json!({"name": "Anna", "address": {"country": "at"}}), None);
assert_eq!((abroad.country.as_str(), abroad.tax_type), ("AT", "FOREIGN"));
}
}