Levage & Rigging

// 🚫 Détection: Opérations de levage sans zone d'exclusion
// Detection: Lifting operations without exclusion zone

MATCH (t:Task {type: 'Lift'})-[:LOCATED_IN]->(z)-[:PART_OF]->(p {id: $projectId})
WHERE NOT (z)-[:HAS]->(:Zone {type: 'Exclusion'})
RETURN 
    t.id AS taskId,
    t.description AS description,
    t.load AS loadTonnes,
    t.liftHeight AS heightMeters,
    t.startDate AS startDate,
    z.name AS zoneName,
    z.id AS zoneId,
    'MISSING_EXCLUSION_ZONE' AS violation,
    CASE
        WHEN t.load > 50 THEN 'CRITICAL'
        WHEN t.load > 20 THEN 'HIGH'
        ELSE 'MEDIUM'
    END AS riskLevel
ORDER BY t.load DESC

// ⚠️ Détection: Interférences grue avec enveloppes (structures)
// Detection: Crane interferences with envelopes (structures)

MATCH (cr:Asset {class: 'Crane'})-[:OPERATES_IN]->(z1)-[:PART_OF]->(p {id: $projectId})
MATCH (env:Asset {class: 'Envelope'})-[:LOCATED_IN]->(z2)
WITH cr, z1, env, z2,
     point.distance(point(z1), point(z2)) AS distanceMeters
WHERE distanceMeters < $swingClearance  // Clearance minimale (ex: 3m + rayon de flèche)
RETURN 
    cr.id AS craneId,
    cr.type AS craneType,
    cr.boomRadius AS boomRadiusMeters,
    z1.name AS craneZone,
    env.id AS envelopeId,
    env.type AS envelopeType,
    z2.name AS envelopeZone,
    round(distanceMeters, 2) AS distanceMeters,
    ($swingClearance - distanceMeters) AS clearanceDeficit,
    'CRANE_ENVELOPE_INTERFERENCE' AS violation
ORDER BY distanceMeters ASC

// 📋 Détection: Levages lourds sans plan de levage signé
// Detection: Heavy lifts without signed rigging plan

MATCH (t:Task {type: 'Lift'})-[:PART_OF]->(p {id: $projectId})
WHERE t.load >= $tonnage  // Seuil levage critique (ex: 20 tonnes)
  AND NOT (:Document {type: 'RiggingPlan', status: 'Signed'})-[:FOR]->(t)
RETURN 
    t.id AS taskId,
    t.description AS description,
    t.load AS loadTonnes,
    t.liftHeight AS heightMeters,
    t.startDate AS startDate,
    t.complexity AS liftComplexity,
    'MISSING_SIGNED_RIGGING_PLAN' AS violation,
    CASE
        WHEN t.load >= 100 THEN 'CRITICAL'
        WHEN t.load >= 50 THEN 'HIGH'
        ELSE 'MEDIUM'
    END AS riskLevel,
    EXISTS {
        MATCH (:Document {type: 'RiggingPlan'})-[:FOR]->(t)
    } AS hasDraft
ORDER BY t.load DESC

// 👷 Détection: Opérateurs de grue sans certification valide
// Detection: Crane operators without valid certification

MATCH (op:Worker)-[:OPERATES]->(:Asset {class: 'Crane'})-[:PART_OF]->(p {id: $projectId})
WHERE NOT (op)-[:CERTIFIED_FOR]->(:Certification {type: 'CraneOperator'})
WITH op,
     COLLECT {
         MATCH (op)-[:CERTIFIED_FOR]->(c:Certification)
         RETURN c.type
     } AS existingCerts
RETURN 
    op.id AS operatorId,
    op.name AS operatorName,
    op.employeeNumber AS employeeNumber,
    op.hireDate AS hireDate,
    existingCerts,
    'MISSING_CRANE_CERTIFICATION' AS violation,
    'CraneOperator' AS requiredCertification,
    CASE
        WHEN SIZE(existingCerts) = 0 THEN 'CRITICAL'
        ELSE 'HIGH'
    END AS riskLevel
ORDER BY riskLevel DESC, op.name

// 💨 Détection: Levages avec vitesse de vent excessive (verrou vent)
// Detection: Lifts with excessive wind speed (wind lock)

MATCH (t:Task {type: 'Lift'})-[:LOCATED_IN]->(z)-[:PART_OF]->(p {id: $projectId})
MATCH (r:Reading {type: 'WindSpeed'})-[:AT]->(z)
WHERE r.timestamp BETWEEN t.startDate AND t.endDate
  AND r.value > $limit  // Limite vent (ex: 40 km/h / 25 mph)
WITH t, z, 
     MAX(r.value) AS maxWindSpeed,
     AVG(r.value) AS avgWindSpeed,
     COUNT(r) AS violationReadings
RETURN DISTINCT
    t.id AS taskId,
    t.description AS description,
    t.load AS loadTonnes,
    t.liftHeight AS heightMeters,
    t.startDate AS startDate,
    t.endDate AS endDate,
    z.name AS zoneName,
    round(maxWindSpeed, 1) AS maxWindSpeedKmh,
    round(avgWindSpeed, 1) AS avgWindSpeedKmh,
    violationReadings,
    'WIND_SPEED_EXCEEDED' AS violation,
    CASE
        WHEN maxWindSpeed > ($limit * 1.5) THEN 'CRITICAL'
        WHEN maxWindSpeed > ($limit * 1.2) THEN 'HIGH'
        ELSE 'MEDIUM'
    END AS riskLevel
ORDER BY maxWindSpeed DESC