Safety Graph

MATCH (t:Task {type: 'ManualHandling'})-[:PART_OF]->(p {id: $projectId})
WHERE t.weightKg * t.freqPerHour > $riskIndex
RETURN t.id AS task_id,
       t.description AS task_desc,
       t.weightKg AS weight,
       t.freqPerHour AS frequency,
       t.weightKg * t.freqPerHour AS risk_score,
       t.assignedWorker AS worker_anon
ORDER BY risk_score DESC
LIMIT 20

MATCH (w:Worker)-[:USES]->(tool:Asset {class: 'VibratingTool'})-[:PART_OF]->(p {id: $projectId})
MATCH (ev:Event {type: 'ToolUse'})-[:BY]->(w)-[:ON]->(tool)
WITH w,
     sum(ev.durationMin * tool.havAeq) AS exposure_points,
     collect(DISTINCT tool.name) AS tools_used,
     count(DISTINCT ev) AS usage_sessions
WHERE exposure_points > $havLimit
RETURN w.id AS worker_id,
       w.name_anon AS worker,
       exposure_points,
       tools_used,
       usage_sessions,
       CASE 
         WHEN exposure_points > $havLimit * 1.5 THEN 'CRITIQUE'
         WHEN exposure_points > $havLimit THEN 'ÉLEVÉ'
         ELSE 'MODÉRÉ'
       END AS risk_level
ORDER BY exposure_points DESC

MATCH (post:Posture {type: 'Kneeling'})-[:BY]->(w:Worker)-[:PART_OF]->(p {id: $projectId})
WITH w,
     sum(post.durationMin) AS total_kneeling_mins,
     collect(post.taskDescription) AS tasks,
     count(post) AS kneeling_sessions
WHERE total_kneeling_mins > $minMin 
  AND NOT (w)-[:WEARS]->(:PPE {type: 'KneePad'})
RETURN w.id AS worker_id,
       w.name_anon AS worker,
       total_kneeling_mins,
       tasks,
       kneeling_sessions,
       ROUND(total_kneeling_mins / 60.0, 1) AS hours,
       CASE 
         WHEN total_kneeling_mins > 180 THEN 'URGENT'
         WHEN total_kneeling_mins > 120 THEN 'ÉLEVÉ'
         ELSE 'MODÉRÉ'
       END AS priority
ORDER BY total_kneeling_mins DESC

MATCH (w:Worker)-[:PART_OF_CREW]->(c:Crew)-[:PART_OF]->(p {id: $projectId})
MATCH (ev:Event {type: 'MicroPause'})-[:BY]->(w)
WHERE ev.timestamp >= $since
WITH c,
     count(ev) AS total_micropauses,
     count(DISTINCT w) AS crew_size,
     ROUND(count(ev) * 1.0 / count(DISTINCT w), 1) AS avg_per_worker,
     collect(DISTINCT w.name_anon) AS workers
WHERE total_micropauses < $minPerShift * crew_size
RETURN c.id AS crew_id,
       c.name AS crew_name,
       crew_size,
       total_micropauses,
       avg_per_worker,
       $minPerShift AS recommended_per_worker,
       workers,
       ROUND(100.0 * total_micropauses / ($minPerShift * crew_size), 1) AS compliance_pct
ORDER BY compliance_pct ASC

MATCH (ws:Workstation)-[:PART_OF]->(p {id: $projectId})
MATCH (w:Worker)-[:ASSIGNED_TO]->(ws)
WITH ws, w,
     coalesce(w.elbowHeightCm, 105) AS worker_elbow_height,
     ws.heightCm AS station_height,
     abs(ws.heightCm - coalesce(w.elbowHeightCm, 105)) AS height_delta
WHERE height_delta > $deltaCm
RETURN ws.id AS workstation_id,
       ws.name AS workstation,
       ws.heightCm AS current_height,
       w.id AS worker_id,
       w.name_anon AS worker,
       worker_elbow_height,
       height_delta AS mismatch_cm,
       CASE 
         WHEN height_delta > 15 THEN 'CRITIQUE'
         WHEN height_delta > 10 THEN 'ÉLEVÉ'
         ELSE 'MODÉRÉ'
       END AS severity,
       CASE
         WHEN ws.heightCm > worker_elbow_height THEN 'Trop haut - Risque épaules'
         ELSE 'Trop bas - Risque dos/poignets'
       END AS risk_type
ORDER BY height_delta DESC

┌─────────────────────────────────────────────────────────────────┐
│                  COLLECTE DONNÉES (Sources Multiples)           │
├─────────────────────────────────────────────────────────────────┤
│  📱 Wearables IoT    │  📹 Caméras IA    │  📋 Rapports Manuels│
│  (Vibrations, MVT)   │  (Postures, MoC)  │  (Auto-évaluation)  │
└──────────────┬────────────────┬────────────────┬────────────────┘
               │                │                │
               └────────────────┴────────────────┘
                                │
                    ┌───────────▼───────────┐
                    │  ETL + Anonymisation  │
                    │   (Python Pipeline)   │
                    └───────────┬───────────┘
                                │
                    ┌───────────▼───────────┐
                    │    NEO4J SAFETYGRAPH  │
                    │  (Graphe + Propriétés)│
                    └───────────┬───────────┘
                                │
            ┌───────────────────┼───────────────────┐
            │                   │                   │
    ┌───────▼────────┐  ┌──────▼──────┐  ┌────────▼────────┐
    │  CYPHER QUERIES│  │  ALERTES    │  │  ML PREDICTIF   │
    │  (5 Ergonomie) │  │  Temps Réel │  │  (Prévision TMS)│
    └───────┬────────┘  └──────┬──────┘  └────────┬────────┘
            │                   │                   │
            └───────────────────┴───────────────────┘
                                │
                    ┌───────────▼───────────┐
                    │    DASHBOARDS D3.js   │
                    │  (Visualisations +    │
                    │   Actions suggérées)  │
                    └───────────┬───────────┘
                                │
            ┌───────────────────┼───────────────────┐
            │                   │                   │
    ┌───────▼────────┐  ┌──────▼──────┐  ┌────────▼────────┐
    │  COORD. SST    │  │  TRAVAILLEURS│  │  GESTIONNAIRES  │
    │  (Interventions│  │  (Alertes)   │  │  (KPIs)         │
    │   Préventives) │  │              │  │                 │
    └────────────────┘  └─────────────┘  └─────────────────┘

FRÉQUENCE DE MISE À JOUR:
• Données wearables: Temps réel (streaming)
• Requêtes Cypher: Toutes les 15 minutes (ou on-demand)
• ML predictions: Recalcul quotidien (overnight)
• Dashboards: Rafraîchissement automatique