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();

apps/edr-freight-web/backoffice/src/App.tsx

@@ -309,7 +309,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
           },
           {
             label: "Terminal Inventory",
-            href: "/dashboard/warehouse-inventory",
+            href: "/dashboard/warehouse-inventory?direction=IMPORT",
             icon: <Package />,
           },
           {
@@ -356,7 +356,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
           },
           {
             label: "Terminal Inventory",
-            href: "/dashboard/warehouse-inventory",
+            href: "/dashboard/warehouse-inventory?direction=EXPORT",
             icon: <Package />,
           },
         ],

apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts

@@ -94,6 +94,8 @@ export const QUERY_KEYS = {
       ["train-scheduling", "unassigned", id] as const,
     compositionRemovals: (id: string) =>
       ["train-scheduling", "removals", id] as const,
+    importLoadingBookings: (id: string) =>
+      ["train-scheduling", "import-loading-bookings", id] as const,
   },
 
   FLEET: {

apps/edr-freight-web/backoffice/src/constants/URLS.ts

@@ -301,6 +301,10 @@ export const URL_CONSTANTS = {
     PIN_WAGONS: (id: string) => `/train-scheduling/schedules/${id}/pin-wagons`,
     FINALIZE: (id: string) => `/train-scheduling/schedules/${id}/finalize`,
     DISPATCH: (id: string) => `/train-scheduling/schedules/${id}/dispatch`,
+    IMPORT_LOADING_BOOKINGS: (id: string) =>
+      `/train-scheduling/schedules/${id}/import-loading-bookings`,
+    IMPORT_LOADING_STATUS: (id: string) =>
+      `/train-scheduling/schedules/${id}/import-loading-status`,
     IMPORT_DJIBOUTI: (id: string) =>
       `/train-scheduling/schedules/${id}/import-djibouti`,
     IMPORT_DJIBOUTI_DOCUMENTS: (id: string) =>

apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx

@@ -21,6 +21,7 @@ export default function WarehouseInventoryPage() {
   const navigate = useNavigate();
   const [searchParams] = useSearchParams();
   const initialStatus = (searchParams.get('status') as InventoryStatus | null) ?? undefined;
+  const direction = (searchParams.get('direction') as 'IMPORT' | 'EXPORT' | null) ?? undefined;
   const [filter, setFilter] = useState<InventoryFilter>(
     initialStatus ? { status: initialStatus } : {},
   );
@@ -28,8 +29,8 @@ export default function WarehouseInventoryPage() {
 
   const [debouncedSearch] = useDebouncedValue(search, 300);
   const queryFilter = useMemo<InventoryFilter>(
-    () => ({ ...filter, search: debouncedSearch || undefined }),
-    [filter, debouncedSearch],
+    () => ({ ...filter, direction, search: debouncedSearch || undefined }),
+    [filter, direction, debouncedSearch],
   );
 
   const warehousesQuery = useWarehouses();
@@ -53,7 +54,13 @@ export default function WarehouseInventoryPage() {
   return (
     <PageContainer>
       <PageHeader
-        title="Warehouse Inventory"
+        title={
+          direction === 'IMPORT'
+            ? 'Import Terminal Inventory'
+            : direction === 'EXPORT'
+              ? 'Export Terminal Inventory'
+              : 'Warehouse Inventory'
+        }
         subtitle="Track received items through the storage, reservation, loading and dispatch lifecycle."
         action={
           <Group gap="xs">

apps/edr-freight-web/backoffice/src/services/api.ts

@@ -43,6 +43,8 @@ import type {
   CreateTrainSchedulePayload,
   EligibleContainerBookingsResponse,
   FreightType,
+  ImportLoadingBookingsResponse,
+  LoadingStatus,
   LocomotiveRecord,
   PinWagonsPayload,
   RecordCheckpointPayload,
@@ -343,6 +345,25 @@ export const api = {
         QUERY_KEYS.TRAIN_SCHEDULING.compositionRemovals(scheduleId),
     ),
 
+    importLoadingBookings: endpoint<{ id: string }, ImportLoadingBookingsResponse>(
+      "train-scheduling",
+      "import-loading-bookings",
+      ({ id }) => trainSchedulingService.getImportLoadingBookings(id),
+      ({ id }) => QUERY_KEYS.TRAIN_SCHEDULING.importLoadingBookings(id),
+    ),
+
+    updateImportLoadingStatus: endpoint<
+      { id: string; bookingIds: string[]; loadingStatus: LoadingStatus },
+      ImportLoadingBookingsResponse
+    >(
+      "train-scheduling",
+      "update-import-loading-status",
+      ({ id, bookingIds, loadingStatus }) =>
+        trainSchedulingService.updateImportLoadingStatus(id, { bookingIds, loadingStatus }),
+      undefined,
+      ({ id }) => [QUERY_KEYS.TRAIN_SCHEDULING.importLoadingBookings(id)],
+    ),
+
     // ── Mutations ──────────────────────────────────────────────────────────
     runAllocation: endpoint<{ scheduleId: string }, WagonAllocationAttemptResult>(
       "train-scheduling",

apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts

@@ -15,6 +15,8 @@ import type {
   ImportDjiboutiActionPayload,
   ImportDjiboutiLoadList,
   ImportDjiboutiOperation,
+  ImportLoadingBookingsResponse,
+  LoadingStatus,
   LocomotiveRecord,
   PinWagonsPayload,
   RecordCheckpointPayload,
@@ -298,6 +300,26 @@ export const trainSchedulingService = {
     return unwrap(response.data);
   },
 
+  getImportLoadingBookings: async (
+    scheduleId: string,
+  ): Promise<ImportLoadingBookingsResponse> => {
+    const response = await client.get<ImportLoadingBookingsResponse>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.IMPORT_LOADING_BOOKINGS(scheduleId),
+    );
+    return unwrap(response.data);
+  },
+
+  updateImportLoadingStatus: async (
+    scheduleId: string,
+    payload: { bookingIds: string[]; loadingStatus: LoadingStatus },
+  ): Promise<ImportLoadingBookingsResponse> => {
+    const response = await client.patch<ImportLoadingBookingsResponse>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.IMPORT_LOADING_STATUS(scheduleId),
+      payload,
+    );
+    return unwrap(response.data);
+  },
+
   getImportDjiboutiOperation: async (
     scheduleId: string,
   ): Promise<ImportDjiboutiOperation> => {

apps/edr-freight-web/backoffice/src/types/trainScheduling.ts

@@ -453,6 +453,21 @@ export interface ImportDjiboutiDocumentRecord {
   notes?: string | null;
 }
 
+export type LoadingStatus = "LOADED" | "UNLOADED";
+
+export interface ImportLoadingBooking {
+  id: string;
+  reference: string | null;
+  customer: string | null;
+  weightTons: number;
+  loadingStatus: LoadingStatus;
+}
+
+export interface ImportLoadingBookingsResponse {
+  count: number;
+  items: ImportLoadingBooking[];
+}
+
 export interface ImportDjiboutiOperation {
   trainScheduleId: string;
   trainNumber: string | null;

apps/edr-freight-web/backoffice/src/types/warehouse.ts

@@ -1013,6 +1013,7 @@ export interface InventoryFilter {
   containerId?: string;
   goodsId?: string;
   status?: InventoryStatus;
+  direction?: 'IMPORT' | 'EXPORT';
   search?: string;
   dateFrom?: string;
   dateTo?: string;

packages/types/src/freight/index.ts

@@ -198,6 +198,11 @@ export enum TrainSetWagonStatus {
   Departed = "DEPARTED",
 }
 
+export enum LoadingStatus {
+  Loaded = "LOADED",
+  Unloaded = "UNLOADED",
+}
+
 export enum WagonStatus {
   Available = "AVAILABLE",
   Assigned = "ASSIGNED",