Update

Akompta/settings.py

@@ -25,8 +25,17 @@ BASE_DIR = Path(__file__).resolve().parent.parent
 # SECURITY WARNING: keep the secret key used in production secret!
 SECRET_KEY = config('SECRET_KEY', default='django-insecure-3m1!a3u-z=5k8x9y#-954&3ree&mr&$o97fuy8ds*8dox!(rvx')
 
+# decouple's built-in bool cast is strict and can crash on values like "release".
+def _parse_bool(value):
+    s = str(value).strip().lower()
+    if s in {"1", "true", "yes", "y", "on"}:
+        return True
+    if s in {"0", "false", "no", "n", "off", ""}:
+        return False
+    return False
+
 # SECURITY WARNING: don't run with debug turned on in production!
-DEBUG = config('DEBUG', default=True, cast=bool)
+DEBUG = config('DEBUG', default=True, cast=_parse_bool)
 
 ALLOWED_HOSTS = config('ALLOWED_HOSTS', default='*', cast=Csv())
 

api/syscohada_reports.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+import csv
+import io
+import json
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+
+from django.utils import timezone
+
+from .models import Transaction, User
+
+
+TEMPLATES_DIR = Path(__file__).resolve().parent / "syscohada_templates"
+
+
+def _load_template_json(filename: str) -> Any:
+    with (TEMPLATES_DIR / filename).open("r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _year_bounds(year: int) -> tuple[datetime, datetime]:
+    start = timezone.make_aware(datetime(year, 1, 1, 0, 0, 0))
+    end = timezone.make_aware(datetime(year + 1, 1, 1, 0, 0, 0))
+    return start, end
+
+
+def _normalize_text(value: str | None) -> str:
+    return (value or "").strip().lower()
+
+
+def _map_transaction_to_cr_ref(tx: Transaction) -> str:
+    """
+    MVP mapping: map Akompta Transaction -> SYSCOHADA Compte de Résultat ref.
+    This is intentionally heuristic and can be replaced later by a user-configurable mapping table.
+    """
+    category = _normalize_text(getattr(tx, "category", ""))
+    name = _normalize_text(getattr(tx, "name", ""))
+    haystack = f"{category} {name}".strip()
+
+    if tx.type == "income":
+        if any(k in haystack for k in ["service", "prestation", "consult"]):
+            return "TC"  # travaux, services vendus
+        if any(k in haystack for k in ["produit accessoire", "accessoire"]):
+            return "TD"
+        return "TA"  # ventes de marchandises
+
+    # expense
+    if any(k in haystack for k in ["achat", "marchandise", "appro", "approvisionnement"]):
+        return "RA"
+    if any(k in haystack for k in ["transport", "taxi", "bus", "essence", "carburant", "livraison"]):
+        return "RG"
+    if any(k in haystack for k in ["loyer", "internet", "eau", "electric", "électric", "telephone", "téléphone", "prestataire", "maintenance", "marketing", "publicit", "pub"]):
+        return "RH"
+    if any(k in haystack for k in ["impot", "impôt", "taxe", "douane", "etat", "état"]):
+        return "RI"
+    if any(k in haystack for k in ["salaire", "salaires", "personnel", "paie", "payroll"]):
+        return "RK"
+    return "RJ"
+
+
+_CR_TOKEN_RE = re.compile(r"([A-Z]{1,2})|([+-])")
+
+
+def _eval_cr_formula(formula: str, values: dict[str, Decimal]) -> Decimal:
+    """
+    Evaluate formulas like: "XB-RA+RB+TE-RE" using Decimal arithmetic.
+    Supports only refs (A-Z, 1-2 chars) and + / -.
+    """
+    tokens = [m.group(0) for m in _CR_TOKEN_RE.finditer(formula.replace(" ", ""))]
+    if not tokens:
+        return Decimal("0")
+
+    total = Decimal("0")
+    op = "+"
+    for tok in tokens:
+        if tok in {"+", "-"}:
+            op = tok
+            continue
+        value = values.get(tok, Decimal("0"))
+        total = total + value if op == "+" else total - value
+    return total
+
+
+@dataclass(frozen=True)
+class CompteResultatComputed:
+    year: int
+    values_n: dict[str, Decimal]
+    values_n_1: dict[str, Decimal]
+    resultat_net_n: Decimal
+    total_income_n: Decimal
+    total_expense_n: Decimal
+    total_income_n_1: Decimal
+    total_expense_n_1: Decimal
+
+
+def compute_compte_resultat(user: User, year: int) -> CompteResultatComputed:
+    structure = _load_template_json("compte_resultat_structure.json")
+    lignes: list[dict[str, Any]] = structure["lignes"]
+
+    start_n, end_n = _year_bounds(year)
+    start_n_1, end_n_1 = _year_bounds(year - 1)
+
+    tx_n = Transaction.objects.filter(user=user, date__gte=start_n, date__lt=end_n).only(
+        "amount",
+        "type",
+        "category",
+        "name",
+    )
+    tx_n_1 = Transaction.objects.filter(user=user, date__gte=start_n_1, date__lt=end_n_1).only(
+        "amount",
+        "type",
+        "category",
+        "name",
+    )
+
+    values_n: dict[str, Decimal] = {item["ref"]: Decimal("0") for item in lignes}
+    values_n_1: dict[str, Decimal] = {item["ref"]: Decimal("0") for item in lignes}
+
+    total_income_n = Decimal("0")
+    total_expense_n = Decimal("0")
+    for tx in tx_n:
+        ref = _map_transaction_to_cr_ref(tx)
+        amount = Decimal(tx.amount)
+        values_n[ref] = values_n.get(ref, Decimal("0")) + amount
+        if tx.type == "income":
+            total_income_n += amount
+        else:
+            total_expense_n += amount
+
+    total_income_n_1 = Decimal("0")
+    total_expense_n_1 = Decimal("0")
+    for tx in tx_n_1:
+        ref = _map_transaction_to_cr_ref(tx)
+        amount = Decimal(tx.amount)
+        values_n_1[ref] = values_n_1.get(ref, Decimal("0")) + amount
+        if tx.type == "income":
+            total_income_n_1 += amount
+        else:
+            total_expense_n_1 += amount
+
+    # Compute total lines in order (formulas reference previous totals, order in structure matters)
+    for item in lignes:
+        if not item.get("is_total"):
+            continue
+        formula = item.get("formula") or ""
+        values_n[item["ref"]] = _eval_cr_formula(formula, values_n)
+        values_n_1[item["ref"]] = _eval_cr_formula(formula, values_n_1)
+
+    # For MVP, use the computed XI if available; fallback to income-expense.
+    resultat_net_n = values_n.get("XI")
+    if resultat_net_n is None:
+        resultat_net_n = total_income_n - total_expense_n
+
+    return CompteResultatComputed(
+        year=year,
+        values_n=values_n,
+        values_n_1=values_n_1,
+        resultat_net_n=resultat_net_n,
+        total_income_n=total_income_n,
+        total_expense_n=total_expense_n,
+        total_income_n_1=total_income_n_1,
+        total_expense_n_1=total_expense_n_1,
+    )
+
+
+def generate_compte_resultat_csv(compte: CompteResultatComputed) -> bytes:
+    structure = _load_template_json("compte_resultat_structure.json")
+    lignes: list[dict[str, Any]] = structure["lignes"]
+
+    out = io.StringIO()
+    writer = csv.writer(out)
+    writer.writerow(["REF", "LIBELLES", "NUMERO DE COMPTES", "MONTANT_N", "MONTANT_N_1"])
+    for item in lignes:
+        ref = item["ref"]
+        writer.writerow(
+            [
+                ref,
+                item.get("libelle", ""),
+                item.get("compte", ""),
+                str(compte.values_n.get(ref, Decimal("0"))),
+                str(compte.values_n_1.get(ref, Decimal("0"))),
+            ]
+        )
+    return out.getvalue().encode("utf-8")
+
+
+def generate_bilan_csv(user: User, compte: CompteResultatComputed) -> bytes:
+    structure = _load_template_json("bilan_structure.json")
+    actif: list[dict[str, Any]] = structure["actif"]
+    passif: list[dict[str, Any]] = structure["passif"]
+
+    # Minimal model: only cash + equity + result to keep the bilan balanced.
+    cash_n = user.initial_balance + compte.total_income_n - compte.total_expense_n
+    cash_n_1 = user.initial_balance + compte.total_income_n_1 - compte.total_expense_n_1
+
+    capital_n = user.initial_balance
+    capital_n_1 = user.initial_balance
+
+    # Actif values stored by ref: BRUT, AMORT, NET_N, NET_N_1
+    brut: dict[str, Decimal] = {item["ref"]: Decimal("0") for item in actif}
+    amort: dict[str, Decimal] = {item["ref"]: Decimal("0") for item in actif}
+
+    brut["BS"] = Decimal(cash_n)
+    amort["BS"] = Decimal("0")
+
+    brut_n_1: dict[str, Decimal] = {item["ref"]: Decimal("0") for item in actif}
+    amort_n_1: dict[str, Decimal] = {item["ref"]: Decimal("0") for item in actif}
+    brut_n_1["BS"] = Decimal(cash_n_1)
+    amort_n_1["BS"] = Decimal("0")
+
+    def net_for(ref: str) -> Decimal:
+        return brut.get(ref, Decimal("0")) - amort.get(ref, Decimal("0"))
+
+    def net_for_n_1(ref: str) -> Decimal:
+        return brut_n_1.get(ref, Decimal("0")) - amort_n_1.get(ref, Decimal("0"))
+
+    # Compute header subtotals (stable SYSCOHADA groupings)
+    header_groups = {
+        "AD": ["AE", "AF", "AG", "AH"],
+        "AI": ["AJ", "AK", "AL", "AM", "AN", "AP"],
+        "AQ": ["AR", "AS"],
+        "BG": ["BH", "BI", "BJ"],
+    }
+    for header_ref, children in header_groups.items():
+        brut[header_ref] = sum((brut.get(c, Decimal("0")) for c in children), Decimal("0"))
+        amort[header_ref] = sum((amort.get(c, Decimal("0")) for c in children), Decimal("0"))
+        brut_n_1[header_ref] = sum((brut_n_1.get(c, Decimal("0")) for c in children), Decimal("0"))
+        amort_n_1[header_ref] = sum((amort_n_1.get(c, Decimal("0")) for c in children), Decimal("0"))
+
+    # Compute totals based on formulas (only '+' is expected in these bilan totals)
+    def parse_bilan_sum_formula(formula: str) -> list[str]:
+        return [part.strip() for part in formula.split("+") if part.strip()]
+
+    for item in actif:
+        if not item.get("is_total"):
+            continue
+        parts = parse_bilan_sum_formula(item.get("formula", ""))
+        brut[item["ref"]] = sum((brut.get(p, Decimal("0")) for p in parts), Decimal("0"))
+        amort[item["ref"]] = sum((amort.get(p, Decimal("0")) for p in parts), Decimal("0"))
+        brut_n_1[item["ref"]] = sum((brut_n_1.get(p, Decimal("0")) for p in parts), Decimal("0"))
+        amort_n_1[item["ref"]] = sum((amort_n_1.get(p, Decimal("0")) for p in parts), Decimal("0"))
+
+    # Passif values: NET only, but handle "negative" lines like CB by applying sign.
+    passif_meta: dict[str, dict[str, Any]] = {item["ref"]: item for item in passif}
+    net_passif_n: dict[str, Decimal] = {item["ref"]: Decimal("0") for item in passif}
+    net_passif_n_1: dict[str, Decimal] = {item["ref"]: Decimal("0") for item in passif}
+
+    net_passif_n["CA"] = Decimal(capital_n)
+    net_passif_n_1["CA"] = Decimal(capital_n_1)
+
+    net_passif_n["CJ"] = Decimal(compte.resultat_net_n)
+    net_passif_n_1["CJ"] = Decimal("0")  # not computed in this MVP
+
+    def signed_passif_value(values: dict[str, Decimal], ref: str) -> Decimal:
+        val = values.get(ref, Decimal("0"))
+        meta = passif_meta.get(ref, {})
+        if meta.get("is_negative"):
+            return -val
+        return val
+
+    def eval_passif_formula(values: dict[str, Decimal], formula: str) -> Decimal:
+        parts = parse_bilan_sum_formula(formula)
+        return sum((signed_passif_value(values, p) for p in parts), Decimal("0"))
+
+    for item in passif:
+        if not item.get("is_total"):
+            continue
+        ref = item["ref"]
+        net_passif_n[ref] = eval_passif_formula(net_passif_n, item.get("formula", ""))
+        net_passif_n_1[ref] = eval_passif_formula(net_passif_n_1, item.get("formula", ""))
+
+    # Build a single CSV containing both sections.
+    out = io.StringIO()
+    writer = csv.writer(out)
+    writer.writerow(["SECTION", "REF", "LIBELLE", "NOTE", "BRUT", "AMORT/DEPREC", "NET_N", "NET_N_1"])
+
+    for item in actif:
+        ref = item["ref"]
+        writer.writerow(
+            [
+                "ACTIF",
+                ref,
+                item.get("libelle", ""),
+                item.get("note", ""),
+                str(brut.get(ref, Decimal("0"))),
+                str(amort.get(ref, Decimal("0"))),
+                str(net_for(ref)),
+                str(net_for_n_1(ref)),
+            ]
+        )
+
+    for item in passif:
+        ref = item["ref"]
+        writer.writerow(
+            [
+                "PASSIF",
+                ref,
+                item.get("libelle", ""),
+                item.get("note", ""),
+                "",
+                "",
+                str(signed_passif_value(net_passif_n, ref)),
+                str(signed_passif_value(net_passif_n_1, ref)),
+            ]
+        )
+
+    return out.getvalue().encode("utf-8")
+

api/syscohada_templates/bilan_structure.json

@@ -0,0 +1,64 @@
+{
+  "actif": [
+    {"ref": "AD", "libelle": "IMMOBILISATIONS INCORPORELLES", "note": "3", "is_total": false, "is_header": true},
+    {"ref": "AE", "libelle": "Frais de développement et de prospection", "note": "", "is_total": false},
+    {"ref": "AF", "libelle": "Brevets, licences, logiciels, et droits similaires", "note": "", "is_total": false},
+    {"ref": "AG", "libelle": "Fonds commercial et droit au bail", "note": "", "is_total": false},
+    {"ref": "AH", "libelle": "Autres immobilisations incorporelles", "note": "", "is_total": false},
+    {"ref": "AI", "libelle": "IMMOBILISATIONS CORPORELLES", "note": "3", "is_total": false, "is_header": true},
+    {"ref": "AJ", "libelle": "Terrains (1)", "note": "", "is_total": false},
+    {"ref": "AK", "libelle": "Bâtiments (1)", "note": "", "is_total": false},
+    {"ref": "AL", "libelle": "Aménagements, agencements et installations", "note": "", "is_total": false},
+    {"ref": "AM", "libelle": "Matériel, mobilier et actifs biologiques", "note": "", "is_total": false},
+    {"ref": "AN", "libelle": "Matériel de transport", "note": "", "is_total": false},
+    {"ref": "AP", "libelle": "Avances et acomptes versés sur immobilisations", "note": "3", "is_total": false},
+    {"ref": "AQ", "libelle": "IMMOBILISATIONS FINANCIERES", "note": "4", "is_total": false, "is_header": true},
+    {"ref": "AR", "libelle": "Titres de participation", "note": "", "is_total": false},
+    {"ref": "AS", "libelle": "Autres immobilisations financières", "note": "", "is_total": false},
+    {"ref": "AZ", "libelle": "TOTAL ACTIF IMMOBILISE", "note": "", "is_total": true, "formula": "AD+AI+AQ"},
+    {"ref": "BA", "libelle": "ACTIF CIRCULANT HAO", "note": "5", "is_total": false},
+    {"ref": "BB", "libelle": "STOCKS ET ENCOURS", "note": "6", "is_total": false},
+    {"ref": "BG", "libelle": "CREANCES ET EMPLOIS ASSIMILES", "note": "", "is_total": false, "is_header": true},
+    {"ref": "BH", "libelle": "Fournisseurs avances versées", "note": "17", "is_total": false},
+    {"ref": "BI", "libelle": "Clients", "note": "7", "is_total": false},
+    {"ref": "BJ", "libelle": "Autres créances", "note": "8", "is_total": false},
+    {"ref": "BK", "libelle": "TOTAL ACTIF CIRCULANT", "note": "", "is_total": true, "formula": "BA+BB+BG"},
+    {"ref": "BQ", "libelle": "Titres de placement", "note": "9", "is_total": false},
+    {"ref": "BR", "libelle": "Valeurs à encaisser", "note": "10", "is_total": false},
+    {"ref": "BS", "libelle": "Banques, chèques postaux, caisse et assimilés", "note": "11", "is_total": false},
+    {"ref": "BT", "libelle": "TOTAL TRESORERIE-ACTIF", "note": "", "is_total": true, "formula": "BQ+BR+BS"},
+    {"ref": "BU", "libelle": "Ecart de conversion-Actif", "note": "12", "is_total": false},
+    {"ref": "BZ", "libelle": "TOTAL GENERAL", "note": "", "is_total": true, "formula": "AZ+BK+BT+BU"}
+  ],
+  "passif": [
+    {"ref": "CA", "libelle": "Capital", "note": "13", "is_total": false},
+    {"ref": "CB", "libelle": "Apporteurs capital non appelé (-)", "note": "13", "is_total": false, "is_negative": true},
+    {"ref": "CD", "libelle": "Primes liées au capital social", "note": "14", "is_total": false},
+    {"ref": "CE", "libelle": "Ecarts de réévaluation", "note": "3e", "is_total": false},
+    {"ref": "CF", "libelle": "Réserves indisponibles", "note": "14", "is_total": false},
+    {"ref": "CG", "libelle": "Réserves libres", "note": "14", "is_total": false},
+    {"ref": "CH", "libelle": "Report à nouveau (+ ou -)", "note": "14", "is_total": false},
+    {"ref": "CJ", "libelle": "Résultat net de l'exercice (bénéfice + ou perte -)", "note": "", "is_total": false},
+    {"ref": "CL", "libelle": "Subventions d'investissement", "note": "15", "is_total": false},
+    {"ref": "CM", "libelle": "Provisions réglementées", "note": "15", "is_total": false},
+    {"ref": "CP", "libelle": "TOTAL CAPITAUX PROPRES ET RESSOURCES ASSIMILEES", "note": "", "is_total": true, "formula": "CA+CB+CD+CE+CF+CG+CH+CJ+CL+CM"},
+    {"ref": "DA", "libelle": "Emprunts et dettes financières diverses", "note": "16", "is_total": false},
+    {"ref": "DB", "libelle": "Dettes de location acquisition", "note": "16", "is_total": false},
+    {"ref": "DC", "libelle": "Provisions pour risques et charges", "note": "16", "is_total": false},
+    {"ref": "DD", "libelle": "TOTAL DETTES FINANCIERES ET RESSOURCES ASSIMILEES", "note": "", "is_total": true, "formula": "DA+DB+DC"},
+    {"ref": "DF", "libelle": "TOTAL RESSOURCES STABLES", "note": "", "is_total": true, "formula": "CP+DD"},
+    {"ref": "DH", "libelle": "Dettes circulantes HAO", "note": "5", "is_total": false},
+    {"ref": "DI", "libelle": "Clients, avances reçues", "note": "7", "is_total": false},
+    {"ref": "DJ", "libelle": "Fournisseurs d'exploitation", "note": "17", "is_total": false},
+    {"ref": "DK", "libelle": "Dettes fiscales et sociales", "note": "18", "is_total": false},
+    {"ref": "DM", "libelle": "Autres dettes", "note": "19", "is_total": false},
+    {"ref": "DN", "libelle": "Provisions pour risques à court terme", "note": "19", "is_total": false},
+    {"ref": "DP", "libelle": "TOTAL PASSIF CIRCULANT", "note": "", "is_total": true, "formula": "DH+DI+DJ+DK+DM+DN"},
+    {"ref": "DQ", "libelle": "Banques, crédits d'escompte", "note": "20", "is_total": false},
+    {"ref": "DR", "libelle": "Banques, établissements financiers et crédits de trésorerie", "note": "20", "is_total": false},
+    {"ref": "DT", "libelle": "TOTAL TRESORERIE-PASSIF", "note": "", "is_total": true, "formula": "DQ+DR"},
+    {"ref": "DV", "libelle": "Ecart de conversion-Passif", "note": "12", "is_total": false},
+    {"ref": "DZ", "libelle": "TOTAL GENERAL", "note": "", "is_total": true, "formula": "DF+DP+DT+DV"}
+  ]
+}
+

api/syscohada_templates/compte_resultat_structure.json

@@ -0,0 +1,47 @@
+{
+  "lignes": [
+    {"ref": "TA", "libelle": "Ventes de marchandises", "compte": "701", "type": "produit", "is_total": false},
+    {"ref": "RA", "libelle": "Achats de marchandises", "compte": "601", "type": "charge", "is_total": false},
+    {"ref": "RB", "libelle": "Variation de stocks de marchandises", "compte": "6031", "type": "mixte", "is_total": false},
+    {"ref": "XA", "libelle": "MARGE COMMERCIALE (Somme TA à RB)", "formula": "TA-RA+RB", "is_total": true, "bg_color": "#DDEBF7"},
+    {"ref": "TB", "libelle": "Ventes de produits fabriqués", "compte": "702, 703, 704", "type": "produit", "is_total": false},
+    {"ref": "TC", "libelle": "Travaux, services vendus", "compte": "705, 706", "type": "produit", "is_total": false},
+    {"ref": "TD", "libelle": "Produits accessoires", "compte": "707", "type": "produit", "is_total": false},
+    {"ref": "XB", "libelle": "CHIFFRE D'AFFAIRES (A + B + C + D)", "formula": "TA+TB+TC+TD", "is_total": true, "bg_color": "#DDEBF7"},
+    {"ref": "TE", "libelle": "Production stockée (ou déstockage)", "compte": "73", "type": "produit", "is_total": false},
+    {"ref": "TF", "libelle": "Production immobilisée", "compte": "72", "type": "produit", "is_total": false},
+    {"ref": "TG", "libelle": "Subventions d'exploitation", "compte": "71", "type": "produit", "is_total": false},
+    {"ref": "TH", "libelle": "Autres produits", "compte": "75", "type": "produit", "is_total": false},
+    {"ref": "TI", "libelle": "Transferts de charges d'exploitation", "compte": "781", "type": "produit", "is_total": false},
+    {"ref": "RC", "libelle": "Achats de matières premières et fournitures liées", "compte": "602", "type": "charge", "is_total": false},
+    {"ref": "RD", "libelle": "Variation de stocks de matières premières et fournitures liées", "compte": "6032", "type": "mixte", "is_total": false},
+    {"ref": "RE", "libelle": "Autres achats", "compte": "604, 605, 608", "type": "charge", "is_total": false},
+    {"ref": "RF", "libelle": "Variation de stocks d'autres approvisionnements", "compte": "6033", "type": "mixte", "is_total": false},
+    {"ref": "RG", "libelle": "Transports", "compte": "61", "type": "charge", "is_total": false},
+    {"ref": "RH", "libelle": "Services extérieurs", "compte": "62, 63", "type": "charge", "is_total": false},
+    {"ref": "RI", "libelle": "Impôts et taxes", "compte": "64", "type": "charge", "is_total": false},
+    {"ref": "RJ", "libelle": "Autres charges", "compte": "65", "type": "charge", "is_total": false},
+    {"ref": "XC", "libelle": "VALEUR AJOUTEE (XB + RA + RB) + (somme TE à RJ)", "formula": "XB-RA+RB+TE+TF+TG+TH+TI-RC+RD-RE+RF-RG-RH-RI-RJ", "is_total": true, "bg_color": "#DDEBF7"},
+    {"ref": "RK", "libelle": "Charges de personnel", "compte": "66", "type": "charge", "is_total": false},
+    {"ref": "XD", "libelle": "EXCEDENT BRUT D'EXPLOITATION (XC + RK)", "formula": "XC-RK", "is_total": true, "bg_color": "#DDEBF7"},
+    {"ref": "TJ", "libelle": "Reprises d'amortissements, de provisions et dépréciations", "compte": "791, 798, 799", "type": "produit", "is_total": false},
+    {"ref": "RL", "libelle": "Dotations aux amortissements, aux provisions et dépréciations", "compte": "681, 691", "type": "charge", "is_total": false},
+    {"ref": "XE", "libelle": "RESULTAT D'EXPLOITATION (XD + TJ + RL)", "formula": "XD+TJ-RL", "is_total": true, "bg_color": "#DDEBF7"},
+    {"ref": "TK", "libelle": "Revenus financiers et assimilés", "compte": "77", "type": "produit", "is_total": false},
+    {"ref": "TL", "libelle": "Reprises de provisions et dépréciations financières", "compte": "797", "type": "produit", "is_total": false},
+    {"ref": "TM", "libelle": "Transferts de charges financières", "compte": "787", "type": "produit", "is_total": false},
+    {"ref": "RM", "libelle": "Frais financiers et charges assimilés", "compte": "67", "type": "charge", "is_total": false},
+    {"ref": "RN", "libelle": "Dotations aux provisions et aux dépréciations financières", "compte": "697", "type": "charge", "is_total": false},
+    {"ref": "XF", "libelle": "RESULTAT FINANCIER (somme TK à RN)", "formula": "TK+TL+TM-RM-RN", "is_total": true, "bg_color": "#DDEBF7"},
+    {"ref": "XG", "libelle": "RESULTAT DES ACTIVITES ORDINAIRES (XE + XF)", "formula": "XE+XF", "is_total": true, "bg_color": "#FCE4D6"},
+    {"ref": "TN", "libelle": "Produits des cessions d'immobilisations", "compte": "82", "type": "produit", "is_total": false},
+    {"ref": "TO", "libelle": "Autres Produits HAO", "compte": "84, 86, 88", "type": "produit", "is_total": false},
+    {"ref": "RO", "libelle": "Valeurs comptables des cessions d'immobilisations", "compte": "81", "type": "charge", "is_total": false},
+    {"ref": "RP", "libelle": "Autres Charges HAO", "compte": "83, 85", "type": "charge", "is_total": false},
+    {"ref": "XH", "libelle": "RESULTAT HORS ACTIVITES ORDINAIRES (somme TN à RP)", "formula": "TN+TO-RO-RP", "is_total": true, "bg_color": "#DDEBF7"},
+    {"ref": "RQ", "libelle": "Participation des travailleurs", "compte": "87", "type": "charge", "is_total": false},
+    {"ref": "RS", "libelle": "Impôts sur le résultat", "compte": "89", "type": "charge", "is_total": false},
+    {"ref": "XI", "libelle": "RESULTAT NET (XG + XH + RQ + RS)", "formula": "XG+XH-RQ-RS", "is_total": true, "bg_color": "#E2EFDA"}
+  ]
+}
+

api/tests_new.py

@@ -3,6 +3,8 @@ from rest_framework.test import APITestCase, APIClient
 from rest_framework import status
 from django.contrib.auth import get_user_model
 from .models import Notification, SupportTicket
+import zipfile
+import io
 
 User = get_user_model()
 
@@ -113,3 +115,38 @@ class SupportTicketTests(APITestCase):
         response = self.client.get(self.support_url)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(len(response.data['results']), 1)
+
+
+class SyscohadaReportsTests(APITestCase):
+    """Tests pour l'export SYSCOHADA (ZIP)"""
+
+    def setUp(self):
+        self.user = User.objects.create_user(
+            email='syscohada@example.com',
+            password='TestPass123!',
+            first_name='John',
+            last_name='Doe'
+        )
+        self.client = APIClient()
+        self.client.force_authenticate(user=self.user)
+        self.url = reverse('syscohada-download')
+
+    def test_download_zip_contains_two_files(self):
+        response = self.client.get(self.url, {'year': 2026})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response['Content-Type'], 'application/zip')
+
+        zf = zipfile.ZipFile(io.BytesIO(response.content))
+        names = sorted(zf.namelist())
+        self.assertEqual(len(names), 2)
+        self.assertTrue(any(name.startswith('compte_resultat_syscohada_2026') for name in names))
+        self.assertTrue(any(name.startswith('bilan_syscohada_2026') for name in names))
+
+        # Basic content sanity
+        cr_name = next(name for name in names if name.startswith('compte_resultat_syscohada_2026'))
+        cr_csv = zf.read(cr_name).decode('utf-8')
+        self.assertIn('REF,LIBELLES,NUMERO DE COMPTES,MONTANT_N,MONTANT_N_1', cr_csv)
+
+        bilan_name = next(name for name in names if name.startswith('bilan_syscohada_2026'))
+        bilan_csv = zf.read(bilan_name).decode('utf-8')
+        self.assertIn('SECTION,REF,LIBELLE,NOTE,BRUT,AMORT/DEPREC,NET_N,NET_N_1', bilan_csv)

api/urls.py

@@ -6,6 +6,7 @@ from .views import (
     RegisterView, LoginView, ProfileView, ChangePasswordView,
     ProductViewSet, TransactionViewSet, BudgetViewSet, AdViewSet,
     NotificationViewSet, SupportTicketViewSet, VoiceCommandView, AIInsightsView,
+    SyscohadaReportsDownloadView,
     analytics_overview, analytics_breakdown, analytics_kpi, analytics_activity,
     analytics_balance_history
 )
@@ -40,4 +41,7 @@ urlpatterns = [
     # ===== VOICE AI =====
     path('voice-command/', VoiceCommandView.as_view(), name='voice-command'),
     path('ai-insights/', AIInsightsView.as_view(), name='ai-insights'),
+
+    # ===== REPORTS (SYSCOHADA) =====
+    path('reports/syscohada/download/', SyscohadaReportsDownloadView.as_view(), name='syscohada-download'),
 ]

api/views.py

@@ -29,6 +29,8 @@ from .groq_service import GroqService
 from .assemblyai_service import AssemblyAIService
 import tempfile
 import os
+import io
+import zipfile
 
 User = get_user_model()
 
@@ -836,4 +838,49 @@ class AIInsightsView(APIView):
             if last_insight:
                 return Response({'insights': last_insight.content, 'cached': True, 'error_fallback': str(e)})
                 
-            return Response({'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            return Response({'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+class SyscohadaReportsDownloadView(APIView):
+    """
+    Téléchargement en 1 clic des 2 rapports SYSCOHADA (MVP):
+    - Compte de résultat (CSV)
+    - Bilan (CSV)
+
+    Réponse: un ZIP contenant exactement 2 fichiers.
+    """
+
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request):
+        from .syscohada_reports import (
+            compute_compte_resultat,
+            generate_bilan_csv,
+            generate_compte_resultat_csv,
+        )
+
+        try:
+            year = int(request.query_params.get("year") or timezone.now().year)
+        except ValueError:
+            return Response(
+                {"type": "validation_error", "errors": {"year": ["Invalid year."]}},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        compte = compute_compte_resultat(request.user, year)
+        compte_csv = generate_compte_resultat_csv(compte)
+        bilan_csv = generate_bilan_csv(request.user, compte)
+
+        zip_buf = io.BytesIO()
+        zip_name = f"rapports_syscohada_{year}.zip"
+        cr_name = f"compte_resultat_syscohada_{year}.csv"
+        bilan_name = f"bilan_syscohada_{year}.csv"
+
+        with zipfile.ZipFile(zip_buf, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
+            zf.writestr(cr_name, compte_csv)
+            zf.writestr(bilan_name, bilan_csv)
+
+        zip_buf.seek(0)
+        response = HttpResponse(zip_buf.getvalue(), content_type="application/zip")
+        response["Content-Disposition"] = f'attachment; filename="{zip_name}"'
+        return response