Upload 2 files

main.js

@@ -1190,7 +1190,6 @@ function collectInvoicePayload() {
       name,
       quantity,
       unit,
-      unitPrice: unitGross.toFixed(2),
       unit_price_gross: unitGross.toFixed(2),
       vat_code: vatCode,
     });

server.py

@@ -12,16 +12,17 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from flask import Flask, jsonify, request, send_from_directory
 
-from db import (
-    create_account,
-    fetch_all,
-    fetch_one,
-    fetch_business_logo,
-    insert_invoice,
-    update_business,
-    update_business_logo,
-    upsert_client,
-)
+from db import (
+    create_account,
+    execute,
+    fetch_all,
+    fetch_one,
+    fetch_business_logo,
+    insert_invoice,
+    update_business,
+    update_business_logo,
+    upsert_client,
+)
 
 APP_ROOT = Path(__file__).parent.resolve()
 DATA_DIR = Path(os.environ.get("DATA_DIR", APP_ROOT))
@@ -66,15 +67,26 @@ def _quantize(value: Decimal) -> Decimal:
     return value.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
 
 
-def _decimal(value: Any) -> Decimal:
-    try:
-        return Decimal(str(value))
-    except Exception as error:  # pragma: no cover - defensive
-        raise ValueError(f"Niepoprawna wartosc liczby: {value}") from error
-
-
-def hash_password(password: str) -> str:
-    return hashlib.sha256(password.encode("utf-8")).hexdigest()
+def _decimal(value: Any) -> Decimal:
+    try:
+        return Decimal(str(value))
+    except Exception as error:  # pragma: no cover - defensive
+        raise ValueError(f"Niepoprawna wartosc liczby: {value}") from error
+
+
+def _format_decimal_str(value: Any, default: str = "0.00") -> str:
+    if value in (None, ""):
+        return default
+    if isinstance(value, Decimal):
+        return str(_quantize(value))
+    try:
+        return str(_quantize(Decimal(str(value))))
+    except Exception:
+        return str(value)
+
+
+def hash_password(password: str) -> str:
+    return hashlib.sha256(password.encode("utf-8")).hexdigest()
 
 
 EMAIL_PATTERN = re.compile(r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$")
@@ -139,11 +151,23 @@ def get_account(data: Dict[str, Any], login_key: str) -> Dict[str, Any]:
     return account
 
 
-def get_account_row(login_key: str) -> Dict[str, Any]:
-    row = fetch_one("SELECT id, login FROM accounts WHERE login = %s", (login_key,))
-    if not row:
-        raise KeyError("Nie znaleziono konta.")
-    return row
+def get_account_row(login_key: str) -> Dict[str, Any]:
+    row = fetch_one("SELECT id, login FROM accounts WHERE login = %s", (login_key,))
+    if not row:
+        raise KeyError("Nie znaleziono konta.")
+    return row
+
+
+def get_business_profile(account_id: int) -> Optional[Dict[str, Any]]:
+    return fetch_one(
+        """
+        SELECT company_name, owner_name, address_line, postal_code,
+               city, tax_id, bank_account
+        FROM business_profiles
+        WHERE account_id = %s
+        """,
+        (account_id,),
+    )
 
 
 def require_auth() -> str:
@@ -441,44 +465,48 @@ def normalize_phone(phone: Optional[str]) -> Optional[str]:
     return digits or None
 
 
-def validate_client(payload: Dict[str, Any]) -> Dict[str, str]:
-    client = {
-        "name": (payload.get("clientName") or "").strip(),
-        "tax_id": (payload.get("clientTaxId") or "").strip(),
-        "address_line": (payload.get("clientAddress") or "").strip(),
-        "postal_code": (payload.get("clientPostalCode") or "").strip(),
-        "city": (payload.get("clientCity") or "").strip(),
-        "phone": normalize_phone(payload.get("clientPhone")),
-    }
-    return client
-
-
-def build_invoice(payload: Dict[str, Any], business: Dict[str, Any], client: Dict[str, str]) -> Dict[str, Any]:
-    now = datetime.now()
-    invoice_id = f"FV-{now.strftime('%Y%m%d-%H%M%S')}"
-    issued_at = now.strftime("%Y-%m-%d %H:%M")
-    sale_date = payload.get("saleDate") or date.today().isoformat()
-    payment_term = int(payload.get("paymentTerm") or 14)
-    items = payload.get("items") or []
-
-    normalized_items: List[Dict[str, Any]] = []
-    for item in items:
-        name = (item.get("name") or "").strip()
+def validate_client(payload: Dict[str, Any]) -> Dict[str, str]:
+    client_payload = payload.get("client") or {}
+    client = {
+        "name": (client_payload.get("name") or payload.get("clientName") or "").strip(),
+        "tax_id": (client_payload.get("tax_id") or payload.get("clientTaxId") or "").strip(),
+        "address_line": (client_payload.get("address_line") or payload.get("clientAddress") or "").strip(),
+        "postal_code": (client_payload.get("postal_code") or payload.get("clientPostalCode") or "").strip(),
+        "city": (client_payload.get("city") or payload.get("clientCity") or "").strip(),
+        "phone": normalize_phone(client_payload.get("phone") or payload.get("clientPhone")),
+    }
+    return client
+
+
+def build_invoice(payload: Dict[str, Any], business: Dict[str, Any], client: Dict[str, str]) -> Dict[str, Any]:
+    now = datetime.now()
+    invoice_id = f"FV-{now.strftime('%Y%m%d-%H%M%S')}"
+    issued_at = now.strftime("%Y-%m-%d %H:%M")
+    sale_date = payload.get("sale_date") or payload.get("saleDate") or date.today().isoformat()
+    payment_term = int(payload.get("payment_term") or payload.get("paymentTerm") or 14)
+    items = payload.get("items") or []
+
+    normalized_items: List[Dict[str, Any]] = []
+    for item in items:
+        name = (item.get("name") or "").strip()
         if not name:
             raise ValueError("Nazwa pozycji nie moze byc pusta.")
         quantity = _quantize(_decimal(item.get("quantity") or "0"))
         if quantity <= Decimal("0"):
             raise ValueError("Ilosc musi byc dodatnia.")
         unit = item.get("unit") or DEFAULT_UNIT
-        vat_code = str(item.get("vat") or "23")
-        if vat_code not in VAT_RATES:
-            raise ValueError("Niepoprawna stawka VAT.")
-        unit_price_gross = _quantize(_decimal(item.get("unitPrice") or "0"))
-        if unit_price_gross <= Decimal("0"):
-            raise ValueError("Cena musi byc dodatnia.")
-        vat_rate = VAT_RATES[vat_code]
-        if vat_rate is None:
-            unit_price_net = unit_price_gross
+        vat_code = str(item.get("vat_code") or item.get("vat") or item.get("vatCode") or "23")
+        if vat_code not in VAT_RATES:
+            raise ValueError("Niepoprawna stawka VAT.")
+        unit_price_raw = item.get("unit_price_gross")
+        if unit_price_raw in (None, ""):
+            unit_price_raw = item.get("unitPrice") or item.get("unit_price") or item.get("price")
+        unit_price_gross = _quantize(_decimal(unit_price_raw or "0"))
+        if unit_price_gross <= Decimal("0"):
+            raise ValueError("Cena musi byc dodatnia.")
+        vat_rate = VAT_RATES[vat_code]
+        if vat_rate is None:
+            unit_price_net = unit_price_gross
             vat_amount = Decimal("0.00")
         else:
             unit_price_net = _quantize(unit_price_gross / (Decimal("1.0") + vat_rate))
@@ -524,7 +552,7 @@ def build_invoice(payload: Dict[str, Any], business: Dict[str, Any], client: Dic
         for label, values in summary.items()
     ]
 
-    exemption_note = payload.get("exemptionNote", "").strip()
+    exemption_note = (payload.get("exemption_note") or payload.get("exemptionNote") or "").strip()
 
     return {
         "invoice_id": invoice_id,
@@ -553,20 +581,127 @@ def api_invoices() -> Any:
                 account_row = get_account_row(login_key)
             except KeyError:
                 return jsonify({"error": "Nie znaleziono konta."}), 404
-            rows = fetch_all(
+            invoice_rows = fetch_all(
                 """
-                SELECT invoice_number AS invoice_id,
-                       to_char(issued_at, 'YYYY-MM-DD HH24:MI') AS issued_at,
-                       sale_date,
-                       total_gross
-                FROM invoices
-                WHERE account_id = %s
-                ORDER BY issued_at DESC
+                SELECT i.id,
+                       i.invoice_number,
+                       i.issued_at,
+                       i.sale_date,
+                       i.payment_term_days,
+                       i.exemption_note,
+                       i.total_net,
+                       i.total_vat,
+                       i.total_gross,
+                       c.name AS client_name,
+                       c.address_line AS client_address,
+                       c.postal_code AS client_postal_code,
+                       c.city AS client_city,
+                       c.tax_id AS client_tax_id,
+                       c.phone AS client_phone
+                FROM invoices AS i
+                LEFT JOIN clients AS c ON c.id = i.client_id
+                WHERE i.account_id = %s
+                ORDER BY i.issued_at DESC
                 LIMIT %s
                 """,
                 (account_row["id"], INVOICE_HISTORY_LIMIT),
             )
-            return jsonify({"invoices": rows})
+            if not invoice_rows:
+                return jsonify({"invoices": []})
+
+            invoice_ids = [row["id"] for row in invoice_rows]
+            items_map: Dict[int, List[Dict[str, Any]]] = {row_id: [] for row_id in invoice_ids}
+            summary_map: Dict[int, List[Dict[str, str]]] = {row_id: [] for row_id in invoice_ids}
+
+            if invoice_ids:
+                item_rows = fetch_all(
+                    """
+                    SELECT invoice_id, line_no, name, quantity, unit,
+                           vat_code, vat_label, unit_price_net,
+                           unit_price_gross, net_total, vat_amount, gross_total
+                    FROM invoice_items
+                    WHERE invoice_id = ANY(%s)
+                    ORDER BY line_no
+                    """,
+                    (invoice_ids,),
+                )
+                for item in item_rows:
+                    items_map.setdefault(item["invoice_id"], []).append(
+                        {
+                            "name": item["name"],
+                            "quantity": _format_decimal_str(item.get("quantity"), "0.00"),
+                            "unit": item.get("unit") or DEFAULT_UNIT,
+                            "vat_code": item.get("vat_code"),
+                            "vat_label": item.get("vat_label") or item.get("vat_code"),
+                            "unit_price_net": _format_decimal_str(item.get("unit_price_net")),
+                            "unit_price_gross": _format_decimal_str(item.get("unit_price_gross")),
+                            "net_total": _format_decimal_str(item.get("net_total")),
+                            "vat_amount": _format_decimal_str(item.get("vat_amount")),
+                            "gross_total": _format_decimal_str(item.get("gross_total")),
+                        }
+                    )
+
+                summary_rows = fetch_all(
+                    """
+                    SELECT invoice_id, vat_label, net_total, vat_total, gross_total
+                    FROM invoice_vat_summary
+                    WHERE invoice_id = ANY(%s)
+                    ORDER BY vat_label
+                    """,
+                    (invoice_ids,),
+                )
+                for entry in summary_rows:
+                    summary_map.setdefault(entry["invoice_id"], []).append(
+                        {
+                            "vat_label": entry.get("vat_label"),
+                            "net_total": _format_decimal_str(entry.get("net_total")),
+                            "vat_total": _format_decimal_str(entry.get("vat_total")),
+                            "gross_total": _format_decimal_str(entry.get("gross_total")),
+                        }
+                    )
+
+            business_profile = get_business_profile(account_row["id"])
+            invoices: List[Dict[str, Any]] = []
+            for row in invoice_rows:
+                issued_at_value = row.get("issued_at")
+                sale_date_value = row.get("sale_date")
+                if isinstance(issued_at_value, datetime):
+                    issued_at = issued_at_value.strftime("%Y-%m-%d %H:%M")
+                else:
+                    issued_at = issued_at_value
+                if hasattr(sale_date_value, "isoformat"):
+                    sale_date = sale_date_value.isoformat()
+                else:
+                    sale_date = sale_date_value
+                client = None
+                if row.get("client_name"):
+                    client = {
+                        "name": row.get("client_name"),
+                        "address_line": row.get("client_address"),
+                        "postal_code": row.get("client_postal_code"),
+                        "city": row.get("client_city"),
+                        "tax_id": row.get("client_tax_id"),
+                        "phone": row.get("client_phone"),
+                    }
+                invoices.append(
+                    {
+                        "invoice_id": row.get("invoice_number"),
+                        "issued_at": issued_at,
+                        "sale_date": sale_date,
+                        "payment_term": row.get("payment_term_days"),
+                        "exemption_note": row.get("exemption_note"),
+                        "items": items_map.get(row["id"], []),
+                        "summary": summary_map.get(row["id"], []),
+                        "totals": {
+                            "net": _format_decimal_str(row.get("total_net")),
+                            "vat": _format_decimal_str(row.get("total_vat")),
+                            "gross": _format_decimal_str(row.get("total_gross")),
+                        },
+                        "client": client,
+                        "business": business_profile,
+                    }
+                )
+            return jsonify({"invoices": invoices})
 
         data = load_store()
         try:
@@ -583,15 +718,7 @@ def api_invoices() -> Any:
             account_row = get_account_row(login_key)
         except KeyError:
             return jsonify({"error": "Nie znaleziono konta."}), 404
-        business = fetch_one(
-            """
-            SELECT company_name, owner_name, address_line, postal_code,
-                   city, tax_id, bank_account
-            FROM business_profiles
-            WHERE account_id = %s
-            """,
-            (account_row["id"],),
-        )
+        business = get_business_profile(account_row["id"])
         if not business:
             return jsonify({"error": "Ustaw dane sprzedawcy przed dodaniem faktury."}), 400
 
@@ -636,10 +763,115 @@ def api_invoices() -> Any:
     account["invoices"] = invoices[:INVOICE_HISTORY_LIMIT]
     save_store(data)
     return jsonify({"message": "Faktura zostala zapisana.", "invoice": invoice})
-
-
-@app.route("/api/invoices/summary", methods=["GET"])
-def api_invoice_summary() -> Any:
+
+
+@app.route("/api/invoices/<invoice_id>", methods=["PUT", "DELETE"])
+def api_invoice_detail(invoice_id: str) -> Any:
+    try:
+        login_key = require_auth()
+    except PermissionError:
+        return jsonify({"error": "Brak autoryzacji."}), 401
+
+    if DATABASE_AVAILABLE:
+        try:
+            account_row = get_account_row(login_key)
+        except KeyError:
+            return jsonify({"error": "Nie znaleziono konta."}), 404
+
+        invoice_row = fetch_one(
+            """
+            SELECT id, issued_at
+            FROM invoices
+            WHERE account_id = %s AND invoice_number = %s
+            """,
+            (account_row["id"], invoice_id),
+        )
+        if not invoice_row:
+            return jsonify({"error": "Nie znaleziono faktury."}), 404
+
+        if request.method == "DELETE":
+            execute("DELETE FROM invoice_items WHERE invoice_id = %s", (invoice_row["id"],))
+            execute("DELETE FROM invoice_vat_summary WHERE invoice_id = %s", (invoice_row["id"],))
+            execute("DELETE FROM invoices WHERE id = %s", (invoice_row["id"],))
+            return jsonify({"message": "Faktura zostala usunieta."})
+
+        payload = request.get_json(force=True)
+        business = get_business_profile(account_row["id"])
+        if not business:
+            return jsonify({"error": "Ustaw dane sprzedawcy przed dodaniem faktury."}), 400
+
+        client = validate_client(payload)
+        try:
+            invoice = build_invoice(payload, business, client)
+        except ValueError as error:
+            return jsonify({"error": str(error)}), 400
+
+        invoice["invoice_id"] = invoice_id
+        existing_issued_at = invoice_row.get("issued_at")
+        if isinstance(existing_issued_at, datetime):
+            invoice["issued_at"] = existing_issued_at.strftime("%Y-%m-%d %H:%M")
+        elif existing_issued_at:
+            invoice["issued_at"] = str(existing_issued_at)
+
+        client_id = upsert_client(
+            account_row["id"],
+            {
+                "name": client["name"],
+                "address_line": client["address_line"],
+                "postal_code": client["postal_code"],
+                "city": client["city"],
+                "tax_id": client["tax_id"],
+                "phone": client.get("phone"),
+            },
+        )
+
+        execute("DELETE FROM invoice_items WHERE invoice_id = %s", (invoice_row["id"],))
+        execute("DELETE FROM invoice_vat_summary WHERE invoice_id = %s", (invoice_row["id"],))
+        execute("DELETE FROM invoices WHERE id = %s", (invoice_row["id"],))
+        insert_invoice(account_row["id"], client_id, invoice)
+        return jsonify({"message": "Faktura zostala zaktualizowana.", "invoice": invoice})
+
+    data = load_store()
+    try:
+        account = get_account(data, login_key)
+    except KeyError:
+        return jsonify({"error": "Nie znaleziono konta."}), 404
+
+    invoices = account.get("invoices", [])
+    invoice_index = next(
+        (idx for idx, entry in enumerate(invoices) if entry.get("invoice_id") == invoice_id),
+        None,
+    )
+    if invoice_index is None:
+        return jsonify({"error": "Nie znaleziono faktury."}), 404
+
+    if request.method == "DELETE":
+        invoices.pop(invoice_index)
+        save_store(data)
+        return jsonify({"message": "Faktura zostala usunieta."})
+
+    payload = request.get_json(force=True)
+    business = account.get("business")
+    if not business:
+        return jsonify({"error": "Ustaw dane sprzedawcy przed dodaniem faktury."}), 400
+
+    client = validate_client(payload)
+    try:
+        invoice = build_invoice(payload, business, client)
+    except ValueError as error:
+        return jsonify({"error": str(error)}), 400
+
+    invoice["invoice_id"] = invoice_id
+    existing_invoice = invoices[invoice_index]
+    if existing_invoice.get("issued_at"):
+        invoice["issued_at"] = existing_invoice.get("issued_at")
+    invoices[invoice_index] = invoice
+    save_store(data)
+    return jsonify({"message": "Faktura zostala zaktualizowana.", "invoice": invoice})
+
+
+@app.route("/api/invoices/summary", methods=["GET"])
+def api_invoice_summary() -> Any:
     try:
         login_key = require_auth()
     except PermissionError: