feat(train-scheduling): implement day-level booking pool

- Added `unplaced` method in `BookingNotifierService` to log warnings for bookings that cannot be placed on any train.
- Introduced `getAvailableDays` method in `TrainSchedulingService` to retrieve distinct days with open departures for a given route.
- Created `AvailableDaysQueryDto` for querying available days based on origin and destination yards.
- Updated `TrainSchedulingController` to expose an endpoint for available days.
- Modified frontend components to support day-level booking, allowing customers to select only a day without pinning to a specific train.
- Removed references to train schedules in booking forms and review steps, emphasizing day selection.
- Added a database migration to create an index for efficient querying of bookings by route and day.

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

@@ -689,6 +689,11 @@ export class BookingsRepository extends BaseRepository<Booking> {
     destinationStationId?: string;
     schedulingStatus?: string;
     trainScheduleId?: string;
+    /**
+     * EAT calendar day (yyyy-MM-dd). With day-level pooling the staff wizard sees
+     * the whole (route, day) pool rather than bookings pre-targeted to one train.
+     */
+    day?: string;
   }): Promise<Booking[]> {
     const qb = this.repository
       .createQueryBuilder('booking')
@@ -706,9 +711,16 @@ export class BookingsRepository extends BaseRepository<Booking> {
       .where('booking.status = :paidStatus', { paidStatus: 'PAID' })
       .andWhere('scheduleBooking.id IS NULL');
 
-    // Mirror the automatic batch pool: a schedule only ever considers bookings that
-    // targeted THAT schedule (same as findBatchPool's train_schedule_id filter).
-    if (options.trainScheduleId) {
+    // Day-level pooling: customers no longer set train_schedule_id, so the wizard
+    // surfaces the whole (route, EAT day) pool. Fall back to the legacy
+    // single-schedule filter only when no day is supplied (e.g. a staff-pinned
+    // booking that still carries train_schedule_id).
+    if (options.day) {
+      qb.andWhere(
+        `DATE(booking.scheduled_date AT TIME ZONE 'Africa/Addis_Ababa') = :day`,
+        { day: options.day },
+      );
+    } else if (options.trainScheduleId) {
       qb.andWhere('booking.train_schedule_id = :trainScheduleId', {
         trainScheduleId: options.trainScheduleId,
       });
@@ -765,6 +777,43 @@ export class BookingsRepository extends BaseRepository<Booking> {
       .getMany();
   }
 
+  /**
+   * Day-level batch pool: ready, not-yet-allocated bookings on a route for one
+   * EAT calendar day, regardless of which train they end up on. Same status
+   * rules and ordering as {@link findBatchPool}, but keyed on
+   * (origin, destination, day) instead of train_schedule_id — the engine then
+   * distributes these across all trains departing that day.
+   */
+  findBatchPoolByRouteDay(
+    originYardId: string,
+    destinationYardId: string,
+    day: string,
+  ): Promise<Booking[]> {
+    return this.repository
+      .createQueryBuilder('booking')
+      .leftJoinAndSelect('booking.company', 'company')
+      .leftJoinAndSelect('booking.bookingContainers', 'bookingContainer')
+      .leftJoin(TrainScheduleBooking, 'sb', 'sb.booking_id = booking.id')
+      .where('booking.origin_yard_id = :originYardId', { originYardId })
+      .andWhere('booking.destination_yard_id = :destinationYardId', {
+        destinationYardId,
+      })
+      .andWhere(
+        `DATE(booking.scheduled_date AT TIME ZONE 'Africa/Addis_Ababa') = :day`,
+        { day },
+      )
+      .andWhere('sb.id IS NULL')
+      .andWhere(
+        `((booking.is_government = false AND booking.status = 'FULLY_EXECUTED')
+          OR (booking.is_government = true AND booking.status IN ('APPROVED','PAID')))`,
+      )
+      .orderBy('booking.is_government', 'DESC')
+      .addOrderBy('booking.priority_score', 'DESC')
+      .addOrderBy('booking.fully_executed_at', 'ASC')
+      .addOrderBy('booking.created_at', 'ASC')
+      .getMany();
+  }
+
   /** Every booking that targeted a schedule (any status) — for the batch monitoring board. */
   findAllBySchedule(scheduleId: string): Promise<Booking[]> {
     return this.repository

apps/edr-freight-api/src/modules/bookings/bookings.service.ts

@@ -11,6 +11,7 @@ import { Freight, SchedulingStatus } from '@edr/types';
 // import { CustomersService } from '../customers/customers.service';
 import { CompaniesService } from '../companies/companies.service';
 import { TrainSchedulingService } from '../train-scheduling/train-scheduling.service';
+import { eatDay } from '../train-scheduling/batch-window.util';
 import { FilesService } from '../files/files.service';
 import { MinioService } from '../minio/minio.service';
 import { ContainerTypesService } from '../rule-engine/services/container-types.service';
@@ -273,8 +274,8 @@ export class BookingsService {
       companyId = company.id;
     }
 
-    // Schedule targeting: when provided, the schedule must be OPEN and on the same route.
     if (dto.trainScheduleId) {
+      // Staff manual pin: the schedule must be OPEN and on the same route.
       const schedule = await this.dataSource
         .getRepository(TrainSchedule)
         .findOne({ where: { id: dto.trainScheduleId } });
@@ -290,6 +291,22 @@ export class BookingsService {
       ) {
         throw new BadRequestException('Selected schedule is not on the booking route');
       }
+    } else {
+      // Day-level pool: the customer picked a DAY — require that the route has at
+      // least one OPEN departure on that EAT day. The batch engine assigns the
+      // train later.
+      const day = eatDay(new Date(dto.scheduledDate));
+      const hasDeparture =
+        await this.trainSchedulingService.existsOpenScheduleOnRouteDay(
+          dto.originYardId,
+          dto.destinationYardId,
+          day,
+        );
+      if (!hasDeparture) {
+        throw new BadRequestException(
+          'No departures available on the selected day for this route',
+        );
+      }
     }
 
     const reference = dto.reference || (await this.generateReference());

apps/edr-freight-api/src/modules/bookings/dto/create-booking.dto.ts

@@ -91,12 +91,21 @@ export class CreateBookingDto {
   @IsUUID()
   trainId?: string;
 
-  /** Target schedule this booking is created against (required by the backoffice create form). */
-  @ApiPropertyOptional({ format: 'uuid', description: 'Target train schedule (pool membership)' })
+  /**
+   * Staff-only manual pin to a specific train. Customers omit this — they pick a
+   * DAY via {@link scheduledDate} and the batch engine assigns a train within
+   * that (route, day) pool. When provided, the schedule must be OPEN and on the
+   * booking route.
+   */
+  @ApiPropertyOptional({
+    format: 'uuid',
+    description: 'Staff only: pin to a specific train schedule. Customers omit this.',
+  })
   @IsOptional()
   @IsUUID()
   trainScheduleId?: string;
 
+  /** The day the customer wants to ship (the pool day key). */
   @ApiProperty({ example: '2026-06-15T00:00:00.000Z' })
   @IsDateString()
   scheduledDate!: string;

apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts

@@ -277,7 +277,15 @@ export class Booking extends BaseEntity {
   @Column({ name: 'scheduled_at', type: 'timestamptz', nullable: true })
   scheduledAt?: Date | null;
 
-  /** The schedule this booking targets (pool membership), set at creation. FK to train_schedules. */
+  /**
+   * The train this booking is assigned to. FK to train_schedules.
+   *
+   * Day-level pooling: customers no longer pick a train — they pick a DAY, and
+   * this stays null at creation. The batch engine sets it when it assigns the
+   * booking to a specific train within its (route, day) pool; staff may also
+   * pin it manually. The day-level pool is keyed on
+   * (origin_yard_id, destination_yard_id, day of scheduled_date), not this column.
+   */
   @Column({ name: 'train_schedule_id', type: 'uuid', nullable: true })
   trainScheduleId?: string | null;