company or personal

src/controllers/account.rs

@@ -16,6 +16,11 @@ use crate::{
 
 #[derive(Debug, Deserialize)]
 struct ProfileForm {
+    account_type: Option<String>,
+    company_name: Option<String>,
+    company_id: Option<String>,
+    tax_id: Option<String>,
+    vat_id: Option<String>,
     phone_prefix: Option<String>,
     phone: Option<String>,
     address: Option<String>,
@@ -28,9 +33,27 @@ fn trimmed(value: Option<&str>) -> Option<String> {
     value.map(str::trim).filter(|v| !v.is_empty()).map(String::from)
 }
 
+/// Normalize an account type to one of the two known values, defaulting to
+/// "personal" for anything unexpected.
+pub fn normalize_account_type(value: Option<&str>) -> String {
+    match value.map(str::trim) {
+        Some("company") => "company".to_string(),
+        _ => "personal".to_string(),
+    }
+}
+
 impl From<ProfileForm> for ProfileFields {
     fn from(form: ProfileForm) -> Self {
+        let is_company = normalize_account_type(form.account_type.as_deref()) == "company";
+        // Company identifiers are only stored for company accounts, so switching
+        // back to personal clears stale data.
+        let company = |v: Option<&str>| if is_company { trimmed(v) } else { None };
         Self {
+            account_type: normalize_account_type(form.account_type.as_deref()),
+            company_name: company(form.company_name.as_deref()),
+            company_id: company(form.company_id.as_deref()),
+            tax_id: company(form.tax_id.as_deref()),
+            vat_id: company(form.vat_id.as_deref()),
             phone_prefix: trimmed(form.phone_prefix.as_deref()),
             phone: trimmed(form.phone.as_deref()),
             address: trimmed(form.address.as_deref()),
@@ -61,6 +84,11 @@ fn profile_view(
             "saved": saved,
             "name": name,
             "email": email,
+            "account_type": profile.map_or("personal", |p| p.account_type.as_str()),
+            "company_name": profile.and_then(|p| p.company_name.clone()),
+            "company_id": profile.and_then(|p| p.company_id.clone()),
+            "tax_id": profile.and_then(|p| p.tax_id.clone()),
+            "vat_id": profile.and_then(|p| p.vat_id.clone()),
             "phone_prefix": profile.and_then(|p| p.phone_prefix.clone()),
             "phone": profile.and_then(|p| p.phone.clone()),
             "address": profile.and_then(|p| p.address.clone()),

src/controllers/checkout.rs

@@ -9,6 +9,7 @@ use serde_json::json;
 use time::Duration as TimeDuration;
 
 use crate::{
+    controllers::account::normalize_account_type,
     controllers::cart::{resolve_cart, CART_COOKIE},
     models::{customer_profiles::{self, ProfileFields}, order_items, orders, shipping_methods},
     controllers::i18n::current_lang,
@@ -24,6 +25,11 @@ struct CheckoutForm {
     phone_prefix: String,
     phone: String,
     customer_name: String,
+    account_type: Option<String>,
+    company_name: Option<String>,
+    company_id: Option<String>,
+    tax_id: Option<String>,
+    vat_id: Option<String>,
     address: String,
     city: String,
     zip: String,
@@ -115,6 +121,11 @@ async fn checkout_page(
             "logged_in_customer": is_customer,
             "prefill_email": user.as_ref().filter(|_| is_customer).map(|u| u.email.clone()),
             "prefill_name": user.as_ref().filter(|_| is_customer).map(|u| u.name.clone()),
+            "prefill_account_type": profile.as_ref().map_or("personal", |x| x.account_type.as_str()),
+            "prefill_company_name": p(|x| x.company_name.clone()),
+            "prefill_company_id": p(|x| x.company_id.clone()),
+            "prefill_tax_id": p(|x| x.tax_id.clone()),
+            "prefill_vat_id": p(|x| x.vat_id.clone()),
             "prefill_phone_prefix": p(|x| x.phone_prefix.clone()),
             "prefill_phone": p(|x| x.phone.clone()),
             "prefill_address": p(|x| x.address.clone()),
@@ -158,6 +169,20 @@ async fn place_order(
     let zip = require(&form.zip, "zip")?;
     let country = require(&form.country, "country")?;
 
+    // Company purchases must carry the invoicing identifiers (IČO + DIČ
+    // required, IČ DPH optional). Personal orders carry none.
+    let account_type = normalize_account_type(form.account_type.as_deref());
+    let (company_name, company_id, tax_id, vat_id) = if account_type == "company" {
+        (
+            Some(require(form.company_name.as_deref().unwrap_or(""), "company name")?),
+            Some(require(form.company_id.as_deref().unwrap_or(""), "IČO")?),
+            Some(require(form.tax_id.as_deref().unwrap_or(""), "DIČ")?),
+            form.vat_id.as_deref().and_then(trimmed),
+        )
+    } else {
+        (None, None, None, None)
+    };
+
     if !PAYMENT_METHODS.contains(&form.payment_method.as_str()) {
         return Err(Error::BadRequest("invalid payment method".to_string()));
     }
@@ -190,6 +215,11 @@ async fn place_order(
         if let Some(user) = guard::current_user(&ctx, &jar).await {
             if !guard::is_admin(&ctx, &user) {
                 let fields = ProfileFields {
+                    account_type: account_type.clone(),
+                    company_name: company_name.clone(),
+                    company_id: company_id.clone(),
+                    tax_id: tax_id.clone(),
+                    vat_id: vat_id.clone(),
                     phone_prefix: trimmed(&form.phone_prefix),
                     phone: Some(number.clone()),
                     address: Some(address.clone()),
@@ -211,6 +241,11 @@ async fn place_order(
             email,
             phone,
             customer_name: Some(customer_name),
+            account_type,
+            company_name,
+            company_id,
+            tax_id,
+            vat_id,
             address: Some(address),
             city: Some(city),
             zip: Some(zip),