fix

apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts

@@ -1,5 +1,5 @@
 import { BadRequestException, ConflictException, Injectable, Logger, NotFoundException } from '@nestjs/common';
-import { FindOptionsWhere } from 'typeorm';
+import { FindOptionsWhere, In } from 'typeorm';
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource } from 'typeorm';
 
@@ -7,6 +7,7 @@ import { BookingsRepository } from '../bookings/bookings.repository';
 import { DriversService } from '../drivers/drivers.service';
 import { SmsClientService } from '../notifications/sms-client.service';
 import { VehiclesService } from '../vehicles/vehicles.service';
+import { VehicleStatus } from '../vehicles/entities/vehicle.entity';
 import { CreateFirstMileDto } from './dto/create-first-mile.dto';
 import { UpdateFirstMileDto } from './dto/update-first-mile.dto';
 import { FirstMile, FirstMileStatus } from './entities/first-mile.entity';
@@ -181,7 +182,7 @@ export class FirstMileService {
       return existing;
     }
 
-    return this.firstMileRepository.create({
+    const record = await this.firstMileRepository.create({
       bookingId: dto.bookingId,
       status: dto.status ?? 'READY_TO_TRANSIT',
       advancedPayment: dto.advancedPayment ?? 0,
@@ -191,6 +192,12 @@ export class FirstMileService {
       vehicleId: dto.vehicleId ?? null,
       paid: (dto as any).paid ?? false,
     });
+
+    if (dto.vehicleId) {
+      await this.vehiclesService.setStatus(dto.vehicleId, VehicleStatus.BUSY);
+    }
+
+    return record;
   }
 
   private async findByBookingId(bookingId: string): Promise<FirstMile | null> {
@@ -236,24 +243,61 @@ export class FirstMileService {
       throw new NotFoundException(`First-mile record ${id} not found`);
     }
 
+    // Keep vehicle statuses in sync: new vehicle goes BUSY, replaced one goes back to FREE
+    if (dto.vehicleId !== undefined && dto.vehicleId !== existing.vehicleId) {
+      if (dto.vehicleId) {
+        await this.vehiclesService.setStatus(dto.vehicleId, VehicleStatus.BUSY);
+      }
+      if (existing.vehicleId) {
+        await this.vehiclesService.releaseIfUnused([existing.vehicleId]);
+      }
+    }
+
     // Notify assigned driver on every explicit vehicle assignment or reassignment
     if (dto.vehicleId) {
       void this.notifyDriverAssignment(dto.vehicleId, existing);
     }
 
+    // Trip finished — release the vehicles it was holding
+    if (dto.status === 'RECEIVED_TO_PORT' && existing.status !== 'RECEIVED_TO_PORT') {
+      await this.releaseVehicles(updated);
+    }
+
     return updated;
   }
 
   async updateStatus(id: string, status: FirstMileStatus): Promise<FirstMile> {
+    const existing = await this.findById(id);
     const updated = await this.firstMileRepository.update(id, { status });
 
     if (!updated) {
       throw new NotFoundException(`First-mile record ${id} not found`);
     }
 
+    if (status === 'RECEIVED_TO_PORT' && existing.status !== 'RECEIVED_TO_PORT') {
+      await this.releaseVehicles(updated);
+    }
+
     return updated;
   }
 
+  /**
+   * Free every vehicle held by this record (direct assignment + container
+   * allocations), unless still in use by another active trip.
+   */
+  private async releaseVehicles(record: FirstMile): Promise<void> {
+    const recordAllocations = await this.dataSource.manager.find(FirstMileContainerAllocation, {
+      where: { firstMileId: record.id },
+    });
+    const vehicleIds = recordAllocations
+      .map((a) => a.vehicleId)
+      .filter((id): id is string => Boolean(id));
+    if (record.vehicleId) {
+      vehicleIds.push(record.vehicleId);
+    }
+    await this.vehiclesService.releaseIfUnused(vehicleIds);
+  }
+
   private async notifyDriverAssignment(vehicleId: string, record: FirstMile): Promise<void> {
     try {
       const vehicle = await this.vehiclesService.findById(vehicleId);
@@ -302,6 +346,16 @@ export class FirstMileService {
       throw new NotFoundException(`First-mile record ${firstMileId} not found`);
     }
 
+    const previousAllocations = await this.dataSource.manager.find(FirstMileContainerAllocation, {
+      where: {
+        firstMileId,
+        containerId: In(allocations.map((a) => a.containerId)),
+      },
+    });
+    const previousVehicleIds = previousAllocations
+      .map((a) => a.vehicleId)
+      .filter((id): id is string => Boolean(id));
+
     await this.dataSource.transaction(async (manager) => {
       for (const allocation of allocations) {
         await manager.delete(FirstMileContainerAllocation, {
@@ -318,6 +372,14 @@ export class FirstMileService {
       }
     });
 
+    const vehicleIds = new Set(allocations.map((a) => a.vehicleId));
+    await Promise.all(
+      [...vehicleIds].map((vehicleId) => this.vehiclesService.setStatus(vehicleId, VehicleStatus.BUSY)),
+    );
+    await this.vehiclesService.releaseIfUnused(
+      previousVehicleIds.filter((id) => !vehicleIds.has(id)),
+    );
+
     return {
       success: true,
       allocated: allocations.length,