Initial commit

2026-06-13 14:57:15 +02:00
commit 48ed7fe65e
209 changed files with 49979 additions and 0 deletions
@@ -0,0 +1,373 @@
+import { Router } from 'express';
+import bcrypt from 'bcryptjs';
+import { z } from 'zod';
+import db from '../db/index.js';
+import { HttpError } from '../middleware/errorHandler.js';
+import { checkStatutsRetard } from '../jobs/autoStatut.js';
+
+// ── Helpers similarité de noms ──────────────────────────────────────────── */
+
+/** Distance de Levenshtein entre deux chaînes */
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, (_, i) => [i, ...Array(n).fill(0)]);
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1]
+        ? dp[i - 1][j - 1]
+        : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+
+/** Similarité normalisée [0..1] — insensible à la casse et aux accents */
+function normalize(s) {
+  return (s || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().trim();
+}
+function similarity(a, b) {
+  const na = normalize(a), nb = normalize(b);
+  if (!na && !nb) return 1;
+  const maxLen = Math.max(na.length, nb.length);
+  return maxLen === 0 ? 1 : 1 - levenshtein(na, nb) / maxLen;
+}
+
+const SIMILARITY_THRESHOLD = 0.80;
+
+// Registre des jobs disponibles (nom → fonction synchrone)
+const JOBS = {
+  auto_statut_retard: checkStatutsRetard,
+};
+
+const router = Router();
+// requireAuth + requireAdmin sont appliqués dans server.js avant ce router
+
+/* ── Utilisateurs ─────────────────────────────────────────────────────── */
+
+/** Liste tous les utilisateurs */
+router.get('/users', (req, res) => {
+  const users = db.prepare(`
+    SELECT id, email, display_name, role, created_at
+    FROM users
+    ORDER BY id ASC
+  `).all();
+  res.json(users);
+});
+
+/** Crée un utilisateur */
+const CreateUserSchema = z.object({
+  email:       z.string().email(),
+  password:    z.string().min(8),
+  displayName: z.string().min(1).optional(),
+  role:        z.enum(['user', 'admin']).default('user'),
+});
+
+router.post('/users', (req, res, next) => {
+  try {
+    const body = CreateUserSchema.parse(req.body);
+    const exists = db.prepare('SELECT id FROM users WHERE email = ?').get(body.email);
+    if (exists) throw new HttpError(409, 'Email déjà utilisé');
+
+    const hash   = bcrypt.hashSync(body.password, 10);
+    const result = db
+      .prepare('INSERT INTO users (email, password_hash, display_name, role) VALUES (?, ?, ?, ?)')
+      .run(body.email, hash, body.displayName || null, body.role);
+
+    const userId   = result.lastInsertRowid;
+    const fullName = body.displayName || body.email.split('@')[0];
+    const prenom   = fullName.includes(' ') ? fullName.split(' ')[0] : null;
+    db.prepare(
+      `INSERT INTO investisseurs (user_id, nom, prenom, type, type_fiscal) VALUES (?, ?, ?, 'famille', 'PP')`
+    ).run(userId, fullName, prenom);
+
+    res.status(201).json({ id: userId, email: body.email, display_name: body.displayName || null, role: body.role });
+  } catch (e) { next(e); }
+});
+
+/** Modifie le rôle d'un utilisateur */
+const PatchRoleSchema = z.object({
+  role: z.enum(['user', 'admin']),
+});
+
+router.patch('/users/:id/role', (req, res, next) => {
+  try {
+    const { role } = PatchRoleSchema.parse(req.body);
+    const targetId = Number(req.params.id);
+
+    // Empêche un admin de se rétrograder lui-même
+    if (targetId === req.user.id && role !== 'admin') {
+      throw new HttpError(400, 'Vous ne pouvez pas vous rétrograder vous-même');
+    }
+
+    const r = db.prepare("UPDATE users SET role=?, updated_at=datetime('now') WHERE id=?")
+      .run(role, targetId);
+    if (r.changes === 0) throw new HttpError(404, 'Utilisateur introuvable');
+
+    res.json({ id: targetId, role });
+  } catch (e) { next(e); }
+});
+
+/** Supprime un utilisateur (sauf soi-même) */
+router.delete('/users/:id', (req, res, next) => {
+  try {
+    const targetId = Number(req.params.id);
+    if (targetId === req.user.id) {
+      throw new HttpError(400, 'Vous ne pouvez pas supprimer votre propre compte');
+    }
+    const r = db.prepare('DELETE FROM users WHERE id = ?').run(targetId);
+    if (r.changes === 0) throw new HttpError(404, 'Utilisateur introuvable');
+    res.status(204).end();
+  } catch (e) { next(e); }
+});
+
+/* ── Logs des jobs ────────────────────────────────────────────────────── */
+
+router.get('/job-logs', (req, res) => {
+  const limit  = Math.min(Number(req.query.limit)  || 100, 500);
+  const offset = Number(req.query.offset) || 0;
+  const job    = req.query.job || null;
+
+  const conds  = job ? 'WHERE job_name = ?' : '';
+  const params = job ? [job, limit, offset] : [limit, offset];
+
+  const rows = db.prepare(`
+    SELECT id, job_name, run_at, status, nb_changes, details, error_msg
+    FROM job_logs
+    ${conds}
+    ORDER BY run_at DESC
+    LIMIT ? OFFSET ?
+  `).all(...params);
+
+  const total = db.prepare(`SELECT COUNT(*) AS n FROM job_logs ${conds}`)
+    .get(...(job ? [job] : [])).n;
+
+  res.json({ total, rows });
+});
+
+/* ── Plateformes orphelines (sans référentiel) ───────────────────────── */
+
+/** Liste les plateformes user sans referentiel_id, avec suggestion de liaison si nom similaire */
+router.get('/plateformes-orphelines', (_req, res) => {
+  const rows = db.prepare(`
+    SELECT p.id, p.nom, p.domiciliation, p.fiscalite, p.created_at,
+           u.id AS user_id, u.email AS user_email, u.display_name AS user_display_name
+    FROM plateformes p
+    JOIN users u ON u.id = p.user_id
+    WHERE p.referentiel_id IS NULL
+    ORDER BY u.email, p.nom
+  `).all();
+
+  // Charger le référentiel pour calculer les suggestions de liaison
+  const refs = db.prepare('SELECT id, nom FROM plateformes_referentiel ORDER BY nom').all();
+
+  const enriched = rows.map(plat => {
+    let bestRef = null, bestScore = 0;
+    for (const ref of refs) {
+      const score = similarity(plat.nom, ref.nom);
+      if (score > bestScore) { bestScore = score; bestRef = ref; }
+    }
+    return {
+      ...plat,
+      suggestion: bestScore >= SIMILARITY_THRESHOLD
+        ? { referentiel_id: bestRef.id, referentiel_nom: bestRef.nom, score: Math.round(bestScore * 100) }
+        : null,
+    };
+  });
+
+  res.json(enriched);
+});
+
+/** Importe une plateforme orpheline dans le référentiel et la lie */
+router.post('/plateformes-orphelines/:id/importer', (req, res, next) => {
+  try {
+    const plat = db.prepare(`
+      SELECT p.*, u.email AS user_email
+      FROM plateformes p
+      JOIN users u ON u.id = p.user_id
+      WHERE p.id = ?
+    `).get(req.params.id);
+    if (!plat) throw new HttpError(404, 'Plateforme introuvable');
+    if (plat.referentiel_id) throw new HttpError(409, 'Plateforme deja liee a un referentiel');
+
+    // Verifier si un referentiel avec ce nom existe deja
+    const existing = db.prepare('SELECT id FROM plateformes_referentiel WHERE nom = ?').get(plat.nom);
+    if (existing) {
+      // Lier simplement la plateforme au referentiel existant
+      db.prepare(
+        "UPDATE plateformes SET referentiel_id = ?, overridden_fields = '[]' WHERE id = ?"
+      ).run(existing.id, plat.id);
+      const ref = db.prepare('SELECT * FROM plateformes_referentiel WHERE id = ?').get(existing.id);
+      return res.json({ linked: true, created: false, referentiel: ref });
+    }
+
+    // Creer un nouveau referentiel depuis la plateforme
+    db.transaction(() => {
+      const r = db.prepare(`
+        INSERT INTO plateformes_referentiel
+          (nom, url, domiciliation, fiscalite, taux_fiscalite_locale, type_produit_fiscal, logo_filename, updated_at)
+        VALUES (?,?,?,?,?,?,?, datetime('now'))
+      `).run(
+        plat.nom, plat.url || null, plat.domiciliation, plat.fiscalite,
+        plat.taux_fiscalite_locale ?? null, plat.type_produit_fiscal || '2TT',
+        plat.logo_filename ?? null
+      );
+      const refId = r.lastInsertRowid;
+
+      // Copier les categories (noms) depuis la plateforme source
+      const cats = db.prepare(`
+        SELECT cp.nom FROM plateforme_categories pc
+        JOIN categories_plateforme cp ON cp.id = pc.categorie_id
+        WHERE pc.plateforme_id = ?
+      `).all(plat.id);
+      const insC = db.prepare('INSERT OR IGNORE INTO referentiel_categories (referentiel_id, categorie_nom) VALUES (?,?)');
+      for (const c of cats) insC.run(refId, c.nom);
+
+      // Copier les criteres de notation
+      const notations = db.prepare('SELECT * FROM notation_criteres WHERE plateforme_id = ?').all(plat.id);
+      const insN = db.prepare(`
+        INSERT INTO referentiel_notation (referentiel_id, nom, type, valeurs, min_val, max_val, description, ordre)
+        VALUES (?,?,?,?,?,?,?,?)
+      `);
+      for (const n of notations) insN.run(refId, n.nom, n.type, n.valeurs, n.min_val, n.max_val, n.description, n.ordre);
+
+      // Lier la plateforme au nouveau referentiel, overridden_fields vide
+      db.prepare(
+        "UPDATE plateformes SET referentiel_id = ?, overridden_fields = '[]' WHERE id = ?"
+      ).run(refId, plat.id);
+    })();
+
+    const ref = db.prepare('SELECT * FROM plateformes_referentiel WHERE nom = ?').get(plat.nom);
+    res.status(201).json({ linked: true, created: true, referentiel: ref });
+  } catch (e) { next(e); }
+});
+
+/** Lie directement une plateforme orpheline à un référentiel existant (sans import) */
+router.post('/plateformes-orphelines/:id/lier', (req, res, next) => {
+  try {
+    const { referentiel_id } = req.body;
+    if (!referentiel_id) throw new HttpError(400, 'referentiel_id requis');
+
+    const plat = db.prepare('SELECT id, referentiel_id FROM plateformes WHERE id = ?').get(req.params.id);
+    if (!plat) throw new HttpError(404, 'Plateforme introuvable');
+    if (plat.referentiel_id) throw new HttpError(409, 'Plateforme déjà liée à un référentiel');
+
+    const ref = db.prepare('SELECT * FROM plateformes_referentiel WHERE id = ?').get(referentiel_id);
+    if (!ref) throw new HttpError(404, 'Référentiel introuvable');
+
+    db.prepare(
+      "UPDATE plateformes SET referentiel_id = ?, overridden_fields = '[]' WHERE id = ?"
+    ).run(ref.id, plat.id);
+
+    res.json({ linked: true, referentiel: ref });
+  } catch (e) { next(e); }
+});
+
+/* -- Execution manuelle d'un job ----------------------------------------- */
+
+router.post('/jobs/:name/run', (req, res, next) => {
+  try {
+    const { name } = req.params;
+    const fn = JOBS[name];
+    if (!fn) throw new HttpError(404, `Job inconnu : ${name}`);
+
+    const nbChanges = fn();
+    const lastLog   = db.prepare(
+      'SELECT * FROM job_logs WHERE job_name = ? ORDER BY run_at DESC LIMIT 1'
+    ).get(name);
+
+    res.json({ ok: true, nb_changes: nbChanges, log: lastLog });
+  } catch (e) { next(e); }
+});
+
+export default router;
+
+/* ── Catégories & secteurs suggérés par les utilisateurs ─────────────── */
+
+/** Compte les catégories et secteurs créés par les utilisateurs (non globaux) */
+router.get('/inv-suggestions-count', (_req, res) => {
+  const cats  = db.prepare('SELECT COUNT(*) AS n FROM categories_inv WHERE user_id IS NOT NULL').get().n;
+  const sects = db.prepare('SELECT COUNT(*) AS n FROM secteurs_inv WHERE user_id IS NOT NULL').get().n;
+  res.json({ cats, sects, total: cats + sects });
+});
+
+/** Liste toutes les catégories et secteurs créés par les utilisateurs */
+router.get('/inv-suggestions', (_req, res) => {
+  const categories = db.prepare(`
+    SELECT c.id, c.nom, c.user_id, u.email, u.display_name,
+      (SELECT COUNT(*) FROM plateforme_categories_inv WHERE categorie_id = c.id) AS nb_plateformes,
+      (SELECT COUNT(*) FROM investissement_categories_inv WHERE categorie_id = c.id) AS nb_investissements
+    FROM categories_inv c
+    JOIN users u ON u.id = c.user_id
+    WHERE c.user_id IS NOT NULL
+    ORDER BY u.email, c.nom
+  `).all();
+
+  const secteurs = db.prepare(`
+    SELECT s.id, s.nom, s.user_id, u.email, u.display_name,
+      (SELECT COUNT(*) FROM plateforme_secteurs_inv WHERE secteur_id = s.id) AS nb_plateformes,
+      (SELECT COUNT(*) FROM investissement_secteurs_inv WHERE secteur_id = s.id) AS nb_investissements
+    FROM secteurs_inv s
+    JOIN users u ON u.id = s.user_id
+    WHERE s.user_id IS NOT NULL
+    ORDER BY u.email, s.nom
+  `).all();
+
+  res.json({ categories, secteurs });
+});
+
+/** Promeut une catégorie utilisateur en catégorie globale (user_id → NULL) */
+router.post('/inv-suggestions/categories/:id/promouvoir', (req, res, next) => {
+  try {
+    const row = db.prepare('SELECT id, nom, user_id FROM categories_inv WHERE id = ?').get(req.params.id);
+    if (!row) throw new HttpError(404, 'Catégorie introuvable');
+    if (row.user_id === null) throw new HttpError(400, 'Déjà globale');
+    const dup = db.prepare('SELECT id FROM categories_inv WHERE nom = ? AND user_id IS NULL').get(row.nom);
+    if (dup) throw new HttpError(409, `Une catégorie globale "${row.nom}" existe déjà.`);
+    db.prepare('UPDATE categories_inv SET user_id = NULL WHERE id = ?').run(row.id);
+    res.json({ ok: true, msg: `"${row.nom}" promue en catégorie globale.` });
+  } catch (e) { next(e); }
+});
+
+/** Supprime une catégorie suggérée */
+router.delete('/inv-suggestions/categories/:id', (req, res, next) => {
+  try {
+    const row = db.prepare('SELECT id, nom, user_id FROM categories_inv WHERE id = ?').get(req.params.id);
+    if (!row) throw new HttpError(404, 'Catégorie introuvable');
+    if (row.user_id === null) throw new HttpError(403, 'Ne peut pas supprimer une catégorie globale depuis cette route.');
+    db.transaction(() => {
+      db.prepare('DELETE FROM plateforme_categories_inv WHERE categorie_id = ?').run(row.id);
+      db.prepare('DELETE FROM investissement_categories_inv WHERE categorie_id = ?').run(row.id);
+      db.prepare('DELETE FROM categories_inv WHERE id = ?').run(row.id);
+    })();
+    res.json({ ok: true, msg: `"${row.nom}" supprimée.` });
+  } catch (e) { next(e); }
+});
+
+/** Promeut un secteur utilisateur en secteur global */
+router.post('/inv-suggestions/secteurs/:id/promouvoir', (req, res, next) => {
+  try {
+    const row = db.prepare('SELECT id, nom, user_id FROM secteurs_inv WHERE id = ?').get(req.params.id);
+    if (!row) throw new HttpError(404, 'Secteur introuvable');
+    if (row.user_id === null) throw new HttpError(400, 'Déjà global');
+    const dup = db.prepare('SELECT id FROM secteurs_inv WHERE nom = ? AND user_id IS NULL').get(row.nom);
+    if (dup) throw new HttpError(409, `Un secteur global "${row.nom}" existe déjà.`);
+    db.prepare('UPDATE secteurs_inv SET user_id = NULL WHERE id = ?').run(row.id);
+    res.json({ ok: true, msg: `"${row.nom}" promu en secteur global.` });
+  } catch (e) { next(e); }
+});
+
+/** Supprime un secteur suggéré */
+router.delete('/inv-suggestions/secteurs/:id', (req, res, next) => {
+  try {
+    const row = db.prepare('SELECT id, nom, user_id FROM secteurs_inv WHERE id = ?').get(req.params.id);
+    if (!row) throw new HttpError(404, 'Secteur introuvable');
+    if (row.user_id === null) throw new HttpError(403, 'Ne peut pas supprimer un secteur global depuis cette route.');
+    db.transaction(() => {
+      db.prepare('DELETE FROM plateforme_secteurs_inv WHERE secteur_id = ?').run(row.id);
+      db.prepare('DELETE FROM investissement_secteurs_inv WHERE secteur_id = ?').run(row.id);
+      db.prepare('DELETE FROM secteurs_inv WHERE id = ?').run(row.id);
+    })();
+    res.json({ ok: true, msg: `"${row.nom}" supprimé.` });
+  } catch (e) { next(e); }
+});