front: import missions from xml file

Signed-off-by: romainvalls <[email protected]>

Author: RomainValls

front/src/applications/operationalStudies/views/ImportTimetableItem.tsx

@@ -12,6 +12,7 @@ import {
   ImportTimetableItemConfig,
   ImportTimetableItemTrainsList,
 } from 'modules/trainschedule/components/ImportTimetableItem';
+import type { ImportedPacedTrainSchedule } from 'modules/trainschedule/components/ImportTimetableItem/ImportTimetableItemConfig';
 import { setFailure } from 'reducers/main';
 import type { TimetableItem } from 'reducers/osrdconf/types';
 import { useAppDispatch } from 'store';
@@ -31,6 +32,7 @@ const ImportTimetableItem = ({ timetableId, upsertTimetableItems }: ImportTimeta
     paced_trains: [],
   });
   const [trainsXmlData, setTrainsXmlData] = useState<ImportedTrainSchedule[]>([]);
+  const [pacedTrainXmlData, setPacedTrainXmlData] = useState<ImportedPacedTrainSchedule[]>([]);
 
   const { data: { results: rollingStocks } = { results: [] }, isError } =
     osrdEditoastApi.endpoints.getLightRollingStock.useQuery({
@@ -55,13 +57,15 @@ const ImportTimetableItem = ({ timetableId, upsertTimetableItems }: ImportTimeta
         setTrainsList={setTrainsList}
         setTrainsJsonData={setTrainsJsonData}
         setTrainsXmlData={setTrainsXmlData}
+        setPacedTrainsXmlData={setPacedTrainXmlData}
       />
       <ImportTimetableItemTrainsList
         isLoading={isLoading}
         timetableId={timetableId}
         trainsList={trainsList}
         trainsJsonData={trainsJsonData}
         trainsXmlData={trainsXmlData}
+        pacedTrainXmlData={pacedTrainXmlData}
         upsertTimetableItems={upsertTimetableItems}
       />
     </main>

front/src/modules/trainschedule/components/ImportTimetableItem/ImportTimetableItemConfig.tsx

@@ -20,26 +20,36 @@ import StationSelector from 'modules/trainschedule/components/ImportTimetableIte
 import { setFailure, setWarning } from 'reducers/main';
 import { useAppDispatch } from 'store';
 import { formatLocalDate } from 'utils/date';
+import { Duration } from 'utils/duration';
 
 import { buildSteps, cleanTimeFormat } from './helpers/buildStepsFromOcp';
+import { findMostFrequentScheduleInPacedTrain } from './helpers/findMostFrequentXmlSchedule';
 import {
   handleFileReadingError,
   processJsonFile,
   processXmlFile,
 } from '../ManageTrainSchedule/helpers/handleParseFiles';
 
+export type ImportedPacedTrainSchedule = ImportedTrainSchedule & {
+  paced: {
+    interval: string;
+    time_window: string;
+  };
+};
 interface ImportTimetableItemConfigProps {
   setTrainsList: (trainsList: ImportedTrainSchedule[]) => void;
   setIsLoading: (isLoading: boolean) => void;
   setTrainsJsonData: (trainsJsonData: TimetableJsonPayload) => void;
   setTrainsXmlData: (trainsXmlData: ImportedTrainSchedule[]) => void;
+  setPacedTrainsXmlData: (pacedTrainsXmlData: ImportedPacedTrainSchedule[]) => void;
 }
 
 const ImportTimetableItemConfig = ({
   setTrainsList,
   setIsLoading,
   setTrainsJsonData,
   setTrainsXmlData,
+  setPacedTrainsXmlData,
 }: ImportTimetableItemConfigProps) => {
   const { t } = useTranslation('operational-studies', { keyPrefix: 'importTrains' });
   const [from, setFrom] = useState<ImportStation | undefined>();
@@ -215,7 +225,7 @@ const ImportTimetableItemConfig = ({
     return updatedTrainSchedules;
   };
 
-  const parseRailML = async (xmlDoc: Document): Promise<ImportedTrainSchedule[]> => {
+  const parseXML = async (xmlDoc: Document): Promise<ImportedTrainSchedule[]> => {
     const trainSchedules: ImportedTrainSchedule[] = [];
 
     // Initialize localCichDict
@@ -237,6 +247,10 @@ const ImportTimetableItemConfig = ({
       });
     });
 
+    const pacedTrains: Record<string, ImportedTrainSchedule[]> = {};
+    const trainGroups = Array.from(xmlDoc.getElementsByTagName('trainGroup'));
+
+    const trainSchedulesByTrainPartId: Record<string, ImportedTrainSchedule> = {};
     const trainParts = Array.from(xmlDoc.getElementsByTagName('trainPart'));
     const period = xmlDoc.getElementsByTagName('timetablePeriod')[0];
     const startDate = period ? period.getAttribute('startDate') : null;
@@ -248,9 +262,10 @@ const ImportTimetableItemConfig = ({
 
     trainParts.forEach((train) => {
       const trainNumber = train.getAttribute('id') || '';
+      const trainPartId = train.getAttribute('id') || '';
       const ocpSteps = Array.from(train.getElementsByTagName('ocpTT'));
       const formationTT = train.getElementsByTagName('formationTT')[0];
-      const rollingStockViriato = formationTT?.getAttribute('formationRef');
+      const rollingStockXml = formationTT?.getAttribute('formationRef');
       const firstOcpTT = ocpSteps[0];
       const firstDepartureTime = firstOcpTT
         .getElementsByTagName('times')[0]
@@ -269,18 +284,144 @@ const ImportTimetableItemConfig = ({
 
       const trainSchedule: ImportedTrainSchedule = {
         trainNumber,
-        rollingStock: rollingStockViriato, // RollingStocks in viriato files rarely have the correct format
+        rollingStock: rollingStockXml, // RollingStocks in xml files rarely have the correct format
         departureTime: `${startDate} ${firstDepartureTimeformatted}`,
         arrivalTime: `${startDate} ${lastDepartureTimeformatted}`,
         departure: '', // Default for testing
         steps: adaptedSteps,
       };
-
+      trainSchedulesByTrainPartId[trainPartId] = trainSchedule;
       trainSchedules.push(trainSchedule);
     });
+
+    const trainElementsById: Record<string, Element> = {};
+    Array.from(xmlDoc.getElementsByTagName('train')).forEach((train) => {
+      const id = train.getAttribute('id');
+      if (id) {
+        trainElementsById[id] = train;
+      }
+    });
+
+    trainGroups.forEach((trainGroup) => {
+      const pacedTrainId = trainGroup.getAttribute('id')!;
+
+      const trainRefs = Array.from(trainGroup.getElementsByTagName('trainRef'));
+      pacedTrains[pacedTrainId] = trainRefs
+        .map((trainRef) => {
+          const trainId = trainRef.getAttribute('ref');
+          const trainElement = trainId ? trainElementsById[trainId] : undefined;
+
+          const trainPartRef = trainElement?.querySelector('trainPartRef')?.getAttribute('ref');
+
+          return trainPartRef ? trainSchedulesByTrainPartId[trainPartRef] : undefined;
+        })
+        .filter((schedule) => schedule !== undefined);
+    });
+
+    const pacedTrainMostFrequentSchedules: Record<
+      string,
+      { schedule: ImportedTrainSchedule | null; count: number }
+    > = {};
+
+    Object.entries(pacedTrains).forEach(([pacedTrainId, schedules]) => {
+      const { mostFrequent, highestCount } = findMostFrequentScheduleInPacedTrain(schedules);
+      pacedTrainMostFrequentSchedules[pacedTrainId] = {
+        schedule: mostFrequent,
+        count: highestCount,
+      };
+    });
+
+    const getMostFrequentInterval = (schedules: ImportedTrainSchedule[]): Duration => {
+      const departureTimes = schedules
+        .map((s) => new Date(s.departureTime))
+        .sort((a, b) => a.getTime() - b.getTime());
+
+      const intervalsCount = new Map<number, number>();
+
+      for (let i = 1; i < departureTimes.length; i += 1) {
+        const interval = Duration.subtractDate(departureTimes[i], departureTimes[i - 1]);
+        const rawMin = interval.total('minute');
+
+        let roundedMin: number;
+        if (rawMin > 5) {
+          roundedMin = Math.round(rawMin / 10) * 10;
+        } else if (rawMin >= 1) {
+          roundedMin = Math.round(rawMin);
+        } else {
+          roundedMin = 1;
+        }
+
+        intervalsCount.set(roundedMin, (intervalsCount.get(roundedMin) || 0) + 1);
+      }
+
+      let mostFrequentRoundedMin = 0;
+      let maxCount = 0;
+
+      for (const [minutes, count] of intervalsCount.entries()) {
+        if (count > maxCount) {
+          mostFrequentRoundedMin = minutes;
+          maxCount = count;
+        } else if (count === maxCount && minutes < mostFrequentRoundedMin) {
+          // we take smaller interval in case of tie
+          mostFrequentRoundedMin = minutes;
+        }
+      }
+
+      return new Duration({ minutes: mostFrequentRoundedMin });
+    };
+
+    const buildPacedTrain = (
+      pacedTrainId: string,
+      pacedTrainSchedules: ImportedTrainSchedule[]
+    ): ImportedPacedTrainSchedule | null => {
+      if (pacedTrainSchedules.length < 2) {
+        console.warn('Not enough schedules to build a paced train');
+        return null;
+      }
+
+      const sortedSchedules = pacedTrainSchedules.sort(
+        (a, b) => new Date(a.departureTime).getTime() - new Date(b.departureTime).getTime()
+      );
+
+      const departureDates = sortedSchedules.map((s) => new Date(s.departureTime));
+      const intervalDuration = getMostFrequentInterval(pacedTrainSchedules);
+
+      const totalDuration = Duration.subtractDate(
+        departureDates[departureDates.length - 1],
+        departureDates[0]
+      ).add(intervalDuration);
+
+      return {
+        ...sortedSchedules[0],
+        trainNumber: pacedTrainId,
+        paced: {
+          interval: intervalDuration.toISOString(),
+          time_window: totalDuration.toISOString(),
+        },
+      };
+    };
+
+    const importedPacedTrains: ImportedPacedTrainSchedule[] = Object.entries(pacedTrains)
+      .map(([pacedTrainId, pacedTrainSchedules]) =>
+        buildPacedTrain(pacedTrainId, pacedTrainSchedules)
+      )
+      .filter((pacedTrain) => pacedTrain !== null);
+
+    setPacedTrainsXmlData(importedPacedTrains);
+
     const trains = Array.from(xmlDoc.getElementsByTagName('train'));
     const updatedTrainSchedules = mapTrainNames(trainSchedules, trains);
-    setTrainsXmlData(updatedTrainSchedules);
+    const trainSchedulesInPacedTrain = new Set(
+      Object.values(pacedTrains)
+        .flat()
+        .map((schedule) => schedule.trainNumber)
+    );
+
+    const singleTrainSchedules = trainSchedules.filter(
+      (schedule) => !trainSchedulesInPacedTrain.has(schedule.trainNumber)
+    );
+    setTrainsXmlData(singleTrainSchedules);
+
     return updatedTrainSchedules;
   };
 
@@ -311,7 +452,7 @@ const ImportTimetableItemConfig = ({
 
     // try to parse the file as an XML file
     try {
-      await processXmlFile(fileContent, parseRailML, updateTrainSchedules);
+      await processXmlFile(fileContent, parseXML, updateTrainSchedules);
     } catch {
       // the file is not supported or is an invalid XML file
       dispatch(

front/src/modules/trainschedule/components/ImportTimetableItem/ImportTimetableItemTrainsList.tsx

@@ -20,7 +20,11 @@ import type {
 import { useAppDispatch } from 'store';
 import { formatEditoastIdToPacedTrainId, formatEditoastIdToTrainScheduleId } from 'utils/trainId';
 
-import { generateTrainSchedulesPayloads } from './generateTrainSchedulesPayloads';
+import {
+  generatePacedTrainPayloads,
+  generateTrainSchedulesPayloads,
+} from './generateTrainSchedulesPayloads';
+import type { ImportedPacedTrainSchedule } from './ImportTimetableItemConfig';
 import findValidTrainNameKey from '../ManageTrainSchedule/helpers/findValidTrainNameKey';
 
 function LoadingIfSearching({
@@ -44,6 +48,7 @@ type ImportTimetableItemTrainsListProps = {
   trainsJsonData: TimetableJsonPayload;
   trainsXmlData: ImportedTrainSchedule[];
   upsertTimetableItems: (timetableItems: TimetableItem[]) => void;
+  pacedTrainXmlData: ImportedPacedTrainSchedule[];
 };
 
 const ImportTimetableItemTrainsList = ({
@@ -53,12 +58,12 @@ const ImportTimetableItemTrainsList = ({
   trainsJsonData,
   trainsXmlData,
   upsertTimetableItems,
+  pacedTrainXmlData,
 }: ImportTimetableItemTrainsListProps) => {
   const { t } = useTranslation('operational-studies', { keyPrefix: 'importTrains' });
 
   const { train_schedules: trainSchedulesJsonData, paced_trains: pacedTrainsJsonData } =
     trainsJsonData;
-
   const formattedTrainsList = useMemo(
     () =>
       trainsList.map(({ rollingStock, ...train }) => {
@@ -87,9 +92,9 @@ const ImportTimetableItemTrainsList = ({
       let trainSchedulePayloads: TrainSchedule[] = [];
       let pacedTrainPayloads: PacedTrain[] = [];
 
-      // Viriato import (TODO Paced train : handle viriato imports for paced trains)
+      // XML import
       if (trainsXmlData.length > 0) {
-        trainSchedulePayloads = generateTrainSchedulesPayloads(trainsXmlData, true);
+        trainSchedulePayloads = generateTrainSchedulesPayloads(trainsXmlData);
 
         // JSON import
       } else if (trainSchedulesJsonData.length > 0 || pacedTrainsJsonData.length > 0) {
@@ -98,7 +103,11 @@ const ImportTimetableItemTrainsList = ({
 
         // Open data import (only handle trainSchedules)
       } else {
-        trainSchedulePayloads = generateTrainSchedulesPayloads(formattedTrainsList, false);
+        trainSchedulePayloads = generateTrainSchedulesPayloads(formattedTrainsList);
+      }
+
+      if (pacedTrainXmlData.length > 0) {
+        pacedTrainPayloads = generatePacedTrainPayloads(pacedTrainXmlData);
       }
 
       let formattedTrainSchedules: TrainScheduleResponseWithTrainId[] = [];
@@ -154,18 +163,29 @@ const ImportTimetableItemTrainsList = ({
   }
 
   const computedItemImportLabel = () => {
-    if (!trainSchedulesJsonData.length && !trainsList.length && !!pacedTrainsJsonData.length) {
+    if (
+      !trainSchedulesJsonData.length &&
+      !trainsList.length &&
+      (!!pacedTrainsJsonData.length || !!pacedTrainXmlData)
+    ) {
       return t('pacedTrainsFound', {
-        count: pacedTrainsJsonData.length,
-        pacedTrainsFound: pacedTrainsJsonData.length,
+        count: pacedTrainsJsonData.length || pacedTrainXmlData.length,
+        pacedTrainsFound: pacedTrainsJsonData.length || pacedTrainXmlData.length,
       });
     }
 
     return t('itemsFound', {
-      count: trainsList.length || [...trainSchedulesJsonData, ...pacedTrainsJsonData].length,
-      pacedTrainsFound: pacedTrainsJsonData.length,
-      trainsFound: trainsList.length || trainSchedulesJsonData.length,
-      and: !!trainSchedulesJsonData.length && !!pacedTrainsJsonData.length ? t('and') : '',
+      count:
+        trainsList.length ||
+        [...trainSchedulesJsonData, ...pacedTrainsJsonData, ...trainsXmlData, ...pacedTrainXmlData]
+          .length,
+      pacedTrainsFound: pacedTrainsJsonData.length || pacedTrainXmlData.length,
+      trainsFound: trainsList.length || trainSchedulesJsonData.length || trainsXmlData.length,
+      and:
+        (!!trainSchedulesJsonData.length && !!pacedTrainsJsonData.length) ||
+        (!!trainsXmlData.length && !!pacedTrainXmlData)
+          ? t('and')
+          : '',
     });
   };