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/contracts/contract-booking.service.ts

@@ -98,6 +98,12 @@ export class ContractBookingService {
     const reference = await this.generateReference();
     const freightType = contract.freightType;
 
+    // GENERAL + customs (Path B) runs per-booking clearance: the booking starts
+    // in the clearance gate (AWAITING_DOCUMENTS) instead of going straight to
+    // operations, and there is NO contract-level clearance cycle to link.
+    const generalCustoms =
+      contract.contractKind === 'GENERAL' && Boolean(contract.customsClearingEnabled);
+
     // Denormalize route/direction/freight onto the booking for the scheduling engine.
     const booking = await this.bookingsRepository.create({
       reference,
@@ -105,7 +111,7 @@ export class ContractBookingService {
       companyProfileId: contract.companyProfileId ?? null,
       isGovernment: contract.isGovernment,
       governmentInstitution: contract.governmentInstitution ?? null,
-      status: 'OPERATION_REQUEST_PENDING',
+      status: generalCustoms ? 'AWAITING_DOCUMENTS' : 'OPERATION_REQUEST_PENDING',
       bookingType: 'ONE_TIME',
       contractId: contract.id,
       contractRouteId: route?.id ?? null,
@@ -165,9 +171,11 @@ export class ContractBookingService {
       warnings.push(...computed.warnings);
     }
 
-    // Path B side effects: link the clearance cycle, seed post-booking
-    // milestones onto the booking, and advance the contract.
-    if (contract.customsClearingEnabled) {
+    // ONE_TIME customs (legacy contract-cycle path): link the contract clearance
+    // cycle to this booking, seed post-booking milestones, and lock the contract
+    // to ACTIVE_SHIPMENT_IN_PROGRESS. NOT for GENERAL — it has no contract cycle
+    // and must stay CONTRACT_ACTIVE so further shipment requests can be accepted.
+    if (contract.customsClearingEnabled && !generalCustoms) {
       const cycle = await this.contractsRepository.currentCycle(contract.id);
       if (cycle) {
         await this.contractsRepository.linkBooking(cycle.id, booking.id);
@@ -180,6 +188,14 @@ export class ContractBookingService {
         status: 'ACTIVE_SHIPMENT_IN_PROGRESS',
         clearanceStatus: 'ACTIVE_SHIPMENT_IN_PROGRESS',
       } as never);
+    } else if (generalCustoms) {
+      // Per-booking clearance: seed post-booking milestones on the booking (no
+      // cycle needed) and leave the contract active. The booking now drives its
+      // own clearance via the booking-level pipeline.
+      await this.milestoneService.seedPostBookingMilestones(
+        booking.id,
+        contract.tradeDirection,
+      );
     }
 
     const result = await this.bookingsRepository.findByIdWithFiles(booking.id);
@@ -192,14 +208,24 @@ export class ContractBookingService {
    */
   private async assertGate(contract: Contract, isGlActor: boolean): Promise<string> {
     if (contract.customsClearingEnabled) {
-      // Path B — Global Logistics creates the booking ON BEHALF OF the customer
-      // once GL has finalized the pre-booking clearance. The customer never
-      // books a customs contract himself.
+      // Path B — Global Logistics creates the booking ON BEHALF OF the customer.
+      // The customer never books a customs contract himself.
       if (!isGlActor) {
         throw new ForbiddenException(
           'Customs-clearance contracts are booked by Global Logistics on behalf of the customer.',
         );
       }
+      if (contract.contractKind === 'GENERAL') {
+        // GENERAL customs has NO contract clearance cycle — GL books per accepted
+        // shipment request while the contract is active; clearance is per booking.
+        if (contract.status !== 'CONTRACT_ACTIVE') {
+          throw new BadRequestException(
+            'Contract must be active to book a shipment.',
+          );
+        }
+        return 'GL_ET';
+      }
+      // ONE_TIME customs — UNCHANGED: requires the finalized contract cycle.
       if (contract.clearanceStatus !== 'CLEARANCE_READY_FOR_BOOKING') {
         throw new BadRequestException(
           'Contract clearance is not ready for booking yet.',
@@ -233,6 +259,42 @@ export class ContractBookingService {
    * cap. Container caps are per size; bulk is a single tons/items cap. Bookings
    * that never shipped (CANCELLED / REJECTED / EXPIRED) release their hold.
    */
+  /**
+   * Capacity check for a SHIPMENT REQUEST (no per-unit data) — mirrors
+   * {@link assertWithinQuantityCap} but reads the request's quantity shape.
+   */
+  async assertRequestWithinCapacity(
+    contract: Contract,
+    lines: {
+      containers?: Array<{ containerSize: string; quantity: number }>;
+      bulk?: { cargoWeightTons?: number; itemCount?: number };
+    },
+  ): Promise<void> {
+    const capacity = await this.computeCapacity(contract);
+    if (capacity.length === 0) return; // uncapped contract
+
+    if (contract.freightType === 'CONTAINER') {
+      for (const line of lines.containers ?? []) {
+        const cap = capacity.find((c) => c.containerSize === line.containerSize);
+        if (!cap || cap.remaining == null) continue;
+        if (line.quantity > cap.remaining) {
+          throw new BadRequestException(
+            `Only ${cap.remaining} of ${cap.cap} ${line.containerSize} containers remain on this contract.`,
+          );
+        }
+      }
+    } else {
+      const requested =
+        (lines.bulk?.cargoWeightTons ?? lines.bulk?.itemCount ?? 0) || 0;
+      const cap = capacity.find((c) => c.cap != null);
+      if (cap && cap.remaining != null && requested > cap.remaining) {
+        throw new BadRequestException(
+          `Only ${cap.remaining} of ${cap.cap} remain on this contract.`,
+        );
+      }
+    }
+  }
+
   private async assertWithinQuantityCap(
     contract: Contract,
     dto: CreateBookingUnderContractDto,