Merge pull request #923 from Tria-plc/freight_feature/usermanagement

Freight feature/usermanagement

apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts

@@ -122,6 +122,7 @@ import {
   roundTons,
   sumWagonsRequired,
   type TrainLimitConfig,
+  maxEdgeConsistUsage,
   validateContainerPlacements,
   validateMixedTrainLimitsPerEdge,
   type ContainerPlacementInput,
@@ -130,9 +131,12 @@ import {
 import { deriveScheduleDirection } from './derive-schedule-direction.util';
 import { pickLowestFreeNumber, pickTrainNumberPool } from './train-number.util';
 import {
+  bookingCargoTons,
   deriveTrainCapacityFromLocomotive,
   minLocomotiveLimits,
+  trainSetLocomotiveLimits,
   wagonTypeDimensionsFromEntity,
+  LocomotiveLimits,
   WagonTypeDimensions,
 } from './train-capacity.util';
 import {
@@ -1706,25 +1710,36 @@ export class TrainSchedulingService {
           relations: { wagonType: true },
         })
       : null;
-    const planTareTons = consistWagons
+    const planTareTons = roundTons(
+      wagonPlan.reduce((sum, slot) => sum + Number(slot.tareWeightTons ?? 0), 0),
+    );
+    const consistTareTons = consistWagons
       ? roundTons(
           consistWagons.reduce(
             (sum, wagon) => sum + Number(wagon.wagonType?.tareWeightTons ?? 0),
             0,
           ),
         )
-      : roundTons(
-          wagonPlan.reduce((sum, slot) => sum + Number(slot.tareWeightTons ?? 0), 0),
-        );
-    const grossWeightTons = roundTons(totalWeightTons + planTareTons);
+      : planTareTons;
+    // The pull limit binds on the HEAVIEST LEG, not the whole-route sum —
+    // disjoint legs (intercity Gelan→Adama + export Adama→Doraleh) are never
+    // hauled at the same time. Coupled-but-unplanned wagons ride every edge,
+    // so their tare rides on top of the binding edge.
+    const emptyConsistTareTons = Math.max(0, consistTareTons - planTareTons);
+    const edgeUsage = maxEdgeConsistUsage(
+      wagonPlan,
+      await this.stopYardsForSchedule(schedule),
+    );
+    const grossWeightTons = roundTons(edgeUsage.grossWeightTons + emptyConsistTareTons);
     if (!dto.forceAssign && weightCapWithOverage < grossWeightTons) {
       throw new BadRequestException(
-        `Train set locomotives cannot pull ${grossWeightTons}T gross (${totalWeightTons}T cargo + ${planTareTons}T wagon tare)`,
+        `Train set locomotives cannot pull ${grossWeightTons}T gross on the heaviest leg (limit ${roundTons(weightCapWithOverage)}T incl. tolerance)`,
       );
     }
-    if (!dto.forceAssign && lengthCapWithOverage < totalLengthMeters) {
+    const maxEdgeLengthMeters = roundTons(edgeUsage.lengthMeters);
+    if (!dto.forceAssign && lengthCapWithOverage < maxEdgeLengthMeters) {
       throw new BadRequestException(
-        `Train set locomotives cannot support ${totalLengthMeters}m`,
+        `Train set locomotives cannot support ${maxEdgeLengthMeters}m`,
       );
     }
 
@@ -4081,9 +4096,6 @@ export class TrainSchedulingService {
     }
 
     const totalWeightTons = totalAssignedWeight(fittingBookings);
-    // Every weight limit below (global max, loco pull) is a GROSS axis, so the
-    // figure spent against it must be gross too — cargo alone under-reports the
-    // train by the full consist tare and disagrees with the assign path.
     const totalTareTons = roundTons(
       wagonPlan.reduce((sum, w) => sum + (Number(w.tareWeightTons) || 0), 0),
     );
@@ -4091,12 +4103,13 @@ export class TrainSchedulingService {
     const totalLengthMeters = roundTons(
       wagonPlan.reduce((sum, w) => sum + w.lengthMeters, 0),
     );
-    if (grossWeightTons > trainLimits.maxWeightTons) {
-      const message = `Total gross weight ${grossWeightTons}T (${totalWeightTons}T cargo + ${totalTareTons}T wagon tare) exceeds max train weight ${trainLimits.maxWeightTons}T`;
-      if (!violations.includes(message) && !warnings.includes(message)) {
-        pushLimit([message]);
-      }
-    }
+    // Weight/length limits are enforced PER EDGE by validateMixedTrainLimitsPerEdge
+    // above — the whole-route totals here are informational (summary) only. The
+    // locomotive checks below also compare the heaviest single edge: a train is
+    // never heavier than its heaviest leg, so disjoint legs must not be summed.
+    const edgeUsage = maxEdgeConsistUsage(wagonPlan, stops);
+    const maxEdgeGrossTons = roundTons(edgeUsage.grossWeightTons);
+    const maxEdgeLengthMeters = roundTons(edgeUsage.lengthMeters);
 
     let assignedLocomotives: Locomotive[] = [];
     if (targetScheduleId) {
@@ -4119,9 +4132,9 @@ export class TrainSchedulingService {
       if (
         setLimits &&
         (setLimits.maxPullWeightTons + (Number(setLimits.overageToleranceTons) || 0) <
-          grossWeightTons ||
+          maxEdgeGrossTons ||
           setLimits.maxTrainLengthMeters + (Number(setLimits.overageToleranceMeters) || 0) <
-            totalLengthMeters)
+            maxEdgeLengthMeters)
       ) {
         pushLimit([
           'Assigned locomotives cannot support the total train weight and length',
@@ -4140,9 +4153,9 @@ export class TrainSchedulingService {
         !inServiceLocomotives.some(
           (l) =>
             Number(l.maxPullWeightTons) + (Number(l.overageToleranceTons) || 0) >=
-              grossWeightTons &&
+              maxEdgeGrossTons &&
             Number(l.maxTrainLengthMeters) + (Number(l.overageToleranceMeters) || 0) >=
-              totalLengthMeters,
+              maxEdgeLengthMeters,
         )
       ) {
         pushLimit(['No locomotive can support the total train weight and length']);
@@ -4201,10 +4214,7 @@ export class TrainSchedulingService {
       maxTrainLengthMeters?: number;
       maxWagonsPerTrain?: number;
     },
-    locomotive?: Pick<
-      Locomotive,
-      'maxPullWeightTons' | 'maxTrainLengthMeters' | 'overageToleranceTons' | 'overageToleranceMeters'
-    >,
+    locomotive?: LocomotiveLimits | null,
   ): Promise<Required<TrainLimitConfig>> {
     const row = await this.loadGlobalRulesRow();
     const configured = this.configService?.get<{
@@ -6512,7 +6522,7 @@ export class TrainSchedulingService {
     >,
     tareDims: Awaited<ReturnType<TrainSchedulingService['loadWagonTareDims']>>,
   ): number {
-    const cargo = Number(booking.cargoTotalWeightVgm ?? 0);
+    const cargo = bookingCargoTons(booking);
     const fallback =
       booking.freightType === 'BULK' ? tareDims.bulk : tareDims.container;
     // Same first-configured-type resolution the batch engine's dimsFor uses.
@@ -6878,6 +6888,18 @@ export class TrainSchedulingService {
       // Ordered corridor stops (route milestones; falls back to the two
       // endpoints) — lets the UI draw per-segment occupancy and label legs.
       stops: this.mapScheduleStops(schedule),
+      // Gross ceiling the validator holds each leg to: the set's weakest
+      // locomotive pull limit plus its overage tolerance. Booking weightTons
+      // above are gross too, so the strip can sum them per leg against this.
+      maxGrossWeightTons: (() => {
+        const setLimits = trainSetLocomotiveLimits(schedule.trainSet);
+        return setLimits
+          ? roundTons(
+              Number(setLimits.maxPullWeightTons) +
+                (Number(setLimits.overageToleranceTons) || 0),
+            )
+          : null;
+      })(),
       // True when the wagon plan above is served from the frozen snapshot (schedule
       // is dispatched/arrived/cancelled) rather than the live joins — the UI can badge
       // it "historical" and skip re-pin affordances.
@@ -6973,7 +6995,10 @@ export class TrainSchedulingService {
       originStationId: schedule.originStationId,
       destinationStationId: schedule.destinationStationId,
     };
-    const limits = await this.resolveTrainLimitConfig(undefined, schedule.trainSet.locomotive);
+    const limits = await this.resolveTrainLimitConfig(
+      undefined,
+      trainSetLocomotiveLimits(schedule.trainSet),
+    );
 
     const validation = await this.validateBookingsForScheduling(
       previewDto,
@@ -7099,7 +7124,7 @@ export class TrainSchedulingService {
     };
     const limits = await this.resolveTrainLimitConfig(
       undefined,
-      schedule.trainSet.locomotive,
+      trainSetLocomotiveLimits(schedule.trainSet),
     );
 
     let validation: Awaited<ReturnType<TrainSchedulingService['validateBookingsForScheduling']>>;
@@ -7643,7 +7668,7 @@ export class TrainSchedulingService {
     };
     const limits = await this.resolveTrainLimitConfig(
       undefined,
-      schedule.trainSet.locomotive,
+      trainSetLocomotiveLimits(schedule.trainSet),
     );
 
     let validation: Awaited<ReturnType<TrainSchedulingService['validateBookingsForScheduling']>>;