import loading backend

apps/edr-freight-api/src/migrations/1900000000000-AddLoadingStatusToTrainScheduleBookings.ts

@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Track per-booking loading confirmation (LOADED/UNLOADED) on train_schedule_bookings.
+ * Tracking only — does not gate dispatch.
+ */
+export class AddLoadingStatusToTrainScheduleBookings1900000000000
+  implements MigrationInterface
+{
+  name = "AddLoadingStatusToTrainScheduleBookings1900000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedule_bookings
+      ADD COLUMN IF NOT EXISTS loading_status varchar(20) NOT NULL DEFAULT 'UNLOADED'
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedule_bookings
+      DROP COLUMN IF EXISTS loading_status
+    `);
+  }
+}

apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule-booking.entity.ts

@@ -1,9 +1,15 @@
 import { BaseEntity } from '@edr/api-common';
+import { LoadingStatus } from '@edr/types';
 import { Entity, Index, JoinColumn, ManyToOne, Column } from 'typeorm';
 
 import { Booking } from '../../bookings/entities/booking.entity';
 import { TrainSchedule } from './train-schedule.entity';
 
+export const TRAIN_SCHEDULE_BOOKING_LOADING_STATUSES = [
+  LoadingStatus.Unloaded,
+  LoadingStatus.Loaded,
+] as const;
+
 @Entity({ schema: 'freight', name: 'train_schedule_bookings' })
 @Index(['trainScheduleId', 'bookingId'], { unique: true })
 @Index(['bookingId'], { unique: true })
@@ -23,4 +29,7 @@ export class TrainScheduleBooking extends BaseEntity {
   @ManyToOne(() => Booking)
   @JoinColumn({ name: 'booking_id' })
   booking?: Booking;
+
+  @Column({ name: 'loading_status', type: 'varchar', length: 20, default: 'UNLOADED' })
+  loadingStatus!: string;
 }

apps/edr-freight-api/src/modules/train-schedules/train-schedule-bookings.repository.ts

@@ -47,4 +47,27 @@ export class TrainScheduleBookingsRepository extends BaseRepository<TrainSchedul
       select: { id: true, bookingId: true, trainScheduleId: true },
     });
   }
+
+  findByScheduleId(
+    trainScheduleId: string,
+    manager?: EntityManager,
+  ): Promise<TrainScheduleBooking[]> {
+    return this.repo(manager).find({
+      where: { trainScheduleId },
+      select: { id: true, bookingId: true, trainScheduleId: true, loadingStatus: true },
+    });
+  }
+
+  async updateLoadingStatusMany(
+    trainScheduleId: string,
+    bookingIds: string[],
+    loadingStatus: string,
+    manager?: EntityManager,
+  ): Promise<void> {
+    if (!bookingIds.length) return;
+    await this.repo(manager).update(
+      { trainScheduleId, bookingId: In(bookingIds) },
+      { loadingStatus },
+    );
+  }
 }

apps/edr-freight-api/src/modules/train-scheduling/dto/update-import-loading-status.dto.ts

@@ -0,0 +1,15 @@
+import { LoadingStatus } from '@edr/types';
+import { ApiProperty } from '@nestjs/swagger';
+import { ArrayMinSize, IsArray, IsEnum, IsUUID } from 'class-validator';
+
+export class UpdateImportLoadingStatusDto {
+  @ApiProperty({ type: [String] })
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsUUID('4', { each: true })
+  bookingIds!: string[];
+
+  @ApiProperty({ enum: LoadingStatus })
+  @IsEnum(LoadingStatus)
+  loadingStatus!: LoadingStatus;
+}

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

@@ -28,6 +28,7 @@ import { GetEligibleBulkBookingsDto } from "./dto/get-eligible-bulk-bookings.dto
 import { GetEligibleContainerBookingsDto } from "./dto/get-eligible-container-bookings.dto";
 import { PinWagonsDto } from "./dto/pin-wagons.dto";
 import { UpdateContainerItemDto } from "./dto/update-container-item.dto";
+import { UpdateImportLoadingStatusDto } from "./dto/update-import-loading-status.dto";
 import { PreviewBulkTrainScheduleDto } from "./dto/preview-bulk-train-schedule.dto";
 import { PreviewContainerTrainScheduleDto } from "./dto/preview-container-train-schedule.dto";
 import { PreviewTrainScheduleDto } from "./dto/preview-train-schedule.dto";
@@ -325,6 +326,28 @@ export class TrainSchedulingController {
     return this.trainSchedulingService.getCompositionRemovals(id);
   }
 
+  @Get("schedules/:id/import-loading-bookings")
+  @TrainSchedulingView()
+  @ApiOperation({
+    summary: "List import bookings eligible for loading confirmation on this schedule",
+  })
+  getImportLoadingBookings(@Param("id", ParseUUIDPipe) id: string) {
+    return this.trainSchedulingService.getImportLoadingBookings(id);
+  }
+
+  @Patch("schedules/:id/import-loading-status")
+  @TrainSchedulingManage()
+  @ApiOperation({
+    summary:
+      "Mark import bookings loaded/unloaded on this schedule (tracking only, does not affect dispatch)",
+  })
+  updateImportLoadingStatus(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: UpdateImportLoadingStatusDto,
+  ) {
+    return this.trainSchedulingService.updateImportLoadingStatus(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

@@ -1,5 +1,6 @@
 import {
   AllocationLoadType,
+  LoadingStatus,
   SchedulingStatus,
   TrainCheckpointKind,
   TrainScheduleStatus as TrainScheduleStatusEnum,
@@ -45,6 +46,7 @@ import { GetEligibleBulkBookingsDto } from './dto/get-eligible-bulk-bookings.dto
 import { GetEligibleContainerBookingsDto } from './dto/get-eligible-container-bookings.dto';
 import { PinWagonsDto } from './dto/pin-wagons.dto';
 import { UpdateContainerItemDto } from './dto/update-container-item.dto';
+import { UpdateImportLoadingStatusDto } from './dto/update-import-loading-status.dto';
 import { PreviewBulkTrainScheduleDto } from './dto/preview-bulk-train-schedule.dto';
 import { PreviewContainerTrainScheduleDto } from './dto/preview-container-train-schedule.dto';
 import { PreviewTrainScheduleDto } from './dto/preview-train-schedule.dto';
@@ -744,6 +746,87 @@ export class TrainSchedulingService {
     );
   }
 
+  async getImportLoadingBookings(scheduleId: string) {
+    const schedule = await this.trainSchedulesRepository.findById(scheduleId);
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+
+    const [scheduleBookings, allocations] = await Promise.all([
+      this.trainScheduleBookingsRepository.findByScheduleId(scheduleId),
+      this.wagonBookingAllocationsRepository.findByScheduleId(scheduleId),
+    ]);
+    if (!scheduleBookings.length) {
+      return { count: 0, items: [] };
+    }
+
+    const allocatedBookingIds = new Set(allocations.map((a) => a.bookingId));
+    const statusByBookingId = new Map(
+      scheduleBookings.map((sb) => [sb.bookingId, sb.loadingStatus]),
+    );
+    const candidateIds = scheduleBookings
+      .map((sb) => sb.bookingId)
+      .filter((id) => allocatedBookingIds.has(id));
+    if (!candidateIds.length) {
+      return { count: 0, items: [] };
+    }
+
+    const bookings = await this.bookingsRepository.findByIdsForScheduling(candidateIds);
+    const items = bookings
+      .filter((b) => b.tradeDirection === 'IMPORT' && b.paymentStatus === 'PAID')
+      .map((b) => ({
+        id: b.id,
+        reference: b.reference ?? null,
+        customer: b.company?.name ?? null,
+        weightTons: b.cargoTotalWeightVgm,
+        loadingStatus: statusByBookingId.get(b.id) ?? LoadingStatus.Unloaded,
+      }));
+    return { count: items.length, items };
+  }
+
+  async updateImportLoadingStatus(scheduleId: string, dto: UpdateImportLoadingStatusDto) {
+    const schedule = await this.trainSchedulesRepository.findById(scheduleId);
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+
+    const [scheduleBookings, allocations, bookings] = await Promise.all([
+      this.trainScheduleBookingsRepository.findByScheduleId(scheduleId),
+      this.wagonBookingAllocationsRepository.findByScheduleId(scheduleId),
+      this.bookingsRepository.findByIdsForScheduling(dto.bookingIds),
+    ]);
+
+    const scheduledIds = new Set(scheduleBookings.map((sb) => sb.bookingId));
+    const allocatedIds = new Set(allocations.map((a) => a.bookingId));
+    const bookingById = new Map(bookings.map((b) => [b.id, b]));
+
+    const invalid: string[] = [];
+    for (const id of dto.bookingIds) {
+      const booking = bookingById.get(id);
+      if (
+        !scheduledIds.has(id) ||
+        !allocatedIds.has(id) ||
+        !booking ||
+        booking.tradeDirection !== 'IMPORT' ||
+        booking.paymentStatus !== 'PAID'
+      ) {
+        invalid.push(id);
+      }
+    }
+    if (invalid.length) {
+      throw new BadRequestException(
+        `Not eligible for import loading confirmation on this schedule: ${invalid.join(', ')}`,
+      );
+    }
+
+    await this.trainScheduleBookingsRepository.updateLoadingStatusMany(
+      scheduleId,
+      dto.bookingIds,
+      dto.loadingStatus,
+    );
+    return this.getImportLoadingBookings(scheduleId);
+  }
+
   async pinWagons(scheduleId: string, dto: PinWagonsDto) {
     const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
     if (!schedule) {

apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts

@@ -52,6 +52,11 @@ export class FilterWarehouseInventoryDto {
   @IsEnum(WAREHOUSE_INVENTORY_STATUSES)
   status?: WarehouseInventoryStatus;
 
+  @ApiPropertyOptional({ enum: ['IMPORT', 'EXPORT'] })
+  @IsOptional()
+  @IsEnum(['IMPORT', 'EXPORT'])
+  direction?: 'IMPORT' | 'EXPORT';
+
   @ApiPropertyOptional()
   @IsOptional()
   @IsString()

apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts

@@ -430,6 +430,7 @@ export class WarehouseInventoryService {
       ...(filter.status ? { status: filter.status } : {}),
       ...(createdAt ? { createdAt } : {}),
       ...(filter.facilityId ? { warehouse: { stationId: filter.facilityId } } : {}),
+      ...(filter.direction ? { booking: { tradeDirection: filter.direction } } : {}),
     };
 
     const search = filter.search?.trim();