auto allocation and batch managemnt, tracking the train

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

@@ -1,5 +1,7 @@
 import {
   BadRequestException,
+  forwardRef,
+  Inject,
   Injectable,
   Logger,
   NotFoundException,
@@ -20,6 +22,7 @@ import { assertBookingStatus } from './booking-status.util';
 import { ContractViewDto } from './dto/contract-view.dto';
 import { SignContractDto } from './dto/sign-contract.dto';
 import { ContractSignerRole } from './entities/booking-contract-signature.entity';
+import { BookingBatchService } from '../train-scheduling/booking-batch.service';
 
 @Injectable()
 export class BookingContractService {
@@ -33,6 +36,8 @@ export class BookingContractService {
     private readonly viewModelBuilder: ContractViewModelBuilder,
     private readonly renderer: ContractRendererService,
     private readonly pdfService: ContractPdfService,
+    @Inject(forwardRef(() => BookingBatchService))
+    private readonly bookingBatchService: BookingBatchService,
   ) {}
 
   buildContractSummary(booking: Booking): string {
@@ -203,6 +208,9 @@ export class BookingContractService {
     }
 
     const updated = await this.bookingsRepository.update(bookingId, updates as never);
+    if (role === 'STAFF' && updated?.trainScheduleId) {
+      this.bookingBatchService.enqueueScheduleProcessing(updated.trainScheduleId);
+    }
     try {
       await this.upsertContractPdf(
         bookingId,

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

@@ -22,7 +22,7 @@ export class BookingPaymentService {
 
   async pay(bookingId: string): Promise<{ redirectUrl: string }> {
     const booking = await this.requireBooking(bookingId);
-    assertBookingStatus(booking, ['FULLY_EXECUTED', 'AWAITING_PAYMENT', '']);
+    assertBookingStatus(booking, ['FULLY_EXECUTED', 'SELECTED_FOR_BATCH', 'AWAITING_PAYMENT', '']);
 
     const existing = await this.paymentService.findBookingById(bookingId);
     if (existing && NON_TERMINAL_STATUSES.includes(existing.status)) {

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

@@ -0,0 +1,94 @@
+import { BookingPricingService } from './booking-pricing.service';
+import type { Booking } from './entities/booking.entity';
+import type { Rate } from '../rule-engine/entities/rate.entity';
+
+describe('BookingPricingService — domestic corridor', () => {
+  const intercityBulkEtb: Rate = {
+    id: 'rate-intercity-bulk-etb',
+    rateType: 'INTERCITY_BULK',
+    currency: 'ETB',
+    rateValue: 1900,
+    rateUnit: 'PER_TON',
+    status: 'LIVE',
+    containerTypeId: null,
+  } as Rate;
+
+  const intercityContainerEtb: Rate = {
+    id: 'rate-intercity-container-etb',
+    rateType: 'INTERCITY_CONTAINER',
+    currency: 'ETB',
+    rateValue: 25000,
+    rateUnit: 'PER_CONTAINER',
+    status: 'LIVE',
+    containerTypeId: null,
+  } as Rate;
+
+  let service: BookingPricingService;
+  let bookingsRepository: { calculateWagonCount: jest.Mock };
+  let ratesService: { findLiveRates: jest.Mock };
+
+  beforeEach(() => {
+    bookingsRepository = { calculateWagonCount: jest.fn().mockResolvedValue(2) };
+    ratesService = {
+      findLiveRates: jest.fn().mockResolvedValue([intercityBulkEtb, intercityContainerEtb]),
+    };
+
+    service = new BookingPricingService(
+      bookingsRepository as never,
+      {} as never,
+      {} as never,
+      ratesService as never,
+      {} as never,
+    );
+  });
+
+  it('prices domestic bulk using INTERCITY_BULK and cargo tons', async () => {
+    const booking = {
+      id: 'b-1',
+      freightType: 'BULK',
+      tradeDirection: 'DOMESTIC',
+      paymentCurrency: 'ETB',
+      cargoTotalWeightVgm: 120,
+      bookingContainers: [],
+    } as unknown as Booking;
+
+    const result = await (
+      service as unknown as {
+        computeBaseRailLinesWithRates: (
+          b: Booking,
+          input: { containers: [] },
+        ) => Promise<{ lineItems: Array<{ amount: number; code: string }> }>;
+      }
+    ).computeBaseRailLinesWithRates(booking, { containers: [] });
+
+    expect(result.lineItems).toHaveLength(1);
+    expect(result.lineItems[0].code).toBe('INTERCITY_BULK');
+    expect(result.lineItems[0].amount).toBe(1900 * 120);
+  });
+
+  it('prices domestic container using INTERCITY_CONTAINER fallback', async () => {
+    const booking = {
+      id: 'b-2',
+      freightType: 'CONTAINER',
+      tradeDirection: 'DOMESTIC',
+      paymentCurrency: 'ETB',
+      cargoTotalWeightVgm: 50,
+      bookingContainers: [],
+    } as unknown as Booking;
+
+    const result = await (
+      service as unknown as {
+        computeBaseRailLinesWithRates: (
+          b: Booking,
+          input: {
+            containers: Array<{ containerTypeId: string; quantity: number }>;
+          },
+        ) => Promise<{ lineItems: Array<{ amount: number; code: string }> }>;
+      }
+    ).computeBaseRailLinesWithRates(booking, {
+      containers: [{ containerTypeId: 'ct-20', quantity: 3 }],
+    });
+
+    expect(result.lineItems.some((l) => l.code === 'INTERCITY_CONTAINER')).toBe(true);
+  });
+});

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

@@ -275,7 +275,9 @@ export class BookingPricingService {
           ? isBulk
             ? 'BULK_EXPORT'
             : 'CONTAINER_EXPORT'
-          : 'INTERCITY_CONTAINER';
+          : isBulk
+            ? 'INTERCITY_BULK'
+            : 'INTERCITY_CONTAINER';
 
     const lines: PriceLineItemDto[] = [];
     const usedRatesMap = new Map<string, Rate>();
@@ -301,7 +303,10 @@ export class BookingPricingService {
       );
       if (fallback) {
         usedRatesMap.set(fallback.id, fallback);
-        const amount = this.amountForRate(fallback, 1, wagonCount);
+        const bulkTons = Number(booking.cargoTotalWeightVgm ?? 0);
+        const quantity =
+          isBulk && fallback.rateUnit === 'PER_TON' ? Math.max(bulkTons, 0) : 1;
+        const amount = this.amountForRate(fallback, quantity, wagonCount);
         lines.push({
           code: rateType,
           description: `Base rail (${rateType})`,

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

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { Module, forwardRef } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 
 // import { CustomersModule } from '../customers/customers.module';
@@ -29,6 +29,7 @@ import { ContractRendererService } from '../../contracts/contract-renderer.servi
 import { ContractTemplateResolver } from '../../contracts/contract-template.resolver';
 import { ContractViewModelBuilder } from '../../contracts/contract-view-model.builder';
 import { PaymentModule } from '../payment/payment.module';
+import { TrainSchedulingModule } from '../train-scheduling/train-scheduling.module';
 
 @Module({
   imports: [
@@ -42,6 +43,7 @@ import { PaymentModule } from '../payment/payment.module';
       BookingContractSignature,
     ]),
     PaymentModule,
+    forwardRef(() => TrainSchedulingModule),
     FilesModule,
     MinioModule,
     CompaniesModule,

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

@@ -720,6 +720,7 @@ export class BookingsRepository extends BaseRepository<Booking> {
   findBatchPool(scheduleId: 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.train_schedule_id = :scheduleId', { scheduleId })
@@ -748,13 +749,33 @@ export class BookingsRepository extends BaseRepository<Booking> {
       .getMany();
   }
 
-  /** Bookings currently reserved (AWAITING_PAYMENT) against a schedule. */
+  /** Bookings currently reserved (SELECTED_FOR_BATCH) against a schedule. */
   findReservedForSchedule(scheduleId: string): Promise<Booking[]> {
     return this.repository
       .createQueryBuilder('booking')
+      .leftJoinAndSelect('booking.company', 'company')
       .leftJoinAndSelect('booking.bookingContainers', 'bookingContainer')
       .where('booking.train_schedule_id = :scheduleId', { scheduleId })
-      .andWhere(`booking.status = 'AWAITING_PAYMENT'`)
+      .andWhere(`booking.status IN ('SELECTED_FOR_BATCH', 'AWAITING_PAYMENT')`)
+      .getMany();
+  }
+
+  /** PAID bookings targeting a schedule that have no train_schedule_bookings link yet. */
+  findPaidUnlinkedForSchedule(scheduleId: string): Promise<Booking[]> {
+    return this.repository
+      .createQueryBuilder('booking')
+      .leftJoinAndSelect('booking.company', 'company')
+      .leftJoinAndSelect('booking.bookingContainers', 'bookingContainer')
+      .leftJoin(
+        TrainScheduleBooking,
+        'scheduleBooking',
+        'scheduleBooking.booking_id = booking.id',
+      )
+      .where('booking.train_schedule_id = :scheduleId', { scheduleId })
+      .andWhere(`booking.status = 'PAID'`)
+      .andWhere('scheduleBooking.id IS NULL')
+      .orderBy('booking.priority_score', 'DESC')
+      .addOrderBy('booking.created_at', 'ASC')
       .getMany();
   }
 

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

@@ -15,7 +15,10 @@ import {
   RuleEngineService,
 } from '../rule-engine/rule-engine.service';
 import { InjectDataSource } from '@nestjs/typeorm';
-import { DataSource } from 'typeorm';
+import { DataSource, In } from 'typeorm';
+
+import { deriveTradeDirection } from '../../common/derive-trade-direction.util';
+import { Yard } from '../rule-engine/entities/yard.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
 import { BookingsRepository } from './bookings.repository';
 import { ConsolidationService } from './consolidation.service';
@@ -54,6 +57,36 @@ export class BookingsService {
     private readonly consolidationService: ConsolidationService,
   ) {}
 
+  /** Resolve trade direction from yard countries; reject client mismatch. */
+  private async resolveTradeDirectionForBooking(
+    originYardId: string,
+    destinationYardId: string,
+    provided?: string,
+  ): Promise<string> {
+    const yards = await this.dataSource.getRepository(Yard).find({
+      where: { id: In([originYardId, destinationYardId]) },
+    });
+    const origin = yards.find((y) => y.id === originYardId);
+    const destination = yards.find((y) => y.id === destinationYardId);
+    if (!origin) {
+      throw new BadRequestException(`Origin yard ${originYardId} not found`);
+    }
+    if (!destination) {
+      throw new BadRequestException(`Destination yard ${destinationYardId} not found`);
+    }
+    if (originYardId === destinationYardId) {
+      throw new BadRequestException('Origin and destination yards must differ');
+    }
+
+    const expected = deriveTradeDirection(origin, destination);
+    if (provided && provided !== expected) {
+      throw new BadRequestException(
+        `tradeDirection must be ${expected} for the selected yard pair (got ${provided})`,
+      );
+    }
+    return expected;
+  }
+
   /** Generate a unique booking reference number. */
   private async generateReference(): Promise<string> {
     const year = new Date().getFullYear();
@@ -230,6 +263,12 @@ export class BookingsService {
       containers,
     });
 
+    const tradeDirection = await this.resolveTradeDirectionForBooking(
+      dto.originYardId,
+      dto.destinationYardId,
+      dto.tradeDirection,
+    );
+
     const allowConsolidation =
       dto.freightType === 'CONTAINER'
         ? await this.resolveConsolidation(containers, dto.allowConsolidation)
@@ -240,7 +279,7 @@ export class BookingsService {
       cargoTypeId: dto.freightType === 'BULK' ? dto.cargoTypeId : null,
       serviceTypeId: dto.serviceTypeId,
       paymentCurrency: dto.paymentCurrency,
-      tradeDirection: dto.tradeDirection,
+      tradeDirection,
       isHazardous: dto.isHazardous,
       isGovernment,
       allowConsolidation,
@@ -267,7 +306,7 @@ export class BookingsService {
       equipmentReturn: dto.equipmentReturn,
       originYardId: dto.originYardId,
       destinationYardId: dto.destinationYardId,
-      tradeDirection: dto.tradeDirection,
+      tradeDirection,
       freightType: dto.freightType,
       cargoTypeId: dto.freightType === 'BULK' ? dto.cargoTypeId! : null,
       cargoFreeText: dto.cargoFreeText,
@@ -362,6 +401,14 @@ export class BookingsService {
 
     assertFreightShape({ freightType, cargoTypeId, containers });
 
+    const originYardId = dto.originYardId ?? existing.originYardId;
+    const destinationYardId = dto.destinationYardId ?? existing.destinationYardId;
+    const tradeDirection = await this.resolveTradeDirectionForBooking(
+      originYardId,
+      destinationYardId,
+      dto.tradeDirection,
+    );
+
     const allowConsolidation =
       freightType === 'CONTAINER'
         ? await this.resolveConsolidation(
@@ -375,7 +422,7 @@ export class BookingsService {
       cargoTypeId,
       serviceTypeId: dto.serviceTypeId ?? existing.serviceTypeId,
       paymentCurrency: dto.paymentCurrency ?? existing.paymentCurrency,
-      tradeDirection: dto.tradeDirection ?? existing.tradeDirection,
+      tradeDirection,
       isHazardous: dto.isHazardous ?? existing.isHazardous,
       allowConsolidation,
       shippingLineId: dto.shippingLineId ?? existing.shippingLineId ?? undefined,
@@ -401,6 +448,7 @@ export class BookingsService {
       cargoTypeId: freightType === 'BULK' ? cargoTypeId : null,
       allowConsolidation,
       priorityScore: ruleResult.priorityScore,
+      tradeDirection,
     };
     if (dto.scheduledDate) updates.scheduledDate = new Date(dto.scheduledDate);
     if (dto.startDate) updates.startDate = new Date(dto.startDate);

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

@@ -26,6 +26,8 @@ export const BOOKING_STATUSES = [
   'CONTRACT_READY',
   'SIGNED_CUSTOMER',
   'FULLY_EXECUTED',
+  'SELECTED_FOR_BATCH',
+  'EXPIRED',
   'PNR_GENERATED',
   'PAYMENT_VERIFICATION_IN_PROGRESS',
   'PAID',
@@ -278,10 +280,14 @@ export class Booking extends BaseEntity {
   @Column({ name: 'train_schedule_id', type: 'uuid', nullable: true })
   trainScheduleId?: string | null;
 
-  /** End of the 1h pay window once the booking is AWAITING_PAYMENT. */
+  /** End of the pay window once the booking is SELECTED_FOR_BATCH. */
   @Column({ name: 'payment_deadline', type: 'timestamptz', nullable: true })
   paymentDeadline?: Date | null;
 
+  /** When the batch engine picked this booking and opened the pay window. */
+  @Column({ name: 'selected_for_batch_at', type: 'timestamptz', nullable: true })
+  selectedForBatchAt?: Date | null;
+
   @OneToMany(() => BookingContainer, (bc) => bc.booking)
   bookingContainers?: BookingContainer[];