refactor: remove gate pass granting logic from clearance services and UI

- Removed the gate pass granting functionality from the BookingClearanceService and ContractClearanceService, replacing it with a new method to retrieve gate pass status from train schedules.
- Updated the ContractsController to eliminate endpoints related to gate pass granting.
- Refactored the UI components (ExportClearanceStepper and PhasedClearanceActionPanel) to reflect the new gate pass securing process, linking to the train scheduling interface instead.
- Cleaned up related constants and query hooks, removing unused code and references to the gate pass functionality.
- Adjusted types in the contracts to accommodate changes in the gate pass handling logic.

apps/edr-freight-api/src/modules/contracts/gl-operations.service.ts

@@ -4,7 +4,7 @@ import {
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
-import { DataSource, In, IsNull } from 'typeorm';
+import { DataSource, IsNull } from 'typeorm';
 import { Freight, GL_FINAL_INVOICE_TYPE, isT1TransportFileCode } from '@edr/types';
 
 import { BillingService } from '../billing/billing.service';
@@ -17,7 +17,6 @@ import {
   ClearanceIncident,
   IncidentType,
 } from './entities/clearance-incident.entity';
-import { ClearanceMilestone } from './entities/clearance-milestone.entity';
 import { ContractClearanceCycle } from './entities/contract-clearance-cycle.entity';
 import { ClearanceMilestoneService } from './clearance-milestone.service';
 import {
@@ -198,6 +197,7 @@ export class GlOperationsService {
     }
 
     return {
+      scheduleId: schedule?.id ?? null,
       wagonAllocated,
       departedAt: schedule?.actualDepartureAt
         ? new Date(schedule.actualDepartureAt).toISOString()
@@ -208,6 +208,41 @@ export class GlOperationsService {
     };
   }
 
+  /**
+   * Gate pass status for a booking, sourced from the train schedule's Djibouti
+   * gate-pass operation (secured via the train-scheduling "Save as Secured"
+   * action) rather than a clearance milestone. For EXPORT bookings this also
+   * backfills the arrival-chain milestones once secured, same as the retired
+   * clearance-side grant action used to.
+   */
+  async gatepassForBooking(
+    bookingId: string,
+  ): Promise<{ granted: boolean; grantedAt: string | null }> {
+    const train = await this.trainState(bookingId);
+    if (!train.scheduleId) return { granted: false, grantedAt: null };
+    const operation = await this.dataSource
+      .getRepository(ImportDjiboutiOperation)
+      .findOne({ where: { trainScheduleId: train.scheduleId } });
+    const grantedAt = operation?.gatepassGrantedAt
+      ? new Date(operation.gatepassGrantedAt).toISOString()
+      : null;
+
+    if (grantedAt) {
+      const booking = await this.getBooking(bookingId);
+      if ((booking.tradeDirection ?? 'IMPORT') === 'EXPORT') {
+        const milestones = await this.milestoneService.listForBooking(bookingId);
+        const byCode = new Map(milestones.map((m) => [m.milestoneCode, m]));
+        for (const code of GlOperationsService.EXPORT_ARRIVAL_CHAIN) {
+          if (byCode.get(code)?.status === 'PENDING') {
+            await this.milestoneService.completeForBooking(bookingId, code);
+          }
+        }
+      }
+    }
+
+    return { granted: Boolean(grantedAt), grantedAt };
+  }
+
   /**
    * T1 transit-document lifecycle state for an import shipment booking. Wagon
    * allocation opens the upload window; train departure locks it; train arrival
@@ -302,8 +337,11 @@ export class GlOperationsService {
           'The transport document must be uploaded before T1 can be closed.',
         );
       }
-      if (!done('GATEPASS_GRANTED')) {
-        throw new BadRequestException('Grant the gate pass before closing T1.');
+      const gatepass = await this.gatepassForBooking(bookingId);
+      if (!gatepass.granted) {
+        throw new BadRequestException(
+          'Secure the Djibouti gate pass on the train schedule before closing T1.',
+        );
       }
       // Export bookings seeded before T1_CLOSED joined the catalog lack the row.
       await this.milestoneService.ensureForBooking(bookingId, 'T1_CLOSED', tradeDirection);
@@ -322,182 +360,6 @@ export class GlOperationsService {
     'ARRIVED_AT_DJIBOUTI',
   ];
 
-  /**
-   * GL Djibouti grants the gate pass for a customs booking, capturing the time.
-   * Export: requires the train to have arrived at Djibouti; back-fills the
-   * arrival-chain milestones. Import: requires wagon allocation (pre-loading).
-   */
-  async grantGatepass(
-    bookingId: string,
-    gatepassAt?: string,
-    userId?: string,
-  ): Promise<{ bookingId: string; gatepassAt: string }> {
-    const booking = await this.getBooking(bookingId);
-    if (!booking.customsClearingEnabled) {
-      throw new BadRequestException('Gate pass applies to customs bookings only.');
-    }
-    const tradeDirection = booking.tradeDirection ?? 'IMPORT';
-    const milestones = await this.milestoneService.listForBooking(bookingId);
-    const byCode = new Map(milestones.map((m) => [m.milestoneCode, m]));
-
-    const existing = byCode.get('GATEPASS_GRANTED');
-    if (existing?.status === 'COMPLETED') {
-      return {
-        bookingId,
-        gatepassAt:
-          existing.metadata?.gatepassAt ??
-          (existing.triggeredAt ? new Date(existing.triggeredAt).toISOString() : ''),
-      };
-    }
-
-    const train = await this.trainState(bookingId);
-    if (tradeDirection === 'EXPORT') {
-      if (!train.arrivedAt) {
-        throw new BadRequestException(
-          'The train has not arrived at Djibouti yet — gate pass can be granted after arrival.',
-        );
-      }
-      for (const code of GlOperationsService.EXPORT_ARRIVAL_CHAIN) {
-        if (byCode.get(code)?.status === 'PENDING') {
-          await this.milestoneService.completeForBooking(bookingId, code, userId);
-        }
-      }
-    } else if (!train.wagonAllocated) {
-      throw new BadRequestException(
-        'Wagons must be allocated before the gate pass can be granted.',
-      );
-    }
-
-    const at = gatepassAt?.trim() || new Date().toISOString();
-    await this.milestoneService.completeWithMetadataForBooking(
-      bookingId,
-      'GATEPASS_GRANTED',
-      { gatepassAt: at },
-      userId,
-    );
-    return { bookingId, gatepassAt: at };
-  }
-
-  /** Train schedules carrying ≥1 customs booking — the GL Djibouti gate-pass table. */
-  async djSchedules(): Promise<Freight.DjClearanceSchedule[]> {
-    const schedules = await this.dataSource.getRepository(TrainSchedule).find({
-      relations: {
-        scheduleBookings: { booking: true },
-        originStation: true,
-        destinationStation: true,
-      },
-      order: { scheduledDepartureDate: 'DESC' },
-    });
-
-    const withCustoms = schedules
-      .filter((s) => s.status !== 'CANCELLED')
-      .map((s) => ({
-        schedule: s,
-        customs: (s.scheduleBookings ?? [])
-          .map((sb) => sb.booking)
-          .filter((b): b is Booking => Boolean(b?.customsClearingEnabled)),
-      }))
-      .filter((s) => s.customs.length > 0);
-
-    const bookingIds = withCustoms.flatMap((s) => s.customs.map((b) => b.id));
-    const gatepassRows = bookingIds.length
-      ? await this.dataSource.getRepository(ClearanceMilestone).find({
-          where: { bookingId: In(bookingIds), milestoneCode: 'GATEPASS_GRANTED' },
-        })
-      : [];
-    const gatepassByBooking = new Map(gatepassRows.map((m) => [m.bookingId, m]));
-
-    return withCustoms.map(({ schedule, customs }) => {
-      const freightTypes = [...new Set(customs.map((b) => b.freightType).filter(Boolean))];
-      return {
-        id: schedule.id,
-        trainNumber: schedule.trainNumber ?? null,
-        routeName: null,
-        origin: schedule.originStation?.label ?? schedule.originStation?.code ?? null,
-        destination:
-          schedule.destinationStation?.label ?? schedule.destinationStation?.code ?? null,
-        status: schedule.status,
-        scheduledDepartureDate: schedule.scheduledDepartureDate
-          ? new Date(schedule.scheduledDepartureDate).toISOString()
-          : null,
-        actualDepartureAt: schedule.actualDepartureAt
-          ? new Date(schedule.actualDepartureAt).toISOString()
-          : null,
-        actualArrivalAt: schedule.actualArrivalAt
-          ? new Date(schedule.actualArrivalAt).toISOString()
-          : null,
-        freightType:
-          freightTypes.length === 1 ? (freightTypes[0] as string) : freightTypes.length ? 'MIXED' : null,
-        customsBookings: customs.map((b) => {
-          const m = gatepassByBooking.get(b.id);
-          const granted = m?.status === 'COMPLETED';
-          return {
-            bookingId: b.id,
-            reference: b.reference ?? b.id,
-            tradeDirection: b.tradeDirection ?? 'IMPORT',
-            contractId: b.contractId ?? null,
-            gatepassGranted: granted,
-            gatepassAt: granted
-              ? (m?.metadata?.gatepassAt ??
-                (m?.triggeredAt ? new Date(m.triggeredAt).toISOString() : null))
-              : null,
-          };
-        }),
-      };
-    });
-  }
-
-  /**
-   * One-click gate pass for every customs booking on a train schedule. Per-booking
-   * guard failures are collected, not fatal. Import schedules also get the
-   * schedule-level ImportDjiboutiOperation gate pass so loading unblocks.
-   */
-  async grantScheduleGatepass(
-    scheduleId: string,
-    gatepassAt?: string,
-    userId?: string,
-  ): Promise<{ granted: number; skipped: Array<{ bookingId: string; error: string }> }> {
-    const schedule = await this.dataSource.getRepository(TrainSchedule).findOne({
-      where: { id: scheduleId },
-      relations: { scheduleBookings: { booking: true } },
-    });
-    if (!schedule) throw new NotFoundException(`Train schedule ${scheduleId} not found`);
-
-    const customs = (schedule.scheduleBookings ?? [])
-      .map((sb) => sb.booking)
-      .filter((b): b is Booking => Boolean(b?.customsClearingEnabled));
-    if (customs.length === 0) {
-      throw new BadRequestException('No customs bookings ride this schedule.');
-    }
-
-    let granted = 0;
-    const skipped: Array<{ bookingId: string; error: string }> = [];
-    for (const booking of customs) {
-      try {
-        await this.grantGatepass(booking.id, gatepassAt, userId);
-        granted += 1;
-      } catch (e) {
-        skipped.push({
-          bookingId: booking.id,
-          error: e instanceof Error ? e.message : 'Failed',
-        });
-      }
-    }
-
-    if (granted > 0 && customs.some((b) => (b.tradeDirection ?? 'IMPORT') === 'IMPORT')) {
-      const opRepo = this.dataSource.getRepository(ImportDjiboutiOperation);
-      let operation = await opRepo.findOne({ where: { trainScheduleId: scheduleId } });
-      if (!operation) {
-        operation = opRepo.create({ trainScheduleId: scheduleId });
-      }
-      if (!operation.gatepassGrantedAt) {
-        operation.gatepassGrantedAt = gatepassAt ? new Date(gatepassAt) : new Date();
-        await opRepo.save(operation);
-      }
-    }
-
-    return { granted, skipped };
-  }
 
   /**
    * GL Djibouti raises the post-offload final invoice (export): manual amount +