add booking request functionality for GENERAL customs contracts

- Create migration for booking_requests table with necessary fields and indexes.
- Implement BookingRequestRepository for database operations related to booking requests.
- Develop BookingRequestService to handle business logic for submitting, accepting, rejecting, and canceling booking requests.
- Create DTOs for creating booking requests and reviewing them.
- Define BookingRequest entity to map to the booking_requests table.
- Add UI components for managing shipment requests, including detail and list pages.
- Implement OperationDatePicker component for selecting available shipment days.

apps/edr-freight-api/src/modules/train-scheduling/dto/available-days-for-cargo-query.dto.ts

@@ -0,0 +1,66 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import {
+  IsArray,
+  IsEnum,
+  IsNumber,
+  IsOptional,
+  IsString,
+  IsUUID,
+  Min,
+} from 'class-validator';
+
+export interface CargoContainerLine {
+  containerSize: string;
+  quantity: number;
+}
+
+/**
+ * Cargo-aware availability query. Beyond the route yards, it carries the cargo
+ * sizing so the service can check matching-wagon + train capacity per day. The
+ * `containers` array is passed as a JSON string in the query string (GET) and
+ * parsed here.
+ */
+export class AvailableDaysForCargoQueryDto {
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  originYardId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  destinationYardId?: string;
+
+  @ApiProperty({ enum: ['CONTAINER', 'BULK'] })
+  @IsEnum(['CONTAINER', 'BULK'])
+  freightType!: 'CONTAINER' | 'BULK';
+
+  @ApiPropertyOptional({ description: 'Bulk cargo type code (e.g. COFFEE).' })
+  @IsOptional()
+  @IsString()
+  cargoTypeCode?: string;
+
+  @ApiPropertyOptional({ description: 'Total bulk weight in tons.' })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  @IsNumber()
+  @Min(0)
+  totalWeightTons?: number;
+
+  @ApiPropertyOptional({
+    description: 'Container lines as a JSON string: [{containerSize,quantity}].',
+  })
+  @IsOptional()
+  @Transform(({ value }) => {
+    if (value == null || value === '') return undefined;
+    if (typeof value !== 'string') return value;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return undefined;
+    }
+  })
+  @IsArray()
+  containers?: CargoContainerLine[];
+}

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

@@ -33,6 +33,7 @@ import { RecordCheckpointDto } from "./dto/record-checkpoint.dto";
 import { AvailableLocomotivesQueryDto } from "./dto/available-locomotives-query.dto";
 import { BookableSchedulesQueryDto } from "./dto/bookable-schedules-query.dto";
 import { AvailableDaysQueryDto } from "./dto/available-days-query.dto";
+import { AvailableDaysForCargoQueryDto } from "./dto/available-days-for-cargo-query.dto";
 import { UpdateTrainSchedulingGlobalRulesDto } from "./dto/update-train-scheduling-global-rules.dto";
 import { TrainSchedulingService } from "./train-scheduling.service";
 import { BookingBatchService } from "./booking-batch.service";
@@ -123,6 +124,24 @@ export class TrainSchedulingController {
     );
   }
 
+  @Get("available-days-for-cargo")
+  // No staff guard: customers (portal) and GL (backoffice) both hit this while
+  // creating a booking to find which DAYS are feasible for THIS cargo — i.e. the
+  // route has a train with remaining capacity AND enough matching-type wagons.
+  @ApiOperation({
+    summary: "Days bookable for a specific cargo (wagon + train capacity aware)",
+  })
+  getAvailableDaysForCargo(@Query() query: AvailableDaysForCargoQueryDto) {
+    return this.trainSchedulingService.getAvailableDaysForCargo({
+      originYardId: query.originYardId,
+      destinationYardId: query.destinationYardId,
+      freightType: query.freightType,
+      cargoTypeCode: query.cargoTypeCode,
+      totalWeightTons: query.totalWeightTons,
+      containers: query.containers,
+    });
+  }
+
   @Get("container/eligible-bookings")
   @TrainSchedulingView()
   @ApiOperation({ summary: "List eligible container bookings" })

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

@@ -2074,7 +2074,18 @@ export class TrainSchedulingService {
    * Supports sub-route matching: if originYardId and/or destinationYardId are provided,
    * returns schedules whose route passes through both yards in the correct order.
    */
-  async getBookableSchedules(originYardId?: string, destinationYardId?: string) {
+  /**
+   * Raw OPEN same-route schedule entities a new booking may target (with the
+   * relations needed for capacity/fleet checks). Shared by getBookableSchedules
+   * (which maps to list items) and getAvailableDaysForCargo (which needs the raw
+   * originStationId / scheduledDepartureDate / trainSet).
+   */
+  private async getBookableScheduleEntities(
+    originYardId?: string,
+    destinationYardId?: string,
+  ): Promise<
+    import('../train-schedules/entities/train-schedule.entity').TrainSchedule[]
+  > {
     const schedules = await this.trainSchedulesRepository.findAll({
       where: {
         bookingWindowStatus: 'OPEN',
@@ -2089,7 +2100,7 @@ export class TrainSchedulingService {
       order: { scheduledDepartureDate: 'ASC' },
     });
 
-    const filteredSchedules = schedules
+    return schedules
       .filter((s) => ['DRAFT', 'SCHEDULED'].includes(s.status))
       .filter((s) => {
         // Build the full stop list: origin -> milestones (ordered) -> destination
@@ -2128,10 +2139,15 @@ export class TrainSchedulingService {
         }
 
         return true;
-      })
-      .map((s) => this.mapScheduleListItem(s));
+      });
+  }
 
-    return filteredSchedules;
+  async getBookableSchedules(originYardId?: string, destinationYardId?: string) {
+    const schedules = await this.getBookableScheduleEntities(
+      originYardId,
+      destinationYardId,
+    );
+    return schedules.map((s) => this.mapScheduleListItem(s));
   }
 
   /**
@@ -2151,6 +2167,93 @@ export class TrainSchedulingService {
     return { days: [...days].sort() };
   }
 
+  /**
+   * Cargo-aware day pool: the EAT days that are actually FEASIBLE for the given
+   * cargo. A day is selectable only when ≥1 OPEN schedule on the route that day
+   * has BOTH (a) enough AVAILABLE wagons of the cargo's matching type at that
+   * schedule's origin yard, and (b) remaining train capacity (not fully
+   * allocated). Days with trains but not enough matching wagons are excluded.
+   * Same `{ days: string[] }` shape as getAvailableDays — the customer still
+   * picks a DAY, not a train.
+   */
+  async getAvailableDaysForCargo(input: {
+    originYardId?: string;
+    destinationYardId?: string;
+    freightType: 'CONTAINER' | 'BULK';
+    cargoTypeCode?: string | null;
+    totalWeightTons?: number;
+    containers?: Array<{ containerSize: string; quantity: number }>;
+  }): Promise<{ days: string[] }> {
+    const schedules = await this.getBookableScheduleEntities(
+      input.originYardId,
+      input.destinationYardId,
+    );
+    if (schedules.length === 0) return { days: [] };
+
+    const wagonTypes = await this.dataSource.getRepository(WagonType).find();
+
+    // Resolve the wagon type this cargo needs.
+    const requiredType =
+      input.freightType === 'BULK'
+        ? pickBulkWagonType(wagonTypes, input.cargoTypeCode)
+        : wagonTypes.find(
+            (wt) => wt.code === getDefaultContainerWagonTypeCode() && wt.isActive,
+          );
+    if (!requiredType) return { days: [] };
+
+    // How many wagons of that type the cargo needs.
+    const slotsNeeded = this.wagonsNeededForCargo(input, requiredType);
+
+    // AVAILABLE wagons of the required type, counted once per origin yard.
+    const availableByYard = new Map<string, number>();
+    const availableAt = async (yardId: string): Promise<number> => {
+      const cached = availableByYard.get(yardId);
+      if (cached !== undefined) return cached;
+      const counts = await this.countFleetAvailability(yardId);
+      const n =
+        counts.find((c) => c.wagonTypeId === requiredType.id)?.available ?? 0;
+      availableByYard.set(yardId, n);
+      return n;
+    };
+
+    const days = new Set<string>();
+    for (const s of schedules) {
+      const hasCapacity =
+        Math.max(0, (s.maxWagons ?? 0) - (s.trainSet?.wagonCount ?? 0)) > 0;
+      if (!hasCapacity) continue;
+      const enoughWagons = (await availableAt(s.originStationId)) >= slotsNeeded;
+      if (!enoughWagons) continue;
+      if (s.scheduledDepartureDate)
+        days.add(eatDay(new Date(s.scheduledDepartureDate)));
+    }
+    return { days: [...days].sort() };
+  }
+
+  /**
+   * Wagons needed for a cargo (pre-booking estimate). BULK: ceil(weight /
+   * capacity). CONTAINER: TEU packing — 40ft = 2 TEU, 20ft = 1 TEU, 2 TEU per
+   * wagon. Mirrors wagon-plan.util without fabricating Booking entities.
+   */
+  private wagonsNeededForCargo(
+    input: {
+      freightType: 'CONTAINER' | 'BULK';
+      totalWeightTons?: number;
+      containers?: Array<{ containerSize: string; quantity: number }>;
+    },
+    wagonType: WagonType,
+  ): number {
+    if (input.freightType === 'BULK') {
+      const capacity = Number(wagonType.capacityTons) || 1;
+      const weight = Number(input.totalWeightTons ?? 0);
+      return Math.max(1, Math.ceil(weight / capacity));
+    }
+    const teu = (input.containers ?? []).reduce((sum, c) => {
+      const per = c.containerSize === '40ft' ? 2 : 1;
+      return sum + per * Math.max(0, Number(c.quantity ?? 0));
+    }, 0);
+    return Math.max(1, Math.ceil(teu / 2));
+  }
+
   /** Whether a route has ≥1 OPEN bookable departure on a given EAT day. */
   async existsOpenScheduleOnRouteDay(
     originYardId: string,