Mise en place de la notion de perte définitive, ainsi que la révision avec statut Polongation

backend/src/routes/investissements.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import db from '../db/index.js';
 import { HttpError } from '../middleware/errorHandler.js';
 import { requireInvestisseur } from '../middleware/investisseurScope.js';
-import { generateSimul, generateSimulWithReinvestissements, monthsDiff } from '../utils/schedule.js';
+import { generateSimul, generateSimulWithReinvestissements, monthsDiff, adjustSimulForActuals, replayAdjustSimulForActuals } from '../utils/schedule.js';
 import { checkStatutsRetard } from '../jobs/autoStatut.js';
 
 const router = Router();
@@ -61,20 +61,53 @@ const RevisionSchema = z.object({
   message: 'Au moins un changement (nouveau taux ou nouvelle date cible) doit être renseigné',
 });
 
+// Déclaration d'une perte définitive de capital sur un investissement en_retard/procedure.
+// montant_perte est éditable (perte partielle possible si une partie du capital a déjà
+// été recouvrée) — préfilli côté frontend avec le capital restant dû, non recalculé ici.
+const PerteSchema = z.object({
+  date_effet:    z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  montant_perte: z.number().nonnegative(),
+  motif:         z.string().trim().min(1, 'Le motif est obligatoire'),
+});
+
 function regenererEcheancier(investissementId) {
+  const inv = db.prepare(`
+    SELECT id, montant_investi, taux_interet, duree_mois, type_remb, freq_interets,
+           date_premiere_echeance, date_debut_simul, date_souscription, echeance_fin_de_mois
+    FROM investissements WHERE id = ?
+  `).get(investissementId);
+  if (!inv) return;
+
   const hasReinvest = db.prepare(
     'SELECT 1 FROM reinvestissements WHERE investissement_id = ? LIMIT 1'
   ).get(investissementId);
   if (hasReinvest) {
     generateSimulWithReinvestissements(db, investissementId);
   } else {
-    const inv = db.prepare(`
-      SELECT id, montant_investi, taux_interet, duree_mois, type_remb, freq_interets,
-             date_premiere_echeance, date_debut_simul, date_souscription, echeance_fin_de_mois
-      FROM investissements WHERE id = ?
-    `).get(investissementId);
     generateSimul(db, inv);
   }
+
+  // generateSimul()/generateSimulWithReinvestissements() reconstruisent l'échéancier à partir
+  // du montant_investi ORIGINAL, sans connaître les remboursements anticipés partiels déjà
+  // effectués — il faut donc systématiquement réappliquer l'ajustement de capital réel après
+  // toute régénération, sous peine de l'écraser silencieusement :
+  //  - Restructuration (date_debut_simul renseigné, création d'une révision) : seules de
+  //    NOUVELLES échéances futures sont insérées, les échéances déjà honorées ("kept") sont
+  //    préservées telles quelles par generateSimul() lui-même -> un simple adjustSimulForActuals()
+  //    suffit à recalculer ces nouvelles échéances sur la base du capital réellement restant dû.
+  //  - Régénération complète (annulation d'une révision, ou toute autre modif hors
+  //    restructuration) : TOUT l'échéancier est réécrit à neuf -> adjustSimulForActuals() seul
+  //    ne peut PAS reconstruire l'historique (il ne recalcule que ce qui suit le DERNIER
+  //    remboursement connu, jamais une valeur intermédiaire déjà "gelée" par un remboursement
+  //    plus récent) -> il faut rejouer chronologiquement tout l'historique de remboursements
+  //    de capital anticipés via replayAdjustSimulForActuals().
+  // Bug découvert le 22/08/26 sur le dossier "L'Olympique" : l'annulation d'une révision avait
+  // effacé l'intégralité de l'ajustement de capital anticipé accumulé sur 18 échéances.
+  if (inv.date_debut_simul) {
+    adjustSimulForActuals(db, investissementId);
+  } else {
+    replayAdjustSimulForActuals(db, investissementId);
+  }
 }
 
 const Schema = z.object({
@@ -135,6 +168,8 @@ router.get('/', (req, res) => {
            (SELECT COALESCE(SUM(r.interets_nets),0)  FROM remboursements r WHERE r.investissement_id = i.id) AS interets_nets_total,
            (SELECT COALESCE(SUM(r.net_recu),0)       FROM remboursements r WHERE r.investissement_id = i.id) AS net_recu_total,
            (SELECT COALESCE(SUM(rv.montant),0)       FROM reinvestissements rv WHERE rv.investissement_id = i.id) AS reinvestissements_total,
+           (SELECT COALESCE(SUM(ip.montant_perte),0)    FROM investissement_pertes ip WHERE ip.investissement_id = i.id) AS capital_perdu,
+           (SELECT ip.date_effet FROM investissement_pertes ip WHERE ip.investissement_id = i.id ORDER BY ip.id DESC LIMIT 1) AS perte_date_effet,
            i.montant_investi + (SELECT COALESCE(SUM(rv.montant),0) FROM reinvestissements rv WHERE rv.investissement_id = i.id) AS capital_total
     FROM investissements i
     JOIN plateformes p ON p.id = i.plateforme_id
@@ -425,6 +460,9 @@ router.get('/:id', (req, res, next) => {
     const revisions = db.prepare(
       'SELECT * FROM investissement_revisions WHERE investissement_id = ? ORDER BY id ASC'
     ).all(req.params.id);
+    const pertes = db.prepare(
+      'SELECT * FROM investissement_pertes WHERE investissement_id = ? ORDER BY id ASC'
+    ).all(req.params.id);
     const reinvestissements = db.prepare(
       'SELECT * FROM reinvestissements WHERE investissement_id = ? ORDER BY date_reinvestissement'
     ).all(req.params.id);
@@ -445,7 +483,7 @@ router.get('/:id', (req, res, next) => {
       WHERE is2.investissement_id = ?
       ORDER BY is_global DESC, s.nom
     `).all(req.params.id);
-    res.json({ ...inv, capital_total, reinvestissements_total, remboursements, simul, historique, revisions, reinvestissements, categories_inv, secteurs_inv });
+    res.json({ ...inv, capital_total, reinvestissements_total, remboursements, simul, historique, revisions, pertes, reinvestissements, categories_inv, secteurs_inv });
   } catch (e) { next(e); }
 });
 
@@ -611,6 +649,10 @@ router.delete('/:id/historique/:hid', (req, res, next) => {
 // qui n'est qu'un champ d'affichage/contractuel). Donc si nouvelle_date_cible est fournie et
 // diffère de la date actuelle, duree_mois doit être recalculé en conséquence, sinon la
 // nouvelle date cible ne serait que cosmétique et l'échéancier généré ne la refléterait pas.
+//
+// Statut "Prolongation" : si la date cible change réellement sur un dossier en_retard/procedure,
+// le statut bascule automatiquement à 'prolongation' (sort temporairement du scope "à risque",
+// jusqu'à ce que jobs/autoStatut.js le repasse en_retard si la nouvelle échéance est dépassée).
 router.post('/:id/revisions', (req, res, next) => {
   try {
     const body = RevisionSchema.parse(req.body);
@@ -631,27 +673,41 @@ router.post('/:id/revisions', (req, res, next) => {
     // Recalcule duree_mois si la date cible change réellement, pour que l'échéancier régénéré
     // atteigne effectivement cette nouvelle date (cf. convention date_cible = date_premiere_echeance
     // + (duree_mois - 1) mois, utilisée côté frontend pour tous les types de prêt).
+    const dateChangee = nouvelle_date_cible !== ancienne_date_cible;
     let nouveau_duree_mois = ancien_duree_mois;
-    if (nouvelle_date_cible !== ancienne_date_cible && inv.date_premiere_echeance) {
+    if (dateChangee && inv.date_premiere_echeance) {
       nouveau_duree_mois = monthsDiff(inv.date_premiere_echeance, nouvelle_date_cible) + 1;
     }
 
+    // Statut "Prolongation" : uniquement quand la date cible change réellement ET que le
+    // dossier est actuellement en_retard/procedure (renégociation d'un prêt à risque). Un
+    // changement de taux seul, ou une révision sur un dossier en_cours, ne déclenche jamais
+    // ce statut — décision confirmée avec Olivier le 22/08/26. Le dossier sort ainsi
+    // temporairement du scope "à risque" jusqu'à ce que jobs/autoStatut.js le repasse en
+    // en_retard si la nouvelle date cible est à son tour dépassée sans remboursement.
+    const RISQUE_STATUTS = ['en_retard', 'procedure'];
+    const ancien_statut  = (dateChangee && RISQUE_STATUTS.includes(inv.statut)) ? inv.statut : null;
+    const nouveau_statut = ancien_statut ? 'prolongation' : null;
+
     let revisionId;
     const tx = db.transaction(() => {
       const r = db.prepare(`
         INSERT INTO investissement_revisions
           (investissement_id, date_effet, ancien_taux, nouveau_taux, ancienne_date_cible, nouvelle_date_cible,
-           ancien_duree_mois, nouveau_duree_mois, motif)
-        VALUES (?,?,?,?,?,?,?,?,?)
+           ancien_duree_mois, nouveau_duree_mois, ancien_statut, nouveau_statut, motif)
+        VALUES (?,?,?,?,?,?,?,?,?,?,?)
       `).run(invId, body.date_effet, ancien_taux, nouveau_taux, ancienne_date_cible, nouvelle_date_cible,
-        ancien_duree_mois, nouveau_duree_mois, body.motif);
+        ancien_duree_mois, nouveau_duree_mois, ancien_statut, nouveau_statut, body.motif);
       revisionId = r.lastInsertRowid;
 
+      // COALESCE(?, statut) : nouveau_statut est NULL quand la révision ne doit pas changer
+      // le statut (taux seul, dossier déjà sain…) — le statut courant est alors préservé.
       db.prepare(`
         UPDATE investissements
-        SET taux_interet = ?, date_cible = ?, duree_mois = ?, date_debut_simul = ?, updated_at = datetime('now')
+        SET taux_interet = ?, date_cible = ?, duree_mois = ?, date_debut_simul = ?,
+            statut = COALESCE(?, statut), updated_at = datetime('now')
         WHERE id = ?
-      `).run(nouveau_taux, nouvelle_date_cible, nouveau_duree_mois, body.date_effet, invId);
+      `).run(nouveau_taux, nouvelle_date_cible, nouveau_duree_mois, body.date_effet, nouveau_statut, invId);
 
       regenererEcheancier(invId);
     });
@@ -670,7 +726,7 @@ router.delete('/:id/revisions/:rid', (req, res, next) => {
   try {
     const invId = Number(req.params.id);
     const inv = db.prepare(`
-      SELECT i.id FROM investissements i
+      SELECT i.id, i.statut FROM investissements i
       JOIN investisseurs inv ON inv.id = i.investisseur_id
       WHERE i.id = ? AND inv.user_id = ?
     `).get(invId, req.user.id);
@@ -683,17 +739,25 @@ router.delete('/:id/revisions/:rid', (req, res, next) => {
       throw new HttpError(400, 'Seule la révision la plus récente peut être supprimée');
     }
 
+    // Ne restaure le statut que si rien ne l'a fait évoluer depuis cette révision (ex : le
+    // job autoStatut a déjà repassé le dossier en_retard entre-temps) — sinon on écraserait
+    // un état plus récent et légitime avec l'ancien statut de la révision annulée.
+    const statutRestore = (derniere.nouveau_statut && inv.statut === derniere.nouveau_statut)
+      ? derniere.ancien_statut
+      : null;
+
     const tx = db.transaction(() => {
       db.prepare(`
         UPDATE investissements
         SET taux_interet = ?, date_cible = ?, duree_mois = ?,
+            statut = COALESCE(?, statut),
             date_debut_simul = (
               SELECT date_effet FROM investissement_revisions
               WHERE investissement_id = ? AND id != ? ORDER BY id DESC LIMIT 1
             ),
             updated_at = datetime('now')
         WHERE id = ?
-      `).run(derniere.ancien_taux, derniere.ancienne_date_cible, derniere.ancien_duree_mois, invId, derniere.id, invId);
+      `).run(derniere.ancien_taux, derniere.ancienne_date_cible, derniere.ancien_duree_mois, statutRestore, invId, derniere.id, invId);
 
       db.prepare('DELETE FROM investissement_revisions WHERE id = ?').run(derniere.id);
 
@@ -705,6 +769,163 @@ router.delete('/:id/revisions/:rid', (req, res, next) => {
   } catch (e) { next(e); }
 });
 
+// PUT /api/investissements/:id/revisions/:rid
+// Corrige la révision la plus récente en place (même ligne d'historique conservée), plutôt que
+// de la supprimer puis d'en recréer une — évite un aller-retour et garde une trace stable dans
+// l'historique. ancien_taux/ancienne_date_cible/ancien_duree_mois restent figés sur l'état
+// D'AVANT CETTE RÉVISION (jamais modifiés par une correction) ; seuls les nouveau_* et le motif
+// sont mis à jour. Même contrainte que la suppression : seule la révision la plus récente peut
+// être corrigée, pour éviter un état incohérent si une révision intermédiaire était éditée.
+router.put('/:id/revisions/:rid', (req, res, next) => {
+  try {
+    const body = RevisionSchema.parse(req.body);
+    const invId = Number(req.params.id);
+    const inv = db.prepare(`
+      SELECT i.id, i.statut, i.date_premiere_echeance FROM investissements i
+      JOIN investisseurs inv ON inv.id = i.investisseur_id
+      WHERE i.id = ? AND inv.user_id = ?
+    `).get(invId, req.user.id);
+    if (!inv) throw new HttpError(404, 'Investissement introuvable');
+
+    const derniere = db.prepare(
+      'SELECT * FROM investissement_revisions WHERE investissement_id = ? ORDER BY id DESC LIMIT 1'
+    ).get(invId);
+    if (!derniere || derniere.id !== Number(req.params.rid)) {
+      throw new HttpError(400, 'Seule la révision la plus récente peut être corrigée');
+    }
+
+    // Baseline inchangée : l'état d'AVANT cette révision (jamais retouché par une correction).
+    const ancien_taux = derniere.ancien_taux;
+    const ancienne_date_cible = derniere.ancienne_date_cible;
+    const ancien_duree_mois = derniere.ancien_duree_mois;
+    const nouveau_taux = body.nouveau_taux ?? ancien_taux;
+    const nouvelle_date_cible = body.nouvelle_date_cible ?? ancienne_date_cible;
+
+    const dateChangee = nouvelle_date_cible !== ancienne_date_cible;
+    let nouveau_duree_mois = ancien_duree_mois;
+    if (dateChangee && inv.date_premiere_echeance) {
+      nouveau_duree_mois = monthsDiff(inv.date_premiere_echeance, nouvelle_date_cible) + 1;
+    }
+
+    // Statut : on rejoue le même raisonnement que POST/DELETE combinés — d'abord retrouver le
+    // statut d'avant l'effet de cette révision (sauf si autre chose l'a fait évoluer entre
+    // temps, ex. autoStatut), puis réévaluer si la version CORRIGÉE doit déclencher Prolongation.
+    const RISQUE_STATUTS = ['en_retard', 'procedure'];
+    const statutBase = (derniere.nouveau_statut && inv.statut === derniere.nouveau_statut)
+      ? derniere.ancien_statut
+      : inv.statut;
+    const ancien_statut  = (dateChangee && RISQUE_STATUTS.includes(statutBase)) ? statutBase : null;
+    const nouveau_statut = ancien_statut ? 'prolongation' : null;
+    const statutFinal    = nouveau_statut ?? statutBase;
+
+    const tx = db.transaction(() => {
+      db.prepare(`
+        UPDATE investissement_revisions
+        SET date_effet = ?, nouveau_taux = ?, nouvelle_date_cible = ?, nouveau_duree_mois = ?,
+            ancien_statut = ?, nouveau_statut = ?, motif = ?
+        WHERE id = ?
+      `).run(body.date_effet, nouveau_taux, nouvelle_date_cible, nouveau_duree_mois,
+        ancien_statut, nouveau_statut, body.motif, derniere.id);
+
+      db.prepare(`
+        UPDATE investissements
+        SET taux_interet = ?, date_cible = ?, duree_mois = ?, date_debut_simul = ?,
+            statut = ?, updated_at = datetime('now')
+        WHERE id = ?
+      `).run(nouveau_taux, nouvelle_date_cible, nouveau_duree_mois, body.date_effet, statutFinal, invId);
+
+      regenererEcheancier(invId);
+    });
+    tx();
+
+    const revision = db.prepare('SELECT * FROM investissement_revisions WHERE id = ?').get(derniere.id);
+    res.json(revision);
+  } catch (e) { next(e); }
+});
+
+// POST /api/investissements/:id/perte-definitive
+// Déclare qu'un investissement en_retard/procedure est définitivement perdu (irrécouvrable).
+// Le montant est renseigné explicitement (perte totale ou partielle si récupération partielle)
+// plutôt que recalculé côté serveur, pour laisser l'utilisateur ajuster au moment du constat.
+// Trace l'ancien statut dans investissement_pertes pour permettre une annulation propre.
+router.post('/:id/perte-definitive', (req, res, next) => {
+  try {
+    const body = PerteSchema.parse(req.body);
+    const invId = Number(req.params.id);
+    const inv = db.prepare(`
+      SELECT i.* FROM investissements i
+      JOIN investisseurs inv ON inv.id = i.investisseur_id
+      WHERE i.id = ? AND inv.user_id = ?
+    `).get(invId, req.user.id);
+    if (!inv) throw new HttpError(404, 'Investissement introuvable');
+    if (!['en_retard', 'procedure'].includes(inv.statut)) {
+      throw new HttpError(400, 'Seuls les dossiers "En retard" ou "Procédure" peuvent être déclarés en perte définitive');
+    }
+
+    let perteId;
+    const tx = db.transaction(() => {
+      const r = db.prepare(`
+        INSERT INTO investissement_pertes (investissement_id, date_effet, montant_perte, ancien_statut, motif)
+        VALUES (?,?,?,?,?)
+      `).run(invId, body.date_effet, body.montant_perte, inv.statut, body.motif);
+      perteId = r.lastInsertRowid;
+
+      db.prepare(`
+        UPDATE investissements SET statut = 'perte_definitive', updated_at = datetime('now') WHERE id = ?
+      `).run(invId);
+
+      recordHistory(invId, {
+        type_evenement: 'perte_definitive',
+        changements: [{ champ: 'statut', label: 'Statut', ancienne_valeur: inv.statut, nouvelle_valeur: 'perte_definitive' }],
+        notes: `Perte définitive déclarée (${body.montant_perte.toFixed(2)} €) : ${body.motif}`,
+      });
+    });
+    tx();
+
+    const perte = db.prepare('SELECT * FROM investissement_pertes WHERE id = ?').get(perteId);
+    res.status(201).json(perte);
+  } catch (e) { next(e); }
+});
+
+// DELETE /api/investissements/:id/perte-definitive
+// Annule la déclaration de perte la plus récente et restaure le statut précédent
+// (en_retard ou procédure) — le dossier redevient actif au sens fiscal/KPI.
+router.delete('/:id/perte-definitive', (req, res, next) => {
+  try {
+    const invId = Number(req.params.id);
+    const inv = db.prepare(`
+      SELECT i.* FROM investissements i
+      JOIN investisseurs inv ON inv.id = i.investisseur_id
+      WHERE i.id = ? AND inv.user_id = ?
+    `).get(invId, req.user.id);
+    if (!inv) throw new HttpError(404, 'Investissement introuvable');
+    if (inv.statut !== 'perte_definitive') {
+      throw new HttpError(400, "Ce dossier n'est pas déclaré en perte définitive");
+    }
+
+    const derniere = db.prepare(
+      'SELECT * FROM investissement_pertes WHERE investissement_id = ? ORDER BY id DESC LIMIT 1'
+    ).get(invId);
+    const statutRestaure = derniere?.ancien_statut || 'en_retard';
+
+    const tx = db.transaction(() => {
+      if (derniere) db.prepare('DELETE FROM investissement_pertes WHERE id = ?').run(derniere.id);
+      db.prepare(`
+        UPDATE investissements SET statut = ?, updated_at = datetime('now') WHERE id = ?
+      `).run(statutRestaure, invId);
+
+      recordHistory(invId, {
+        type_evenement: 'annulation_perte_definitive',
+        changements: [{ champ: 'statut', label: 'Statut', ancienne_valeur: 'perte_definitive', nouvelle_valeur: statutRestaure }],
+        notes: 'Annulation de la déclaration de perte définitive',
+      });
+    });
+    tx();
+
+    res.status(204).end();
+  } catch (e) { next(e); }
+});
+
 // PUT /api/investissements/:id/auto-reinvest  { active: true|false }
 router.put('/:id/auto-reinvest', (req, res, next) => {
   try {