Dashboard enhancement

apps/edr-freight-api/src/migrations/1791000000002-AddImportPickupDeliveryColumns.ts

@@ -0,0 +1,37 @@
+import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm';
+
+/**
+ * Import pickup branch on warehouse_inventory:
+ *  - release_order_reference: DO / release order number sent to the customer
+ *  - delivered_at: when the goods were handed over (proof of delivery)
+ *
+ * Idempotent: the shared dev DB may already carry some of these columns
+ * (added by another checkout), so only add what is missing.
+ */
+export class AddImportPickupDeliveryColumns1791000000002 implements MigrationInterface {
+  private readonly table = 'freight.warehouse_inventory';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    if (!(await queryRunner.hasColumn(this.table, 'release_order_reference'))) {
+      await queryRunner.addColumn(
+        this.table,
+        new TableColumn({ name: 'release_order_reference', type: 'varchar', length: '100', isNullable: true }),
+      );
+    }
+    if (!(await queryRunner.hasColumn(this.table, 'delivered_at'))) {
+      await queryRunner.addColumn(
+        this.table,
+        new TableColumn({ name: 'delivered_at', type: 'timestamptz', isNullable: true }),
+      );
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    if (await queryRunner.hasColumn(this.table, 'release_order_reference')) {
+      await queryRunner.dropColumn(this.table, 'release_order_reference');
+    }
+    if (await queryRunner.hasColumn(this.table, 'delivered_at')) {
+      await queryRunner.dropColumn(this.table, 'delivered_at');
+    }
+  }
+}

apps/edr-freight-api/src/modules/warehouses/dto/deliver-inventory.dto.ts

@@ -0,0 +1,24 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsDateString, IsOptional, IsString } from 'class-validator';
+
+/** Proof of delivery captured when import goods are handed over to the customer. */
+export class DeliverInventoryDto {
+  @ApiProperty({ description: 'Name of the person who received the goods' })
+  @IsString()
+  receiverName!: string;
+
+  @ApiPropertyOptional({ description: 'When the goods were delivered (defaults to now)' })
+  @IsOptional()
+  @IsDateString()
+  deliveredAt?: string;
+
+  @ApiPropertyOptional({ description: 'Delivery remarks / notes' })
+  @IsOptional()
+  @IsString()
+  remarks?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  performedBy?: string;
+}

apps/edr-freight-api/src/modules/warehouses/dto/release-order.dto.ts

@@ -0,0 +1,20 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsDateString, IsOptional, IsString } from 'class-validator';
+
+/** Records a DO / release order being sent to the customer for import pickup. */
+export class ReleaseOrderDto {
+  @ApiPropertyOptional({ description: 'DO / release order reference number' })
+  @IsOptional()
+  @IsString()
+  reference?: string;
+
+  @ApiPropertyOptional({ description: 'Release date (defaults to now)' })
+  @IsOptional()
+  @IsDateString()
+  releaseDate?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  performedBy?: string;
+}

apps/edr-freight-api/src/modules/warehouses/entities/warehouse-activity-log.entity.ts

@@ -9,6 +9,9 @@ export const WAREHOUSE_ACTIVITY_TYPES = [
   'READY_FOR_LOADING',
   'INVENTORY_LOADED',
   'INVENTORY_DISPATCHED',
+  'READY_FOR_PICKUP',
+  'INVENTORY_RELEASED',
+  'INVENTORY_DELIVERED',
 ] as const;
 export type WarehouseActivityType = (typeof WAREHOUSE_ACTIVITY_TYPES)[number];
 

apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts

@@ -8,8 +8,11 @@ import { Warehouse } from './warehouse.entity';
 import { WarehouseYard } from './warehouse-yard.entity';
 import { WarehouseZone } from './warehouse-zone.entity';
 
-// Batch 2 lifecycle. Supersedes the Batch 1 set
+// Lifecycle. Supersedes the Batch 1 set
 // (ARRIVED_AT_WAREHOUSE / UNDER_INSPECTION / READY_FOR_LOADING) — migrated in place.
+// After RECEIVED + inspection (PASSED), the flow branches by booking trade direction:
+//   EXPORT/DOMESTIC: STORED → RESERVED → READY_FOR_LOADING → LOADED → DISPATCHED
+//   IMPORT:          READY_FOR_PICKUP → DELIVERED (release order + proof of delivery)
 export const WAREHOUSE_INVENTORY_STATUSES = [
   'RECEIVED',
   'STORED',
@@ -17,17 +20,21 @@ export const WAREHOUSE_INVENTORY_STATUSES = [
   'READY_FOR_LOADING',
   'LOADED',
   'DISPATCHED',
+  'READY_FOR_PICKUP',
+  'DELIVERED',
 ] as const;
 export type WarehouseInventoryStatus = (typeof WAREHOUSE_INVENTORY_STATUSES)[number];
 
 /** Allowed forward transitions for the inventory lifecycle. */
 export const WAREHOUSE_INVENTORY_TRANSITIONS: Record<WarehouseInventoryStatus, WarehouseInventoryStatus[]> = {
-  RECEIVED: ['STORED'],
+  RECEIVED: ['STORED', 'READY_FOR_PICKUP'],
   STORED: ['RESERVED'],
   RESERVED: ['READY_FOR_LOADING'],
   READY_FOR_LOADING: ['LOADED'],
   LOADED: ['DISPATCHED'],
   DISPATCHED: [],
+  READY_FOR_PICKUP: ['DELIVERED'],
+  DELIVERED: [],
 };
 
 @Entity({ schema: 'freight', name: 'warehouse_inventory' })
@@ -135,6 +142,14 @@ export class WarehouseInventory extends BaseEntity {
   @Column({ name: 'release_date', type: 'timestamptz', nullable: true })
   releaseDate?: Date | null;
 
+  // Import branch: reference of the DO / release order sent to the customer.
+  @Column({ name: 'release_order_reference', type: 'varchar', length: 100, nullable: true })
+  releaseOrderReference?: string | null;
+
+  // Import branch: when the goods were handed over to the customer (proof of delivery).
+  @Column({ name: 'delivered_at', type: 'timestamptz', nullable: true })
+  deliveredAt?: Date | null;
+
   @Column({ name: 'gate_cleared_at', type: 'timestamptz', nullable: true })
   gateClearedAt?: Date | null;
 

apps/edr-freight-api/src/modules/warehouses/entities/warehouse.entity.ts

@@ -1,5 +1,5 @@
 import { BaseEntity } from '@edr/api-common';
-import { Column, Entity, Index, ManyToOne, OneToMany } from 'typeorm';
+import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
 
 import { Facility } from '../../facilities/entities/facility.entity';
 import { WarehouseYard } from './warehouse-yard.entity';
@@ -63,6 +63,7 @@ export class Warehouse extends BaseEntity {
   facilityId?: string | null;
 
   @ManyToOne(() => Facility, (facility) => facility.warehouses, { nullable: true })
+  @JoinColumn({ name: 'facility_id' })
   facility?: Facility | null;
 
   @OneToMany(() => WarehouseYard, (yard) => yard.warehouse)

apps/edr-freight-api/src/modules/warehouses/warehouse-dashboard.service.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import { DataSource } from 'typeorm';
+import { DataSource, IsNull } from 'typeorm';
 
 import { Warehouse } from './entities/warehouse.entity';
 import { WarehouseInventory } from './entities/warehouse-inventory.entity';
@@ -8,11 +8,18 @@ export interface WarehouseDashboard {
   totalWarehouses: number;
   totalInventory: number;
   receivedToday: number;
+  // Inspection gate
+  awaitingInspection: number;
+  inspected: number;
+  // Export branch
   stored: number;
   reserved: number;
   readyForLoading: number;
   loaded: number;
   dispatched: number;
+  // Import branch
+  readyForPickup: number;
+  delivered: number;
 }
 
 @Injectable()
@@ -26,15 +33,31 @@ export class WarehouseDashboardService {
     const startOfToday = new Date();
     startOfToday.setHours(0, 0, 0, 0);
 
-    const [totalWarehouses, totalInventory, stored, reserved, readyForLoading, loaded, dispatched, receivedToday] =
-      await Promise.all([
+    const [
+      totalWarehouses,
+      totalInventory,
+      awaitingInspection,
+      inspected,
+      stored,
+      reserved,
+      readyForLoading,
+      loaded,
+      dispatched,
+      readyForPickup,
+      delivered,
+      receivedToday,
+    ] = await Promise.all([
       warehouseRepo.count(),
       inventoryRepo.count(),
+      inventoryRepo.count({ where: { status: 'RECEIVED', inspectionStatus: IsNull() } }),
+      inventoryRepo.count({ where: { inspectionStatus: 'PASSED' } }),
       inventoryRepo.count({ where: { status: 'STORED' } }),
       inventoryRepo.count({ where: { status: 'RESERVED' } }),
       inventoryRepo.count({ where: { status: 'READY_FOR_LOADING' } }),
       inventoryRepo.count({ where: { status: 'LOADED' } }),
       inventoryRepo.count({ where: { status: 'DISPATCHED' } }),
+      inventoryRepo.count({ where: { status: 'READY_FOR_PICKUP' } }),
+      inventoryRepo.count({ where: { status: 'DELIVERED' } }),
       inventoryRepo
         .createQueryBuilder('inv')
         .where('inv.arrived_at >= :start', { start: startOfToday })
@@ -45,11 +68,15 @@ export class WarehouseDashboardService {
       totalWarehouses,
       totalInventory,
       receivedToday,
+      awaitingInspection,
+      inspected,
       stored,
       reserved,
       readyForLoading,
       loaded,
       dispatched,
+      readyForPickup,
+      delivered,
     };
   }
 }

apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts

@@ -1,11 +1,13 @@
 import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
+import { DeliverInventoryDto } from './dto/deliver-inventory.dto';
 import { FilterWarehouseInventoryDto } from './dto/filter-inventory.dto';
 import { InquiryWarehouseInventoryDto } from './dto/inquiry-inventory.dto';
 import { LoadInventoryDto } from './dto/load-inventory.dto';
 import { MoveInventoryDto } from './dto/move-inventory.dto';
 import { ReceiveWarehouseInventoryDto } from './dto/receive-inventory.dto';
+import { ReleaseOrderDto } from './dto/release-order.dto';
 import { ReserveInventoryDto } from './dto/reserve-inventory.dto';
 import { UnloadBookingDto } from './dto/unload-booking.dto';
 import { SchedulingReadFacade } from './scheduling-read.facade';
@@ -137,6 +139,24 @@ export class WarehouseInventoryController {
     return this.inventoryService.load(id, dto);
   }
 
+  @Post(':id/ready-for-pickup')
+  @ApiOperation({ summary: 'Mark inspected IMPORT inventory READY_FOR_PICKUP' })
+  readyForPickup(@Param('id', ParseUUIDPipe) id: string, @Body('performedBy') performedBy?: string) {
+    return this.inventoryService.readyForPickup(id, performedBy);
+  }
+
+  @Post(':id/release')
+  @ApiOperation({ summary: 'Issue a DO / release order for ready-for-pickup inventory' })
+  release(@Param('id', ParseUUIDPipe) id: string, @Body() dto: ReleaseOrderDto) {
+    return this.inventoryService.release(id, dto);
+  }
+
+  @Post(':id/deliver')
+  @ApiOperation({ summary: 'Deliver import goods to the customer + capture proof of delivery' })
+  deliver(@Param('id', ParseUUIDPipe) id: string, @Body() dto: DeliverInventoryDto) {
+    return this.inventoryService.deliver(id, dto);
+  }
+
   @Patch(':id/dispatch')
   @ApiOperation({ summary: 'Mark loaded inventory DISPATCHED (left the terminal)' })
   dispatch(@Param('id', ParseUUIDPipe) id: string, @Body('performedBy') performedBy?: string) {

apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts

@@ -1,11 +1,14 @@
 import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
 import { DataSource, EntityManager, FindManyOptions, ILike } from 'typeorm';
 
+import { Cargo } from '../cargoes/entities/cargoes.entity';
+import { DeliverInventoryDto } from './dto/deliver-inventory.dto';
 import { FilterWarehouseInventoryDto } from './dto/filter-inventory.dto';
 import { InquiryWarehouseInventoryDto } from './dto/inquiry-inventory.dto';
 import { LoadInventoryDto } from './dto/load-inventory.dto';
 import { MoveInventoryDto } from './dto/move-inventory.dto';
 import { ReceiveWarehouseInventoryDto } from './dto/receive-inventory.dto';
+import { ReleaseOrderDto } from './dto/release-order.dto';
 import { ReserveInventoryDto } from './dto/reserve-inventory.dto';
 import { UnloadBookingDto } from './dto/unload-booking.dto';
 import { WarehouseAllocationService } from './warehouse-allocation.service';
@@ -511,6 +514,9 @@ export class WarehouseInventoryService {
     if (!item.bookingId || !item.warehouseId || !item.yardId || !item.zoneId) {
       throw new BadRequestException('Inventory must have booking, warehouse, yard and zone before loading prep');
     }
+    if (item.inspectionStatus !== 'PASSED') {
+      throw new BadRequestException('Inventory must pass inspection before it can be marked ready for loading');
+    }
     return this.transition(id, 'READY_FOR_LOADING', {
       timestampField: 'readyForLoadingAt',
       activityType: 'READY_FOR_LOADING',
@@ -520,6 +526,112 @@ export class WarehouseInventoryService {
     });
   }
 
+  // ── Import branch (READY_FOR_PICKUP → DELIVERED) ───────────────────────────
+
+  /** Mark inspected IMPORT inventory ready for customer pickup (RECEIVED → READY_FOR_PICKUP). */
+  async readyForPickup(id: string, performedBy?: string): Promise<WarehouseInventory> {
+    const item = await this.findById(id);
+
+    if (item.inspectionStatus !== 'PASSED') {
+      throw new BadRequestException('Inventory must pass inspection before it can be marked ready for pickup');
+    }
+
+    const direction = item.bookingId ? await this.getBookingDirection(item.bookingId) : null;
+    if (direction !== 'IMPORT') {
+      throw new BadRequestException('Only IMPORT inventory can be marked ready for pickup');
+    }
+
+    return this.transition(id, 'READY_FOR_PICKUP', {
+      timestampField: 'readyForPickupAt',
+      activityType: 'READY_FOR_PICKUP',
+      description: 'Inventory ready for customer pickup',
+      performedBy,
+      preloaded: item,
+    });
+  }
+
+  /** Record a DO / release order sent to the customer. Item stays READY_FOR_PICKUP. */
+  async release(id: string, dto: ReleaseOrderDto): Promise<WarehouseInventory> {
+    const item = await this.findById(id);
+    if (item.status !== 'READY_FOR_PICKUP') {
+      throw new BadRequestException(
+        `Inventory must be READY_FOR_PICKUP to issue a release order (current: ${item.status})`,
+      );
+    }
+
+    const releaseDate = dto.releaseDate ? new Date(dto.releaseDate) : new Date();
+    const reference = dto.reference?.trim() || null;
+
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(WarehouseInventory).update(id, {
+        releaseDate,
+        releaseOrderReference: reference,
+      });
+      await this.activityLog.record(
+        {
+          activityType: 'INVENTORY_RELEASED',
+          inventoryId: id,
+          warehouseId: item.warehouseId,
+          description: reference
+            ? `Release order ${reference} sent to customer`
+            : 'Release order sent to customer',
+          performedBy: dto.performedBy,
+        },
+        manager,
+      );
+    });
+
+    return this.findById(id);
+  }
+
+  /** Hand import goods to the customer + capture proof of delivery (READY_FOR_PICKUP → DELIVERED). */
+  async deliver(id: string, dto: DeliverInventoryDto): Promise<WarehouseInventory> {
+    const item = await this.findById(id);
+    this.assertTransition(item.status, 'DELIVERED');
+
+    if (!item.releaseDate) {
+      throw new BadRequestException('A release order must be issued before the goods can be delivered');
+    }
+
+    const receiverName = dto.receiverName.trim();
+    const deliveredAt = dto.deliveredAt ? new Date(dto.deliveredAt) : new Date();
+    const weight = Number(item.weight) || 0;
+    const volume = Number(item.volume) || 0;
+    const containerCount = item.containerId ? Math.round(Number(item.quantity) || 0) : 0;
+
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(WarehouseInventory).update(id, {
+        status: 'DELIVERED',
+        deliveredAt,
+      });
+
+      // Goods physically leave the warehouse on pickup — free up capacity.
+      await this.applyCapacityDelta(manager, item.warehouseId, item.yardId, item.zoneId, weight, volume, containerCount, -1);
+
+      // Proof of delivery is captured on the linked cargo.
+      if (item.cargoId) {
+        await manager.getRepository(Cargo).update(item.cargoId, {
+          receiverName,
+          deliveredAt,
+          deliveryRemarks: dto.remarks?.trim() ?? null,
+        });
+      }
+
+      await this.activityLog.record(
+        {
+          activityType: 'INVENTORY_DELIVERED',
+          inventoryId: id,
+          warehouseId: item.warehouseId,
+          description: `Delivered to ${receiverName}`,
+          performedBy: dto.performedBy,
+        },
+        manager,
+      );
+    });
+
+    return this.findById(id);
+  }
+
   /**
    * Load READY_FOR_LOADING inventory onto a wagon. Creates a WarehouseLoading record.
    * Reads wagon/schedule data read-only — never modifies scheduling.
@@ -886,6 +998,15 @@ export class WarehouseInventoryService {
     return rows?.[0]?.status ?? null;
   }
 
+  /** IMPORT | EXPORT | DOMESTIC for the booking, or null if the booking is missing. */
+  private async getBookingDirection(bookingId: string): Promise<string | null> {
+    const rows = await this.dataSource.query(
+      'SELECT trade_direction FROM freight.bookings WHERE id = $1 AND deleted_at IS NULL LIMIT 1',
+      [bookingId],
+    );
+    return rows?.[0]?.trade_direction ?? null;
+  }
+
   private assertCapacity(
     label: string,
     node: LocationNode,

apps/edr-freight-web/backoffice/src/components/warehouses/DeliverInventoryModal.tsx

@@ -0,0 +1,80 @@
+import { useEffect, useState } from 'react';
+import { Alert, Button, Group, Modal, Stack, Text, Textarea, TextInput } from '@mantine/core';
+import { Info } from 'lucide-react';
+
+import { useToast } from '@/hooks/use-toast';
+import { useDeliverInventory } from '@/hooks/useWarehouses';
+import type { WarehouseInventoryItem } from '@/types/warehouse';
+import { extractErrorMessage } from './options';
+
+interface DeliverInventoryModalProps {
+  opened: boolean;
+  onClose: () => void;
+  item: WarehouseInventoryItem | null;
+}
+
+export function DeliverInventoryModal({ opened, onClose, item }: DeliverInventoryModalProps) {
+  const { toast } = useToast();
+  const deliverMutation = useDeliverInventory();
+  const [receiverName, setReceiverName] = useState('');
+  const [remarks, setRemarks] = useState('');
+
+  useEffect(() => {
+    if (opened) {
+      setReceiverName('');
+      setRemarks('');
+    }
+  }, [opened, item]);
+
+  const handleSubmit = async () => {
+    if (!item) return;
+    if (!receiverName.trim()) {
+      toast({ variant: 'destructive', title: 'Receiver name is required' });
+      return;
+    }
+    try {
+      await deliverMutation.mutateAsync({
+        id: item.id,
+        payload: { receiverName: receiverName.trim(), remarks: remarks.trim() || undefined },
+      });
+      toast({ title: 'Delivered — proof of delivery captured' });
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Delivery failed', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal opened={opened} onClose={onClose} title="Deliver to customer (proof of delivery)" centered size="md">
+      <Stack gap="md">
+        <Alert icon={<Info size={16} />} color="green" variant="light">
+          <Text size="sm">
+            A release order must already be issued. Capturing the receiver marks the goods <b>DELIVERED</b>.
+          </Text>
+        </Alert>
+        <TextInput
+          label="Receiver name"
+          required
+          placeholder="Who received the goods"
+          value={receiverName}
+          onChange={(e) => setReceiverName(e.currentTarget.value)}
+        />
+        <Textarea
+          label="Remarks"
+          placeholder="Optional delivery notes"
+          minRows={2}
+          value={remarks}
+          onChange={(e) => setRemarks(e.currentTarget.value)}
+        />
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose} disabled={deliverMutation.isPending}>
+            Cancel
+          </Button>
+          <Button color="green" onClick={handleSubmit} loading={deliverMutation.isPending}>
+            Confirm delivery
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}

apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx

@@ -5,14 +5,17 @@ import { useToast } from '@/hooks/use-toast';
 import {
   useDispatchInventory,
   useMarkReadyForLoading,
+  useMarkReadyForPickup,
   useStoreInventory,
 } from '@/hooks/useWarehouses';
 import type { InventoryAction, WarehouseInventoryItem } from '@/types/warehouse';
+import { DeliverInventoryModal } from './DeliverInventoryModal';
 import { FeePreviewModal } from './FeePreviewModal';
 import { InspectionReportModal } from './InspectionReportModal';
 import { InventoryHistoryModal } from './InventoryHistoryModal';
 import { LoadInventoryModal } from './LoadInventoryModal';
 import { MoveInventoryModal } from './MoveInventoryModal';
+import { ReleaseOrderModal } from './ReleaseOrderModal';
 import { ReserveInventoryModal } from './ReserveInventoryModal';
 import { WarehouseInventoryTable } from './WarehouseInventoryTable';
 import { extractErrorMessage } from './options';
@@ -32,9 +35,12 @@ export function InventoryWorkbench({ items, isLoading }: InventoryWorkbenchProps
   const [historyItem, setHistoryItem] = useState<WarehouseInventoryItem | null>(null);
   const [inspectItem, setInspectItem] = useState<WarehouseInventoryItem | null>(null);
   const [feeItem, setFeeItem] = useState<WarehouseInventoryItem | null>(null);
+  const [releaseItem, setReleaseItem] = useState<WarehouseInventoryItem | null>(null);
+  const [deliverItem, setDeliverItem] = useState<WarehouseInventoryItem | null>(null);
 
   const storeMutation = useStoreInventory();
   const readyMutation = useMarkReadyForLoading();
+  const pickupMutation = useMarkReadyForPickup();
   const dispatchMutation = useDispatchInventory();
 
   const runDirect = async (item: WarehouseInventoryItem, fn: () => Promise<unknown>, label: string) => {
@@ -63,6 +69,14 @@ export function InventoryWorkbench({ items, isLoading }: InventoryWorkbenchProps
         return;
       case 'dispatch':
         return runDirect(item, () => dispatchMutation.mutateAsync(item.id), 'Inventory dispatched');
+      case 'ready-for-pickup':
+        return runDirect(item, () => pickupMutation.mutateAsync(item.id), 'Ready for pickup');
+      case 'release':
+        setReleaseItem(item);
+        return;
+      case 'deliver':
+        setDeliverItem(item);
+        return;
       default:
         return;
     }
@@ -110,6 +124,8 @@ export function InventoryWorkbench({ items, isLoading }: InventoryWorkbenchProps
         onClose={() => setFeeItem(null)}
         inventoryId={feeItem?.id ?? null}
       />
+      <ReleaseOrderModal opened={Boolean(releaseItem)} onClose={() => setReleaseItem(null)} item={releaseItem} />
+      <DeliverInventoryModal opened={Boolean(deliverItem)} onClose={() => setDeliverItem(null)} item={deliverItem} />
     </>
   );
 }

apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx

@@ -0,0 +1,62 @@
+import { useEffect, useState } from 'react';
+import { Alert, Button, Group, Modal, Stack, Text, TextInput } from '@mantine/core';
+import { Info } from 'lucide-react';
+
+import { useToast } from '@/hooks/use-toast';
+import { useReleaseInventory } from '@/hooks/useWarehouses';
+import type { WarehouseInventoryItem } from '@/types/warehouse';
+import { extractErrorMessage } from './options';
+
+interface ReleaseOrderModalProps {
+  opened: boolean;
+  onClose: () => void;
+  item: WarehouseInventoryItem | null;
+}
+
+export function ReleaseOrderModal({ opened, onClose, item }: ReleaseOrderModalProps) {
+  const { toast } = useToast();
+  const releaseMutation = useReleaseInventory();
+  const [reference, setReference] = useState('');
+
+  useEffect(() => {
+    if (opened) setReference(item?.releaseOrderReference ?? '');
+  }, [opened, item]);
+
+  const handleSubmit = async () => {
+    if (!item) return;
+    try {
+      await releaseMutation.mutateAsync({ id: item.id, payload: { reference: reference.trim() || undefined } });
+      toast({ title: 'Release order issued' });
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Release failed', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal opened={opened} onClose={onClose} title="Issue release order (DO)" centered size="md">
+      <Stack gap="md">
+        <Alert icon={<Info size={16} />} color="orange" variant="light">
+          <Text size="sm">
+            Records the delivery order / release order sent to the customer. Once issued, the goods can be
+            picked up and delivered.
+          </Text>
+        </Alert>
+        <TextInput
+          label="Release order reference"
+          placeholder="e.g. DO-2026-001"
+          value={reference}
+          onChange={(e) => setReference(e.currentTarget.value)}
+        />
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose} disabled={releaseMutation.isPending}>
+            Cancel
+          </Button>
+          <Button color="orange" onClick={handleSubmit} loading={releaseMutation.isPending}>
+            Issue release order
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}

apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx

@@ -2,7 +2,7 @@ import { ActionIcon, Badge, Button, Group, Table, Text, Tooltip } from '@mantine
 import { ArrowRightLeft, ClipboardList, Coins, History } from 'lucide-react';
 
 import type { InventoryAction, WarehouseInventoryItem } from '@/types/warehouse';
-import { INVENTORY_NEXT_ACTION } from '@/types/warehouse';
+import { getNextInventoryAction } from '@/types/warehouse';
 import { InventoryStatusBadge } from './badges';
 import { formatDate, formatNumber, humanizeEnum } from './options';
 
@@ -29,6 +29,9 @@ const actionColor: Record<InventoryAction, string> = {
   'ready-for-loading': 'cyan',
   load: 'teal',
   dispatch: 'green',
+  'ready-for-pickup': 'orange',
+  release: 'yellow',
+  deliver: 'green',
 };
 
 export function WarehouseInventoryTable({
@@ -70,7 +73,7 @@ export function WarehouseInventoryTable({
           {items.map((item) => {
             const kind = itemKind(item);
             const busy = busyId === item.id;
-            const nextAction = INVENTORY_NEXT_ACTION[item.status];
+            const nextAction = getNextInventoryAction(item);
             return (
               <Table.Tr key={item.id}>
                 <Table.Td>

apps/edr-freight-web/backoffice/src/components/warehouses/badges.tsx

@@ -40,6 +40,8 @@ const inventoryStatusColor: Record<InventoryStatus, string> = {
   READY_FOR_LOADING: 'cyan',
   LOADED: 'teal',
   DISPATCHED: 'green',
+  READY_FOR_PICKUP: 'orange',
+  DELIVERED: 'green',
 };
 
 export function InventoryStatusBadge({ status }: { status: InventoryStatus }) {

apps/edr-freight-web/backoffice/src/constants/URLS.ts

@@ -302,6 +302,10 @@ export const URL_CONSTANTS = {
     MARK_READY: (id: string) => `/warehouse-inventory/${id}/ready-for-loading`,
     LOAD: (id: string) => `/warehouse-inventory/${id}/load`,
     DISPATCH: (id: string) => `/warehouse-inventory/${id}/dispatch`,
+    // Import branch
+    MARK_READY_PICKUP: (id: string) => `/warehouse-inventory/${id}/ready-for-pickup`,
+    RELEASE: (id: string) => `/warehouse-inventory/${id}/release`,
+    DELIVER: (id: string) => `/warehouse-inventory/${id}/deliver`,
   },
 
   WAREHOUSE_LOADINGS: {

apps/edr-freight-web/backoffice/src/constants/apiConfig.ts

@@ -1,3 +1,4 @@
-export const API_BASE_URL = 'https://edrfreightapi.triaplc.com';
-
-// export const API_BASE_URL = 'http://localhost:3001';
+// API host is env-driven (set VITE_API_URL per environment, e.g. the remote
+// https://edrfreightapi.triaplc.com for prod). Falls back to the local API for dev.
+export const API_BASE_URL =
+  (import.meta.env.VITE_API_URL as string | undefined) ?? 'http://localhost:3001';

apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts

@@ -12,6 +12,8 @@ import type {
   LoadInventoryPayload,
   MoveInventoryPayload,
   ReceiveInventoryPayload,
+  ReleaseOrderPayload,
+  DeliverInventoryPayload,
   ReserveInventoryPayload,
   SaveWarehousePayload,
   SaveYardPayload,
@@ -172,6 +174,18 @@ export const useMoveInventory = () =>
     warehouseService.move(args.id, args.payload),
   );
 
+// ── Import branch (READY_FOR_PICKUP → DELIVERED) ───────────────────────────
+export const useMarkReadyForPickup = () =>
+  useInventoryMutation((id: string) => warehouseService.markReadyForPickup(id));
+export const useReleaseInventory = () =>
+  useInventoryMutation((args: { id: string; payload: ReleaseOrderPayload }) =>
+    warehouseService.release(args.id, args.payload),
+  );
+export const useDeliverInventory = () =>
+  useInventoryMutation((args: { id: string; payload: DeliverInventoryPayload }) =>
+    warehouseService.deliver(args.id, args.payload),
+  );
+
 // ── Loading (Batch 3) ────────────────────────────────────────────────────────
 
 export function useLoadableWagons(enabled = true) {

apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDashboardPage.tsx

@@ -2,8 +2,12 @@ import { useNavigate } from 'react-router-dom';
 import { Card, Center, Container, Group, Loader, SimpleGrid, Stack, Text, ThemeIcon } from '@mantine/core';
 import {
   ClipboardCheck,
+  ClipboardList,
+  ShieldCheck,
   PackageCheck,
   PackagePlus,
+  PackageSearch,
+  CircleCheck,
   Send,
   Truck,
   Warehouse as WarehouseIcon,
@@ -33,11 +37,15 @@ const METRICS: Metric[] = [
   { key: 'totalWarehouses', label: 'Total Warehouses', icon: <WarehouseIcon size={22} />, to: '/dashboard/warehouses', theme: ORANGE },
   { key: 'totalInventory', label: 'Total Inventory', icon: <Boxes size={22} />, to: '/dashboard/warehouse-inventory', theme: GREEN },
   { key: 'receivedToday', label: 'Received Today', icon: <PackagePlus size={22} />, to: '/dashboard/warehouse-inventory?status=RECEIVED', theme: ORANGE },
+  { key: 'awaitingInspection', label: 'Awaiting Inspection', icon: <ClipboardList size={22} />, to: '/dashboard/warehouse-inventory?status=RECEIVED', theme: GREEN },
+  { key: 'inspected', label: 'Inspected', icon: <ShieldCheck size={22} />, to: '/dashboard/warehouse-inventory', theme: ORANGE },
   { key: 'stored', label: 'Stored', icon: <Layers size={22} />, to: '/dashboard/warehouse-inventory?status=STORED', theme: GREEN },
   { key: 'reserved', label: 'Reserved', icon: <ClipboardCheck size={22} />, to: '/dashboard/warehouse-inventory?status=RESERVED', theme: ORANGE },
   { key: 'readyForLoading', label: 'Ready For Loading', icon: <PackageCheck size={22} />, to: '/dashboard/loading-queue', theme: GREEN },
   { key: 'loaded', label: 'Loaded', icon: <Truck size={22} />, to: '/dashboard/loaded-inventory', theme: ORANGE },
   { key: 'dispatched', label: 'Dispatched', icon: <Send size={22} />, to: '/dashboard/dispatch-queue', theme: GREEN },
+  { key: 'readyForPickup', label: 'Ready For Pickup', icon: <PackageSearch size={22} />, to: '/dashboard/warehouse-inventory?status=READY_FOR_PICKUP', theme: ORANGE },
+  { key: 'delivered', label: 'Delivered', icon: <CircleCheck size={22} />, to: '/dashboard/warehouse-inventory?status=DELIVERED', theme: GREEN },
 ];
 
 export default function WarehouseDashboardPage() {

apps/edr-freight-web/backoffice/src/services/warehouse.service.ts

@@ -27,6 +27,8 @@ import type {
   LoadInventoryPayload,
   MoveInventoryPayload,
   ReceiveInventoryPayload,
+  ReleaseOrderPayload,
+  DeliverInventoryPayload,
   ReserveInventoryPayload,
   SaveWarehousePayload,
   SaveYardPayload,
@@ -104,6 +106,14 @@ export const warehouseService = {
     apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.LOAD(id), payload),
   dispatch: (id: string) =>
     apiClient.patch<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.DISPATCH(id)),
+
+  // ── Import branch (READY_FOR_PICKUP → DELIVERED) ─────────────────────────
+  markReadyForPickup: (id: string) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.MARK_READY_PICKUP(id)),
+  release: (id: string, payload: ReleaseOrderPayload) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.RELEASE(id), payload),
+  deliver: (id: string, payload: DeliverInventoryPayload) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.DELIVER(id), payload),
   move: (id: string, payload: MoveInventoryPayload) =>
     apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.MOVE(id), payload),
   movements: (id: string) =>

apps/edr-freight-web/backoffice/src/types/warehouse.ts

@@ -29,10 +29,28 @@ export const INVENTORY_STATUSES = [
   'READY_FOR_LOADING',
   'LOADED',
   'DISPATCHED',
+  // Import branch
+  'READY_FOR_PICKUP',
+  'DELIVERED',
 ] as const;
 export type InventoryStatus = (typeof INVENTORY_STATUSES)[number];
 
-/** Next allowed lifecycle action keyed by current status. */
+export type InventoryAction =
+  | 'store'
+  | 'reserve'
+  | 'ready-for-loading'
+  | 'load'
+  | 'dispatch'
+  // Import branch
+  | 'ready-for-pickup'
+  | 'release'
+  | 'deliver';
+
+/**
+ * Default next lifecycle action keyed by current status. The RECEIVED and
+ * READY_FOR_PICKUP rows are direction/release dependent — use
+ * {@link getNextInventoryAction} which resolves those at runtime.
+ */
 export const INVENTORY_NEXT_ACTION: Record<InventoryStatus, InventoryAction | null> = {
   RECEIVED: 'store',
   STORED: 'reserve',
@@ -40,9 +58,34 @@ export const INVENTORY_NEXT_ACTION: Record<InventoryStatus, InventoryAction | nu
   READY_FOR_LOADING: 'load',
   LOADED: 'dispatch',
   DISPATCHED: null,
+  READY_FOR_PICKUP: 'release',
+  DELIVERED: null,
 };
 
-export type InventoryAction = 'store' | 'reserve' | 'ready-for-loading' | 'load' | 'dispatch';
+/**
+ * Resolve the next action for an inventory item, accounting for trade
+ * direction, the inspection gate, and whether a release order was issued.
+ * Returns null when no advance button should be shown (e.g. awaiting inspection).
+ */
+export function getNextInventoryAction(item: WarehouseInventoryItem): InventoryAction | null {
+  const inspected = item.inspectionStatus === 'PASSED';
+  const isImport = item.booking?.tradeDirection === 'IMPORT';
+
+  switch (item.status) {
+    case 'RECEIVED':
+      // Import goods skip storage; they need inspection before pickup.
+      if (isImport) return inspected ? 'ready-for-pickup' : null;
+      return 'store';
+    case 'RESERVED':
+      // Export loading is gated on a passed inspection.
+      return inspected ? 'ready-for-loading' : null;
+    case 'READY_FOR_PICKUP':
+      // Issue the DO / release order first, then hand over the goods.
+      return item.releaseDate ? 'deliver' : 'release';
+    default:
+      return INVENTORY_NEXT_ACTION[item.status];
+  }
+}
 
 export interface WarehouseZone {
   id: string;
@@ -136,6 +179,7 @@ export interface WarehouseInventoryItem {
   weight: number;
   volume: number | null;
   status: InventoryStatus;
+  inspectionStatus: string | null;
   arrivedAt: string | null;
   storedAt: string | null;
   reservedAt: string | null;
@@ -143,6 +187,11 @@ export interface WarehouseInventoryItem {
   readyForLoadingAt: string | null;
   loadedAt: string | null;
   dispatchedAt: string | null;
+  // Import branch
+  readyForPickupAt: string | null;
+  releaseDate: string | null;
+  releaseOrderReference: string | null;
+  deliveredAt: string | null;
   notes: string | null;
   warehouse?: Warehouse | null;
   yard?: WarehouseYard | null;
@@ -156,6 +205,7 @@ export interface InventoryBookingRef {
   reference?: string | null;
   status?: string | null;
   paymentStatus?: string | null;
+  tradeDirection?: string | null;
 }
 
 export interface InventoryMovement {
@@ -197,11 +247,15 @@ export interface WarehouseDashboard {
   totalWarehouses: number;
   totalInventory: number;
   receivedToday: number;
+  awaitingInspection: number;
+  inspected: number;
   stored: number;
   reserved: number;
   readyForLoading: number;
   loaded: number;
   dispatched: number;
+  readyForPickup: number;
+  delivered: number;
 }
 
 // ── Loading (Batch 3) ────────────────────────────────────────────────────────
@@ -265,6 +319,19 @@ export interface ReserveInventoryPayload {
   inventoryId: string;
 }
 
+/** Import branch: DO / release order sent to the customer. */
+export interface ReleaseOrderPayload {
+  reference?: string;
+  releaseDate?: string;
+}
+
+/** Import branch: proof of delivery captured on customer pickup. */
+export interface DeliverInventoryPayload {
+  receiverName: string;
+  deliveredAt?: string;
+  remarks?: string;
+}
+
 export interface InventoryInquiryResult {
   id: string;
   bookingId: string;