Invoicing: the invoice request is marked before it goes to Billingo; a retry after a lost answer looks the invoice up under the invoice's own partner instead of issuing a second one. An invoice issued but never e-mailed counts as issued (downloadable). A Hungarian company with only an EU VAT number is invoiced without a domestic tax number, the EU number in the comment. Security: the login redirect takes only plain local paths (no backslash); the waitlist rate limit and share visits use X-Real-IP, which Caddy sets from Cloudflare's address, not the spoofable first X-Forwarded-For entry; a Google/Apple sign-in to an unconfirmed password account removes its password and sessions; a person's birth data can no longer be published through a share. Credits and jobs: analysis requests are serialized per user, so a double click queues and pays once; a forecast analysis also fixes a person's birth data; admins can restart stuck tarot readings; a worker forgets an attempt an admin restarted, so a stop does not requeue it; two people accepting one comparison invite at once get one comparison. Expired invitations are no longer accepted by e-mail, and unsubscribing revokes the invitation's promo codes too. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
195 lines
7.4 KiB
Rust
195 lines
7.4 KiB
Rust
//! 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,
|
|
(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, \
|
|
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 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"));
|
|
}
|
|
}
|