Merge branch 'dev' into fixes

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

@@ -73,6 +73,7 @@ import {
   bookingCargoTons,
   bulkItemsFitFor,
   bulkItemWagonsRequired,
+  bulkTonsPerWagon,
   bookingGrossWeightTons,
   deriveTrainCapacityFromLocomotive,
   sizePartialOfferWagons,
@@ -152,6 +153,14 @@ export interface ExportTrainOption {
   }>;
 }
 
+/** A train a paid-unallocated booking can board (route + capacity verified). */
+export interface AllocationCandidate {
+  id: string;
+  reference: string | null;
+  direction: string | null;
+  scheduledDepartureDate: Date;
+}
+
 /** A day-level pool key: all trains on this route departing on this EAT day. */
 interface RouteDayGroup {
   originYardId: string;
@@ -1448,6 +1457,7 @@ export class BookingBatchService implements OnModuleInit {
    */
   async getBatchBoard(
     query: BatchBoardQueryDto = {},
+    allowedDirections?: string[],
   ): Promise<BatchBoardListResponse> {
     // Board cards are heavy (per-schedule booking summaries), so the default
     // page is smaller than the toolkit-wide 20.
@@ -1455,6 +1465,11 @@ export class BookingBatchService implements OnModuleInit {
       defaultPageSize: 12,
     });
 
+    // The board is IMPORT-only — a user scoped away from IMPORT sees nothing.
+    if (allowedDirections && !allowedDirections.includes("IMPORT")) {
+      return { items: [], meta: buildPaginationMeta(0, page, pageSize) };
+    }
+
     // Status filter: any subset of the lifecycle. Omitted = all statuses, so
     // arrived / cancelled / dispatched schedules stay visible as history.
     const allowedStatuses = new Set<string>(BATCH_BOARD_STATUSES);
@@ -3027,6 +3042,7 @@ export class BookingBatchService implements OnModuleInit {
           : booking.status;
       await manager.getRepository(Booking).update(bookingId, {
         trainScheduleId: newScheduleId,
+        scheduledDate: schedule.scheduledDepartureDate,
         status: restoredStatus,
         // A paid booking still hunting for a wagon keeps its flag through the
         // move — it only clears when wagons are actually assigned.
@@ -3045,6 +3061,104 @@ export class BookingBatchService implements OnModuleInit {
     this.notifyBoardChanged(newScheduleId, "booking_moved");
   }
 
+  /**
+   * Trains a paid-but-unallocated booking can board right now: OPEN window,
+   * future departure, route covers the booking's leg, and remaining corridor
+   * capacity fits it. Split by the booking's own scheduled day so the UI can
+   * offer one-click same-day allocation vs an explicit "another date" choice.
+   */
+  async allocationCandidates(bookingId: string): Promise<{
+    sameDay: AllocationCandidate[];
+    otherDays: AllocationCandidate[];
+  }> {
+    const booking = await this.dataSource.getRepository(Booking).findOne({
+      where: { id: bookingId },
+      relations: {
+        bookingContainers: { containerType: true },
+        // wagonTypes drives the break-bulk items-per-wagon fit — size the
+        // booking exactly as the intercity accept check does.
+        cargoType: { wagonTypes: true },
+      },
+    });
+    if (!booking) throw new NotFoundException(`Booking ${bookingId} not found`);
+    const schedules = await this.trainSchedulesRepository.findAll({
+      where: [
+        { status: TrainScheduleStatusEnum.Draft },
+        { status: TrainScheduleStatusEnum.Scheduled },
+      ],
+    });
+    const today = eatDay(new Date());
+    const bookingDay = booking.scheduledDate ? eatDay(booking.scheduledDate) : null;
+    const sameDay: AllocationCandidate[] = [];
+    const otherDays: AllocationCandidate[] = [];
+    for (const s of schedules) {
+      if (!s.scheduledDepartureDate || eatDay(s.scheduledDepartureDate) < today) continue;
+      if (s.bookingWindowStatus !== "OPEN") continue;
+      if (s.id === booking.trainScheduleId) continue;
+      const stops = await this.stopsForSchedule(s);
+      const fromIdx = stops.indexOf(booking.originYardId);
+      const toIdx = stops.indexOf(booking.destinationYardId);
+      if (fromIdx < 0 || toIdx < 0 || fromIdx >= toIdx) continue;
+      // ponytail: full capacity build per candidate is heavy; the set is small
+      // (future OPEN trains on the booking's route) — precompute if it grows.
+      const cap = await this.intercityCapacity(s.id);
+      if (!cap) continue;
+      const leg = cap.budget.legForYards(booking.originYardId, booking.destinationYardId);
+      if (!cap.budget.fits(cap.needFor(booking), leg)) continue;
+      const candidate: AllocationCandidate = {
+        id: s.id,
+        reference: s.reference ?? s.trainNumber ?? null,
+        direction: s.direction ?? null,
+        scheduledDepartureDate: s.scheduledDepartureDate,
+      };
+      (eatDay(s.scheduledDepartureDate) === bookingDay ? sameDay : otherDays).push(candidate);
+    }
+    const byDate = (a: AllocationCandidate, b: AllocationCandidate) =>
+      new Date(a.scheduledDepartureDate).getTime() - new Date(b.scheduledDepartureDate).getTime();
+    sameDay.sort(byDate);
+    otherDays.sort(byDate);
+    return { sameDay, otherDays };
+  }
+
+  /**
+   * Place a PAID booking that lost (or never got) its train: re-point via
+   * moveToSchedule (window/route validation + day sync), then allocate it
+   * immediately — payment already landed, so no new pay window opens. The
+   * customer gets an in-app notice when the new train departs on a different
+   * day than their original choice.
+   */
+  async allocatePaid(bookingId: string, scheduleId: string): Promise<void> {
+    const before = await this.dataSource
+      .getRepository(Booking)
+      .findOne({ where: { id: bookingId } });
+    if (!before) throw new NotFoundException(`Booking ${bookingId} not found`);
+    if (before.paymentStatus !== "PAID" && before.status !== "PAID") {
+      throw new BadRequestException(
+        "Booking is not paid — use the regular scheduling flow",
+      );
+    }
+    const previousDay = before.scheduledDate ? eatDay(before.scheduledDate) : null;
+    await this.moveToSchedule(bookingId, scheduleId);
+    const fresh = await this.dataSource.getRepository(Booking).findOne({
+      where: { id: bookingId },
+      relations: { bookingContainers: { containerType: true }, cargoType: true },
+    });
+    if (!fresh) return;
+    if (!(await this.holdIfWagonShort(scheduleId, fresh))) {
+      await this.allocate(scheduleId, fresh, "paid");
+    }
+    const schedule = await this.dataSource
+      .getRepository(TrainSchedule)
+      .findOne({ where: { id: scheduleId } });
+    if (
+      previousDay &&
+      schedule?.scheduledDepartureDate &&
+      eatDay(schedule.scheduledDepartureDate) !== previousDay
+    ) {
+      this.notifier.allocatedOtherDay(fresh, schedule.scheduledDepartureDate);
+    }
+  }
+
   /**
    * One reminder per hold, shortly before its pay deadline (the window tick
    * calls this every pass; `payment_reminder_sent_at` dedups). Skips paid
@@ -3531,6 +3645,16 @@ export class BookingBatchService implements OnModuleInit {
         }
         return;
       }
+      // Paid but detached from any train (staff removed it from an allocation,
+      // or a sweep caught it unpinned): money was taken, so it must board — it
+      // stays paid-unallocated for staff to place via the allocate action.
+      if (paid) {
+        this.logger.log(
+          `[BATCH] expire skipped for ${booking.reference} — payment landed ` +
+            `but no train attached; left paid-unallocated for manual placement`,
+        );
+        return;
+      }
       // Reconcile-before-expire (only when a pay window was actually open):
       // no webhook arrived, so ask the gateway DIRECTLY whether the money
       // landed. A late capture found there is registered as SUCCEEDED and
@@ -3859,12 +3983,26 @@ export class BookingBatchService implements OnModuleInit {
       // booking can use — don't kill it for nothing.
       const overlaps = victimLeg.fromEdge < leg.toEdge && leg.fromEdge < victimLeg.toEdge;
       if (!overlaps) continue;
+      const victimPaid =
+        victim.paymentStatus === "PAID" || victim.status === "PAID";
       await this.dataSource.transaction(async (manager) => {
         await this.trainScheduleBookingsRepository.deleteByScheduleAndBooking(
           scheduleId,
           victim.id,
           manager,
         );
+        if (victimPaid) {
+          // Paid bookings are never expired — money was taken, so it boards.
+          // Detach it so it surfaces in the paid-unallocated queue for staff
+          // to re-place; the settled invoice stays untouched.
+          await manager.getRepository(Booking).update(victim.id, {
+            trainScheduleId: null,
+            schedulingStatus: "ELIGIBLE",
+            paymentDeadline: null,
+            selectedForBatchAt: null,
+          } as never);
+          return;
+        }
         await manager.getRepository(Booking).update(victim.id, {
           status: "EXPIRED",
           schedulingStatus: "ELIGIBLE",
@@ -4106,8 +4244,15 @@ export class BookingBatchService implements OnModuleInit {
 
     const capacityTons = this.dimsFor(booking, wagonDims).capacityTons;
     const cargoTons = bookingCargoTons(booking);
+    // PER_TON cargo may cap tons per wagon below the rating (sugar 50T on a 70T
+    // wagon), so divide by the cap where one is configured for this type.
+    const tonsPerWagon = bulkTonsPerWagon(
+      booking.cargoType,
+      booking.cargoType?.wagonTypes?.[0]?.id,
+      capacityTons,
+    );
     const byWeight =
-      cargoTons > 0 && capacityTons > 0 ? Math.ceil(cargoTons / capacityTons) : 0;
+      cargoTons > 0 && tonsPerWagon > 0 ? Math.ceil(cargoTons / tonsPerWagon) : 0;
 
     // Break-bulk (PER_ITEM): indivisible items can need more wagons than raw
     // tonnage suggests (floor items-per-wagon loses the fractional capacity).
@@ -4175,6 +4320,13 @@ export class BookingBatchService implements OnModuleInit {
       .filter((o) => o.wagonTypeId && (stockByTypeId.get(o.wagonTypeId) ?? 0) > 0)
       .map((o) => {
         const wagonTypeId = o.wagonTypeId as string;
+        // Each type sized on its OWN per-wagon tonnage cap, not just its rating
+        // — a type capped lower swallows less per wagon.
+        const tonsPerWagon = bulkTonsPerWagon(
+          booking.cargoType,
+          wagonTypeId,
+          o.dims.capacityTons,
+        );
         const wagonsIfAlone = Math.max(
           1,
           bulkItemWagonsRequired(
@@ -4182,8 +4334,8 @@ export class BookingBatchService implements OnModuleInit {
             o.dims.capacityTons,
             bulkItemsFitFor(booking.cargoType, wagonTypeId),
           ) ||
-            (o.dims.capacityTons > 0
-              ? Math.ceil(bookingCargoTons(booking) / o.dims.capacityTons)
+            (tonsPerWagon > 0
+              ? Math.ceil(bookingCargoTons(booking) / tonsPerWagon)
               : total),
         );
         return {