//! 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 { 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, 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, } } } /// 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, item_comment): (&str, &str), gross_huf: i64, vat: Vat, ) -> Result { 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")); } }