fix: correct transaction dates (2024 clock drift); improve validate_date; add fix_dates command

Akompta/settings.py

@@ -13,7 +13,6 @@ https://docs.djangoproject.com/en/5.2/ref/settings/
 import os
 from pathlib import Path
 from datetime import timedelta
-from decouple import config, Csv
 
 # Build paths inside the project like this: BASE_DIR / 'subdir'.
 BASE_DIR = Path(__file__).resolve().parent.parent
@@ -23,7 +22,20 @@ BASE_DIR = Path(__file__).resolve().parent.parent
 # See https://docs.djangoproject.com/en/5.2/howto/deployment/checklist/
 
 # 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')
+def _env(name: str, default: str | None = None) -> str | None:
+    value = os.environ.get(name)
+    if value is None or value == "":
+        return default
+    return value
+
+
+def _parse_csv(value: str | None) -> list[str]:
+    if not value:
+        return []
+    return [item.strip() for item in value.split(",") if item.strip()]
+
+
+SECRET_KEY = _env("SECRET_KEY", "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):
@@ -35,15 +47,16 @@ def _parse_bool(value):
     return False
 
 # SECURITY WARNING: don't run with debug turned on in production!
-DEBUG = config('DEBUG', default=True, cast=_parse_bool)
+DEBUG = _parse_bool(_env("DEBUG", "True"))
 
-ALLOWED_HOSTS = config('ALLOWED_HOSTS', default='*', cast=Csv())
+ALLOWED_HOSTS = _parse_csv(_env("ALLOWED_HOSTS", "*"))
 
 # CSRF Trusted Origins for Hugging Face and Frontend
-CSRF_TRUSTED_ORIGINS = config(
-    'CSRF_TRUSTED_ORIGINS', 
-    default='https://*.hf.space,https://*.huggingface.co,https://akompta-ai-flame.vercel.app,https://cosmolabhub-akomptabackend.hf.space', 
-    cast=Csv()
+CSRF_TRUSTED_ORIGINS = _parse_csv(
+    _env(
+        "CSRF_TRUSTED_ORIGINS",
+        "https://*.hf.space,https://*.huggingface.co,https://akompta-ai-flame.vercel.app,https://cosmolabhub-akomptabackend.hf.space",
+    )
 )
 
 
@@ -215,10 +228,11 @@ SIMPLE_JWT = {
 
 
 # CORS Configuration
-CORS_ALLOWED_ORIGINS = config(
-    'CORS_ALLOWED_ORIGINS',
-    default='http://localhost:3000,http://localhost:5173,http://127.0.0.1:3000,http://127.0.0.1:5173,https://akompta-ai-flame.vercel.app,https://cosmolabhub-akomptabackend.hf.space',
-    cast=Csv()
+CORS_ALLOWED_ORIGINS = _parse_csv(
+    _env(
+        "CORS_ALLOWED_ORIGINS",
+        "http://localhost:3000,http://localhost:5173,http://127.0.0.1:3000,http://127.0.0.1:5173,https://akompta-ai-flame.vercel.app,https://cosmolabhub-akomptabackend.hf.space",
+    )
 )
 
 CORS_ALLOW_CREDENTIALS = True

Documentation/audit_inputs/bilan_syscohada_2026_ginni.csv

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

Documentation/audit_inputs/compte_resultat_syscohada_2026_ginni.csv

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

Documentation/demo_exports/bilan_syscohada_2026_demo.csv

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

Documentation/demo_exports/bilan_syscohada_2026_ginni_recalc.csv

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

Documentation/demo_exports/compte_resultat_syscohada_2026_demo.csv

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

Documentation/demo_exports/compte_resultat_syscohada_2026_ginni_recalc.csv

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

Documentation/syscohada_audit_2026_ginni_at_gmail_com.md

@@ -0,0 +1,39 @@
+# SYSCOHADA Audit — ginni@gmail.com — 2026
+
+## Contexte
+- User id: `5`
+- Solde initial (`initial_balance`): `0.00`
+- Transactions non mappées N: `0`
+- Transactions non mappées N-1: `0`
+
+## Sources comparées
+- CR CSV fourni: `backend/Documentation/audit_inputs/compte_resultat_syscohada_2026_ginni.csv`
+- Bilan CSV fourni: `backend/Documentation/audit_inputs/bilan_syscohada_2026_ginni.csv`
+
+## Résultat
+- Statut: **Match** (les exports correspondent aux calculs DB)
+
+## Calculs (DB)
+- Total revenus N: `0`
+- Total dépenses N: `0`
+- Résultat net N (XI): `0`
+
+## Pourquoi tout est à 0 (explication)
+
+Pour cet utilisateur et cet exercice, les exports sont à zéro parce que les entrées DB utilisées par le calcul sont nulles :
+
+- Exercice N (2026) : **0 transaction** → revenus = `0`, dépenses = `0`
+- Exercice N-1 (2025) : **0 transaction** → revenus = `0`, dépenses = `0`
+- Solde initial (`initial_balance`) = `0.00`
+
+Conséquences directes :
+
+- Compte de résultat : toutes les lignes alimentées par les transactions (TA, RG, RH, RJ, …) restent à `0`, et les totaux/formules (XA…XI) aboutissent à `0`.
+- Bilan :
+  - `BS` (trésorerie) = `initial_balance + revenus - dépenses` = `0.00`
+  - `CJ` (résultat net) = `XI` = `0`
+  - les autres postes (CA, BI, DJ, …) ne peuvent pas être déduits des transactions Akompta et restent à `0` tant qu’ils ne sont pas saisis via `SyscohadaBilanBalance`.
+
+## Notes
+- Les montants attendus sont calculés via `compute_compte_resultat()` + `generate_bilan_csv()`.
+- Si les exports fournis sont à zéro, vérifier: année des transactions, `initial_balance`, et règles de mapping CR.

Documentation/syscohada_audit_2026_ginni_fixed_dates.md

@@ -0,0 +1,23 @@
+# SYSCOHADA Audit — ginni@gmail.com — 2026
+
+## Contexte
+- User id: `5`
+- Solde initial (`initial_balance`): `0.00`
+- Transactions non mappées N: `0`
+- Transactions non mappées N-1: `0`
+
+## Sources comparées
+- CR CSV fourni: `backend/Documentation/demo_exports/compte_resultat_syscohada_2026_ginni_recalc.csv`
+- Bilan CSV fourni: `backend/Documentation/demo_exports/bilan_syscohada_2026_ginni_recalc.csv`
+
+## Résultat
+- Statut: **Match** (les exports correspondent aux calculs DB)
+
+## Calculs (DB)
+- Total revenus N: `500000.00`
+- Total dépenses N: `13200.00`
+- Résultat net N (XI): `486800.00`
+
+## Notes
+- Les montants attendus sont calculés via `compute_compte_resultat()` + `generate_bilan_csv()`.
+- Si les exports fournis sont à zéro, vérifier: année des transactions, `initial_balance`, et règles de mapping CR.

Documentation/syscohada_demo_analysis_2026.md

@@ -0,0 +1,64 @@
+# SYSCOHADA Audit — syscohada.demo@gmail.com — 2026
+
+## Contexte
+- User id: `8`
+- Solde initial (`initial_balance`): `100000.00`
+- Transactions non mappées N: `0`
+- Transactions non mappées N-1: `0`
+
+## Sources comparées
+- CR CSV fourni: `backend/Documentation/demo_exports/compte_resultat_syscohada_2026_demo.csv`
+- Bilan CSV fourni: `backend/Documentation/demo_exports/bilan_syscohada_2026_demo.csv`
+
+## Résultat
+- Statut: **Match** (les exports correspondent aux calculs DB)
+
+## Calculs (DB)
+- Total revenus N: `117000.00`
+- Total dépenses N: `84734.00`
+- Résultat net N (XI): `32266.00`
+
+## Notes
+- Les montants attendus sont calculés via `compute_compte_resultat()` + `generate_bilan_csv()`.
+- Si les exports fournis sont à zéro, vérifier: année des transactions, `initial_balance`, et règles de mapping CR.
+
+## Détails Compte de résultat (comment les lignes sont alimentées)
+
+Transactions 2026 utilisées:
+
+| Date | Type | Catégorie | Libellé | Montant | Ref SYSCOHADA |
+|---|---|---|---|---:|---|
+| 2026-04-02 | income | Accessoire | Produits accessoires | 12000.00 | TD |
+| 2026-05-01 | expense | Loyer | Loyer boutique | 40000.00 | RH |
+| 2026-05-03 | expense | Inconnu | Charge inconnue | 1234.00 | RH |
+| 2026-05-14 | expense | Marketing | Facebook ads | 10000.00 | RH |
+| 2026-05-15 | expense | Achats | Achat marchandises | 30000.00 | RA |
+| 2026-05-16 | income | Service | Prestation conseil | 80000.00 | TC |
+| 2026-05-17 | income | Ventes | Vente tomates | 25000.00 | TA |
+| 2026-05-17 | expense | Transport | Taxi | 3500.00 | RG |
+
+Sommes par ref (MONTANT_N):
+
+| Ref | Montant |
+|---|---:|
+| TA | 25000.00 |
+| TC | 80000.00 |
+| TD | 12000.00 |
+| RA | 30000.00 |
+| RG | 3500.00 |
+| RH | 51234.00 |
+| RI | 0 |
+| RJ | 0 |
+| XI | 32266.00 |
+
+## Détails Bilan (auto + saisies)
+
+- BS (auto, trésorerie) = initial_balance + revenus - dépenses = 100000.00 + 117000.00 - 84734.00 = 132266.00
+- CJ (auto, résultat net) = XI = 32266.00
+- CA (saisi via SyscohadaBilanBalance) = 100000.00 (capital demo)
+
+Totaux calculés (validation):
+
+- Total Actif (BZ) N = 132266.00
+- Total Passif (DZ) N = 132266.00
+- Delta (Actif - Passif) N = 0.00

api/admin.py

@@ -1,7 +1,16 @@
 from django.contrib import admin
 from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
 from django.utils.html import format_html
-from .models import User, Product, Transaction, Budget, Ad, AIInsight
+from .models import (
+    User,
+    Product,
+    Transaction,
+    Budget,
+    Ad,
+    AIInsight,
+    SyscohadaCRMappingRule,
+    SyscohadaBilanBalance,
+)
 
 
 @admin.register(AIInsight)
@@ -245,4 +254,20 @@ class AdAdmin(admin.ModelAdmin):
 # Personnalisation du site admin
 admin.site.site_header = "Akompta AI Administration"
 admin.site.site_title = "Akompta Admin"
-admin.site.index_title = "Bienvenue sur l'administration Akompta"
+admin.site.index_title = "Bienvenue sur l'administration Akompta"
+
+
+@admin.register(SyscohadaCRMappingRule)
+class SyscohadaCRMappingRuleAdmin(admin.ModelAdmin):
+    list_display = ["user", "ref", "tx_type", "match_mode", "priority", "is_active", "updated_at"]
+    list_filter = ["is_active", "tx_type", "match_mode", "ref"]
+    search_fields = ["user__email", "ref", "category_pattern", "name_pattern"]
+    ordering = ["priority", "-updated_at"]
+
+
+@admin.register(SyscohadaBilanBalance)
+class SyscohadaBilanBalanceAdmin(admin.ModelAdmin):
+    list_display = ["user", "year", "section", "ref", "brut", "amort", "net", "updated_at"]
+    list_filter = ["year", "section", "ref"]
+    search_fields = ["user__email", "ref", "note"]
+    ordering = ["-year", "section", "ref"]

api/groq_service.py

@@ -1,11 +1,16 @@
 import os
 import json
 from pathlib import Path
-from groq import Groq
-from django.conf import settings
+
 
 class GroqService:
     def __init__(self):
+        # Import lazy to keep the backend runnable even if the Groq SDK isn't installed
+        try:
+            from groq import Groq  # type: ignore
+        except Exception:
+            Groq = None  # type: ignore
+
         # Try to load from environment first
         self.api_key = os.environ.get("GROQ_API_KEY")
         
@@ -23,8 +28,13 @@ class GroqService:
         if not self.api_key or self.api_key == 'your-groq-api-key-here':
             # Note: We fallback to 'your-groq-api-key-here' to avoid crashing if it's in .env as a placeholder
             print("Warning: GROQ_API_KEY not found or invalid.")
-        
-        self.client = Groq(api_key=self.api_key)
+
+        if Groq is None:
+            print("Warning: Groq SDK not installed (pip install groq).")
+            self.client = None
+        else:
+            self.client = Groq(api_key=self.api_key)
+
         self.model = "whisper-large-v3-turbo"
 
     def transcribe(self, audio_file, language=None):
@@ -32,6 +42,8 @@ class GroqService:
         Transcribe audio file using Groq's Whisper API.
         audio_file can be a file-like object or a path.
         """
+        if not self.client:
+            return None
         try:
             # Groq expects a file object or a tuple (filename, content, content_type)
             # For Django's UploadedFile, passing (file.name, file.read()) works best
@@ -64,6 +76,8 @@ class GroqService:
         """
         Process text command using Groq's LLM models.
         """
+        if not self.client:
+            return None
         if context_products is None:
             context_products = []
             
@@ -87,6 +101,11 @@ class GroqService:
         Inventory Context (Existing Products):
         {json.dumps(context_products)}
         
+        IMPORTANT DATE RULE:
+        - The model does NOT know today's date and MUST NOT invent dates.
+        - Always set "date" to null unless the user explicitly mentions a date.
+        - Even if the user does NOT mention a date, do NOT default to any day/month/year.
+
         Return ONLY a JSON object with this EXACT structure:
         
         If intent is 'create_transaction':
@@ -99,7 +118,7 @@ class GroqService:
                 "currency": "FCFA",
                 "category": "Descriptive category",
                 "name": "Descriptive name",
-                "date": "YYYY-MM-DD"
+                "date": "YYYY-MM-DD" or null
             }}
         }}
 
@@ -134,3 +153,43 @@ class GroqService:
         except Exception as e:
             print(f"Error calling Groq LLM ({model}): {e}")
             return None
+
+    def process_insights(self, context_data, model="llama-3.1-8b-instant"):
+        """
+        Génère 3 insights courts (FR) à partir d'un contexte JSON.
+        Retourne une liste de 3 strings ou None en cas d'échec.
+        """
+        if not self.client:
+            return None
+
+        system_prompt = (
+            "Tu es un analyste financier expert pour l'application Akompta. "
+            "À partir des données JSON (transactions, produits, budgets, etc.), "
+            "génère exactement 3 insights courts (1 phrase chacun) en Français:\n"
+            "1) Observation sur ventes/revenus\n"
+            "2) Observation sur dépenses\n"
+            "3) Alerte stock ou recommandation\n"
+            "Réponds uniquement en JSON avec la structure: "
+            '{ "insights": ["...", "...", "..."] }'
+        )
+
+        try:
+            chat_completion = self.client.chat.completions.create(
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": json.dumps(context_data, ensure_ascii=False)},
+                ],
+                model=model,
+                response_format={"type": "json_object"},
+                temperature=0.2,
+            )
+            result_text = chat_completion.choices[0].message.content
+            data = json.loads(result_text)
+            insights = data.get("insights") if isinstance(data, dict) else None
+            if not isinstance(insights, list):
+                return None
+            items = [str(x).strip() for x in insights if str(x).strip()]
+            return items[:3]
+        except Exception as e:
+            print(f"Error calling Groq for insights: {e}")
+            return None

api/management/commands/fix_dates.py

@@ -0,0 +1,59 @@
+"""
+Commande Django pour corriger les dates de transaction erronées.
+Usage: python manage.py fix_dates
+
+Corrige toutes les transactions dont le champ `date` (envoyé par le client)
+est décalé de plus de 180 jours par rapport à `created_at` (serveur).
+Cela arrive quand l'horloge de l'appareil client est incorrecte.
+"""
+
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+from datetime import timedelta
+from api.models import Transaction
+
+
+class Command(BaseCommand):
+    help = "Corrige les dates de transaction client erronées (horloge appareil décalée)"
+
+    def handle(self, *args, **options):
+        fixed_count = 0
+        now = timezone.now()
+
+        transactions = Transaction.objects.all()
+
+        for tx in transactions:
+            try:
+                created_at = tx.created_at
+                tx_date = tx.date
+                if not created_at or not tx_date:
+                    continue
+
+                delta_days = abs((tx_date - created_at).days)
+                if delta_days > 180:
+                    old_date = tx.date
+                    tx.date = created_at
+                    tx.save(update_fields=["date"])
+                    fixed_count += 1
+                    self.stdout.write(
+                        f"  CORRIGÉ  Transaction #{tx.id} "
+                        f"'({tx.name})': {old_date.strftime('%Y-%m-%d')} -> "
+                        f"{created_at.strftime('%Y-%m-%d')}"
+                    )
+            except Exception as e:
+                self.stdout.write(
+                    self.style.WARNING(f"  ERREUR Transaction #{tx.id}: {e}")
+                )
+
+        self.stdout.write("")
+        if fixed_count > 0:
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"{fixed_count} transaction(s) corrigée(s). "
+                    "Les dates client ont été remplacées par les dates serveur (created_at)."
+                )
+            )
+        else:
+            self.stdout.write(
+                self.style.SUCCESS("Aucune transaction à corriger.")
+            )

api/management/commands/syscohada_audit.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+import csv
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+
+from django.core.management.base import BaseCommand, CommandError
+from django.utils import timezone
+
+from api.models import User
+from api.syscohada_reports import (
+    compute_compte_resultat,
+    generate_bilan_csv,
+    generate_compte_resultat_csv,
+)
+
+
+def _to_decimal(value: str | None) -> Decimal:
+    s = (value or "").strip()
+    if s == "":
+        return Decimal("0")
+    # CSV exports are produced with Decimal -> str, so '.' is expected.
+    try:
+        return Decimal(s)
+    except InvalidOperation:
+        # tolerate commas in pasted files
+        return Decimal(s.replace(",", "."))
+
+
+@dataclass(frozen=True)
+class DiffItem:
+    ref: str
+    field: str
+    expected: Decimal
+    actual: Decimal
+
+
+class Command(BaseCommand):
+    help = "Audit SYSCOHADA exports vs DB calculations (CR + Bilan) for one user and year."
+
+    def add_arguments(self, parser):
+        parser.add_argument("--email", required=True, help="User email to audit (ex: gini@gmail.com)")
+        parser.add_argument("--year", type=int, default=timezone.now().year, help="Exercise year (default: current year)")
+        parser.add_argument("--cr-csv", default="", help="Path to compte_resultat_syscohada_<year>.csv to compare")
+        parser.add_argument("--bilan-csv", default="", help="Path to bilan_syscohada_<year>.csv to compare")
+        parser.add_argument(
+            "--out-md",
+            default="",
+            help="Optional output markdown path. Default: backend/Documentation/syscohada_audit_<year>_<email>.md",
+        )
+
+    def handle(self, *args, **options):
+        email: str = options["email"]
+        year: int = options["year"]
+        cr_csv_path = (options["cr_csv"] or "").strip()
+        bilan_csv_path = (options["bilan_csv"] or "").strip()
+        out_md_path = (options["out_md"] or "").strip()
+
+        try:
+            user = User.objects.get(email=email)
+        except User.DoesNotExist as e:
+            raise CommandError(f"User not found: {email}") from e
+
+        compte = compute_compte_resultat(user, year)
+
+        expected_cr_bytes = generate_compte_resultat_csv(compte)
+        expected_bilan_bytes = generate_bilan_csv(user, compte)
+
+        expected_cr = self._parse_cr_bytes(expected_cr_bytes)
+        expected_bilan = self._parse_bilan_bytes(expected_bilan_bytes)
+
+        diffs: list[DiffItem] = []
+
+        actual_cr = None
+        if cr_csv_path:
+            actual_cr = self._parse_cr_file(Path(cr_csv_path))
+            diffs.extend(self._diff_maps(expected_cr, actual_cr, fields=["MONTANT_N", "MONTANT_N_1"]))
+
+        actual_bilan = None
+        if bilan_csv_path:
+            actual_bilan = self._parse_bilan_file(Path(bilan_csv_path))
+            diffs.extend(
+                self._diff_bilan(expected_bilan, actual_bilan)
+            )
+
+        if not out_md_path:
+            safe_email = email.replace("@", "_at_").replace(".", "_")
+            out_md_path = str(Path("backend/Documentation") / f"syscohada_audit_{year}_{safe_email}.md")
+
+        out_path = Path(out_md_path)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(
+            self._render_md(
+                email=email,
+                year=year,
+                user_id=user.id,
+                initial_balance=user.initial_balance,
+                compte=compte,
+                cr_csv_path=cr_csv_path,
+                bilan_csv_path=bilan_csv_path,
+                diffs=diffs,
+                compared_cr=bool(actual_cr),
+                compared_bilan=bool(actual_bilan),
+            ),
+            encoding="utf-8",
+        )
+
+        if diffs:
+            self.stdout.write(self.style.ERROR(f"Mismatch: {len(diffs)} difference(s). Report: {out_path}"))
+        else:
+            self.stdout.write(self.style.SUCCESS(f"OK: exports match calculations. Report: {out_path}"))
+
+    def _parse_cr_bytes(self, data: bytes) -> dict[str, dict[str, Decimal]]:
+        text = data.decode("utf-8")
+        return self._parse_cr_rows(csv.DictReader(text.splitlines()))
+
+    def _parse_cr_file(self, path: Path) -> dict[str, dict[str, Decimal]]:
+        if not path.exists():
+            raise CommandError(f"File not found: {path}")
+        with path.open("r", encoding="utf-8", newline="") as f:
+            return self._parse_cr_rows(csv.DictReader(f))
+
+    def _parse_cr_rows(self, reader: csv.DictReader) -> dict[str, dict[str, Decimal]]:
+        out: dict[str, dict[str, Decimal]] = {}
+        for row in reader:
+            ref = (row.get("REF") or "").strip()
+            if not ref:
+                continue
+            out[ref] = {
+                "MONTANT_N": _to_decimal(row.get("MONTANT_N")),
+                "MONTANT_N_1": _to_decimal(row.get("MONTANT_N_1")),
+            }
+        return out
+
+    def _parse_bilan_bytes(self, data: bytes) -> dict[tuple[str, str], dict[str, Decimal]]:
+        text = data.decode("utf-8")
+        return self._parse_bilan_rows(csv.DictReader(text.splitlines()))
+
+    def _parse_bilan_file(self, path: Path) -> dict[tuple[str, str], dict[str, Decimal]]:
+        if not path.exists():
+            raise CommandError(f"File not found: {path}")
+        with path.open("r", encoding="utf-8", newline="") as f:
+            return self._parse_bilan_rows(csv.DictReader(f))
+
+    def _parse_bilan_rows(self, reader: csv.DictReader) -> dict[tuple[str, str], dict[str, Decimal]]:
+        out: dict[tuple[str, str], dict[str, Decimal]] = {}
+        for row in reader:
+            section = (row.get("SECTION") or "").strip().upper()
+            ref = (row.get("REF") or "").strip()
+            if not section or not ref:
+                continue
+            out[(section, ref)] = {
+                "BRUT": _to_decimal(row.get("BRUT")),
+                "AMORT/DEPREC": _to_decimal(row.get("AMORT/DEPREC")),
+                "NET_N": _to_decimal(row.get("NET_N")),
+                "NET_N_1": _to_decimal(row.get("NET_N_1")),
+            }
+        return out
+
+    def _diff_maps(
+        self,
+        expected: dict[str, dict[str, Decimal]],
+        actual: dict[str, dict[str, Decimal]],
+        *,
+        fields: list[str],
+    ) -> list[DiffItem]:
+        diffs: list[DiffItem] = []
+        all_refs = sorted(set(expected.keys()) | set(actual.keys()))
+        for ref in all_refs:
+            e = expected.get(ref, {})
+            a = actual.get(ref, {})
+            for field in fields:
+                ev = e.get(field, Decimal("0"))
+                av = a.get(field, Decimal("0"))
+                if ev != av:
+                    diffs.append(DiffItem(ref=ref, field=field, expected=ev, actual=av))
+        return diffs
+
+    def _diff_bilan(
+        self,
+        expected: dict[tuple[str, str], dict[str, Decimal]],
+        actual: dict[tuple[str, str], dict[str, Decimal]],
+    ) -> list[DiffItem]:
+        diffs: list[DiffItem] = []
+        keys = sorted(set(expected.keys()) | set(actual.keys()))
+        for key in keys:
+            e = expected.get(key, {})
+            a = actual.get(key, {})
+            section, ref = key
+            for field in ["BRUT", "AMORT/DEPREC", "NET_N", "NET_N_1"]:
+                ev = e.get(field, Decimal("0"))
+                av = a.get(field, Decimal("0"))
+                if ev != av:
+                    diffs.append(DiffItem(ref=f"{section}:{ref}", field=field, expected=ev, actual=av))
+        return diffs
+
+    def _render_md(
+        self,
+        *,
+        email: str,
+        year: int,
+        user_id: int,
+        initial_balance: Decimal,
+        compte,
+        cr_csv_path: str,
+        bilan_csv_path: str,
+        diffs: list[DiffItem],
+        compared_cr: bool,
+        compared_bilan: bool,
+    ) -> str:
+        lines: list[str] = []
+        lines.append(f"# SYSCOHADA Audit — {email} — {year}")
+        lines.append("")
+        lines.append("## Contexte")
+        lines.append(f"- User id: `{user_id}`")
+        lines.append(f"- Solde initial (`initial_balance`): `{initial_balance}`")
+        lines.append(f"- Transactions non mappées N: `{len(compte.unmapped_tx_ids_n)}`")
+        lines.append(f"- Transactions non mappées N-1: `{len(compte.unmapped_tx_ids_n_1)}`")
+        lines.append("")
+        lines.append("## Sources comparées")
+        lines.append(f"- CR CSV fourni: `{cr_csv_path or '—'}`")
+        lines.append(f"- Bilan CSV fourni: `{bilan_csv_path or '—'}`")
+        lines.append("")
+        lines.append("## Résultat")
+        if not compared_cr and not compared_bilan:
+            lines.append("- Aucun fichier fourni pour comparaison. Le rapport décrit uniquement les calculs attendus.")
+        elif diffs:
+            lines.append(f"- Statut: **Mismatch** ({len(diffs)} différence(s))")
+        else:
+            lines.append("- Statut: **Match** (les exports correspondent aux calculs DB)")
+        lines.append("")
+
+        lines.append("## Calculs (DB)")
+        lines.append(f"- Total revenus N: `{compte.total_income_n}`")
+        lines.append(f"- Total dépenses N: `{compte.total_expense_n}`")
+        lines.append(f"- Résultat net N (XI): `{compte.resultat_net_n}`")
+        lines.append("")
+
+        if diffs:
+            lines.append("## Détails des différences")
+            lines.append("")
+            lines.append("| Ref | Champ | Attendu | Généré |")
+            lines.append("|---|---:|---:|---:|")
+            for d in diffs[:300]:
+                lines.append(f"| `{d.ref}` | `{d.field}` | `{d.expected}` | `{d.actual}` |")
+            if len(diffs) > 300:
+                lines.append("")
+                lines.append(f"_Diffs tronquées: {len(diffs) - 300} lignes supplémentaires._")
+            lines.append("")
+
+        lines.append("## Notes")
+        lines.append("- Les montants attendus sont calculés via `compute_compte_resultat()` + `generate_bilan_csv()`.")
+        lines.append("- Si les exports fournis sont à zéro, vérifier: année des transactions, `initial_balance`, et règles de mapping CR.")
+        lines.append("")
+        return "\n".join(lines)
+

api/migrations/0006_syscohada_mapping_and_balances.py

@@ -0,0 +1,76 @@
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("api", "0005_user_initial_balance"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="SyscohadaCRMappingRule",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("ref", models.CharField(max_length=4)),
+                ("tx_type", models.CharField(blank=True, choices=[("income", "Revenu"), ("expense", "Dépense")], max_length=10, null=True)),
+                ("category_pattern", models.CharField(blank=True, default="", max_length=255)),
+                ("name_pattern", models.CharField(blank=True, default="", max_length=255)),
+                ("match_mode", models.CharField(choices=[("contains", "Contient"), ("regex", "Regex")], default="contains", max_length=20)),
+                ("priority", models.PositiveIntegerField(default=100)),
+                ("is_active", models.BooleanField(default=True)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("user", models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name="syscohada_cr_rules", to="api.user")),
+            ],
+            options={
+                "verbose_name": "Règle SYSCOHADA (CR)",
+                "verbose_name_plural": "Règles SYSCOHADA (CR)",
+                "ordering": ["priority", "-updated_at", "-id"],
+            },
+        ),
+        migrations.CreateModel(
+            name="SyscohadaBilanBalance",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("year", models.PositiveIntegerField()),
+                ("section", models.CharField(choices=[("ACTIF", "Actif"), ("PASSIF", "Passif")], max_length=10)),
+                ("ref", models.CharField(max_length=4)),
+                ("brut", models.DecimalField(blank=True, decimal_places=2, max_digits=15, null=True)),
+                ("amort", models.DecimalField(blank=True, decimal_places=2, max_digits=15, null=True)),
+                ("net", models.DecimalField(blank=True, decimal_places=2, max_digits=15, null=True)),
+                ("note", models.CharField(blank=True, default="", max_length=50)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("user", models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name="syscohada_bilan_balances", to="api.user")),
+            ],
+            options={
+                "verbose_name": "Solde SYSCOHADA (Bilan)",
+                "verbose_name_plural": "Soldes SYSCOHADA (Bilan)",
+                "ordering": ["year", "section", "ref"],
+                "unique_together": {("user", "year", "section", "ref")},
+            },
+        ),
+        migrations.AddIndex(
+            model_name="syscohadacrmappingrule",
+            index=models.Index(fields=["user", "is_active", "priority"], name="api_syscoh_user_id_ea86a0_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="syscohadacrmappingrule",
+            index=models.Index(fields=["user", "tx_type"], name="api_syscoh_user_id_83c3af_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="syscohadacrmappingrule",
+            index=models.Index(fields=["user", "ref"], name="api_syscoh_user_id_03664d_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="syscohadabilanbalance",
+            index=models.Index(fields=["user", "year", "section"], name="api_syscoh_user_id_8bc49d_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="syscohadabilanbalance",
+            index=models.Index(fields=["user", "year", "ref"], name="api_syscoh_user_id_824e07_idx"),
+        ),
+    ]
+

api/models.py

@@ -295,4 +295,104 @@ class AIInsight(models.Model):
 
     def __str__(self):
         return f"Insight pour {self.user.email} - {self.created_at}"
-        
+
+
+class SyscohadaCRMappingRule(models.Model):
+    """
+    Règle de mapping Transaction -> Compte de résultat SYSCOHADA (ref).
+
+    Objectif: rendre le calcul traçable et configurable par utilisateur.
+    Le moteur tente d'appliquer la règle la plus prioritaire qui match
+    (type + catégorie/nom via contains ou regex).
+    """
+
+    MATCH_MODE_CHOICES = [
+        ("contains", "Contient"),
+        ("regex", "Regex"),
+    ]
+
+    TX_TYPE_CHOICES = [
+        ("income", "Revenu"),
+        ("expense", "Dépense"),
+    ]
+
+    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name="syscohada_cr_rules")
+
+    # Référence SYSCOHADA (ex: TA, TC, RA, RG, RH, RJ, ...)
+    ref = models.CharField(max_length=4)
+
+    # Optionnel: limiter aux revenus/dépenses
+    tx_type = models.CharField(max_length=10, choices=TX_TYPE_CHOICES, blank=True, null=True)
+
+    # Champs sur lesquels matcher
+    category_pattern = models.CharField(max_length=255, blank=True, default="")
+    name_pattern = models.CharField(max_length=255, blank=True, default="")
+    match_mode = models.CharField(max_length=20, choices=MATCH_MODE_CHOICES, default="contains")
+
+    # Plus petit = plus prioritaire
+    priority = models.PositiveIntegerField(default=100)
+    is_active = models.BooleanField(default=True)
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        verbose_name = "Règle SYSCOHADA (CR)"
+        verbose_name_plural = "Règles SYSCOHADA (CR)"
+        ordering = ["priority", "-updated_at", "-id"]
+        indexes = [
+            models.Index(fields=["user", "is_active", "priority"]),
+            models.Index(fields=["user", "tx_type"]),
+            models.Index(fields=["user", "ref"]),
+        ]
+
+    def __str__(self):
+        return f"{self.user.email} -> {self.ref} (prio {self.priority})"
+
+
+class SyscohadaBilanBalance(models.Model):
+    """
+    Soldes SYSCOHADA saisis/importés (bilan) par utilisateur et exercice.
+
+    Important:
+    - Akompta n'ayant pas (encore) une comptabilité en partie double,
+      beaucoup de postes du bilan doivent être saisis (ou importés).
+    - Le système auto-calcule BS (trésorerie) et CJ (résultat net) à partir
+      des transactions + compte de résultat.
+    """
+
+    SECTION_CHOICES = [
+        ("ACTIF", "Actif"),
+        ("PASSIF", "Passif"),
+    ]
+
+    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name="syscohada_bilan_balances")
+    year = models.PositiveIntegerField()
+    section = models.CharField(max_length=10, choices=SECTION_CHOICES)
+
+    # Référence SYSCOHADA (ex: BS, BI, CA, DJ, ...)
+    ref = models.CharField(max_length=4)
+
+    # Actif: BRUT/AMORT pour calculer NET. Passif: NET uniquement.
+    brut = models.DecimalField(max_digits=15, decimal_places=2, blank=True, null=True)
+    amort = models.DecimalField(max_digits=15, decimal_places=2, blank=True, null=True)
+    net = models.DecimalField(max_digits=15, decimal_places=2, blank=True, null=True)
+
+    note = models.CharField(max_length=50, blank=True, default="")
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        verbose_name = "Solde SYSCOHADA (Bilan)"
+        verbose_name_plural = "Soldes SYSCOHADA (Bilan)"
+        ordering = ["year", "section", "ref"]
+        unique_together = ["user", "year", "section", "ref"]
+        indexes = [
+            models.Index(fields=["user", "year", "section"]),
+            models.Index(fields=["user", "year", "ref"]),
+        ]
+
+    def __str__(self):
+        return f"{self.user.email} {self.year} {self.section} {self.ref}"
+        

api/serializers.py

@@ -2,7 +2,16 @@ from rest_framework import serializers
 from django.contrib.auth import get_user_model
 from django.contrib.auth.password_validation import validate_password
 from django.utils import timezone
-from .models import Product, Transaction, Budget, Ad, Notification, SupportTicket
+from .models import (
+    Product,
+    Transaction,
+    Budget,
+    Ad,
+    Notification,
+    SupportTicket,
+    SyscohadaCRMappingRule,
+    SyscohadaBilanBalance,
+)
 
 User = get_user_model()
 
@@ -127,6 +136,39 @@ class TransactionSerializer(serializers.ModelSerializer):
             'currency', 'created_at', 'updated_at'
         ]
         read_only_fields = ['id', 'created_at', 'updated_at']
+
+    def validate_date(self, value):
+        """
+        Protège contre les horloges clients incorrectes.
+
+        Compare la date envoyée par le client avec `created_at` (serveur)
+        si la transaction existe déjà, sinon avec `timezone.now()`.
+
+        Si l'écart dépasse 180 jours, on remplace par la date serveur de
+        référence (created_at / timezone.now).
+
+        Override possible: passer `?allow_backdate=1` sur la requête.
+        """
+        request = self.context.get("request")
+        if request and request.query_params.get("allow_backdate") == "1":
+            return value
+
+        # Utiliser created_at (serveur) comme référence si disponible
+        reference = (
+            self.instance.created_at
+            if self.instance and self.instance.created_at
+            else timezone.now()
+        )
+
+        try:
+            delta_days = abs((value - reference).days)
+        except Exception:
+            return reference
+
+        if delta_days > 180:
+            return reference
+
+        return value
     
     def create(self, validated_data):
         validated_data['user'] = self.context['request'].user
@@ -246,4 +288,48 @@ class SupportTicketSerializer(serializers.ModelSerializer):
     
     def create(self, validated_data):
         validated_data['user'] = self.context['request'].user
-        return super().create(validated_data)
+        return super().create(validated_data)
+
+
+class SyscohadaCRMappingRuleSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SyscohadaCRMappingRule
+        fields = [
+            "id",
+            "ref",
+            "tx_type",
+            "category_pattern",
+            "name_pattern",
+            "match_mode",
+            "priority",
+            "is_active",
+            "created_at",
+            "updated_at",
+        ]
+        read_only_fields = ["id", "created_at", "updated_at"]
+
+    def create(self, validated_data):
+        validated_data["user"] = self.context["request"].user
+        return super().create(validated_data)
+
+
+class SyscohadaBilanBalanceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SyscohadaBilanBalance
+        fields = [
+            "id",
+            "year",
+            "section",
+            "ref",
+            "brut",
+            "amort",
+            "net",
+            "note",
+            "created_at",
+            "updated_at",
+        ]
+        read_only_fields = ["id", "created_at", "updated_at"]
+
+    def create(self, validated_data):
+        validated_data["user"] = self.context["request"].user
+        return super().create(validated_data)

api/syscohada_reports.py

@@ -10,6 +10,7 @@ from decimal import Decimal
 from pathlib import Path
 from typing import Any
 
+from django.db import models
 from django.utils import timezone
 
 from .models import Transaction, User
@@ -33,34 +34,132 @@ def _normalize_text(value: str | None) -> str:
     return (value or "").strip().lower()
 
 
-def _map_transaction_to_cr_ref(tx: Transaction) -> str:
+def _pick_effective_datetime(tx: Transaction) -> datetime:
     """
-    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.
+    Choisit la date "effective" d'une transaction pour les rapports.
+
+    Contexte: certains clients envoient une `date` incorrecte (ex: horloge appareil en 2024)
+    alors que `created_at` (serveur) est correcte (2026).
+
+    Règle:
+    - si l'écart absolu entre `date` et `created_at` dépasse 180 jours,
+      on utilise `created_at` comme date effective.
+    - sinon on conserve `date`.
+    """
+    try:
+        created_at = tx.created_at
+        tx_date = tx.date
+        if created_at and tx_date:
+            delta_days = abs((tx_date - created_at).days)
+            if delta_days > 180:
+                return created_at
+        return tx_date
+    except Exception:
+        return tx.date
+
+
+def _in_year_bounds(tx: Transaction, start: datetime, end: datetime) -> bool:
+    eff = _pick_effective_datetime(tx)
+    return start <= eff < end
+
+
+def _map_transaction_to_cr_ref_from_user_rules(user: User, tx: Transaction) -> tuple[str | None, bool]:
+    """
+    Map via règles utilisateur (priorité) si disponibles.
+    Retourne: (ref|None, matched_via_rule)
+    """
+    from .models import SyscohadaCRMappingRule
+
+    try:
+        rules = SyscohadaCRMappingRule.objects.filter(user=user, is_active=True).order_by("priority", "-updated_at", "-id")
+    except Exception:
+        # Si les migrations ne sont pas appliquées ou table absente, ignorer les règles
+        return None, False
+    if not rules.exists():
+        return None, False
+
+    category = _normalize_text(getattr(tx, "category", ""))
+    name = _normalize_text(getattr(tx, "name", ""))
+
+    for rule in rules:
+        if rule.tx_type and rule.tx_type != tx.type:
+            continue
+
+        cat_pat = (rule.category_pattern or "").strip()
+        name_pat = (rule.name_pattern or "").strip()
+
+        # Wildcard rule (no patterns) is allowed for explicit fallbacks
+        if rule.match_mode == "contains":
+            ok_cat = True if not cat_pat else _normalize_text(cat_pat) in category
+            ok_name = True if not name_pat else _normalize_text(name_pat) in name
+            if ok_cat and ok_name:
+                return rule.ref, True
+        else:  # regex
+            ok_cat = True
+            ok_name = True
+            try:
+                if cat_pat:
+                    ok_cat = re.search(cat_pat, category, flags=re.IGNORECASE) is not None
+                if name_pat:
+                    ok_name = re.search(name_pat, name, flags=re.IGNORECASE) is not None
+            except re.error:
+                # Si regex invalide: ignorer la règle (robustesse)
+                continue
+
+            if ok_cat and ok_name:
+                return rule.ref, True
+
+    return None, False
+
+
+def _map_transaction_to_cr_ref_default(tx: Transaction) -> str | None:
+    """
+    Mapping "par défaut" (sans règles utilisateur) basé sur mots-clés.
+    Retourne None si aucune catégorie n'est reconnue (=> transaction non mappée).
     """
     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"]):
+        if any(k in haystack for k in ["service", "prestation", "consult", "honoraire"]):
+            return "TC"  # travaux / services vendus
+        if any(k in haystack for k in ["accessoire"]):
             return "TD"
-        return "TA"  # ventes de marchandises
+        if any(k in haystack for k in ["vente", "ventes", "marchandise", "produit", "produits"]):
+            return "TA"
+        return None
 
     # expense
-    if any(k in haystack for k in ["achat", "marchandise", "appro", "approvisionnement"]):
+    if any(k in haystack for k in ["achat", "achats", "marchandise", "appro", "approvisionnement", "fournisseur"]):
         return "RA"
-    if any(k in haystack for k in ["transport", "taxi", "bus", "essence", "carburant", "livraison"]):
+    if any(k in haystack for k in ["transport", "taxi", "bus", "essence", "carburant", "livraison", "deplacement", "déplacement"]):
         return "RG"
-    if any(k in haystack for k in ["loyer", "internet", "eau", "electric", "électric", "telephone", "téléphone", "prestataire", "maintenance", "marketing", "publicit", "pub"]):
+    if any(
+        k in haystack
+        for k in [
+            "loyer",
+            "internet",
+            "eau",
+            "electric",
+            "électric",
+            "telephone",
+            "téléphone",
+            "prestataire",
+            "maintenance",
+            "marketing",
+            "publicit",
+            "publicité",
+            "pub",
+            "assurance",
+        ]
+    ):
         return "RH"
-    if any(k in haystack for k in ["impot", "impôt", "taxe", "douane", "etat", "état"]):
+    if any(k in haystack for k in ["impot", "impôt", "taxe", "douane", "etat", "état", "tva"]):
         return "RI"
-    if any(k in haystack for k in ["salaire", "salaires", "personnel", "paie", "payroll"]):
+    if any(k in haystack for k in ["salaire", "salaires", "personnel", "paie", "payroll", "prime"]):
         return "RK"
-    return "RJ"
+    return None
 
 
 _CR_TOKEN_RE = re.compile(r"([A-Z]{1,2})|([+-])")
@@ -96,6 +195,8 @@ class CompteResultatComputed:
     total_expense_n: Decimal
     total_income_n_1: Decimal
     total_expense_n_1: Decimal
+    unmapped_tx_ids_n: list[int]
+    unmapped_tx_ids_n_1: list[int]
 
 
 def compute_compte_resultat(user: User, year: int) -> CompteResultatComputed:
@@ -105,26 +206,43 @@ def compute_compte_resultat(user: User, year: int) -> CompteResultatComputed:
     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",
-    )
+    # Important: include both date- and created_at-based windows, then decide per-row
+    # to handle device clock issues (date far from created_at).
+    tx_candidates_n = Transaction.objects.filter(
+        user=user,
+    ).filter(
+        (models.Q(date__gte=start_n, date__lt=end_n))
+        | (models.Q(created_at__gte=start_n, created_at__lt=end_n))
+    ).only("id", "amount", "type", "category", "name", "date", "created_at")
+
+    tx_candidates_n_1 = Transaction.objects.filter(
+        user=user,
+    ).filter(
+        (models.Q(date__gte=start_n_1, date__lt=end_n_1))
+        | (models.Q(created_at__gte=start_n_1, created_at__lt=end_n_1))
+    ).only("id", "amount", "type", "category", "name", "date", "created_at")
+
+    tx_n = [tx for tx in tx_candidates_n if _in_year_bounds(tx, start_n, end_n)]
+    tx_n_1 = [tx for tx in tx_candidates_n_1 if _in_year_bounds(tx, start_n_1, end_n_1)]
 
     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}
+    unmapped_tx_ids_n: list[int] = []
+    unmapped_tx_ids_n_1: list[int] = []
 
     total_income_n = Decimal("0")
     total_expense_n = Decimal("0")
     for tx in tx_n:
-        ref = _map_transaction_to_cr_ref(tx)
+        ref, matched_via_rule = _map_transaction_to_cr_ref_from_user_rules(user, tx)
+        if not ref:
+            ref = _map_transaction_to_cr_ref_default(tx)
+            if not ref:
+                unmapped_tx_ids_n.append(tx.id)
+                ref = "RJ"  # Divers / fallback (si présent dans le template)
+        if ref not in values_n:
+            # ref inconnue => fallback RJ + marquer unmapped
+            unmapped_tx_ids_n.append(tx.id)
+            ref = "RJ"
         amount = Decimal(tx.amount)
         values_n[ref] = values_n.get(ref, Decimal("0")) + amount
         if tx.type == "income":
@@ -135,7 +253,15 @@ def compute_compte_resultat(user: User, year: int) -> CompteResultatComputed:
     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)
+        ref, matched_via_rule = _map_transaction_to_cr_ref_from_user_rules(user, tx)
+        if not ref:
+            ref = _map_transaction_to_cr_ref_default(tx)
+            if not ref:
+                unmapped_tx_ids_n_1.append(tx.id)
+                ref = "RJ"
+        if ref not in values_n_1:
+            unmapped_tx_ids_n_1.append(tx.id)
+            ref = "RJ"
         amount = Decimal(tx.amount)
         values_n_1[ref] = values_n_1.get(ref, Decimal("0")) + amount
         if tx.type == "income":
@@ -165,9 +291,150 @@ def compute_compte_resultat(user: User, year: int) -> CompteResultatComputed:
         total_expense_n=total_expense_n,
         total_income_n_1=total_income_n_1,
         total_expense_n_1=total_expense_n_1,
+        unmapped_tx_ids_n=unmapped_tx_ids_n,
+        unmapped_tx_ids_n_1=unmapped_tx_ids_n_1,
     )
 
 
+def compute_bilan_values(user: User, year: int, compte: CompteResultatComputed) -> dict[str, object]:
+    """
+    Calcule les valeurs du bilan (Actif/Passif) en combinant:
+    - soldes saisis/importés (SyscohadaBilanBalance)
+    - auto-calc: BS (trésorerie) et CJ (résultat net)
+
+    Retourne une structure JSON-friendly utilisable par preview + export.
+    """
+    from .models import SyscohadaBilanBalance
+
+    structure = _load_template_json("bilan_structure.json")
+    actif: list[dict[str, Any]] = structure["actif"]
+    passif: list[dict[str, Any]] = structure["passif"]
+
+    # Load user balances for N and N-1 (support colonnes N et N-1)
+    try:
+        # Force evaluation inside try: sqlite can raise "no such table" only at iteration time.
+        balances_n = list(SyscohadaBilanBalance.objects.filter(user=user, year=year))
+        balances_n_1 = list(SyscohadaBilanBalance.objects.filter(user=user, year=year - 1))
+    except Exception:
+        # Table absente / migrations non appliquées: fallback sans soldes saisis
+        balances_n = []
+        balances_n_1 = []
+
+    def split_balances(qs):
+        actif_bal: dict[str, dict[str, Decimal]] = {}
+        passif_bal: dict[str, Decimal] = {}
+        for b in qs:
+            if b.section == "ACTIF":
+                actif_bal[b.ref] = {
+                    "brut": Decimal(b.brut or 0),
+                    "amort": Decimal(b.amort or 0),
+                }
+            else:
+                passif_bal[b.ref] = Decimal(b.net or 0)
+        return actif_bal, passif_bal
+
+    actif_bal_n, passif_bal_n = split_balances(balances_n)
+    actif_bal_n_1, passif_bal_n_1 = split_balances(balances_n_1)
+
+    # Auto-calc BS (cash) for N and N-1
+    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
+
+    actif_bal_n["BS"] = {"brut": Decimal(cash_n), "amort": Decimal("0")}
+    actif_bal_n_1["BS"] = {"brut": Decimal(cash_n_1), "amort": Decimal("0")}
+
+    # Auto-calc CJ (resultat net) in passif (if template contains CJ)
+    passif_bal_n["CJ"] = Decimal(compte.resultat_net_n)
+    # For N-1 we use computed XI if present; otherwise 0
+    passif_bal_n_1["CJ"] = Decimal(compte.values_n_1.get("XI", Decimal("0")))
+
+    # Compute totals (validation): TOTAL ACTIF (BZ) vs TOTAL PASSIF (DZ)
+    def compute_totals_for(
+        actif_bal: dict[str, dict[str, Decimal]],
+        passif_bal: dict[str, Decimal],
+        cash: Decimal,
+        resultat: Decimal,
+    ) -> dict[str, str]:
+        brut: dict[str, Decimal] = {item["ref"]: Decimal("0") for item in actif}
+        amort: dict[str, Decimal] = {item["ref"]: Decimal("0") for item in actif}
+        for ref, v in actif_bal.items():
+            brut[ref] = Decimal(v.get("brut", 0))
+            amort[ref] = Decimal(v.get("amort", 0))
+
+        brut["BS"] = Decimal(cash)
+        amort["BS"] = Decimal("0")
+
+        net_passif: dict[str, Decimal] = {item["ref"]: Decimal("0") for item in passif}
+        for ref, v in passif_bal.items():
+            net_passif[ref] = Decimal(v)
+        net_passif["CJ"] = Decimal(resultat)
+
+        def net_for(ref: str) -> Decimal:
+            return brut.get(ref, Decimal("0")) - amort.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"))
+
+        # Compute totals based on formulas (only '+' is expected in these bilan totals)
+        def parse_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_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"))
+
+        passif_meta: dict[str, dict[str, Any]] = {item["ref"]: item for item in passif}
+
+        def signed_passif_value(ref: str) -> Decimal:
+            val = net_passif.get(ref, Decimal("0"))
+            meta = passif_meta.get(ref, {})
+            if meta.get("is_negative"):
+                return -val
+            return val
+
+        for item in passif:
+            if not item.get("is_total"):
+                continue
+            parts = parse_sum_formula(item.get("formula", ""))
+            net_passif[item["ref"]] = sum((signed_passif_value(p) for p in parts), Decimal("0"))
+
+        total_actif = net_for("BZ")
+        total_passif = signed_passif_value("DZ")
+        delta = total_actif - total_passif
+        return {
+            "total_actif": str(total_actif),
+            "total_passif": str(total_passif),
+            "delta": str(delta),
+        }
+
+    totals_n = compute_totals_for(actif_bal_n, passif_bal_n, cash_n, compte.resultat_net_n)
+    totals_n_1 = compute_totals_for(actif_bal_n_1, passif_bal_n_1, cash_n_1, passif_bal_n_1["CJ"])
+
+    return {
+        "year": year,
+        "auto": {
+            "BS": {"net_n": str(cash_n), "net_n_1": str(cash_n_1)},
+            "CJ": {"net_n": str(compte.resultat_net_n), "net_n_1": str(passif_bal_n_1["CJ"])},
+        },
+        "totals": {"n": totals_n, "n_1": totals_n_1},
+        "actif": {ref: {"brut": str(v["brut"]), "amort": str(v["amort"])} for ref, v in actif_bal_n.items()},
+        "passif": {ref: str(v) for ref, v in passif_bal_n.items()},
+        "actif_n_1": {ref: {"brut": str(v["brut"]), "amort": str(v["amort"])} for ref, v in actif_bal_n_1.items()},
+        "passif_n_1": {ref: str(v) for ref, v in passif_bal_n_1.items()},
+    }
+
+
 def generate_compte_resultat_csv(compte: CompteResultatComputed) -> bytes:
     structure = _load_template_json("compte_resultat_structure.json")
     lignes: list[dict[str, Any]] = structure["lignes"]
@@ -193,26 +460,53 @@ 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
+    from .models import SyscohadaBilanBalance
 
     # 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_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}
+
+    # Passif values stored by ref: NET_N, NET_N_1
+    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}
+
+    # 1) Load user-provided balances (N and N-1) (optional)
+    try:
+        # Force evaluation inside try: sqlite can raise "no such table" only at iteration time.
+        balances_n = list(SyscohadaBilanBalance.objects.filter(user=user, year=compte.year))
+        balances_n_1 = list(SyscohadaBilanBalance.objects.filter(user=user, year=compte.year - 1))
+    except Exception:
+        balances_n = []
+        balances_n_1 = []
+
+    for b in balances_n:
+        if b.section == "ACTIF":
+            brut[b.ref] = Decimal(b.brut or 0)
+            amort[b.ref] = Decimal(b.amort or 0)
+        else:
+            net_passif_n[b.ref] = Decimal(b.net or 0)
+
+    for b in balances_n_1:
+        if b.section == "ACTIF":
+            brut_n_1[b.ref] = Decimal(b.brut or 0)
+            amort_n_1[b.ref] = Decimal(b.amort or 0)
+        else:
+            net_passif_n_1[b.ref] = Decimal(b.net or 0)
 
+    # 2) Auto-calc: cash (BS) + result (CJ)
+    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
     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")
 
+    net_passif_n["CJ"] = Decimal(compte.resultat_net_n)
+    net_passif_n_1["CJ"] = Decimal(compte.values_n_1.get("XI", Decimal("0")))
+
     def net_for(ref: str) -> Decimal:
         return brut.get(ref, Decimal("0")) - amort.get(ref, Decimal("0"))
 
@@ -245,16 +539,7 @@ def generate_bilan_csv(user: User, compte: CompteResultatComputed) -> bytes:
         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
+    # Notes: CA (capital) et autres postes doivent venir des soldes saisis/importés.
 
     def signed_passif_value(values: dict[str, Decimal], ref: str) -> Decimal:
         val = values.get(ref, Decimal("0"))
@@ -310,4 +595,3 @@ def generate_bilan_csv(user: User, compte: CompteResultatComputed) -> bytes:
         )
 
     return out.getvalue().encode("utf-8")
-

api/tests_syscohada.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from datetime import datetime
+from decimal import Decimal
+
+from django.test import TestCase
+from django.utils import timezone
+
+from .models import (
+    Transaction,
+    User,
+    SyscohadaCRMappingRule,
+    SyscohadaBilanBalance,
+)
+from .syscohada_reports import compute_compte_resultat, generate_bilan_csv, generate_compte_resultat_csv
+from .serializers import TransactionSerializer
+
+
+class SyscohadaComputationTests(TestCase):
+    def setUp(self):
+        self.user = User.objects.create_user(
+            email="syscohada@test.com",
+            password="pass12345",
+            first_name="Sys",
+            last_name="Coha",
+            account_type="personal",
+            initial_balance=Decimal("1000.00"),
+            agreed_terms=True,
+        )
+
+    def _dt(self, year: int, month: int, day: int):
+        return timezone.make_aware(datetime(year, month, day, 12, 0, 0))
+
+    def test_compte_resultat_marks_unmapped_transactions(self):
+        # Year N
+        tx_income = Transaction.objects.create(
+            user=self.user,
+            name="Vente marchandises",
+            amount=Decimal("5000.00"),
+            type="income",
+            category="Ventes",
+            date=self._dt(2026, 2, 2),
+            currency="XOF",
+        )
+        tx_transport = Transaction.objects.create(
+            user=self.user,
+            name="Taxi",
+            amount=Decimal("200.00"),
+            type="expense",
+            category="Transport",
+            date=self._dt(2026, 2, 3),
+            currency="XOF",
+        )
+        tx_unknown = Transaction.objects.create(
+            user=self.user,
+            name="Dépense inconnue",
+            amount=Decimal("50.00"),
+            type="expense",
+            category="Inconnu",
+            date=self._dt(2026, 2, 4),
+            currency="XOF",
+        )
+
+        compte = compute_compte_resultat(self.user, 2026)
+
+        # TA should include the income (default mapping sees "ventes")
+        self.assertGreaterEqual(compte.values_n.get("TA", Decimal("0")), Decimal("5000.00"))
+
+        # RG should include transport
+        self.assertGreaterEqual(compte.values_n.get("RG", Decimal("0")), Decimal("200.00"))
+
+        # Unknown should be marked as unmapped (and goes to RJ fallback)
+        self.assertIn(tx_unknown.id, compte.unmapped_tx_ids_n)
+        self.assertGreaterEqual(compte.values_n.get("RJ", Decimal("0")), Decimal("50.00"))
+
+        # If we add an explicit rule, it should stop being "unmapped"
+        SyscohadaCRMappingRule.objects.create(
+            user=self.user,
+            ref="RH",
+            tx_type="expense",
+            category_pattern="Inconnu",
+            match_mode="contains",
+            priority=1,
+            is_active=True,
+        )
+        compte2 = compute_compte_resultat(self.user, 2026)
+        self.assertNotIn(tx_unknown.id, compte2.unmapped_tx_ids_n)
+        self.assertGreaterEqual(compte2.values_n.get("RH", Decimal("0")), Decimal("50.00"))
+
+    def test_bilan_can_balance_with_user_inputs(self):
+        # Create a simple year with net profit
+        Transaction.objects.create(
+            user=self.user,
+            name="Vente",
+            amount=Decimal("1000.00"),
+            type="income",
+            category="Ventes",
+            date=self._dt(2026, 1, 10),
+            currency="XOF",
+        )
+        Transaction.objects.create(
+            user=self.user,
+            name="Transport",
+            amount=Decimal("100.00"),
+            type="expense",
+            category="Transport",
+            date=self._dt(2026, 1, 11),
+            currency="XOF",
+        )
+
+        compte = compute_compte_resultat(self.user, 2026)
+        cash = self.user.initial_balance + compte.total_income_n - compte.total_expense_n
+        resultat = compte.resultat_net_n
+
+        # Provide capital so that: CA + CJ == BS (minimal bilan)
+        SyscohadaBilanBalance.objects.create(
+            user=self.user,
+            year=2026,
+            section="PASSIF",
+            ref="CA",
+            net=(cash - resultat),
+            note="Capital (test)",
+        )
+
+        bilan_csv = generate_bilan_csv(self.user, compte).decode("utf-8")
+        # Sanity: contains key refs
+        self.assertIn("ACTIF,BS", bilan_csv)
+        self.assertIn("PASSIF,CA", bilan_csv)
+        self.assertIn("PASSIF,CJ", bilan_csv)
+
+    def test_exports_generate_csv_bytes(self):
+        Transaction.objects.create(
+            user=self.user,
+            name="Vente",
+            amount=Decimal("100.00"),
+            type="income",
+            category="Ventes",
+            date=self._dt(2026, 3, 1),
+            currency="XOF",
+        )
+        compte = compute_compte_resultat(self.user, 2026)
+        cr_csv = generate_compte_resultat_csv(compte)
+        bilan_csv = generate_bilan_csv(self.user, compte)
+        self.assertIsInstance(cr_csv, (bytes, bytearray))
+        self.assertIsInstance(bilan_csv, (bytes, bytearray))
+        self.assertGreater(len(cr_csv), 50)
+        self.assertGreater(len(bilan_csv), 50)
+
+    def test_uses_created_at_when_transaction_date_is_way_off(self):
+        """
+        If client sends a wrong `date` (ex: device clock in 2024) but the server-side
+        `created_at` is in 2026, SYSCOHADA calculations should include it in 2026.
+        """
+        tx = Transaction.objects.create(
+            user=self.user,
+            name="Vente (bad date)",
+            amount=Decimal("100.00"),
+            type="income",
+            category="Ventes",
+            date=self._dt(2024, 3, 16),  # wrong
+            currency="XOF",
+        )
+        # Force created_at to 2026 (simulate real server record time)
+        Transaction.objects.filter(id=tx.id).update(created_at=self._dt(2026, 5, 17))
+
+        compte = compute_compte_resultat(self.user, 2026)
+        self.assertGreaterEqual(compte.values_n.get("TA", Decimal("0")), Decimal("100.00"))
+
+    def test_transaction_serializer_clamps_bad_client_dates(self):
+        # Date far away (client clock wrong) should be clamped to "now" by default.
+        payload = {
+            "name": "Bad date tx",
+            "amount": "100.00",
+            "type": "income",
+            "category": "Ventes",
+            "currency": "XOF",
+            "date": self._dt(2024, 3, 16).isoformat().replace("+00:00", "Z"),
+        }
+
+        class _Req:
+            query_params = {}
+            user = self.user
+
+        serializer = TransactionSerializer(data=payload, context={"request": _Req()})
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        value = serializer.validated_data["date"]
+        now = timezone.now()
+        self.assertLessEqual(abs((value - now).days), 1)

api/urls.py

@@ -6,6 +6,7 @@ from .views import (
     RegisterView, LoginView, ProfileView, ChangePasswordView,
     ProductViewSet, TransactionViewSet, BudgetViewSet, AdViewSet,
     NotificationViewSet, SupportTicketViewSet, VoiceCommandView, AIInsightsView,
+    SyscohadaCRMappingRuleViewSet, SyscohadaBilanBalanceViewSet, SyscohadaReportsPreviewView,
     SyscohadaReportsDownloadView,
     analytics_overview, analytics_breakdown, analytics_kpi, analytics_activity,
     analytics_balance_history
@@ -19,6 +20,8 @@ router.register(r'budgets', BudgetViewSet, basename='budget')
 router.register(r'ads', AdViewSet, basename='ad')
 router.register(r'notifications', NotificationViewSet, basename='notification')
 router.register(r'support', SupportTicketViewSet, basename='support')
+router.register(r'syscohada/cr-rules', SyscohadaCRMappingRuleViewSet, basename='syscohada-cr-rule')
+router.register(r'syscohada/bilan-balances', SyscohadaBilanBalanceViewSet, basename='syscohada-bilan-balance')
 
 urlpatterns = [
     # ===== AUTH =====
@@ -43,5 +46,6 @@ urlpatterns = [
     path('ai-insights/', AIInsightsView.as_view(), name='ai-insights'),
 
     # ===== REPORTS (SYSCOHADA) =====
+    path('reports/syscohada/preview/', SyscohadaReportsPreviewView.as_view(), name='syscohada-preview'),
     path('reports/syscohada/download/', SyscohadaReportsDownloadView.as_view(), name='syscohada-download'),
 ]

api/views.py

@@ -16,21 +16,30 @@ import json
 from django.http import HttpResponse
 from django.conf import settings
 
-from .models import Product, Transaction, Budget, Ad, Notification, SupportTicket, AIInsight
+from .models import (
+    Product,
+    Transaction,
+    Budget,
+    Ad,
+    Notification,
+    SupportTicket,
+    AIInsight,
+    SyscohadaCRMappingRule,
+    SyscohadaBilanBalance,
+)
 from .serializers import (
     UserSerializer, RegisterSerializer, ChangePasswordSerializer,
     ProductSerializer, TransactionSerializer, TransactionSummarySerializer,
     BudgetSerializer, AdSerializer, OverviewAnalyticsSerializer,
     BreakdownAnalyticsSerializer, KPISerializer, ActivityAnalyticsSerializer,
-    BalanceHistorySerializer, NotificationSerializer, SupportTicketSerializer
+    BalanceHistorySerializer, NotificationSerializer, SupportTicketSerializer,
+    SyscohadaCRMappingRuleSerializer, SyscohadaBilanBalanceSerializer,
 )
-from .gemini_service import GeminiService
-from .groq_service import GroqService
-from .assemblyai_service import AssemblyAIService
 import tempfile
 import os
 import io
 import zipfile
+import re
 
 User = get_user_model()
 
@@ -586,22 +595,94 @@ class SupportTicketViewSet(viewsets.ModelViewSet):
     def perform_create(self, serializer):
         serializer.save(user=self.request.user)
 
+class SyscohadaCRMappingRuleViewSet(viewsets.ModelViewSet):
+    """CRUD des règles de mapping SYSCOHADA (Compte de résultat)"""
+
+    serializer_class = SyscohadaCRMappingRuleSerializer
+    permission_classes = [IsAuthenticated]
+    filter_backends = [filters.SearchFilter, filters.OrderingFilter]
+    search_fields = ["ref", "category_pattern", "name_pattern"]
+    ordering_fields = ["priority", "updated_at", "created_at"]
+    ordering = ["priority", "-updated_at"]
+
+    def get_queryset(self):
+        return SyscohadaCRMappingRule.objects.filter(user=self.request.user).order_by("priority", "-updated_at", "-id")
+
+
+class SyscohadaBilanBalanceViewSet(viewsets.ModelViewSet):
+    """CRUD des soldes SYSCOHADA (Bilan)"""
+
+    serializer_class = SyscohadaBilanBalanceSerializer
+    permission_classes = [IsAuthenticated]
+    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
+    filterset_fields = ["year", "section"]
+    search_fields = ["ref", "note"]
+    ordering_fields = ["year", "section", "ref", "updated_at"]
+    ordering = ["-year", "section", "ref"]
+
+    def get_queryset(self):
+        return SyscohadaBilanBalance.objects.filter(user=self.request.user).order_by("-year", "section", "ref", "-id")
+
+
+class SyscohadaReportsPreviewView(APIView):
+    """
+    Prévisualisation (debug/validation) des calculs SYSCOHADA.
+    Retourne: valeurs CR + bilan + liste des transactions non mappées.
+    """
+
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request):
+        from .syscohada_reports import (
+            compute_compte_resultat,
+            compute_bilan_values,
+        )
+
+        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)
+        bilan = compute_bilan_values(request.user, year, compte)
+        return Response(
+            {
+                "year": year,
+                "compte_resultat": {
+                    "values_n": {k: str(v) for k, v in compte.values_n.items()},
+                    "values_n_1": {k: str(v) for k, v in compte.values_n_1.items()},
+                    "unmapped_tx_ids_n": compte.unmapped_tx_ids_n,
+                    "unmapped_tx_ids_n_1": compte.unmapped_tx_ids_n_1,
+                    "resultat_net_n": str(compte.resultat_net_n),
+                },
+                "bilan": bilan,
+            }
+        )
+
 
 # ========== VOICE AI ==========
 
 class VoiceCommandView(APIView):
-    """Traitement des commandes vocales via Gemini"""
+    """Traitement des commandes vocales (STT + LLM) via Groq (et AssemblyAI STT en primaire)."""
     permission_classes = [IsAuthenticated]
     
     def post(self, request):
+        # Lazy imports to avoid hard dependency issues in environments where optional AI SDKs are not installed.
+        from .groq_service import GroqService
+        from .assemblyai_service import AssemblyAIService
+
         audio_file = request.FILES.get('audio')
         text_command = request.data.get('text')
+        client_datetime = request.data.get('client_datetime')
+        client_tz_offset_minutes = request.data.get('client_tz_offset_minutes')
         
         if not audio_file and not text_command:
             return Response({'error': 'No audio file or text command provided'}, status=status.HTTP_400_BAD_REQUEST)
             
         try:
-            service = GeminiService()
             
             # Fetch user products for context
             user_products = Product.objects.filter(user=request.user)
@@ -630,7 +711,7 @@ class VoiceCommandView(APIView):
                     debug_url = f"{request.build_absolute_uri(settings.MEDIA_URL)}debug_voice/{debug_filename}"
                     print(f"DEBUG AUDIO SAVED: {debug_path}")
                     
-                    # Important: Réinitialiser le curseur après la sauvegarde pour Groq/Gemini
+                    # Important: Réinitialiser le curseur après la sauvegarde
                     audio_file.seek(0)
                 except Exception as e:
                     print(f"Error saving debug audio: {e}")
@@ -669,18 +750,24 @@ class VoiceCommandView(APIView):
                         result = groq_service.process_text_command(transcription, context_products=products_list, model="llama-3.1-8b-instant")
                     
                     if not result:
-                        # Final resort: Gemini
-                        print("All Groq LLMs failed, falling back to Gemini...")
-                        gemini_service = GeminiService()
-                        result = gemini_service.process_text_command(transcription, context_products=products_list)
+                        return Response(
+                            {
+                                "status": "error",
+                                "transcription": transcription,
+                                "message": "Traitement LLM échoué (Groq).",
+                                "debug_audio_url": debug_url,
+                            },
+                            status=status.HTTP_502_BAD_GATEWAY,
+                        )
                 else:
-                    # Fallback 2: Gemini's native voice processing
-                    print("All STT services failed, falling back to Gemini native voice command")
-                    audio_file.seek(0)
-                    audio_bytes = audio_file.read()
-                    mime_type = audio_file.content_type or 'audio/mp3'
-                    gemini_service = GeminiService()
-                    result = gemini_service.process_voice_command(audio_bytes, mime_type, context_products=products_list)
+                    return Response(
+                        {
+                            "status": "error",
+                            "message": "Transcription audio échouée (AssemblyAI + Groq).",
+                            "debug_audio_url": debug_url,
+                        },
+                        status=status.HTTP_502_BAD_GATEWAY,
+                    )
             else:
                 # Direct text command processing with the same chain
                 groq_service = GroqService()
@@ -692,32 +779,85 @@ class VoiceCommandView(APIView):
                     result = groq_service.process_text_command(text_command, context_products=products_list, model="llama-3.1-8b-instant")
                 
                 if not result:
-                    print("All Groq LLMs failed, falling back to Gemini...")
-                    gemini_service = GeminiService()
-                    result = gemini_service.process_text_command(text_command, context_products=products_list)
+                    return Response(
+                        {
+                            "status": "error",
+                            "transcription": text_command,
+                            "message": "Traitement LLM échoué (Groq).",
+                        },
+                        status=status.HTTP_502_BAD_GATEWAY,
+                    )
             
             print(f"VoiceCommandView - Result Intent: {result.get('intent')}")
             
             if result.get('intent') == 'create_transaction':
                 data = result.get('data', {})
                 print(f"VoiceCommandView - Transaction Data: {data}")
-                
-                # Ensure date is a full datetime string for TransactionSerializer
-                raw_date = data.get('date')
-                final_datetime = timezone.now() # Already aware if USE_TZ=True
-                
-                if raw_date:
+
+                transcription_text = result.get('transcription', '') or ''
+                final_datetime = timezone.now()  # fallback
+
+                # Prefer client-side timestamp (real user time) over server time.
+                # This avoids timezone mismatches and prevents AI from ever influencing the saved date.
+                def parse_client_dt(value, offset_minutes):
+                    if not value:
+                        return None
                     try:
-                        # If AI gives YYYY-MM-DD, combine with current time
-                        parsed_date = datetime.strptime(raw_date, '%Y-%m-%d').date()
-                        # Make sure we create an aware datetime to avoid warnings
-                        naive_dt = datetime.combine(parsed_date, timezone.now().time())
-                        final_datetime = timezone.make_aware(naive_dt)
-                    except:
-                        pass
+                        s = str(value).strip()
+                        # Support ISO strings ending with Z
+                        if s.endswith('Z'):
+                            s = s[:-1] + '+00:00'
+                        dt = datetime.fromisoformat(s)
+
+                        # If timezone-aware, normalize to UTC
+                        if dt.tzinfo is not None:
+                            return dt.astimezone(timezone.utc)
+
+                        # If naive, use explicit offset minutes (JS: minutes to add to local to get UTC)
+                        if offset_minutes is None or str(offset_minutes).strip() == '':
+                            return timezone.make_aware(dt, timezone=timezone.utc)
+                        off = int(offset_minutes)
+                        dt_utc = dt + timedelta(minutes=off)
+                        return timezone.make_aware(dt_utc, timezone=timezone.utc)
+                    except Exception:
+                        return None
+
+                client_dt = parse_client_dt(client_datetime, client_tz_offset_minutes)
+                if client_dt:
+                    final_datetime = client_dt
+
+                # Deterministic date parsing (explicit user dates only), WITHOUT letting the LLM decide.
+                # Base reference: client_dt if provided, otherwise server now.
+                # Supported:
+                # - keywords: aujourd'hui, hier (FR)
+                # - YYYY-MM-DD
+                # - DD/MM/YYYY or DD-MM-YYYY
+                lower_t = transcription_text.lower()
+                base_dt = client_dt or timezone.now()
+
+                if "hier" in lower_t:
+                    final_datetime = base_dt - timedelta(days=1)
+                elif "aujourd" in lower_t:
+                    final_datetime = base_dt
+                else:
+                    m_iso = re.search(r"\b(\d{4})-(\d{2})-(\d{2})\b", transcription_text)
+                    m_fr = re.search(r"\b(\d{2})[/-](\d{2})[/-](\d{4})\b", transcription_text)
+                    try:
+                        if m_iso:
+                            y, mo, d = int(m_iso.group(1)), int(m_iso.group(2)), int(m_iso.group(3))
+                            parsed_date = datetime(y, mo, d).date()
+                            # Keep time from base_dt to preserve "when" in user's local time
+                            naive_dt = datetime.combine(parsed_date, base_dt.time())
+                            final_datetime = timezone.make_aware(naive_dt) if naive_dt.tzinfo is None else naive_dt
+                        elif m_fr:
+                            d, mo, y = int(m_fr.group(1)), int(m_fr.group(2)), int(m_fr.group(3))
+                            parsed_date = datetime(y, mo, d).date()
+                            naive_dt = datetime.combine(parsed_date, base_dt.time())
+                            final_datetime = timezone.make_aware(naive_dt) if naive_dt.tzinfo is None else naive_dt
+                    except Exception:
+                        final_datetime = base_dt
                 
                 # Prepare naming with fallback to transcription
-                transcription_text = result.get('transcription', '')
                 default_name = (transcription_text[:20] + '...') if len(transcription_text) > 20 else transcription_text
                 
                 transaction_data = {
@@ -801,10 +941,13 @@ class VoiceCommandView(APIView):
 
 
 class AIInsightsView(APIView):
-    """Génération d'insights financiers via Gemini avec mise en mémoire en base de données"""
+    """Génération d'insights financiers via Groq avec mise en mémoire en base de données"""
     permission_classes = [IsAuthenticated]
     
     def post(self, request):
+        # Lazy import: Groq SDK may be optional depending on deployment.
+        from .groq_service import GroqService
+
         context_data = request.data.get('context', {})
         
         # Calculer un hash du contexte pour détecter les changements
@@ -821,8 +964,10 @@ class AIInsightsView(APIView):
             return Response({'insights': existing_insight.content, 'cached': True})
         
         try:
-            service = GeminiService()
+            service = GroqService()
             insights = service.process_insights(context_data)
+            if not insights:
+                raise RuntimeError("Groq insights generation failed")
             
             # Sauvegarder le nouvel insight
             AIInsight.objects.create(
@@ -838,7 +983,18 @@ 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)
+            # Fallback ultime (sans IA) pour ne pas casser le dashboard
+            return Response(
+                {
+                    "insights": [
+                        "Analyse des ventes en cours...",
+                        "Vérification des dépenses...",
+                        "Recommandation: surveillez vos postes récurrents et votre trésorerie.",
+                    ],
+                    "cached": False,
+                    "error_fallback": str(e),
+                }
+            )
 
 
 class SyscohadaReportsDownloadView(APIView):

backend/Documentation/syscohada_audit_2026_ginni_at_gmail_com.md

@@ -0,0 +1,23 @@
+# SYSCOHADA Audit — ginni@gmail.com — 2026
+
+## Contexte
+- User id: `5`
+- Solde initial (`initial_balance`): `0.00`
+- Transactions non mappées N: `0`
+- Transactions non mappées N-1: `0`
+
+## Sources comparées
+- CR CSV fourni: `—`
+- Bilan CSV fourni: `—`
+
+## Résultat
+- Aucun fichier fourni pour comparaison. Le rapport décrit uniquement les calculs attendus.
+
+## Calculs (DB)
+- Total revenus N: `0`
+- Total dépenses N: `0`
+- Résultat net N (XI): `0`
+
+## Notes
+- Les montants attendus sont calculés via `compute_compte_resultat()` + `generate_bilan_csv()`.
+- Si les exports fournis sont à zéro, vérifier: année des transactions, `initial_balance`, et règles de mapping CR.