front: align margins display and computation to spec in timestops table

Signed-off-by: Alice Khoudli <[email protected]>

Author: Synar

front/src/modules/timesStops/helpers/__tests__/computeMargins.spec.ts

@@ -1,8 +1,10 @@
+import { keyBy } from 'lodash';
 import { describe, it, expect } from 'vitest';
 
 import type { TrainScheduleResult } from 'common/api/osrdEditoastApi';
+import type { ScheduleEntry } from 'modules/timesStops/types';
 
-import computeMargins from '../computeMargins';
+import computeMargins, { getTheoreticalMargins } from '../computeMargins';
 
 describe('computeMargins', () => {
   const path = [
@@ -28,19 +30,21 @@ describe('computeMargins', () => {
 
   it('should compute simple margin', () => {
     const train = { path, margins } as TrainScheduleResult;
-    expect(computeMargins(train, 0, pathItemTimes)).toEqual({
+    const scheduleByAt: Record<string, ScheduleEntry> = keyBy(train.schedule, 'at');
+    const theoreticalMargins = getTheoreticalMargins(train);
+    expect(computeMargins(theoreticalMargins, train, scheduleByAt, 0, pathItemTimes)).toEqual({
       theoreticalMargin: '10 %',
       theoreticalMarginSeconds: '10 s',
       calculatedMargin: '15 s',
       diffMargins: '5 s',
     });
-    expect(computeMargins(train, 1, pathItemTimes)).toEqual({
+    expect(computeMargins(theoreticalMargins, train, scheduleByAt, 1, pathItemTimes)).toEqual({
       theoreticalMargin: '',
       theoreticalMarginSeconds: '20 s',
       calculatedMargin: '30 s',
       diffMargins: '10 s',
     });
-    expect(computeMargins(train, 2, pathItemTimes)).toEqual({
+    expect(computeMargins(theoreticalMargins, train, scheduleByAt, 2, pathItemTimes)).toEqual({
       theoreticalMargin: undefined,
       theoreticalMarginSeconds: undefined,
       calculatedMargin: undefined,

front/src/modules/timesStops/helpers/computeMargins.ts

@@ -1,41 +1,53 @@
 import type { TrainScheduleResult } from 'common/api/osrdEditoastApi';
-import type { TrainScheduleWithDetails } from 'modules/trainschedule/components/Timetable/types';
+import type {
+  TheoreticalMarginsRecord,
+  TrainScheduleWithDetails,
+} from 'modules/trainschedule/components/Timetable/types';
 import { ms2sec } from 'utils/timeManipulation';
 
 import { formatDigitsAndUnit } from './utils';
+import type { ScheduleEntry } from '../types';
 
-function getTheoreticalMargin(selectedTrainSchedule: TrainScheduleResult, pathStepId: string) {
-  if (selectedTrainSchedule.path.length === 0) {
+export function getTheoreticalMargins(selectedTrainSchedule: TrainScheduleResult) {
+  const selectedTrainScheduleMargins = selectedTrainSchedule.margins;
+  if (!selectedTrainScheduleMargins) {
     return undefined;
   }
-  // pathStep is starting point => we take the first margin
-  if (selectedTrainSchedule.path[0].id === pathStepId) {
-    return selectedTrainSchedule.margins?.values[0];
-  }
-  const theoreticalMarginBoundaryIndex = selectedTrainSchedule.margins?.boundaries?.findIndex(
-    (id) => id === pathStepId
-  );
-  if (
-    theoreticalMarginBoundaryIndex === undefined ||
-    theoreticalMarginBoundaryIndex < 0 ||
-    theoreticalMarginBoundaryIndex > selectedTrainSchedule.margins!.values.length - 2
-  ) {
-    return undefined;
-  }
-
-  return selectedTrainSchedule.margins!.values[theoreticalMarginBoundaryIndex + 1];
+  const theoreticalMargins: TheoreticalMarginsRecord = {};
+  let marginIndex = 0;
+  selectedTrainSchedule.path.forEach((step, index) => {
+    let isBoundary = index === 0;
+    if (step.id === selectedTrainSchedule.margins?.boundaries[marginIndex]) {
+      marginIndex += 1;
+      isBoundary = true;
+    }
+    theoreticalMargins[step.id] = {
+      theoreticalMargin: selectedTrainScheduleMargins.values[marginIndex],
+      isBoundary,
+    };
+  });
+  return theoreticalMargins;
 }
 
 function computeMargins(
+  theoreticalMargins: TheoreticalMarginsRecord | undefined,
   selectedTrainSchedule: TrainScheduleResult,
+  scheduleByAt: Record<string, ScheduleEntry>,
   pathStepIndex: number,
   pathItemTimes: NonNullable<TrainScheduleWithDetails['pathItemTimes']> // in ms
 ) {
   const { path, margins } = selectedTrainSchedule;
+  const pathStepId = path[pathStepIndex].id;
   if (
     !margins ||
-    (margins.values.length === 1 && margins.values[0] === '0%') ||
-    pathStepIndex === selectedTrainSchedule.path.length - 1
+    pathStepIndex === selectedTrainSchedule.path.length - 1 ||
+    !theoreticalMargins ||
+    !theoreticalMargins[pathStepId] ||
+    !(
+      scheduleByAt[pathStepId]?.arrival ||
+      scheduleByAt[pathStepId]?.stop_for ||
+      theoreticalMargins[pathStepId].isBoundary
+    )
   ) {
     return {
       theoreticalMargin: undefined,
@@ -45,14 +57,21 @@ function computeMargins(
     };
   }
 
-  const pathStepId = path[pathStepIndex].id;
-  const theoreticalMargin = getTheoreticalMargin(selectedTrainSchedule, pathStepId);
+  const { theoreticalMargin, isBoundary } = theoreticalMargins[pathStepId];
+
+  // find the next pathStep where constraints are defined
+  let nextIndex = path.length - 1;
 
-  // find the previous pathStep where margin was defined
-  let prevIndex = 0;
-  for (let index = 1; index < pathStepIndex; index += 1) {
-    if (margins.boundaries.includes(path[index].id)) {
-      prevIndex = index;
+  for (let index = pathStepIndex + 1; index < path.length; index += 1) {
+    const curStepId = path[index].id;
+    const curStepSchedule = scheduleByAt[curStepId];
+    if (
+      theoreticalMargins[curStepId]?.isBoundary ||
+      curStepSchedule?.arrival ||
+      curStepSchedule?.stop_for
+    ) {
+      nextIndex = index;
+      break;
     }
   }
 
@@ -61,16 +80,17 @@ function computeMargins(
   // provisional = margins
   // final = margins + requested arrival times
   const { base, provisional, final } = pathItemTimes;
-  const baseDuration = ms2sec(base[pathStepIndex + 1] - base[prevIndex]);
-  const provisionalDuration = ms2sec(provisional[pathStepIndex + 1] - provisional[prevIndex]);
-  const finalDuration = ms2sec(final[pathStepIndex + 1] - final[prevIndex]);
+  const baseDuration = ms2sec(base[nextIndex] - base[pathStepIndex]);
+  const provisionalDuration = ms2sec(provisional[nextIndex] - provisional[pathStepIndex]);
+  const finalDuration = ms2sec(final[nextIndex] - final[pathStepIndex]);
 
   // how much longer it took (s) with the margin than without
   const provisionalLostTime = provisionalDuration - baseDuration;
   const finalLostTime = finalDuration - baseDuration;
 
   return {
     theoreticalMargin: formatDigitsAndUnit(theoreticalMargin),
+    isTheoreticalMarginBoundary: isBoundary,
     theoreticalMarginSeconds: `${Math.round(provisionalLostTime)} s`,
     calculatedMargin: `${Math.round(finalLostTime)} s`,
     diffMargins: `${Math.round(finalLostTime - provisionalLostTime)} s`,

front/src/modules/timesStops/helpers/utils.ts

@@ -114,7 +114,7 @@ const getDigits = (unit: string | undefined) =>
   unit === MarginUnit.second || unit === MarginUnit.percent ? 0 : 1;
 
 export function formatDigitsAndUnit(fullValue: string | number | undefined, unit?: string) {
-  if (fullValue === undefined || fullValue === '0%') {
+  if (fullValue === undefined) {
     return '';
   }
   if (typeof fullValue === 'number') {

front/src/modules/timesStops/hooks/useOutputTableData.ts

@@ -15,7 +15,7 @@ import { calculateTimeDifferenceInSeconds } from 'utils/timeManipulation';
 
 import { ARRIVAL_TIME_ACCEPTABLE_ERROR_MS } from '../consts';
 import { computeInputDatetimes } from '../helpers/arrivalTime';
-import computeMargins from '../helpers/computeMargins';
+import computeMargins, { getTheoreticalMargins } from '../helpers/computeMargins';
 import { formatSchedule } from '../helpers/scheduleData';
 import { type ScheduleEntry, type TimeStopsRow } from '../types';
 
@@ -29,6 +29,8 @@ const useOutputTableData = (
   const { t } = useTranslation('timesStops');
 
   const scheduleByAt: Record<string, ScheduleEntry> = keyBy(selectedTrainSchedule?.schedule, 'at');
+  const theoreticalMargins = selectedTrainSchedule && getTheoreticalMargins(selectedTrainSchedule);
+
   const startDatetime = selectedTrainSchedule
     ? new Date(selectedTrainSchedule.start_time)
     : undefined;
@@ -48,8 +50,19 @@ const useOutputTableData = (
         computedArrival,
         schedule
       );
-      const { theoreticalMargin, theoreticalMarginSeconds, calculatedMargin, diffMargins } =
-        computeMargins(selectedTrainSchedule, index, pathItemTimes);
+      const {
+        theoreticalMargin,
+        isTheoreticalMarginBoundary,
+        theoreticalMarginSeconds,
+        calculatedMargin,
+        diffMargins,
+      } = computeMargins(
+        theoreticalMargins,
+        selectedTrainSchedule,
+        scheduleByAt,
+        index,
+        pathItemTimes
+      );
 
       const { theoreticalArrival, arrival, departure, refDate } = computeInputDatetimes(
         startDatetime,
@@ -78,6 +91,7 @@ const useOutputTableData = (
         onStopSignal,
         shortSlipDistance,
         theoreticalMargin,
+        isTheoreticalMarginBoundary,
 
         theoreticalMarginSeconds,
         calculatedMargin,

front/src/modules/timesStops/hooks/useTimeStopsColumns.tsx

@@ -158,7 +158,7 @@ export const useTimeStopsColumns = <T extends TimeStopsRow>(
             continuousUpdates: false,
             placeholder: !isOutputTable ? t('theoreticalMarginPlaceholder') : '',
             formatBlurredInput: (value) => {
-              if (!value || value === '0%') return '';
+              if (!value) return '';
               if (!isOutputTable && !marginRegExValidation.test(value)) {
                 return `${value}${t('theoreticalMarginPlaceholder')}`;
               }
@@ -168,7 +168,10 @@ export const useTimeStopsColumns = <T extends TimeStopsRow>(
           })
         ),
         cellClassName: ({ rowData }) =>
-          cx({ invalidCell: !isOutputTable && !rowData.isMarginValid }),
+          cx({
+            invalidCell: !isOutputTable && !rowData.isMarginValid,
+            repeatedValue: rowData.isTheoreticalMarginBoundary === false, // the class should be added on false but not undefined
+          }),
         title: t('theoreticalMargin'),
         headerClassName: 'padded-header',
         minWidth: 100,

front/src/modules/timesStops/styles/_timesStopsDatasheet.scss

@@ -23,6 +23,10 @@
     color: red !important;
   }
 
+  .repeatedValue {
+    color: var(--grey30);
+  }
+
   .warning-schedule {
     background: var(--warning30);
   }

front/src/modules/timesStops/types.ts

@@ -21,6 +21,7 @@ export type TimeStopsRow = {
   onStopSignal?: boolean;
   shortSlipDistance?: boolean;
   theoreticalMargin?: string; // value asked by user
+  isTheoreticalMarginBoundary?: boolean; // tells whether the theoreticalMargin value was inputted for this line or if it is repeated from a previous line
 
   theoreticalMarginSeconds?: string;
   calculatedMargin?: string;

front/src/modules/trainschedule/components/Timetable/types.ts

@@ -43,3 +43,8 @@ export type InvalidReason =
   | Extract<SimulationSummaryResult['status'], 'pathfinding_failure' | 'simulation_failed'>
   | PathfindingNotFound['error_type']
   | PathfindingInputError['error_type'];
+
+export type TheoreticalMarginsRecord = Record<
+  string,
+  { theoreticalMargin: string; isBoundary: boolean }
+>;