Add tareWeightTons property to CreateWagonTypeDto and update related components

apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts

@@ -2,6 +2,7 @@ import { AllocationLoadType } from '@edr/types';
 
 import { Booking } from '../bookings/entities/booking.entity';
 import { WagonType } from '../wagon-types/entities/wagon-type.entity';
+import { consistViolations } from './train-capacity.util';
 
 export const MAX_TRAIN_WEIGHT_TONS = 3500;
 export const MAX_TRAIN_LENGTH_METERS = 760;
@@ -35,6 +36,9 @@ export type WagonPlanSlot = {
   wagonTypeCode: string;
   capacityTons: number;
   lengthMeters: number;
+  /** Empty weight of this wagon — the locomotive pulls it whether or not it is loaded. */
+  tareWeightTons: number;
+  /** Cargo tons on this wagon. Gross weight = tareWeightTons + assignedWeightTons. */
   assignedWeightTons: number;
   allocations: WagonAllocationRecord[];
   slotLoadType?: SlotLoadType;
@@ -78,6 +82,14 @@ export function roundTons(value: number | string | null | undefined): number {
   return Number(numericValue.toFixed(3));
 }
 
+/**
+ * Tare of a wagon type. Nullable only on rows predating the NOT NULL backfill;
+ * a missing tare must read as 0 rather than silently inventing dead weight.
+ */
+export function tareTonsOf(wagonType: Pick<WagonType, 'tareWeightTons'>): number {
+  return roundTons(wagonType.tareWeightTons ?? 0);
+}
+
 /** TEU slots on a wagon: 40ft = 2, 20ft = 1 (max 2 TEU / wagon). */
 export function teuSlotsForSizeFt(sizeFt: number): number {
   return sizeFt >= 40 ? 2 : 1;
@@ -146,6 +158,7 @@ export function buildContainerWagonPlan(
     wagonTypeCode: wagonType.code,
     capacityTons: Number(wagonType.capacityTons),
     lengthMeters: Number(wagonType.lengthMeters),
+    tareWeightTons: tareTonsOf(wagonType),
     assignedWeightTons: 0,
     allocations: [],
   }));
@@ -175,6 +188,7 @@ export function buildBulkWagonPlan(
     wagonTypeCode: wagonType.code,
     capacityTons: capacity,
     lengthMeters: Number(wagonType.lengthMeters),
+    tareWeightTons: tareTonsOf(wagonType),
     assignedWeightTons: 0,
     allocations: [],
   }));
@@ -214,6 +228,7 @@ export function buildMixedWagonPlan(
         wagonTypeCode: containerWagonType.code,
         capacityTons: Number(containerWagonType.capacityTons),
         lengthMeters: Number(containerWagonType.lengthMeters),
+        tareWeightTons: tareTonsOf(containerWagonType),
         assignedWeightTons: 0,
         allocations: [],
         slotLoadType: 'CONTAINER',
@@ -443,47 +458,46 @@ export function validateBulkWagonSlotWeights(wagonPlan: WagonPlanSlot[]): string
   return violations;
 }
 
+/**
+ * Check a consist against its train's three limits. Weight is GROSS — every slot
+ * contributes its own tare plus the cargo assigned to it — because the locomotive
+ * pull limit governs what it drags, not what was sold. Length and tare are summed
+ * per slot, so a mixed consist is measured as it actually stands rather than
+ * through one representative wagon type.
+ *
+ * `wagonType` only supplies the fallback wagon count when `limits.maxWagonsPerTrain`
+ * is absent; slot dimensions always win over it.
+ */
 export function validateTrainLimits(
   wagonPlan: WagonPlanSlot[],
   wagonType: Pick<WagonType, 'lengthMeters'>,
   limits?: TrainLimitConfig,
 ): string[] {
-  const violations: string[] = [];
   const maxWeightTons = limits?.maxWeightTons ?? MAX_TRAIN_WEIGHT_TONS;
   const maxLengthMeters = limits?.maxLengthMeters ?? MAX_TRAIN_LENGTH_METERS;
   const wagonLength = Number(wagonType.lengthMeters) || 14;
-  const maxWagonsPerTrain =
-    limits?.maxWagonsPerTrain ??
-    Math.floor(maxLengthMeters / wagonLength);
+  const maxWagonSlots =
+    limits?.maxWagonsPerTrain ?? Math.floor(maxLengthMeters / wagonLength);
 
-  const totalWeightTons = roundTons(
-    wagonPlan.reduce((sum, w) => sum + w.assignedWeightTons, 0),
+  const violations = consistViolations(
+    wagonPlan.map((slot) => ({
+      lengthMeters: Number(slot.lengthMeters),
+      tareWeightTons: Number(slot.tareWeightTons ?? 0),
+      cargoTons: Number(slot.assignedWeightTons),
+    })),
+    { maxWeightTons, maxLengthMeters, maxWagonSlots },
   );
-  const totalLengthMeters = roundTons(
-    wagonPlan.reduce((sum, w) => sum + w.lengthMeters, 0),
-  );
-
-  if (totalWeightTons > maxWeightTons) {
-    violations.push(
-      `Total booking weight ${totalWeightTons}T exceeds max train weight ${maxWeightTons}T`,
-    );
-  }
-  if (totalLengthMeters > maxLengthMeters) {
-    violations.push(
-      `Total wagon length ${totalLengthMeters}m exceeds max train length ${maxLengthMeters}m`,
-    );
-  }
-  if (wagonPlan.length > maxWagonsPerTrain) {
-    violations.push(
-      `Wagon count ${wagonPlan.length} exceeds max wagons per train (${maxWagonsPerTrain})`,
-    );
-  }
 
   violations.push(...validateBulkWagonSlotWeights(wagonPlan));
 
   return violations;
 }
 
+/**
+ * Mixed consist: the wagon-count fallback uses the shortest type present, since
+ * that is the most wagons that could ever fit. Weight and length still come from
+ * the slots themselves.
+ */
 export function validateMixedTrainLimits(
   wagonPlan: WagonPlanSlot[],
   wagonTypes: WagonType[],