add loading status management for bookings

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

@@ -372,6 +372,19 @@ export class TrainSchedulingController {
     return this.trainSchedulingService.updateImportLoadingStatus(id, dto);
   }
 
+  @Patch("schedules/:id/loading-status")
+  @TrainSchedulingManage()
+  @ApiOperation({
+    summary:
+      "Mark bookings loaded/unloaded on this schedule (any direction, pre-dispatch only)",
+  })
+  setBookingLoadingStatus(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: UpdateImportLoadingStatusDto,
+  ) {
+    return this.trainSchedulingService.setBookingLoadingStatus(id, dto);
+  }
+
   @Post("schedules/:id/pin-wagons")
   @TrainSchedulingManage()
   @ApiOperation({ summary: "Pin physical wagons to train set slots" })

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

@@ -787,11 +787,49 @@ export class TrainSchedulingService {
     const setLocomotives = this.locomotivesOfTrainSet(schedule.trainSet);
     const limitLoco = minLocomotiveLimits(setLocomotives) ?? undefined;
     const limits = await this.resolveTrainLimitConfig(previewDto, limitLoco);
+
+    // Callers that add bookings without hand-picking container slots (the
+    // workspace "Add from pool" button, re-adding a removed booking) send no
+    // containerPlacements. Auto-fill them the same way the batch engine does:
+    // preview the wagon plan first, then lay containers into the plan's slots.
+    // Without this the placement validator rejects container bookings outright
+    // ("Container placements are required for container bookings").
+    let containerPlacements = dto.containerPlacements;
+    if (!containerPlacements?.length) {
+      const preview = await this.validateBookingsForScheduling(
+        previewDto,
+        freightType ?? null,
+        dto.forceAssign,
+        [],
+        false,
+        limits,
+        scheduleId,
+      );
+      const containerBookings = preview.bookings.filter(
+        (b) => b.freightType === 'CONTAINER',
+      );
+      if (containerBookings.length) {
+        const units = expandBookingContainerUnits(containerBookings);
+        const slots = getContainerSlotSequenceNos(preview.wagonPlan);
+        const generated = autoFillPlacements(units, slots);
+        const missing = findMissingContainerNumberIssues(units, generated);
+        if (missing.length) {
+          throw new BadRequestException({
+            message: `Booking validation failed: ${missing
+              .map((m) => m.issue)
+              .join('; ')}`,
+            violations: missing.map((m) => m.issue),
+          });
+        }
+        containerPlacements = generated;
+      }
+    }
+
     const validation = await this.validateBookingsForScheduling(
       previewDto,
       freightType ?? null,
       dto.forceAssign,
-      dto.containerPlacements,
+      containerPlacements,
       true,
       limits,
       scheduleId,
@@ -887,7 +925,7 @@ export class TrainSchedulingService {
         savedWagons,
         wagonPlan,
         bookings,
-        dto.containerPlacements ?? [],
+        containerPlacements ?? [],
       );
 
       for (const booking of bookings) {
@@ -1151,6 +1189,50 @@ export class TrainSchedulingService {
     return this.getImportLoadingBookings(scheduleId);
   }
 
+  /**
+   * Flip loaded/unloaded on the schedule↔booking link from the workspace, for any
+   * direction (import/export/domestic). Distinct from unassign: the booking stays
+   * on its wagon; this only records whether cargo is physically loaded. Allowed
+   * only before dispatch — once the train is DISPATCHED/ARRIVED the on-arrival
+   * warehouse automation owns unload, so staff can no longer hand-edit the flag.
+   */
+  async setBookingLoadingStatus(scheduleId: string, dto: UpdateImportLoadingStatusDto) {
+    const schedule = await this.trainSchedulesRepository.findById(scheduleId);
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+    if (!['DRAFT', 'SCHEDULED'].includes(schedule.status)) {
+      throw new BadRequestException(
+        `Loading status can only be changed before dispatch (schedule is ${schedule.status})`,
+      );
+    }
+
+    const [scheduleBookings, allocations] = await Promise.all([
+      this.trainScheduleBookingsRepository.findByScheduleId(scheduleId),
+      this.wagonBookingAllocationsRepository.findByScheduleId(scheduleId),
+    ]);
+    const scheduledIds = new Set(scheduleBookings.map((sb) => sb.bookingId));
+    const allocatedIds = new Set(allocations.map((a) => a.bookingId));
+
+    // Only bookings that are on this train AND pinned to a wagon can be loaded —
+    // no direction/payment filter, staff load whatever is physically on the set.
+    const invalid = dto.bookingIds.filter(
+      (id) => !scheduledIds.has(id) || !allocatedIds.has(id),
+    );
+    if (invalid.length) {
+      throw new BadRequestException(
+        `Not allocated to a wagon on this schedule: ${invalid.join(', ')}`,
+      );
+    }
+
+    await this.trainScheduleBookingsRepository.updateLoadingStatusMany(
+      scheduleId,
+      dto.bookingIds,
+      dto.loadingStatus,
+    );
+    return this.getTrainScheduleById(scheduleId);
+  }
+
   async pinWagons(scheduleId: string, dto: PinWagonsDto) {
     const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
     if (!schedule) {
@@ -3843,9 +3925,11 @@ export class TrainSchedulingService {
   private async mapScheduleDetail(
     schedule: import('../train-schedules/entities/train-schedule.entity').TrainSchedule,
   ) {
-    const allocationIds = (schedule.trainSet?.wagons ?? [])
-      .flatMap((w) => w.allocations ?? [])
-      .map((a) => a.id);
+    const allocations = (schedule.trainSet?.wagons ?? []).flatMap(
+      (w) => w.allocations ?? [],
+    );
+    const allocationIds = allocations.map((a) => a.id);
+    const allocatedBookingIds = new Set(allocations.map((a) => a.bookingId));
 
     const windowCfg = await this.getWindowConfig();
 
@@ -4004,6 +4088,11 @@ export class TrainSchedulingService {
           status: sb.booking?.status ?? null,
           schedulingStatus: sb.booking?.schedulingStatus ?? null,
           freightType: sb.booking?.freightType ?? null,
+          // Loaded/unloaded is tracked on the schedule↔booking link, not the
+          // booking itself — staff flip it per booking in the workspace before
+          // dispatch. Defaults UNLOADED for links written before the column.
+          loadingStatus: sb.loadingStatus ?? LoadingStatus.Unloaded,
+          wagonAssigned: allocatedBookingIds.has(sb.booking?.id ?? sb.bookingId),
         })) ?? [],
     };
   }