feat(r2.3): écrans web exploitation — OT, demandes, préventif, compteurs, urgence

- liste OT (filtres, strie rouge, « immédiat ») ; fiche OT : transitions
  pilotées par allowedTransitions, clôture grisée avec la garde expliquée,
  bilan codé (6 selects sur référentiels), checklist Fait→N-A→à faire,
  activité + commentaires, assignation, annulation motivée
- nouvel OT : interrupteur « personne bloquée » qui force la priorité
- demandes : table + panneau d'approbation (priorité, assignation,
  approuver → fiche OT), rejet en modale à motif obligatoire, signalement
  interne ; statut « Résolue » dérivé de l'OT lié
- préventif : tuiles réelles, générer + résumé (« regénérer ne double
  rien »), gabarits administrables ; compteurs : saisie + historique
- tableau de bord réel : bandeau urgence cliquable, KPIs, OT par statut,
  interventions récentes ; accueil dédié aux rôles sans exploitation
- urgence traversante : chip topbar pulsante (60 s), badges de nav
- GET /assets/options (auth seule) : le Demandeur peut désigner l'appareil
  qu'il signale — trou débusqué par l'e2e (49 opérations au contrat)
- génération préventive durcie : collision de référence RETENTÉE (plus de
  saut silencieux), P2003 toléré ; 3 runs Jest complets consécutifs verts
- 9 tests Playwright (recette R2 officielle rejouée intégralement),
  50 tests API (94,6 % / 78,9 %)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

apps/api/prisma/cleanup-e2e.ts

@@ -6,6 +6,13 @@ import { PrismaClient } from '@prisma/client';
 const prisma = new PrismaClient();
 
 async function main() {
+  await prisma.request.deleteMany({ where: { description: { contains: 'E2E' } } });
+  await prisma.workOrder.deleteMany({ where: { title: { contains: 'E2E' } } });
+  await prisma.meterReading.deleteMany({ where: { value: { gte: 90_000_000 } } });
+  // Un appareil de test peut avoir reçu grilles/demandes (génération du mois) :
+  // on purge ses dépendances avant lui (FK RESTRICT).
+  await prisma.request.deleteMany({ where: { asset: { reference: { startsWith: 'E2E-' } } } });
+  await prisma.workOrder.deleteMany({ where: { asset: { reference: { startsWith: 'E2E-' } } } });
   await prisma.asset.deleteMany({ where: { reference: { startsWith: 'E2E-' } } });
   await prisma.location.deleteMany({ where: { name: { contains: 'E2E' }, parentId: { not: null } } });
   await prisma.location.deleteMany({ where: { name: { contains: 'E2E' } } });

apps/api/src/assets/assets.controller.ts

@@ -31,6 +31,13 @@ export class AssetsController {
     return this.assetsService.list();
   }
 
+  /** Avant ':id' (ordre des routes) — authentification seule : le demandeur
+   *  doit pouvoir désigner l'appareil qu'il signale. */
+  @Get('options')
+  options() {
+    return this.assetsService.options();
+  }
+
   @Get(':id')
   @RequirePermission('ASSETS', 'view')
   get(@Param('id', ParseUUIDPipe) id: string) {

apps/api/src/assets/assets.service.ts

@@ -11,6 +11,7 @@ import type {
   AssetCreate,
   AssetDetail,
   AssetDto,
+  AssetOptionsResponse,
   AssetsResponse,
   AssetUpdate,
 } from '@siop/shared';
@@ -28,6 +29,21 @@ type AssetRow = Prisma.AssetGetPayload<{ include: typeof assetInclude }>;
 export class AssetsService {
   constructor(private readonly prisma: PrismaService) {}
 
+  /** Options minimales pour le signalement — ouvert à tout rôle authentifié. */
+  async options(): Promise<AssetOptionsResponse> {
+    const rows = await this.prisma.asset.findMany({
+      include: { location: { include: { parent: true } } },
+      orderBy: { reference: 'asc' },
+    });
+    return {
+      options: rows.map((r) => ({
+        id: r.id,
+        reference: r.reference,
+        siteName: r.location.parent?.name ?? r.location.name,
+      })),
+    };
+  }
+
   async list(): Promise<AssetsResponse> {
     const rows = await this.prisma.asset.findMany({
       include: assetInclude,

apps/api/src/preventive/preventive.service.ts

@@ -129,44 +129,57 @@ export class PreventiveService {
         skipped++;
         continue;
       }
-      try {
-        const ot = await this.prisma.workOrder.create({
-          data: {
-            reference: await this.nextReference(),
-            title: premierControle
-              ? `Premier contrôle — ${libelleMois}`
-              : `Grille du mois — ${libelleMois}`,
-            type: 'PREVENTIVE',
-            priority: 'LOW',
-            assetId: asset.id,
-            periodKey: period,
-            dueDate: dernierJour,
-            createdById: user.userId,
-            checklist: {
-              create: dues.map((t) => ({ label: t.label, templateId: t.id })),
-            },
-            events: {
-              create: {
-                kind: 'GENERATED',
-                message: `Généré (${premierControle ? 'premier contrôle' : 'grille mensuelle'} · ${dues.length} tâches)`,
-                byId: user.userId,
+      let issue: 'créé' | 'sauté' | null = null;
+      for (let essai = 0; essai < 4 && issue === null; essai++) {
+        try {
+          const ot = await this.prisma.workOrder.create({
+            data: {
+              reference: await this.nextReference(),
+              title: premierControle
+                ? `Premier contrôle — ${libelleMois}`
+                : `Grille du mois — ${libelleMois}`,
+              type: 'PREVENTIVE',
+              priority: 'LOW',
+              assetId: asset.id,
+              periodKey: period,
+              dueDate: dernierJour,
+              createdById: user.userId,
+              checklist: {
+                create: dues.map((t) => ({ label: t.label, templateId: t.id })),
+              },
+              events: {
+                create: {
+                  kind: 'GENERATED',
+                  message: `Généré (${premierControle ? 'premier contrôle' : 'grille mensuelle'} · ${dues.length} tâches)`,
+                  byId: user.userId,
+                },
               },
             },
-          },
-          select: { reference: true },
-        });
-        created++;
-        if (premierControle) firstControls++;
-        references.push(ot.reference);
-      } catch (e) {
-        // [assetId, periodKey] déjà pris → grille déjà en place : idempotence.
-        // (Collision de référence, rarissime : le prochain appel rattrape.)
-        if (e instanceof Prisma.PrismaClientKnownRequestError && e.code === 'P2002') {
-          skipped++;
-          continue;
+            select: { reference: true },
+          });
+          created++;
+          if (premierControle) firstControls++;
+          references.push(ot.reference);
+          issue = 'créé';
+        } catch (e) {
+          if (e instanceof Prisma.PrismaClientKnownRequestError && e.code === 'P2002') {
+            const cible = (e.meta?.target as string[] | string | undefined) ?? '';
+            if (String(cible).includes('periodKey')) {
+              issue = 'sauté'; // grille déjà en place : idempotence
+            }
+            // sinon : collision de référence (course avec une création d'OT)
+            // → on recalcule et on retente
+          } else if (
+            e instanceof Prisma.PrismaClientKnownRequestError &&
+            e.code === 'P2003'
+          ) {
+            issue = 'sauté'; // appareil supprimé entre lecture et écriture
+          } else {
+            throw e;
+          }
         }
-        throw e;
       }
+      if (issue !== 'créé') skipped++;
     }
     this.logger.log(
       `Préventif ${period} : ${created} générés, ${skipped} déjà en place, ${firstControls} premiers contrôles.`,

apps/api/test/preventif.e2e-spec.ts

@@ -80,18 +80,37 @@ describe('Préventif & compteurs (e2e)', () => {
       where: { isActive: true, periodMonths: 1 },
     });
 
-    // B2 n'avait aucun OT préventif avant 2031-01 → premier contrôle
-    const b2 = await prisma.asset.findUniqueOrThrow({ where: { reference: 'B2' } });
-    const grilleB2 = await prisma.workOrder.findUniqueOrThrow({
-      where: { assetId_periodKey: { assetId: b2.id, periodKey: '2031-01' } },
-      include: { _count: { select: { checklist: true } } },
+    // Un appareil VIERGE créé par ce test (aucune génération n'a pu le toucher)
+    const categorie = await prisma.category.findFirstOrThrow({ where: { kind: 'EQUIPMENT' } });
+    const site = await prisma.location.findFirstOrThrow({ where: { parentId: null } });
+    const vierge = await prisma.asset.create({
+      data: {
+        reference: `PVT-${Date.now().toString(36)}`,
+        brand: 'Test',
+        categoryId: categorie.id,
+        locationId: site.id,
+      },
     });
-    expect(grilleB2.title).toContain('Premier contrôle');
-    expect(grilleB2._count.checklist).toBe(templatesActifs);
+    try {
+      await http()
+        .post('/preventive/generate')
+        .set(auth(admin))
+        .send({ month: '2031-09' })
+        .expect(200);
+      const grille = await prisma.workOrder.findUniqueOrThrow({
+        where: { assetId_periodKey: { assetId: vierge.id, periodKey: '2031-09' } },
+        include: { _count: { select: { checklist: true } } },
+      });
+      expect(grille.title).toContain('Premier contrôle');
+      expect(grille._count.checklist).toBe(templatesActifs);
+    } finally {
+      await prisma.workOrder.deleteMany({ where: { assetId: vierge.id } });
+      await prisma.asset.delete({ where: { id: vierge.id } });
+    }
 
-    // A1 a un historique préventif (seed juillet) → grille normale.
-    // Mise en service mars 2020 : janvier 2031 n'est le mois ni du 12, ni du 3,
-    // ni du 6 mois (écart 130) → seules les tâches MENSUELLES sont dues.
+    // A1 a toujours un historique préventif (seed) → grille normale.
+    // Mise en service mars 2020 : janvier 2031 (écart 130 mois) n'est le mois
+    // ni du 3, ni du 6, ni du 12 → seules les tâches MENSUELLES sont dues.
     const a1 = await prisma.asset.findUniqueOrThrow({ where: { reference: 'A1' } });
     const grilleA1 = await prisma.workOrder.findUniqueOrThrow({
       where: { assetId_periodKey: { assetId: a1.id, periodKey: '2031-01' } },