front: display all tracks for all operational points

Akctarus · Akctarus · commit 7e3db8694c6c · 2026-03-23T11:08:25.000+01:00
Signed-off-by: Theo Macron &lt;theo.macron0315@gmail.com&gt;
diff --git a/front/src/applications/operationalStudies/views/Scenario/components/SimulationResults/SimulationResults.tsx b/front/src/applications/operationalStudies/views/Scenario/components/SimulationResults/SimulationResults.tsx
@@ -114,7 +114,6 @@ const SimulationResults = ({
     updateTrackOccupanciesOnDrag: handleTrainDragInTrackOccupancy,
   } = useTrackOccupancy({
     infraId,
-    pathfindingHasFailed: projectionData?.pathfindingStatus === 'failed',
     pathOperationalPoints: filteredOperationalPoints,
     timetableItemProjections,
   });
diff --git a/front/src/modules/simulationResult/components/SpaceTimeChartWrapper/SpaceTimeChartWrapper.tsx b/front/src/modules/simulationResult/components/SpaceTimeChartWrapper/SpaceTimeChartWrapper.tsx
@@ -224,9 +224,7 @@ const SpaceTimeChartWrapper = ({
 
   const { waypointMenu, activeWaypointId, handleWaypointClick } = useWaypointMenu(
     activeWaypointRef,
-    waypointsPanelData,
-    allTrainsProjected,
-    pathfindingHasFailed
+    waypointsPanelData
   );
 
   const hoveredTrainIdForChart = useMemo(() => {
diff --git a/front/src/modules/simulationResult/components/SpaceTimeChartWrapper/useTrackOccupancy.ts b/front/src/modules/simulationResult/components/SpaceTimeChartWrapper/useTrackOccupancy.ts
@@ -43,6 +43,9 @@ type DeployedWaypoint = {
   loading?: boolean;
 };
 
+const NO_TRACK_SPECIFIED_ID = '__no_track_specified__';
+const NO_TRACK_SPECIFIED_SYMBOL = '[ ]';
+
 type StationLabel = { type?: 'label'; label: string } | { type: 'requestedPoint' };
 function extractStationLabel(
   stationLabel: StationLabel | undefined,
@@ -58,11 +61,18 @@ function getOperationalPointReference(
   op: PathOperationalPoint | undefined
 ): OperationalPointReference | undefined {
   if (!op) return undefined;
-  if (op.opId) return { type: 'id', operational_point: op.opId };
+  // Only use the opId when it refers to a real infra OP. Virtual OPs (unrecognised, created
+  // by usePathProjection when pathfinding fails) have a synthetic id like "virtual_op_Zürich"
+  // and an empty part.track — they must be matched by trigram/uic instead.
+  if (op.opId && op.part?.track) return { type: 'id', operational_point: op.opId };
+  // Normalize empty string ch to null — virtual OPs store ch as '' when the original
+  // secondary_code was null (see usePathProjection createVirtualOp), and passing ''
+  // to the backend would filter for OPs with an empty secondary_code rather than any.
+  const ch = op.extensions?.sncf?.ch || null;
   const trigram = op.extensions?.sncf?.trigram;
-  if (trigram) return { type: 'trigram', trigram, secondary_code: op.extensions?.sncf?.ch };
+  if (trigram) return { type: 'trigram', trigram, secondary_code: ch };
   const uic = op.extensions?.identifier?.uic;
-  if (uic != null) return { type: 'uic', uic, secondary_code: op.extensions?.sncf?.ch };
+  if (uic != null) return { type: 'uic', uic, secondary_code: ch };
   return undefined;
 }
 
@@ -89,12 +99,10 @@ const useTrackOccupancy = ({
   infraId,
   timetableItemProjections,
   pathOperationalPoints,
-  pathfindingHasFailed = false,
 }: {
   infraId: number;
   timetableItemProjections: TrainSpaceTimeData[];
   pathOperationalPoints: PathOperationalPoint[];
-  pathfindingHasFailed?: boolean;
 }): {
   deployedWaypoints: DeployedWaypoint[];
   toggleWaypoint: (waypointId: string, selectedState?: boolean) => void;
@@ -171,7 +179,7 @@ const useTrackOccupancy = ({
   const fetchTrackOccupancy = useCallback(
     async (
       opRef: OperationalPointReference | undefined | null,
-      opId: string | undefined | null,
+      waypointId: string | undefined | null,
       trainsCollection: Record<TimetableItemId, TrainSpaceTimeData>
     ): Promise<MovableOccupancyZone[]> => {
       if (!opRef) return [];
@@ -200,11 +208,16 @@ const useTrackOccupancy = ({
       if (pacedResp?.data) {
         for (const trackItem of pacedResp.data) {
           const { local_track_name: localTrackName, trains } = trackItem;
-          if (!localTrackName) continue;
-          const trackId = opId
-            ? localTrackNameToTrackIdRef.current.get(opId)?.get(localTrackName)
-            : undefined;
-          if (!trackId) continue;
+          let trackId: string;
+          if (!localTrackName) {
+            trackId = NO_TRACK_SPECIFIED_ID;
+          } else {
+            const mappedTrackId = waypointId
+              ? localTrackNameToTrackIdRef.current.get(waypointId)?.get(localTrackName)
+              : undefined;
+            // If the track name isn't found in infra, use the name itself as a virtual track ID
+            trackId = mappedTrackId ?? localTrackName;
+          }
           for (const occupation of trains) {
             const pacedId = formatEditoastIdToPacedTrainId(occupation.train_schedule_id);
             const train = trainsCollection[pacedId];
@@ -288,32 +301,58 @@ const useTrackOccupancy = ({
   const deployedWaypoints = useMemo(() => {
     const res: DeployedWaypoint[] = [];
 
-    if (tracksState.type === 'ok')
-      forEach(pathOperationalPointsState, (opState, waypointId) => {
-        const op = pathOpsByWaypointId.get(waypointId);
-        if (opState.selected && op?.opId) {
-          const tracks = tracksState.data[op.opId];
-          res.push({
-            waypointId,
-            operationalPointId: op.opId,
-            operationalPointPosition: op.position,
-            operationalPointName: op.extensions?.identifier?.name || undefined,
-            zones: opState.zones.data?.map((zone) => {
-              const trainStationLabels = trainsStationLabelsRef.current[zone.trainId];
-              return {
-                ...zone,
-                originStation: extractStationLabel(trainStationLabels?.origin, t),
-                destinationStation: extractStationLabel(trainStationLabels?.destination, t),
-              };
-            }),
-            loading: opState.zones.type === 'loading',
-            tracks,
-          });
+    forEach(pathOperationalPointsState, (opState, waypointId) => {
+      const op = pathOpsByWaypointId.get(waypointId);
+      if (opState.selected && op) {
+        const infraTracks = (tracksState.data ?? {})[waypointId] || [];
+        const infraTrackIds = new Set(infraTracks.map((track) => track.id));
+        const trackMapping = localTrackNameToTrackIdRef.current.get(waypointId);
+
+        // Remap zones whose trackId is a local_track_name stored before the infra mapping was
+        // ready (race condition between fetchTrackOccupancy and loadAllTracks). Once the infra
+        // mapping is available via localTrackNameToTrackIdRef, resolve them to the real track
+        // section ID so zones land on the correct infra track row.
+        const resolvedZones = opState.zones.data?.map((zone) => {
+          if (!infraTrackIds.has(zone.trackId) && trackMapping) {
+            const remappedId = trackMapping.get(zone.trackId);
+            if (remappedId) return { ...zone, trackId: remappedId };
+          }
+          return zone;
+        });
+
+        // Collect virtual tracks: zones whose trackId still isn't found in the infrastructure
+        const virtualTrackIds = new Set<string>();
+        if (resolvedZones) {
+          for (const zone of resolvedZones) {
+            if (!infraTrackIds.has(zone.trackId)) virtualTrackIds.add(zone.trackId);
+          }
         }
-      });
+        const virtualTracks: Track[] = [...virtualTrackIds].map((id) => ({
+          id,
+          name: id === NO_TRACK_SPECIFIED_ID ? NO_TRACK_SPECIFIED_SYMBOL : id,
+        }));
+
+        res.push({
+          waypointId,
+          operationalPointId: op?.opId ?? waypointId,
+          operationalPointPosition: op.position,
+          operationalPointName: op.extensions?.identifier?.name || undefined,
+          zones: resolvedZones?.map((zone) => {
+            const trainStationLabels = trainsStationLabelsRef.current[zone.trainId];
+            return {
+              ...zone,
+              originStation: extractStationLabel(trainStationLabels?.origin, t),
+              destinationStation: extractStationLabel(trainStationLabels?.destination, t),
+            };
+          }),
+          loading: opState.zones.type === 'loading',
+          tracks: [...infraTracks, ...virtualTracks],
+        });
+      }
+    });
 
     return res;
-  }, [pathOperationalPointsState, pathOpsByWaypointId, t]);
+  }, [pathOperationalPointsState, pathOpsByWaypointId, tracksState, t]);
 
   const toggleWaypoint = useCallback(
     (waypointId: string, selectedState?: boolean) => {
@@ -333,7 +372,7 @@ const useTrackOccupancy = ({
           (ids) =>
             fetchTrackOccupancy(
               getOperationalPointReference(waypoint),
-              waypoint.opId,
+              waypointId,
               Object.fromEntries(ids.map((id) => [id, timetableItemProjectionsById.get(id)!]))
             ),
           {
@@ -385,7 +424,7 @@ const useTrackOccupancy = ({
 
           const trains = Object.fromEntries(Array.from(timetableItemProjectionsById.entries()));
 
-          fetchTrackOccupancy(opRef, waypoint.opId, trains).then((newZones) => {
+          fetchTrackOccupancy(opRef, waypointId, trains).then((newZones) => {
             if (!newZones.length) return;
 
             updatePathOperationalPointState(waypointId, (state) =>
@@ -450,14 +489,13 @@ const useTrackOccupancy = ({
 
       // Fetch new occupation if dragging has stopped:
       if (stopPanning) {
-        const draggedTrainEditoastId = draggedTrainId;
         await Promise.all(
           [...impactedPathOperationalPointIDs].map(async (waypointId) => {
             const newZones = await fetchTrackOccupancy(
               getOperationalPointReference(pathOpsByWaypointId.get(waypointId)),
-              pathOpsByWaypointId.get(waypointId)?.opId,
+              waypointId,
               {
-                [draggedTrainEditoastId]: newTrainData,
+                [draggedTrainId]: newTrainData,
               }
             );
 
@@ -489,30 +527,26 @@ const useTrackOccupancy = ({
 
   // Load all tracks from all waypoints on mount / waypoints update:
   useEffect(() => {
-    if (pathfindingHasFailed) {
-      return;
-    }
-
     let aborted = false;
 
     const pathOperationalPointsWithoutTracks = pathOperationalPoints.filter(
       (op) => !(tracksState.data || {})[op.waypointId]
     );
     const loadAllTracks = async (
-      operationalPointReferences: { operational_point: string; type: 'id' }[]
+      opsWithReferences: { waypointId: string; reference: OperationalPointReference }[]
     ) => {
       setTracksState((state) => ({ type: 'loading', data: state.data || {} }));
 
       try {
         const data = await postInfraByInfraIdMatchOperationalPoints({
           infraId,
-          body: { operational_point_references: operationalPointReferences },
+          body: { operational_point_references: opsWithReferences.map((o) => o.reference) },
         }).unwrap();
 
         if (aborted) return;
 
         const allTrackIds = data.related_operational_points.flatMap(([points]) =>
-          points.parts.map((part) => part.track)
+          points ? points.parts.map((part) => part.track) : []
         );
         const fetchedTrackSections = await getTrackSectionsByIds(allTrackIds);
 
@@ -523,20 +557,21 @@ const useTrackOccupancy = ({
 
         localTrackNameToTrackIdRef.current = new Map();
 
-        data.related_operational_points.forEach(([operationalPoint]) => {
+        opsWithReferences.forEach(({ waypointId: wId }, i) => {
+          const [operationalPoint] = data.related_operational_points[i];
           if (!operationalPoint) return;
           const mapping = new Map<string, string>();
           for (const part of operationalPoint.parts) {
             mapping.set(part.local_track_name, part.track);
           }
-          localTrackNameToTrackIdRef.current.set(operationalPoint.id, mapping);
+          localTrackNameToTrackIdRef.current.set(wId, mapping);
         });
 
         const loadedTracks = fromPairs(
-          operationalPointReferences.map(({ operational_point }, i) => [
-            operational_point,
+          opsWithReferences.map(({ waypointId: wId }, i) => [
+            wId,
             uniqBy(
-              data.related_operational_points[i][0].parts.map((part) => {
+              (data.related_operational_points[i][0]?.parts ?? []).map((part) => {
                 const trackPart = trackSectionByTrackId.get(part.track);
                 return {
                   id: part.track,
@@ -548,24 +583,32 @@ const useTrackOccupancy = ({
             ),
           ])
         );
-        setTracksState({
+        setTracksState((state) => ({
           type: 'ok',
-          data: loadedTracks,
-        });
+          data: { ...(state.data ?? {}), ...loadedTracks },
+        }));
       } catch (e) {
         console.error(e);
       }
     };
-    const waypointsPayload = pathOperationalPointsWithoutTracks.flatMap((op) =>
-      op.opId ? [{ operational_point: op.opId, type: 'id' as const }] : []
-    );
-    if (!waypointsPayload.length) return noop;
+    const waypointsPayload = pathOperationalPointsWithoutTracks.flatMap<{
+      waypointId: string;
+      reference: OperationalPointReference;
+    }>((op) => {
+      const reference = getOperationalPointReference(op);
+      if (!reference) return [];
+      return [{ waypointId: op.waypointId, reference }];
+    });
+    if (!waypointsPayload.length) {
+      setTracksState((state) => ({ type: 'ok', data: state.data || {} }));
+      return noop;
+    }
 
     loadAllTracks(waypointsPayload);
     return () => {
       aborted = true;
     };
-  }, [pathOperationalPoints, pathfindingHasFailed]);
+  }, [pathOperationalPoints]);
 
   // Update train data for all deployed waypoints on trains update:
   useEffect(() => {
@@ -620,7 +663,7 @@ const useTrackOccupancy = ({
       forEach(pathOperationalPointsState, async (_, waypointId) => {
         const newZones = await fetchTrackOccupancy(
           getOperationalPointReference(pathOpsByWaypointId.get(waypointId)),
-          pathOpsByWaypointId.get(waypointId)?.opId,
+          waypointId,
           Object.fromEntries(
             [...addedTrainIDs, ...modifiedTrainIDs].map((id) => [
               id,
diff --git a/front/src/modules/simulationResult/components/SpaceTimeChartWrapper/useWaypointMenu.tsx b/front/src/modules/simulationResult/components/SpaceTimeChartWrapper/useWaypointMenu.tsx
@@ -13,9 +13,7 @@ import { getWaypointsLocalStorageKey } from './helpers/utils';
 
 const useWaypointMenu = (
   activeWaypointRef: RefObject<HTMLDivElement | null>,
-  waypointsPanelData?: WaypointsPanelData,
-  allTrainsProjected?: boolean,
-  pathfindingHasFailed?: boolean
+  waypointsPanelData?: WaypointsPanelData
 ) => {
   const {
     filteredWaypoints,
@@ -100,7 +98,6 @@ const useWaypointMenu = (
 
       menuItems.push({
         dataTestID: 'occupancy-menu-button',
-        disabled: pathfindingHasFailed || (!isDeployed && !allTrainsProjected),
         title: isDeployed
           ? t('simulationResults.waypointMenu.hideOccupancy')
           : t('simulationResults.waypointMenu.showOccupancy'),
