From a053714ac2498cc57f32f9e4f8a665d8a204246e Mon Sep 17 00:00:00 2001
From: Simon Ser <contact@emersion.fr>
Date: Wed, 31 Jul 2024 14:12:34 +0200
Subject: [PATCH 1/9] front: add NGE DTO types

---
 .../components/MacroEditor/types.ts           | 95 +++++++++++++++++++
 1 file changed, 95 insertions(+)
 create mode 100644 front/src/applications/operationalStudies/components/MacroEditor/types.ts

diff --git a/front/src/applications/operationalStudies/components/MacroEditor/types.ts b/front/src/applications/operationalStudies/components/MacroEditor/types.ts
new file mode 100644
index 00000000000..b81a51da887
--- /dev/null
+++ b/front/src/applications/operationalStudies/components/MacroEditor/types.ts
@@ -0,0 +1,95 @@
+// NGE DTO types, see:
+// https://github.com/SchweizerischeBundesbahnen/netzgrafik-editor-frontend/blob/main/src/app/data-structures/business.data.structures.ts
+
+export type Haltezeit = {
+  haltezeit: number;
+  no_halt: boolean;
+};
+
+export type Node = {
+  id: number | string; // TODO: in NGE this is a number
+  /** Trigram */
+  betriebspunktName: string;
+  fullName: string;
+  positionX: number;
+  positionY: number;
+  ports: unknown[];
+  transitions: unknown[];
+  connections: unknown[];
+  resourceId: number;
+  /** Number of tracks where train can stop */
+  perronkanten: number;
+  /** Time needed to change train in minutes */
+  connectionTime: number;
+  trainrunCategoryHaltezeiten: { [category: string]: Haltezeit };
+  symmetryAxis: number;
+  warnings: unknown[];
+  labelIds: number[];
+};
+
+export type Trainrun = {
+  id: number;
+  name: string;
+  categoryId: number;
+  frequencyId: number;
+  trainrunTimeCategoryId: number;
+  labelIds: number[];
+};
+
+export type TimeLock = {
+  time: number;
+  consecutiveTime: number;
+  lock: boolean;
+  warning: null;
+  timeFormatter: null;
+};
+
+export type TrainrunSection = {
+  id: number;
+  sourceNodeId: number | string;
+  sourcePortId: number;
+  targetNodeId: number | string;
+  targetPortId: number;
+
+  sourceArrival: TimeLock;
+  sourceDeparture: TimeLock;
+  targetArrival: TimeLock;
+  targetDeparture: TimeLock;
+  travelTime: TimeLock;
+
+  numberOfStops: number;
+
+  trainrunId: number;
+  resourceId: number;
+
+  specificTrainrunSectionFrequencyId: number;
+  path: null;
+  warnings: unknown[];
+};
+
+export type Resource = {
+  id: number;
+  capacity: number;
+};
+
+/**
+ * The DTO contains the entire NGE state.
+ */
+export type NetzgrafikDto = {
+  nodes: Node[];
+  trainrunSections: TrainrunSection[];
+  trainruns: Trainrun[];
+  resources: Resource[];
+  metadata: {
+    netzgrafikColors: unknown[];
+    trainrunCategories: unknown[];
+    trainrunFrequencies: unknown[];
+    trainrunTimeCategories: unknown[];
+  };
+  freeFloatingTexts: unknown[];
+  labels: unknown[];
+  labelGroups: unknown[];
+  filterData: {
+    filterSettings: unknown[];
+  };
+};

From 77ba3a4e173475a9ae878959ad14a9cab3475a53 Mon Sep 17 00:00:00 2001
From: Simon Ser <contact@emersion.fr>
Date: Wed, 31 Jul 2024 14:12:51 +0200
Subject: [PATCH 2/9] front: add dto property to NGE component

---
 .../components/MacroEditor/NGE.tsx            | 27 ++++++++++++-------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/front/src/applications/operationalStudies/components/MacroEditor/NGE.tsx b/front/src/applications/operationalStudies/components/MacroEditor/NGE.tsx
index e641b762ee5..737747da858 100644
--- a/front/src/applications/operationalStudies/components/MacroEditor/NGE.tsx
+++ b/front/src/applications/operationalStudies/components/MacroEditor/NGE.tsx
@@ -1,4 +1,4 @@
-import React, { useEffect, useRef } from 'react';
+import React, { useEffect, useRef, useState } from 'react';
 
 /* eslint-disable import/extensions, import/no-unresolved */
 import ngeMain from '@osrd-project/netzgrafik-frontend/dist/netzgrafik-frontend/en/main.js?url';
@@ -8,6 +8,12 @@ import ngeStyles from '@osrd-project/netzgrafik-frontend/dist/netzgrafik-fronten
 import ngeVendor from '@osrd-project/netzgrafik-frontend/dist/netzgrafik-frontend/en/vendor.js?url';
 /* eslint-enable import/extensions, import/no-unresolved */
 
+import type { NetzgrafikDto } from './types';
+
+interface NGEElement extends HTMLElement {
+  netzgrafikDto: NetzgrafikDto;
+}
+
 const frameSrc = `
 <!DOCTYPE html>
 <html class="sbb-lean sbb-light">
@@ -22,29 +28,24 @@ const frameSrc = `
 </html>
 `;
 
-const NGE = () => {
+const NGE = ({ dto }: { dto?: NetzgrafikDto }) => {
   const frameRef = useRef<HTMLIFrameElement>(null);
 
+  const [ngeRootElement, setNgeRootElement] = useState<NGEElement | null>(null);
   useEffect(() => {
     const frame = frameRef.current!;
 
     const handleFrameLoad = () => {
       frame.removeEventListener('load', handleFrameLoad);
 
-      const ngeRoot = frame.contentDocument!.createElement('sbb-root');
+      const ngeRoot = frame.contentDocument!.createElement('sbb-root') as NGEElement;
       frame.contentDocument!.body.appendChild(ngeRoot);
+      setNgeRootElement(ngeRoot);
 
       // listens to create, update and delete operations
       // ngeRoot.addEventListener('operation', (event: Event) => {
       //   console.log('Operation received', (event as CustomEvent).detail);
       // });
-
-      // get netzgrafik model from NGE
-      // let netzgrafikDto = ngeRoot.netzgrafikDto;
-
-      // // set new netzgrafik model with new nodes
-      // netzgrafikDto.nodes = testNodesDto;
-      // ngeRoot.netzgrafikDto = netzgrafikDto;
     };
 
     frame.addEventListener('load', handleFrameLoad);
@@ -54,6 +55,12 @@ const NGE = () => {
     };
   }, []);
 
+  useEffect(() => {
+    if (ngeRootElement && dto) {
+      ngeRootElement.netzgrafikDto = dto;
+    }
+  }, [dto, ngeRootElement]);
+
   return <iframe ref={frameRef} srcDoc={frameSrc} title="NGE" className="nge-iframe-container" />;
 };
 

From 8ce66a87ee572205b3e68e63d39355bb384070ba Mon Sep 17 00:00:00 2001
From: Simon Ser <contact@emersion.fr>
Date: Thu, 1 Aug 2024 09:52:20 +0200
Subject: [PATCH 3/9] front: listen to NGE reloads

When the NGE language is switched, the <iframe> is reloaded. Keep
listening to window load events to restore the DTO properly.
---
 .../operationalStudies/components/MacroEditor/NGE.tsx           | 2 --
 1 file changed, 2 deletions(-)

diff --git a/front/src/applications/operationalStudies/components/MacroEditor/NGE.tsx b/front/src/applications/operationalStudies/components/MacroEditor/NGE.tsx
index 737747da858..d0f89bf0aac 100644
--- a/front/src/applications/operationalStudies/components/MacroEditor/NGE.tsx
+++ b/front/src/applications/operationalStudies/components/MacroEditor/NGE.tsx
@@ -36,8 +36,6 @@ const NGE = ({ dto }: { dto?: NetzgrafikDto }) => {
     const frame = frameRef.current!;
 
     const handleFrameLoad = () => {
-      frame.removeEventListener('load', handleFrameLoad);
-
       const ngeRoot = frame.contentDocument!.createElement('sbb-root') as NGEElement;
       frame.contentDocument!.body.appendChild(ngeRoot);
       setNgeRootElement(ngeRoot);

From ab2c5da84d864cfe3167973097a850f45f9d89e9 Mon Sep 17 00:00:00 2001
From: Simon Ser <contact@emersion.fr>
Date: Wed, 31 Jul 2024 14:13:33 +0200
Subject: [PATCH 4/9] front: add basic NGE node import

---
 .../components/MacroEditor/import.ts          | 245 ++++++++++++++++++
 .../views/v2/ScenarioV2.tsx                   |  16 +-
 2 files changed, 260 insertions(+), 1 deletion(-)
 create mode 100644 front/src/applications/operationalStudies/components/MacroEditor/import.ts

diff --git a/front/src/applications/operationalStudies/components/MacroEditor/import.ts b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
new file mode 100644
index 00000000000..6c6a1a85989
--- /dev/null
+++ b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
@@ -0,0 +1,245 @@
+import { osrdEditoastApi } from 'common/api/osrdEditoastApi';
+import type {
+  SearchResultItemOperationalPoint,
+  SearchPayload,
+  SearchQuery,
+  TrainScheduleResult,
+} from 'common/api/osrdEditoastApi';
+import type { AppDispatch } from 'store';
+
+import type { Node, NetzgrafikDto } from './types';
+
+// TODO: make this optional in NGE since it's SBB-specific
+const TRAINRUN_CATEGORY_HALTEZEITEN = {
+  HaltezeitIPV: { haltezeit: 0, no_halt: false },
+  HaltezeitA: { haltezeit: 0, no_halt: false },
+  HaltezeitB: { haltezeit: 0, no_halt: false },
+  HaltezeitC: { haltezeit: 0, no_halt: false },
+  HaltezeitD: { haltezeit: 0, no_halt: false },
+  HaltezeitUncategorized: { haltezeit: 0, no_halt: false },
+};
+
+const DEFAULT_DTO: NetzgrafikDto = {
+  nodes: [],
+  trainrunSections: [],
+  trainruns: [],
+  resources: [],
+  metadata: {
+    netzgrafikColors: [],
+    trainrunCategories: [],
+    trainrunFrequencies: [],
+    trainrunTimeCategories: [],
+  },
+  freeFloatingTexts: [],
+  labels: [],
+  labelGroups: [],
+  filterData: {
+    filterSettings: [],
+  },
+};
+
+/**
+ * Build a search query to fetch all operational points from their UICs,
+ * trigrams and IDs.
+ */
+const buildOpQuery = (
+  infraId: number,
+  trainSchedules: TrainScheduleResult[]
+): SearchPayload | null => {
+  const pathItems = trainSchedules.map((schedule) => schedule.path).flat();
+  const pathItemQueries = [];
+  const pathItemSet = new Set<string>();
+  // eslint-disable-next-line no-restricted-syntax
+  for (const item of pathItems) {
+    let query: SearchQuery;
+    if ('uic' in item) {
+      query = ['=', ['uic'], item.uic];
+      if (item.secondary_code) {
+        query = ['and', query, ['=', ['ch'], item.secondary_code]];
+      }
+    } else if ('trigram' in item) {
+      query = ['=', ['trigram'], item.trigram];
+      if (item.secondary_code) {
+        query = ['and', query, ['=', ['ch'], item.secondary_code]];
+      }
+    } else if ('operational_point' in item) {
+      query = ['=', ['obj_id'], item.operational_point];
+    } else {
+      // eslint-disable-next-line no-continue
+      continue; // track offset, handled by creating an empty node
+    }
+
+    // Avoid including the same query twice in the search payload
+    const key = JSON.stringify(query);
+    if (pathItemSet.has(key)) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    pathItemSet.add(key);
+    pathItemQueries.push(query);
+  }
+
+  if (pathItemQueries.length === 0) {
+    return null;
+  }
+
+  return {
+    object: 'operationalpoint',
+    query: ['and', ['=', ['infra_id'], infraId], ['or', ...pathItemQueries]],
+  };
+};
+
+/**
+ * Execute the search payload and collect all result pages.
+ */
+const executeSearch = async (
+  searchPayload: SearchPayload,
+  dispatch: AppDispatch
+): Promise<SearchResultItemOperationalPoint[]> => {
+  const pageSize = 100;
+  let done = false;
+  const searchResults: SearchResultItemOperationalPoint[] = [];
+  for (let page = 1; !done; page += 1) {
+    const searchPromise = dispatch(
+      osrdEditoastApi.endpoints.postSearch.initiate({
+        page,
+        pageSize,
+        searchPayload,
+      })
+    );
+    // eslint-disable-next-line no-await-in-loop
+    const results = (await searchPromise.unwrap()) as SearchResultItemOperationalPoint[];
+    searchResults.push(...results);
+    done = results.length < pageSize;
+  }
+  return searchResults;
+};
+
+/**
+ * Convert geographic coordinates (latitude/longitude) into screen coordinates
+ * (pixels).
+ */
+const convertGeoCoords = (nodes: Node[]) => {
+  const xCoords = nodes.map((node) => node.positionX);
+  const yCoords = nodes.map((node) => node.positionY);
+  const minX = Math.min(...xCoords);
+  const minY = Math.min(...yCoords);
+  const maxX = Math.max(...xCoords);
+  const maxY = Math.max(...yCoords);
+  const width = maxX - minX;
+  const height = maxY - minY;
+  // TODO: grab NGE component size
+  const scaleX = 800;
+  const scaleY = 500;
+  const padding = 0.1;
+
+  return nodes.map((node) => {
+    const normalizedX = (node.positionX - minX) / width;
+    const normalizedY = 1 - (node.positionY - minY) / height;
+    const paddedX = normalizedX * (1 - 2 * padding) + padding;
+    const paddedY = normalizedY * (1 - 2 * padding) + padding;
+    return {
+      ...node,
+      positionX: scaleX * paddedX,
+      positionY: scaleY * paddedY,
+    };
+  });
+};
+
+const importTimetable = async (
+  infraId: number,
+  timetableId: number,
+  dispatch: AppDispatch
+): Promise<NetzgrafikDto> => {
+  const timetablePromise = dispatch(
+    osrdEditoastApi.endpoints.getV2TimetableById.initiate({ id: timetableId })
+  );
+  const { train_ids } = await timetablePromise.unwrap();
+
+  const trainSchedulesPromise = dispatch(
+    osrdEditoastApi.endpoints.postV2TrainSchedule.initiate({
+      body: { ids: train_ids },
+    })
+  );
+  const trainSchedules = await trainSchedulesPromise.unwrap();
+
+  const searchPayload = buildOpQuery(infraId, trainSchedules);
+  const searchResults = searchPayload ? await executeSearch(searchPayload, dispatch) : [];
+
+  const resource = {
+    id: 1,
+    capacity: trainSchedules.length,
+  };
+
+  let nodes: Node[] = [];
+  const nodesById = new Map<string | number, Node>();
+  let nodeId = 0;
+  let nodePositionX = 0;
+  const createNode = ({
+    id,
+    trigram,
+    fullName,
+    positionX,
+    positionY,
+  }: {
+    id?: string | number;
+    trigram?: string;
+    fullName?: string;
+    positionX?: number;
+    positionY?: number;
+  }): Node => {
+    if (id === undefined) {
+      id = nodeId;
+      nodeId += 1;
+    }
+    if (positionX === undefined) {
+      positionX = nodePositionX;
+      nodePositionX += 200;
+    }
+
+    const node = {
+      id: id!,
+      betriebspunktName: trigram || '',
+      fullName: fullName || '',
+      positionX: positionX!,
+      positionY: positionY || 0,
+      ports: [],
+      transitions: [],
+      connections: [],
+      resourceId: resource.id,
+      perronkanten: 10,
+      connectionTime: 0,
+      trainrunCategoryHaltezeiten: TRAINRUN_CATEGORY_HALTEZEITEN,
+      symmetryAxis: 0,
+      warnings: [],
+      labelIds: [],
+    };
+
+    nodes.push(node);
+    nodesById.set(node.id, node);
+
+    return node;
+  };
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const op of searchResults) {
+    createNode({
+      id: op.obj_id,
+      trigram: op.trigram + (op.ch ? `/${op.ch}` : ''),
+      fullName: op.name,
+      positionX: op.geographic.coordinates[0],
+      positionY: op.geographic.coordinates[1],
+    });
+  }
+
+  nodes = convertGeoCoords(nodes);
+
+  return {
+    ...DEFAULT_DTO,
+    resources: [resource],
+    nodes,
+  };
+};
+
+export default importTimetable;
diff --git a/front/src/applications/operationalStudies/views/v2/ScenarioV2.tsx b/front/src/applications/operationalStudies/views/v2/ScenarioV2.tsx
index dd8c76a2677..37589747122 100644
--- a/front/src/applications/operationalStudies/views/v2/ScenarioV2.tsx
+++ b/front/src/applications/operationalStudies/views/v2/ScenarioV2.tsx
@@ -32,6 +32,8 @@ import { getSpaceTimeChartData, selectProjectionV2 } from './getSimulationResult
 import ImportTrainScheduleV2 from './ImportTrainScheduleV2';
 import ManageTrainScheduleV2 from './ManageTrainScheduleV2';
 import SimulationResultsV2 from './SimulationResultsV2';
+import importTimetableToNGE from '../../components/MacroEditor/import';
+import type { NetzgrafikDto } from '../../components/MacroEditor/types';
 
 type SimulationParams = {
   projectId: string;
@@ -163,6 +165,18 @@ const ScenarioV2 = () => {
     setCollapsedTimetable(isMacroMode);
   };
 
+  const [ngeDto, setNgeDto] = useState<NetzgrafikDto | undefined>(undefined);
+  useEffect(() => {
+    if (!infraId || !timetableId || !isMacro) {
+      return;
+    }
+    const doImport = async () => {
+      const dto = await importTimetableToNGE(infraId, timetableId, dispatch);
+      setNgeDto(dto);
+    };
+    doImport();
+  }, [infraId, timetableId, isMacro]);
+
   if (!scenario || !infraId || !timetableId || !timetable) return null;
 
   return (
@@ -341,7 +355,7 @@ const ScenarioV2 = () => {
                 )}
                 {isMacro ? (
                   <div className={cx(collapsedTimetable ? 'macro-container' : 'h-100')}>
-                    <NGE />
+                    <NGE dto={ngeDto} />
                   </div>
                 ) : (
                   isInfraLoaded &&

From f597d9cbf75deebabc7c6744d8b0f4453d039d07 Mon Sep 17 00:00:00 2001
From: Simon Ser <contact@emersion.fr>
Date: Mon, 15 Jul 2024 08:33:11 +0200
Subject: [PATCH 5/9] front: add default trainrun categories/freqs to NGE

Fixes errors when adding a new trainrun.
---
 .../components/MacroEditor/import.ts          | 58 +++++++++++++++++--
 .../components/MacroEditor/types.ts           | 42 +++++++++++++-
 2 files changed, 91 insertions(+), 9 deletions(-)

diff --git a/front/src/applications/operationalStudies/components/MacroEditor/import.ts b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
index 6c6a1a85989..497ee264f33 100644
--- a/front/src/applications/operationalStudies/components/MacroEditor/import.ts
+++ b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
@@ -7,7 +7,13 @@ import type {
 } from 'common/api/osrdEditoastApi';
 import type { AppDispatch } from 'store';
 
-import type { Node, NetzgrafikDto } from './types';
+import type {
+  Node,
+  TrainrunCategory,
+  TrainrunFrequency,
+  TrainrunTimeCategory,
+  NetzgrafikDto,
+} from './types';
 
 // TODO: make this optional in NGE since it's SBB-specific
 const TRAINRUN_CATEGORY_HALTEZEITEN = {
@@ -19,16 +25,50 @@ const TRAINRUN_CATEGORY_HALTEZEITEN = {
   HaltezeitUncategorized: { haltezeit: 0, no_halt: false },
 };
 
+const DEFAULT_TRAINRUN_CATEGORY: TrainrunCategory = {
+  id: 1, // In NGE, Trainrun.DEFAULT_TRAINRUN_CATEGORY
+  order: 0,
+  name: 'Default',
+  shortName: '', // TODO: find a better way to hide this in the graph
+  fachCategory: 'HaltezeitUncategorized',
+  colorRef: 'EC',
+  minimalTurnaroundTime: 0,
+  nodeHeadwayStop: 0,
+  nodeHeadwayNonStop: 0,
+  sectionHeadway: 0,
+};
+
+const DEFAULT_TRAINRUN_FREQUENCY: TrainrunFrequency = {
+  id: 3, // In NGE, Trainrun.DEFAULT_TRAINRUN_FREQUENCY
+  order: 0,
+  frequency: 60,
+  offset: 0,
+  name: 'Default',
+  /** Short name, needs to be unique */
+  shortName: 'D',
+  linePatternRef: '60',
+};
+
+const DEFAULT_TRAINRUN_TIME_CATEGORY: TrainrunTimeCategory = {
+  id: 0, // In NGE, Trainrun.DEFAULT_TRAINRUN_TIME_CATEGORY
+  order: 0,
+  name: 'Default',
+  shortName: '7/24',
+  dayTimeInterval: [],
+  weekday: [1, 2, 3, 4, 5, 6, 7],
+  linePatternRef: '7/24',
+};
+
 const DEFAULT_DTO: NetzgrafikDto = {
+  resources: [],
   nodes: [],
-  trainrunSections: [],
   trainruns: [],
-  resources: [],
+  trainrunSections: [],
   metadata: {
     netzgrafikColors: [],
-    trainrunCategories: [],
-    trainrunFrequencies: [],
-    trainrunTimeCategories: [],
+    trainrunCategories: [DEFAULT_TRAINRUN_CATEGORY],
+    trainrunFrequencies: [DEFAULT_TRAINRUN_FREQUENCY],
+    trainrunTimeCategories: [DEFAULT_TRAINRUN_TIME_CATEGORY],
   },
   freeFloatingTexts: [],
   labels: [],
@@ -238,6 +278,12 @@ const importTimetable = async (
   return {
     ...DEFAULT_DTO,
     resources: [resource],
+    metadata: {
+      netzgrafikColors: [],
+      trainrunCategories: [DEFAULT_TRAINRUN_CATEGORY],
+      trainrunFrequencies: [DEFAULT_TRAINRUN_FREQUENCY],
+      trainrunTimeCategories: [DEFAULT_TRAINRUN_TIME_CATEGORY],
+    },
     nodes,
   };
 };
diff --git a/front/src/applications/operationalStudies/components/MacroEditor/types.ts b/front/src/applications/operationalStudies/components/MacroEditor/types.ts
index b81a51da887..19b310703e7 100644
--- a/front/src/applications/operationalStudies/components/MacroEditor/types.ts
+++ b/front/src/applications/operationalStudies/components/MacroEditor/types.ts
@@ -67,6 +67,42 @@ export type TrainrunSection = {
   warnings: unknown[];
 };
 
+export type TrainrunCategory = {
+  id: number;
+  order: number;
+  name: string;
+  /** Short name, needs to be unique */
+  shortName: string;
+  fachCategory: string;
+  colorRef: string;
+  minimalTurnaroundTime: number;
+  nodeHeadwayStop: number;
+  nodeHeadwayNonStop: number;
+  sectionHeadway: number;
+};
+
+export type TrainrunFrequency = {
+  id: number;
+  order: number;
+  frequency: number;
+  offset: number;
+  name: string;
+  /** Short name, needs to be unique */
+  shortName: string;
+  linePatternRef: string;
+};
+
+export type TrainrunTimeCategory = {
+  id: number;
+  order: number;
+  name: string;
+  /** Short name, needs to be unique */
+  shortName: string;
+  dayTimeInterval: unknown[];
+  weekday: number[];
+  linePatternRef: string;
+};
+
 export type Resource = {
   id: number;
   capacity: number;
@@ -82,9 +118,9 @@ export type NetzgrafikDto = {
   resources: Resource[];
   metadata: {
     netzgrafikColors: unknown[];
-    trainrunCategories: unknown[];
-    trainrunFrequencies: unknown[];
-    trainrunTimeCategories: unknown[];
+    trainrunCategories: TrainrunCategory[];
+    trainrunFrequencies: TrainrunFrequency[];
+    trainrunTimeCategories: TrainrunTimeCategory[];
   };
   freeFloatingTexts: unknown[];
   labels: unknown[];

From abcdbb50932341f26ca35711cd616a87776b8af6 Mon Sep 17 00:00:00 2001
From: Simon Ser <contact@emersion.fr>
Date: Mon, 15 Jul 2024 15:11:05 +0200
Subject: [PATCH 6/9] front: import train runs into NGE

---
 .../components/MacroEditor/import.ts          | 90 +++++++++++++++++++
 .../components/MacroEditor/types.ts           | 29 ++++--
 .../components/MacroEditor/utils.ts           | 24 +++++
 3 files changed, 137 insertions(+), 6 deletions(-)
 create mode 100644 front/src/applications/operationalStudies/components/MacroEditor/utils.ts

diff --git a/front/src/applications/operationalStudies/components/MacroEditor/import.ts b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
index 497ee264f33..37171dada1c 100644
--- a/front/src/applications/operationalStudies/components/MacroEditor/import.ts
+++ b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
@@ -9,11 +9,15 @@ import type { AppDispatch } from 'store';
 
 import type {
   Node,
+  Trainrun,
+  TrainrunSection,
   TrainrunCategory,
   TrainrunFrequency,
   TrainrunTimeCategory,
   NetzgrafikDto,
 } from './types';
+import { PortAlignment } from './types';
+import { findOpFromPathItem } from './utils';
 
 // TODO: make this optional in NGE since it's SBB-specific
 const TRAINRUN_CATEGORY_HALTEZEITEN = {
@@ -275,6 +279,90 @@ const importTimetable = async (
 
   nodes = convertGeoCoords(nodes);
 
+  // Create one NGE train run per OSRD train schedule
+  const trainruns: Trainrun[] = trainSchedules.map((trainSchedule) => ({
+    id: trainSchedule.id,
+    name: trainSchedule.train_name,
+    categoryId: DEFAULT_TRAINRUN_CATEGORY.id,
+    frequencyId: DEFAULT_TRAINRUN_FREQUENCY.id,
+    trainrunTimeCategoryId: DEFAULT_TRAINRUN_TIME_CATEGORY.id,
+    labelIds: [],
+  }));
+
+  let portId = 0;
+  const createPort = (trainrunSectionId: number) => {
+    const port = {
+      id: portId,
+      trainrunSectionId,
+      positionIndex: 0,
+      positionAlignment: PortAlignment.Top,
+    };
+    portId += 1;
+    return port;
+  };
+
+  let trainrunSectionId = 0;
+  const trainrunSections: TrainrunSection[] = trainSchedules
+    .map((trainSchedule) => {
+      const ops = trainSchedule.path.map((pathItem) => findOpFromPathItem(pathItem, searchResults));
+      const foundAllOps = ops.every((op) => op);
+      if (!foundAllOps) {
+        return [];
+      }
+
+      // OSRD describes the path in terms of nodes, NGE describes it in terms
+      // of sections between nodes. Iterate over path items two-by-two to
+      // convert them.
+      return ops.slice(0, -1).map((sourceOp, i) => {
+        const sourceNodeId = sourceOp!.obj_id;
+        const targetNodeId = ops[i + 1]!.obj_id;
+
+        const timeLockStub = {
+          time: 0,
+          consecutiveTime: null,
+          lock: false,
+          warning: null,
+          timeFormatter: null,
+        };
+
+        const sourcePort = createPort(trainrunSectionId);
+        const targetPort = createPort(trainrunSectionId);
+
+        const sourceNode = nodesById.get(sourceNodeId)!;
+        const targetNode = nodesById.get(targetNodeId)!;
+        sourceNode.ports.push(sourcePort);
+        targetNode.ports.push(targetPort);
+
+        // TODO: create transitions between ports
+
+        const trainrunSection = {
+          id: trainrunSectionId,
+          sourceNodeId,
+          sourcePortId: sourcePort.id,
+          targetNodeId,
+          targetPortId: targetPort.id,
+          travelTime: { ...timeLockStub },
+          sourceDeparture: { ...timeLockStub },
+          sourceArrival: { ...timeLockStub },
+          targetDeparture: { ...timeLockStub },
+          targetArrival: { ...timeLockStub },
+          numberOfStops: 0,
+          trainrunId: trainSchedule.id,
+          resourceId: resource.id,
+          path: {
+            path: [],
+            textPositions: [],
+          },
+          specificTrainrunSectionFrequencyId: 0,
+          warnings: [],
+        };
+        trainrunSectionId += 1;
+
+        return trainrunSection;
+      });
+    })
+    .flat();
+
   return {
     ...DEFAULT_DTO,
     resources: [resource],
@@ -285,6 +373,8 @@ const importTimetable = async (
       trainrunTimeCategories: [DEFAULT_TRAINRUN_TIME_CATEGORY],
     },
     nodes,
+    trainruns,
+    trainrunSections,
   };
 };
 
diff --git a/front/src/applications/operationalStudies/components/MacroEditor/types.ts b/front/src/applications/operationalStudies/components/MacroEditor/types.ts
index 19b310703e7..88d6f84f09c 100644
--- a/front/src/applications/operationalStudies/components/MacroEditor/types.ts
+++ b/front/src/applications/operationalStudies/components/MacroEditor/types.ts
@@ -13,7 +13,7 @@ export type Node = {
   fullName: string;
   positionX: number;
   positionY: number;
-  ports: unknown[];
+  ports: Port[];
   transitions: unknown[];
   connections: unknown[];
   resourceId: number;
@@ -27,6 +27,20 @@ export type Node = {
   labelIds: number[];
 };
 
+export type Port = {
+  id: number;
+  positionIndex: number;
+  positionAlignment: PortAlignment;
+  trainrunSectionId: number;
+};
+
+export enum PortAlignment {
+  Top,
+  Bottom,
+  Left,
+  Right,
+}
+
 export type Trainrun = {
   id: number;
   name: string;
@@ -38,7 +52,7 @@ export type Trainrun = {
 
 export type TimeLock = {
   time: number;
-  consecutiveTime: number;
+  consecutiveTime: number | null;
   lock: boolean;
   warning: null;
   timeFormatter: null;
@@ -51,11 +65,11 @@ export type TrainrunSection = {
   targetNodeId: number | string;
   targetPortId: number;
 
-  sourceArrival: TimeLock;
+  travelTime: TimeLock;
   sourceDeparture: TimeLock;
-  targetArrival: TimeLock;
+  sourceArrival: TimeLock;
   targetDeparture: TimeLock;
-  travelTime: TimeLock;
+  targetArrival: TimeLock;
 
   numberOfStops: number;
 
@@ -63,7 +77,10 @@ export type TrainrunSection = {
   resourceId: number;
 
   specificTrainrunSectionFrequencyId: number;
-  path: null;
+  path: {
+    path: unknown[];
+    textPositions: unknown[];
+  };
   warnings: unknown[];
 };
 
diff --git a/front/src/applications/operationalStudies/components/MacroEditor/utils.ts b/front/src/applications/operationalStudies/components/MacroEditor/utils.ts
new file mode 100644
index 00000000000..dbe76fb05b9
--- /dev/null
+++ b/front/src/applications/operationalStudies/components/MacroEditor/utils.ts
@@ -0,0 +1,24 @@
+import type {
+  PathItemLocation,
+  SearchResultItemOperationalPoint,
+} from 'common/api/osrdEditoastApi';
+
+// eslint-disable-next-line import/prefer-default-export
+export const findOpFromPathItem = (
+  pathItem: PathItemLocation,
+  searchResults: SearchResultItemOperationalPoint[]
+) =>
+  searchResults.find((searchResult) => {
+    if ('uic' in pathItem) {
+      return searchResult.uic === pathItem.uic && searchResult.ch === pathItem.secondary_code;
+    }
+    if ('trigram' in pathItem) {
+      return (
+        searchResult.trigram === pathItem.trigram && searchResult.ch === pathItem.secondary_code
+      );
+    }
+    if ('operational_point' in pathItem) {
+      return searchResult.obj_id === pathItem.operational_point;
+    }
+    return false;
+  });

From c5acf04b8215e46610d223405eea6efc312ce619 Mon Sep 17 00:00:00 2001
From: Simon Ser <contact@emersion.fr>
Date: Tue, 16 Jul 2024 12:39:25 +0200
Subject: [PATCH 7/9] front: create node transitions in NGE

---
 .../components/MacroEditor/import.ts          | 22 ++++++++++++++++++-
 .../components/MacroEditor/types.ts           |  9 +++++++-
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/front/src/applications/operationalStudies/components/MacroEditor/import.ts b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
index 37171dada1c..ff3c0f0debe 100644
--- a/front/src/applications/operationalStudies/components/MacroEditor/import.ts
+++ b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
@@ -9,6 +9,7 @@ import type { AppDispatch } from 'store';
 
 import type {
   Node,
+  Port,
   Trainrun,
   TrainrunSection,
   TrainrunCategory,
@@ -301,6 +302,18 @@ const importTimetable = async (
     return port;
   };
 
+  let transitionId = 0;
+  const createTransition = (port1Id: number, port2Id: number) => {
+    const transition = {
+      id: transitionId,
+      port1Id,
+      port2Id,
+      isNonStopTransit: false,
+    };
+    transitionId += 1;
+    return transition;
+  };
+
   let trainrunSectionId = 0;
   const trainrunSections: TrainrunSection[] = trainSchedules
     .map((trainSchedule) => {
@@ -313,6 +326,7 @@ const importTimetable = async (
       // OSRD describes the path in terms of nodes, NGE describes it in terms
       // of sections between nodes. Iterate over path items two-by-two to
       // convert them.
+      let prevPort: Port | null = null;
       return ops.slice(0, -1).map((sourceOp, i) => {
         const sourceNodeId = sourceOp!.obj_id;
         const targetNodeId = ops[i + 1]!.obj_id;
@@ -333,7 +347,13 @@ const importTimetable = async (
         sourceNode.ports.push(sourcePort);
         targetNode.ports.push(targetPort);
 
-        // TODO: create transitions between ports
+        // Create a transition between the previous section and the one we're
+        // creating
+        if (prevPort) {
+          const transition = createTransition(prevPort.id, sourcePort.id);
+          sourceNode.transitions.push(transition);
+        }
+        prevPort = targetPort;
 
         const trainrunSection = {
           id: trainrunSectionId,
diff --git a/front/src/applications/operationalStudies/components/MacroEditor/types.ts b/front/src/applications/operationalStudies/components/MacroEditor/types.ts
index 88d6f84f09c..6a68027074a 100644
--- a/front/src/applications/operationalStudies/components/MacroEditor/types.ts
+++ b/front/src/applications/operationalStudies/components/MacroEditor/types.ts
@@ -14,7 +14,7 @@ export type Node = {
   positionX: number;
   positionY: number;
   ports: Port[];
-  transitions: unknown[];
+  transitions: Transition[];
   connections: unknown[];
   resourceId: number;
   /** Number of tracks where train can stop */
@@ -34,6 +34,13 @@ export type Port = {
   trainrunSectionId: number;
 };
 
+export type Transition = {
+  id: number;
+  port1Id: number;
+  port2Id: number;
+  isNonStopTransit: boolean;
+};
+
 export enum PortAlignment {
   Top,
   Bottom,

From e4af5ceb98fcc469494eabc581bfeb20fb0856ee Mon Sep 17 00:00:00 2001
From: Simon Ser <contact@emersion.fr>
Date: Thu, 1 Aug 2024 15:09:21 +0200
Subject: [PATCH 8/9] front: create empty NGE nodes when OSRD OP is missing

---
 .../components/MacroEditor/import.ts          | 20 +++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/front/src/applications/operationalStudies/components/MacroEditor/import.ts b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
index ff3c0f0debe..05049f585b0 100644
--- a/front/src/applications/operationalStudies/components/MacroEditor/import.ts
+++ b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
@@ -317,19 +317,23 @@ const importTimetable = async (
   let trainrunSectionId = 0;
   const trainrunSections: TrainrunSection[] = trainSchedules
     .map((trainSchedule) => {
-      const ops = trainSchedule.path.map((pathItem) => findOpFromPathItem(pathItem, searchResults));
-      const foundAllOps = ops.every((op) => op);
-      if (!foundAllOps) {
-        return [];
-      }
+      // Figure out the node ID for each path item
+      const pathNodeIds = trainSchedule.path.map((pathItem) => {
+        const op = findOpFromPathItem(pathItem, searchResults);
+        if (op) {
+          return op.obj_id;
+        }
+
+        const node = createNode({ trigram: 'trigram' in pathItem ? pathItem.trigram : undefined });
+        return node.id;
+      });
 
       // OSRD describes the path in terms of nodes, NGE describes it in terms
       // of sections between nodes. Iterate over path items two-by-two to
       // convert them.
       let prevPort: Port | null = null;
-      return ops.slice(0, -1).map((sourceOp, i) => {
-        const sourceNodeId = sourceOp!.obj_id;
-        const targetNodeId = ops[i + 1]!.obj_id;
+      return pathNodeIds.slice(0, -1).map((sourceNodeId, i) => {
+        const targetNodeId = pathNodeIds[i + 1]!;
 
         const timeLockStub = {
           time: 0,

From 14182e5ee8982e72eafe515093d85cfc1013e229 Mon Sep 17 00:00:00 2001
From: Simon Ser <contact@emersion.fr>
Date: Thu, 1 Aug 2024 13:23:05 +0200
Subject: [PATCH 9/9] front: import train schedule times into NGE

---
 .../components/MacroEditor/import.ts          | 69 +++++++++++++++----
 .../components/MacroEditor/utils.ts           |  5 +-
 2 files changed, 59 insertions(+), 15 deletions(-)

diff --git a/front/src/applications/operationalStudies/components/MacroEditor/import.ts b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
index 05049f585b0..96875eb9ee6 100644
--- a/front/src/applications/operationalStudies/components/MacroEditor/import.ts
+++ b/front/src/applications/operationalStudies/components/MacroEditor/import.ts
@@ -10,6 +10,7 @@ import type { AppDispatch } from 'store';
 import type {
   Node,
   Port,
+  TimeLock,
   Trainrun,
   TrainrunSection,
   TrainrunCategory,
@@ -18,7 +19,7 @@ import type {
   NetzgrafikDto,
 } from './types';
 import { PortAlignment } from './types';
-import { findOpFromPathItem } from './utils';
+import { findOpFromPathItem, addDurationToDate } from './utils';
 
 // TODO: make this optional in NGE since it's SBB-specific
 const TRAINRUN_CATEGORY_HALTEZEITEN = {
@@ -83,6 +84,14 @@ const DEFAULT_DTO: NetzgrafikDto = {
   },
 };
 
+const DEFAULT_TIME_LOCK: TimeLock = {
+  time: 0,
+  consecutiveTime: null,
+  lock: false,
+  warning: null,
+  timeFormatter: null,
+};
+
 /**
  * Build a search query to fetch all operational points from their UICs,
  * trigrams and IDs.
@@ -328,6 +337,16 @@ const importTimetable = async (
         return node.id;
       });
 
+      const startTime = new Date(trainSchedule.start_time);
+      const createTimeLock = (time: Date): TimeLock => ({
+        time: time.getMinutes(),
+        // getTime() is in milliseconds, consecutiveTime is in minutes
+        consecutiveTime: (time.getTime() - startTime.getTime()) / (60 * 1000),
+        lock: false,
+        warning: null,
+        timeFormatter: null,
+      });
+
       // OSRD describes the path in terms of nodes, NGE describes it in terms
       // of sections between nodes. Iterate over path items two-by-two to
       // convert them.
@@ -335,14 +354,6 @@ const importTimetable = async (
       return pathNodeIds.slice(0, -1).map((sourceNodeId, i) => {
         const targetNodeId = pathNodeIds[i + 1]!;
 
-        const timeLockStub = {
-          time: 0,
-          consecutiveTime: null,
-          lock: false,
-          warning: null,
-          timeFormatter: null,
-        };
-
         const sourcePort = createPort(trainrunSectionId);
         const targetPort = createPort(trainrunSectionId);
 
@@ -351,25 +362,55 @@ const importTimetable = async (
         sourceNode.ports.push(sourcePort);
         targetNode.ports.push(targetPort);
 
+        const sourceScheduleEntry = trainSchedule.schedule!.find(
+          (entry) => entry.at === trainSchedule.path[i].id
+        );
+        const targetScheduleEntry = trainSchedule.schedule!.find(
+          (entry) => entry.at === trainSchedule.path[i + 1].id
+        );
+
         // Create a transition between the previous section and the one we're
         // creating
         if (prevPort) {
           const transition = createTransition(prevPort.id, sourcePort.id);
+          transition.isNonStopTransit = !sourceScheduleEntry?.stop_for;
           sourceNode.transitions.push(transition);
         }
         prevPort = targetPort;
 
+        let sourceDeparture = { ...DEFAULT_TIME_LOCK };
+        if (i === 0) {
+          sourceDeparture = createTimeLock(startTime);
+        } else if (sourceScheduleEntry && sourceScheduleEntry.arrival) {
+          sourceDeparture = createTimeLock(
+            addDurationToDate(
+              addDurationToDate(startTime, sourceScheduleEntry.arrival),
+              sourceScheduleEntry.stop_for || 'P0D'
+            )
+          );
+        }
+
+        let targetArrival = { ...DEFAULT_TIME_LOCK };
+        if (targetScheduleEntry && targetScheduleEntry.arrival) {
+          targetArrival = createTimeLock(addDurationToDate(startTime, targetScheduleEntry.arrival));
+        }
+
+        const travelTime = { ...DEFAULT_TIME_LOCK };
+        if (targetArrival.time && sourceDeparture.time) {
+          travelTime.time = (targetArrival.time - sourceDeparture.time + 60) % 60;
+        }
+
         const trainrunSection = {
           id: trainrunSectionId,
           sourceNodeId,
           sourcePortId: sourcePort.id,
           targetNodeId,
           targetPortId: targetPort.id,
-          travelTime: { ...timeLockStub },
-          sourceDeparture: { ...timeLockStub },
-          sourceArrival: { ...timeLockStub },
-          targetDeparture: { ...timeLockStub },
-          targetArrival: { ...timeLockStub },
+          travelTime,
+          sourceDeparture,
+          sourceArrival: { ...DEFAULT_TIME_LOCK },
+          targetDeparture: { ...DEFAULT_TIME_LOCK },
+          targetArrival,
           numberOfStops: 0,
           trainrunId: trainSchedule.id,
           resourceId: resource.id,
diff --git a/front/src/applications/operationalStudies/components/MacroEditor/utils.ts b/front/src/applications/operationalStudies/components/MacroEditor/utils.ts
index dbe76fb05b9..c2e6e7486df 100644
--- a/front/src/applications/operationalStudies/components/MacroEditor/utils.ts
+++ b/front/src/applications/operationalStudies/components/MacroEditor/utils.ts
@@ -2,8 +2,8 @@ import type {
   PathItemLocation,
   SearchResultItemOperationalPoint,
 } from 'common/api/osrdEditoastApi';
+import { ISO8601Duration2sec } from 'utils/timeManipulation';
 
-// eslint-disable-next-line import/prefer-default-export
 export const findOpFromPathItem = (
   pathItem: PathItemLocation,
   searchResults: SearchResultItemOperationalPoint[]
@@ -22,3 +22,6 @@ export const findOpFromPathItem = (
     }
     return false;
   });
+
+export const addDurationToDate = (date: Date, duration: string) =>
+  new Date(date.getTime() + ISO8601Duration2sec(duration) * 1000);