Merge branch 'freight/develop' into freight/feat/company-profile

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

@@ -1,6 +1,5 @@
 import {
   BadRequestException,
-  ConflictException,
   forwardRef,
   Inject,
   Injectable,
@@ -69,7 +68,12 @@ export class BookingTransitionService {
         priorityScore,
       } as never);
 
-      const finalBooking = await this.bookingsService.findById(updated!.id);
+      // Auto-consolidate now: a partial-wagon booking either pairs with a waiting
+      // partner (both → SUBMITTED) or is parked as PENDING_CONSOLIDATION until one
+      // arrives. The returned status reflects that outcome.
+      const finalBooking = await this.bookingsService.runConsolidationOnSubmit(
+        updated!.id,
+      );
       return {
         bookingId: finalBooking.id,
         status: finalBooking.status,
@@ -143,7 +147,10 @@ export class BookingTransitionService {
       },
     } as never);
 
-    const finalBooking = await this.bookingsService.findById(updated!.id);
+    // Same consolidation treatment as the direct submit path.
+    const finalBooking = await this.bookingsService.runConsolidationOnSubmit(
+      updated!.id,
+    );
     return {
       bookingId: finalBooking.id,
       status: finalBooking.status,
@@ -188,18 +195,11 @@ export class BookingTransitionService {
 
   async acceptIntake(bookingId: string, actorId: string): Promise<Booking> {
     const booking = await this.bookingsService.findById(bookingId);
+    // Only SUBMITTED bookings are acceptable. A booking that still needs
+    // consolidation sits in PENDING_CONSOLIDATION (resolved at submit time) and
+    // is therefore never offered for accept until a partner moves it to SUBMITTED.
     assertBookingStatus(booking, ['SUBMITTED']);
 
-    // Consolidation gate: a booking whose containers don't fill whole wagons
-    // cannot be accepted until it is paired with a complementary booking.
-    const gate = await this.bookingsService.resolveConsolidationGate(bookingId);
-    if (gate.blocked) {
-      throw new ConflictException(
-        gate.message ??
-          'Booking requires consolidation and cannot be accepted until a partner is found.',
-      );
-    }
-
     await this.ruleEngineService.instantiateApprovalSteps(bookingId, {
       freightType: booking.freightType as 'CONTAINER' | 'BULK',
       cargoTypeId: booking.cargoTypeId,

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

@@ -11,6 +11,7 @@ import {
   Query,
   Request,
   Res,
+  UnauthorizedException,
   UploadedFiles,
   UseInterceptors,
 } from '@nestjs/common';
@@ -117,8 +118,22 @@ export class BookingsController {
 
   @Get()
   @ApiOperation({ summary: 'List freight bookings (paginated)' })
-  findAll(@Query() filter: FilterBookingDto) {
-    return this.bookingsService.findAll(filter);
+  async findAll(
+    @Query() filter: FilterBookingDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    // Staff (backoffice) see every booking. Customers (portal) are always
+    // force-scoped to their own company, regardless of any companyId they pass.
+    if (hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
+      return this.bookingsService.findAll(filter);
+    }
+    const userId = user?.id;
+    if (!userId) throw new UnauthorizedException('Authentication required');
+    const companyId =
+      await this.bookingsService.resolveCustomerCompanyId(userId);
+    // No linked company yet → no bookings to show (avoids leaking all bookings).
+    if (!companyId) return { items: [], total: 0 };
+    return this.bookingsService.findAll(filter, companyId);
   }
 
   @Get('list-summary')
@@ -166,18 +181,60 @@ export class BookingsController {
 
   @Get('by-reference/:reference')
   @ApiOperation({ summary: 'Get booking by reference' })
-  async findByReference(@Param('reference') reference: string) {
+  async findByReference(
+    @Param('reference') reference: string,
+    @CurrentUser() user: TCurrentUser,
+  ) {
     const booking = await this.bookingsService.findByReference(reference);
+    // Staff see any booking; customers only their own company's.
+    if (!hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
+      await this.bookingsService.assertCustomerCanAccessBooking(
+        user?.id,
+        booking,
+      );
+    }
     return this.transitionService.enrichBookingResponse(booking);
   }
 
   @Get(':id')
   @ApiOperation({ summary: 'Get booking by ID' })
-  async findOne(@Param('id', ParseUUIDPipe) id: string) {
+  async findOne(
+    @Param('id', ParseUUIDPipe) id: string,
+    @CurrentUser() user: TCurrentUser,
+  ) {
     const booking = await this.bookingsService.findById(id);
+    // Staff see any booking; customers only their own company's.
+    if (!hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
+      await this.bookingsService.assertCustomerCanAccessBooking(
+        user?.id,
+        booking,
+      );
+    }
     return this.transitionService.enrichBookingResponse(booking);
   }
 
+  @Get(':id/tracking')
+  @ApiOperation({
+    summary: 'Shipment tracking timeline for a booking',
+    description:
+      "Returns the booking's consignment (once dispatched) and its ordered " +
+      'tracking events. Scoped to the customer\'s own company.',
+  })
+  async findTracking(
+    @Param('id', ParseUUIDPipe) id: string,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    const booking = await this.bookingsService.findById(id);
+    // Staff see any booking; customers only their own company's.
+    if (!hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
+      await this.bookingsService.assertCustomerCanAccessBooking(
+        user?.id,
+        booking,
+      );
+    }
+    return this.bookingsService.getBookingTracking(id);
+  }
+
   @Delete(':id')
   @HttpCode(204)
   @ApiOperation({ summary: 'Soft-delete DRAFT booking' })

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

@@ -177,8 +177,11 @@ export class BookingsRepository extends BaseRepository<Booking> {
       .where('b.id != :bookingId', { bookingId: booking.id })
       .andWhere('b.allowConsolidation = true')
       .andWhere('b.consolidationPartnerId IS NULL')
+      // Only pair bookings the customer has committed (SUBMITTED) or that are
+      // already waiting (PENDING_CONSOLIDATION). DRAFT bookings are excluded so
+      // pairing never prematurely submits an unfinished/unpriced draft.
       .andWhere('b.status IN (:...statuses)', {
-        statuses: ['DRAFT', 'SUBMITTED', 'PENDING_CONSOLIDATION'],
+        statuses: ['SUBMITTED', 'PENDING_CONSOLIDATION'],
       })
       .andWhere('b.originYardId = :originYardId', {
         originYardId: booking.originYardId,

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

@@ -1,12 +1,16 @@
 import {
   BadRequestException,
   ConflictException,
+  ForbiddenException,
+  forwardRef,
+  Inject,
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
-import { SchedulingStatus } from '@edr/types';
+import { Freight, SchedulingStatus } from '@edr/types';
 // import { CustomersService } from '../customers/customers.service';
 import { CompaniesService } from '../companies/companies.service';
+import { TrainSchedulingService } from '../train-scheduling/train-scheduling.service';
 import { FilesService } from '../files/files.service';
 import { MinioService } from '../minio/minio.service';
 import { ContainerTypesService } from '../rule-engine/services/container-types.service';
@@ -52,6 +56,8 @@ export class BookingsService {
     private readonly minioService: MinioService,
     // private readonly customersService: CustomersService,
     private readonly companiesService: CompaniesService,
+    @Inject(forwardRef(() => TrainSchedulingService))
+    private readonly trainSchedulingService: TrainSchedulingService,
     private readonly ruleEngineService: RuleEngineService,
     private readonly containerTypesService: ContainerTypesService,
     private readonly consolidationService: ConsolidationService,
@@ -146,13 +152,17 @@ export class BookingsService {
 
   /**
    * Enable consolidation when any container line leaves a wagon partially filled
-   * (e.g. 1×20ft on a 2-slot wagon, 1×10ft on a 4-slot wagon), unless opted out.
+   * (e.g. 1×20ft on a 2-slot wagon, 1×10ft on a 4-slot wagon).
+   *
+   * Partial-wagon cargo ALWAYS consolidates — the customer cannot opt out of a
+   * half-empty wagon, so `explicit === false` is ignored when consolidation is
+   * actually needed. The opt-in flag only matters for cargo that already fills
+   * whole wagons (where consolidation is moot anyway).
    */
   private async resolveConsolidation(
     containers: CreateBookingContainerDto[],
     explicit?: boolean,
   ): Promise<boolean> {
-    if (explicit === false) return false;
     const needs = await this.consolidationService.needsConsolidation(
       containers.map((c) => ({
         containerTypeId: c.containerTypeId,
@@ -193,10 +203,11 @@ export class BookingsService {
       return { booking: paired, messages };
     }
 
-    if (booking.status === 'DRAFT') {
-      await this.bookingsRepository.update(booking.id, {
-        status: 'PENDING_CONSOLIDATION',
-      } as never);
+    // No partner yet — park the booking so it waits. Applies both pre-submit
+    // (DRAFT) and at submit time (SUBMITTED); accepted/approved bookings never
+    // reach this method.
+    if (booking.status === 'DRAFT' || booking.status === 'SUBMITTED') {
+      await this.bookingsRepository.parkForConsolidation(booking.id);
     }
 
     const pending = await this.findById(booking.id);
@@ -205,45 +216,24 @@ export class BookingsService {
   }
 
   /**
-   * Consolidation gate used at staff-accept time. Returns the (possibly newly
-   * paired) booking plus whether it still needs a consolidation partner.
-   * When a booking needs consolidation and none is found, it is parked in
-   * PENDING_CONSOLIDATION and `blocked` is true so the caller refuses the accept.
+   * Run consolidation right after a booking reaches SUBMITTED. If a complementary
+   * partner already exists, both are paired and moved (back) to SUBMITTED so staff
+   * can accept them. Otherwise the booking is parked in PENDING_CONSOLIDATION and
+   * waits for a later complementary booking to complete the wagon.
+   *
+   * Returns the re-fetched booking, so callers can reflect the resulting status
+   * (SUBMITTED when paired/not-needed, PENDING_CONSOLIDATION when waiting).
    */
-  async resolveConsolidationGate(bookingId: string): Promise<{
-    booking: Booking;
-    blocked: boolean;
-    message?: string;
-  }> {
-    let booking = await this.findById(bookingId);
+  async runConsolidationOnSubmit(bookingId: string): Promise<Booking> {
+    const booking = await this.findById(bookingId);
 
-    // Already paired — passes the gate.
+    // Already paired (e.g. a partner submitted first) — nothing to do.
     if (booking.consolidationPartnerId) {
-      return { booking, blocked: false };
+      return booking;
     }
 
-    const needs =
-      await this.consolidationService.needsConsolidationFromBooking(booking);
-    if (!needs) {
-      return { booking, blocked: false };
-    }
-
-    // A partner may have appeared since submission — try to pair now.
     const result = await this.tryAutoConsolidate(booking);
-    booking = result.booking;
-    if (booking.consolidationPartnerId) {
-      return { booking, blocked: false, message: result.messages.join(' ') };
-    }
-
-    // Still no partner — park it and block the accept.
-    await this.bookingsRepository.parkForConsolidation(booking.id);
-    booking = await this.findById(booking.id);
-    const slots = await this.consolidationService.slotsFromBooking(booking);
-    return {
-      booking,
-      blocked: true,
-      message: this.consolidationService.describePending(booking, slots),
-    };
+    return result.booking;
   }
 
   /** Create a new freight booking. */
@@ -575,6 +565,7 @@ export class BookingsService {
   /** Return a paginated list of bookings matching the filter. */
   async findAll(
     filter: FilterBookingDto,
+    forceCompanyId?: string,
   ): Promise<{ items: Booking[]; total: number }> {
     const page = filter.page ?? 1;
     const pageSize = filter.pageSize ?? 20;
@@ -587,7 +578,9 @@ export class BookingsService {
       ...statusFilter,
       ...schedulingStatusFilter,
       assignedToSchedule: filter.assignedToSchedule,
-      companyId: filter.companyId,
+      // A forced company scope (portal/customer) overrides any caller-provided
+      // companyId so a customer can only ever see their own company's bookings.
+      companyId: forceCompanyId ?? filter.companyId,
       contractType: filter.contractType,
       serviceTypeId: filter.serviceTypeId,
       cargoTypeId: filter.cargoTypeId,
@@ -631,6 +624,109 @@ export class BookingsService {
     });
   }
 
+  /**
+   * Resolve the company a customer user belongs to, for scoping their own
+   * bookings. Returns null when no profile/company is linked yet.
+   */
+  async resolveCustomerCompanyId(userId: string): Promise<string | null> {
+    try {
+      const { company } =
+        await this.companiesService.getCompanyInfoByUserId(userId);
+      return company?.id ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Authorize a customer's access to a single booking. Staff are scoped at the
+   * controller (they pass `isStaff`); for a customer, the booking must belong
+   * to the company the authenticated user is linked to — otherwise it is hidden
+   * behind a NotFound so booking IDs can't be probed.
+   */
+  async assertCustomerCanAccessBooking(
+    userId: string | undefined,
+    booking: Booking,
+  ): Promise<void> {
+    if (!userId) {
+      throw new ForbiddenException('Authentication required');
+    }
+    const companyId = await this.resolveCustomerCompanyId(userId);
+    if (!companyId || booking.companyId !== companyId) {
+      // Don't reveal that the booking exists for another company.
+      throw new NotFoundException(`Booking ${booking.id} not found`);
+    }
+  }
+
+  /**
+   * Build the customer-facing shipment tracking payload for a booking from the
+   * train schedule it is assigned to and the live checkpoint log. The caller is
+   * responsible for authorizing access to the booking first.
+   *
+   * When the booking has not been assigned to a train yet, returns a valid
+   * "no schedule" payload so the UI can show a pre-dispatch state.
+   */
+  async getBookingTracking(
+    bookingId: string,
+  ): Promise<Freight.IBookingTracking> {
+    const booking = await this.findById(bookingId);
+
+    const empty: Freight.IBookingTracking = {
+      bookingId: booking.id,
+      bookingReference: booking.reference,
+      hasSchedule: false,
+      scheduleId: null,
+      trainNumber: null,
+      scheduleStatus: null,
+      direction: null,
+      origin: null,
+      destination: null,
+      stations: [],
+      checkpoints: [],
+      currentSequenceNo: -1,
+      actualDepartureAt: null,
+      actualArrivalAt: null,
+      scheduledDepartureAt: null,
+      scheduledArrivalAt: null,
+    };
+
+    if (!booking.trainScheduleId) {
+      return empty;
+    }
+
+    // Pull the live corridor + checkpoints for the assigned schedule. If the
+    // schedule was removed, fall back to the pre-dispatch state rather than 500.
+    let track: Awaited<
+      ReturnType<TrainSchedulingService['getScheduleCheckpoints']>
+    >;
+    try {
+      track = await this.trainSchedulingService.getScheduleCheckpoints(
+        booking.trainScheduleId,
+      );
+    } catch {
+      return empty;
+    }
+
+    return {
+      bookingId: booking.id,
+      bookingReference: booking.reference,
+      hasSchedule: true,
+      scheduleId: track.scheduleId,
+      trainNumber: track.trainNumber,
+      scheduleStatus: track.status as Freight.TrainScheduleStatus,
+      direction: track.direction,
+      origin: track.origin,
+      destination: track.destination,
+      stations: track.stations,
+      checkpoints: track.checkpoints as Freight.ITrackingCheckpoint[],
+      currentSequenceNo: track.currentSequenceNo,
+      actualDepartureAt: track.actualDepartureAt,
+      actualArrivalAt: track.actualArrivalAt,
+      scheduledDepartureAt: track.scheduledDepartureAt,
+      scheduledArrivalAt: track.scheduledArrivalAt,
+    };
+  }
+
   /** Aggregate metrics and tab counts for the backoffice booking list. */
   async getListSummary(filter: FilterBookingDto): Promise<BookingListSummaryDto> {
     const page = filter.page ?? 1;

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

@@ -18,7 +18,8 @@ import {
 export class PaymentClientService {
     private readonly logger = new Logger(PaymentClientService.name);
     private readonly baseUrl = (
-        process.env.PAYMENT_API_URL ?? "https://paymentcallback.triaplc.com"
+        // process.env.PAYMENT_API_URL ??
+         "https://paymentcallback.triaplc.com"
     ).replace(/\/$/, "");
     private readonly serviceToken = process.env.SERVICE_AUTH_TOKEN ?? "";
 

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

@@ -145,9 +145,7 @@ export class PaymentService {
             .findOneBy({ id: dto.bookingId });
         if (!booking) throw new NotFoundException("Booking not found");
 
-        console.log("bookingbooking",booking)
-        const amountMinor = Math.round(Number(booking.totalAmount) * 100);
-        console.log("amountminor",amountMinor)
+        const amountMinor = Math.round(Number(booking.totalAmount));
 
         const snapshot = await this.paymentClient.initiate({
             service: PaymentServiceEnum.FREIGHT,
@@ -159,8 +157,8 @@ export class PaymentService {
             provider: dto.method as unknown as ProviderMethod,
             platform: dto.platform,
             payerAccount: dto.payerAccount,
-            returnUrl: dto.returnUrl ?? process.env.PAYMENT_RETURN_URL,
-            failureUrl: dto.failureUrl ?? process.env.PAYMENT_FAILURE_URL,
+            returnUrl:'https://edrfreight.triaplc.com/payment/success',
+            failureUrl: 'https://edrfreight.triaplc.com/payment/failure',
         });
 
         const intent = await this.syncIntentProjection(booking.id, booking, snapshot);

apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.ts

@@ -49,8 +49,17 @@ export class SchedulingRescheduleService {
     if (!schedule) {
       throw new NotFoundException(`Train schedule ${scheduleId} not found`);
     }
+    // A train can be rescheduled (with or without bookings) at any time UNLESS it
+    // is already on the move (DISPATCHED), has completed its run (ARRIVED), or was
+    // cancelled. Only DRAFT / SCHEDULED trains are reschedulable.
     if (schedule.status === TrainScheduleStatus.Dispatched) {
-      throw new BadRequestException('Cannot reschedule a dispatched train');
+      throw new BadRequestException('Cannot reschedule a train that is already dispatched');
+    }
+    if (schedule.status === TrainScheduleStatus.Arrived) {
+      throw new BadRequestException('Cannot reschedule a train that has already arrived');
+    }
+    if (schedule.status === TrainScheduleStatus.Cancelled) {
+      throw new BadRequestException('Cannot reschedule a cancelled train');
     }
 
     const currentOnSchedule = (schedule.scheduleBookings ?? [])
@@ -156,10 +165,24 @@ export class SchedulingRescheduleService {
       }
     }
 
-    const assignResult = await this.trainSchedulingService.assignBookingsToSchedule(scheduleId, {
-      bookingIds: dto.finalBookingIds,
-      forceAssign: dto.trigger === 'GOVERNMENT_PREEMPT',
-    });
+    // A train can be rescheduled even with no bookings (e.g. moved for
+    // maintenance). assignBookingsToSchedule requires at least one booking, so
+    // only call it when something is actually being (re)assigned — the new
+    // departure date above is the meaningful change for an empty train. The
+    // empty-train branch returns the same schedule-detail shape as the assign
+    // path so callers get a consistent response.
+    const assignResult = dto.finalBookingIds.length
+      ? await this.trainSchedulingService.assignBookingsToSchedule(scheduleId, {
+          bookingIds: dto.finalBookingIds,
+          forceAssign: dto.trigger === 'GOVERNMENT_PREEMPT',
+        })
+      : {
+          ...(await this.trainSchedulingService.getContainerTrainScheduleById(
+            scheduleId,
+          )),
+          warnings: [] as string[],
+          deferredBookings: [] as unknown[],
+        };
 
     await this.schedulingRescheduleRepository.createEvent({
       trainScheduleId: scheduleId,

apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts

@@ -721,27 +721,37 @@ export class TrainSchedulingService {
       : null;
 
     if (route) {
-      const origin = route.originYard;
-      const destination = route.destinationYard;
+      // `route.milestones` is the complete ordered corridor and already includes
+      // the origin (first) and destination (last) yards — `route.originYardId`
+      // and `route.destinationYardId` are derived from them. Use the milestones
+      // directly so the endpoints aren't double-counted (Addis…Addis, Dire…Dire).
       const milestones = [...(route.milestones ?? [])].sort(
         (a: RouteMilestone, b: RouteMilestone) => a.sequenceNo - b.sequenceNo,
       );
+
+      if (milestones.length > 0) {
+        milestones.forEach((m, i) =>
+          stations.push({
+            sequenceNo: i,
+            yardId: m.yardId,
+            label: m.yard?.label ?? m.yard?.code ?? `Stop ${i + 1}`,
+            code: m.yard?.code ?? '',
+          }),
+        );
+        return stations;
+      }
+
+      // Route with no milestones recorded — fall back to its origin/destination.
+      const origin = route.originYard;
+      const destination = route.destinationYard;
       stations.push({
         sequenceNo: 0,
         yardId: route.originYardId,
         label: origin?.label ?? origin?.code ?? 'Origin',
         code: origin?.code ?? '',
       });
-      milestones.forEach((m, i) =>
-        stations.push({
-          sequenceNo: i + 1,
-          yardId: m.yardId,
-          label: m.yard?.label ?? m.yard?.code ?? `Stop ${i + 1}`,
-          code: m.yard?.code ?? '',
-        }),
-      );
       stations.push({
-        sequenceNo: milestones.length + 1,
+        sequenceNo: 1,
         yardId: route.destinationYardId,
         label: destination?.label ?? destination?.code ?? 'Destination',
         code: destination?.code ?? '',
@@ -775,8 +785,16 @@ export class TrainSchedulingService {
 
     const stations = await this.buildScheduleStations(schedule);
     const events = await this.trainCheckpointEventsRepository.findBySchedule(scheduleId);
+
+    // Resolve each checkpoint's position by its yard against the canonical
+    // corridor rather than the stored sequenceNo, so legacy checkpoints logged
+    // under an older station numbering still line up with the current stations.
+    const seqByYard = new Map(stations.map((s) => [s.yardId, s.sequenceNo]));
+    const resolvedSeq = (e: TrainCheckpointEvent) =>
+      seqByYard.get(e.yardId) ?? e.sequenceNo;
+
     const currentSequenceNo = events.length
-      ? Math.max(...events.map((e) => e.sequenceNo))
+      ? Math.max(...events.map(resolvedSeq))
       : -1;
 
     return {
@@ -790,13 +808,19 @@ export class TrainSchedulingService {
       actualArrivalAt: schedule.actualArrivalAt
         ? schedule.actualArrivalAt.toISOString()
         : null,
+      scheduledDepartureAt: schedule.scheduledDepartureDate
+        ? schedule.scheduledDepartureDate.toISOString()
+        : null,
+      scheduledArrivalAt: schedule.scheduledArrivalDate
+        ? schedule.scheduledArrivalDate.toISOString()
+        : null,
       origin: stations[0]?.label ?? null,
       destination: stations[stations.length - 1]?.label ?? null,
       stations,
       currentSequenceNo,
       checkpoints: events.map((e) => ({
         id: e.id,
-        sequenceNo: e.sequenceNo,
+        sequenceNo: resolvedSeq(e),
         yardId: e.yardId,
         label: e.yard?.label ?? e.yard?.code ?? null,
         kind: e.kind,

apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts

@@ -0,0 +1,32 @@
+import { IsString, IsEnum, IsNumber, IsOptional } from 'class-validator';
+import { VehicleType, FuelType, VehicleStatus } from '../entities/vehicle.entity';
+
+export class CreateVehicleDto {
+  @IsString()
+  plateNumber!: string;
+
+  @IsEnum(VehicleType)
+  vehicleType!: VehicleType;
+
+  @IsString()
+  manufacturer!: string;
+
+  @IsString()
+  model!: string;
+
+  @IsNumber()
+  year!: number;
+
+  @IsEnum(FuelType)
+  fuelType!: FuelType;
+
+  @IsNumber()
+  capacity!: number;
+
+  @IsEnum(VehicleStatus)
+  status!: VehicleStatus;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+}

apps/edr-freight-api/src/modules/vehicles/dto/update-vehicle.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateVehicleDto } from './create-vehicle.dto';
+
+export class UpdateVehicleDto extends PartialType(CreateVehicleDto) {}

apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts

@@ -0,0 +1,64 @@
+import { Entity, Column, Index } from 'typeorm';
+import { BaseEntity } from '@edr/api-common';
+
+export enum VehicleType {
+  TRUCK = 'TRUCK',
+  VAN = 'VAN',
+  CAR = 'CAR',
+  BUS = 'BUS',
+  TRAILER = 'TRAILER',
+  TANKER = 'TANKER',
+  FLATBED = 'FLATBED',
+}
+
+export enum FuelType {
+  PETROL = 'PETROL',
+  DIESEL = 'DIESEL',
+  ELECTRIC = 'ELECTRIC',
+  HYBRID = 'HYBRID',
+}
+
+export enum VehicleStatus {
+  ACTIVE = 'ACTIVE',
+  MAINTENANCE = 'MAINTENANCE',
+  RETIRED = 'RETIRED',
+  OUT_OF_SERVICE = 'OUT_OF_SERVICE',
+}
+
+@Entity({ name: 'vehicles', schema: 'freight' })
+@Index(['plateNumber'])
+@Index(['registrationNumber'])
+@Index(['status'])
+@Index(['vehicleType'])
+@Index(['manufacturer'])
+export class Vehicle extends BaseEntity {
+  @Column({ name: 'plate_number', unique: true })
+  plateNumber!: string;
+
+  @Column({ name: 'registration_number', unique: true })
+  registrationNumber!: string;
+
+  @Column({ name: 'vehicle_type', type: 'varchar' })
+  vehicleType!: VehicleType;
+
+  @Column()
+  manufacturer!: string;
+
+  @Column()
+  model!: string;
+
+  @Column()
+  year!: number;
+
+  @Column({ name: 'fuel_type', type: 'varchar' })
+  fuelType!: FuelType;
+
+  @Column()
+  capacity!: number;
+
+  @Column({ name: 'status', type: 'varchar', default: VehicleStatus.ACTIVE })
+  status!: VehicleStatus;
+
+  @Column({ type: 'text', nullable: true })
+  description!: string | null;
+}

apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts

@@ -0,0 +1,74 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Patch,
+  Delete,
+  Param,
+  Body,
+  Query,
+  ParseUUIDPipe,
+} from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { FleetManage, FleetView } from '../../common/booking-guards';
+import { VehiclesService } from './vehicles.service';
+import { CreateVehicleDto } from './dto/create-vehicle.dto';
+import { UpdateVehicleDto } from './dto/update-vehicle.dto';
+
+@ApiTags('vehicles')
+@ApiBearerAuth()
+@Controller('vehicles')
+@FleetView()
+export class VehiclesController {
+  constructor(private readonly vehiclesService: VehiclesService) {}
+
+  @Post()
+  @FleetManage()
+  @ApiOperation({ summary: 'Create a new vehicle' })
+  create(@Body() createVehicleDto: CreateVehicleDto) {
+    return this.vehiclesService.create(createVehicleDto);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'Get all vehicles with filters' })
+  findAll(
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+    @Query('page') page?: string,
+    @Query('limit') limit?: string,
+    @Query('sortBy') sortBy?: string,
+    @Query('sortOrder') sortOrder?: 'ASC' | 'DESC',
+  ) {
+    return this.vehiclesService.findAll({
+      search,
+      status: status as any,
+      page: page ? parseInt(page) : undefined,
+      limit: limit ? parseInt(limit) : undefined,
+      sortBy,
+      sortOrder,
+    });
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get vehicle by id' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.vehiclesService.findById(id);
+  }
+
+  @Patch(':id')
+  @FleetManage()
+  @ApiOperation({ summary: 'Update a vehicle' })
+  update(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() updateVehicleDto: UpdateVehicleDto,
+  ) {
+    return this.vehiclesService.update(id, updateVehicleDto);
+  }
+
+  @Delete(':id')
+  @FleetManage()
+  @ApiOperation({ summary: 'Delete a vehicle' })
+  remove(@Param('id', ParseUUIDPipe) id: string) {
+    return this.vehiclesService.remove(id);
+  }
+}

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

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Vehicle } from './entities/vehicle.entity';
+import { VehiclesService } from './vehicles.service';
+import { VehiclesController } from './vehicles.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Vehicle])],
+  providers: [VehiclesService],
+  controllers: [VehiclesController],
+  exports: [VehiclesService],
+})
+export class VehiclesModule {}

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

@@ -0,0 +1,15 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Vehicle } from './entities/vehicle.entity';
+
+@Injectable()
+export class VehiclesRepository extends BaseRepository<Vehicle> {
+  constructor(
+    @InjectRepository(Vehicle)
+    repository: Repository<Vehicle>,
+  ) {
+    super(repository);
+  }
+}

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

@@ -0,0 +1,109 @@
+import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { CreateVehicleDto } from './dto/create-vehicle.dto';
+import { UpdateVehicleDto } from './dto/update-vehicle.dto';
+import { Vehicle, VehicleStatus } from './entities/vehicle.entity';
+
+@Injectable()
+export class VehiclesService {
+  constructor(
+    @InjectRepository(Vehicle)
+    private readonly vehicleRepo: Repository<Vehicle>,
+  ) {}
+
+  async create(dto: CreateVehicleDto): Promise<Vehicle> {
+    const existing = await this.vehicleRepo.findOne({
+      where: { plateNumber: dto.plateNumber },
+    });
+
+    if (existing) {
+      throw new ConflictException(
+        `Vehicle with plate number ${dto.plateNumber} already exists`,
+      );
+    }
+
+    const registrationNumber = `REG-${dto.vehicleType}-${Date.now()}`;
+    const vehicle = this.vehicleRepo.create({
+      ...dto,
+      registrationNumber,
+    });
+
+    return this.vehicleRepo.save(vehicle);
+  }
+
+  async findAll(query: {
+    search?: string;
+    status?: VehicleStatus | string;
+    page?: number;
+    limit?: number;
+    sortBy?: string;
+    sortOrder?: 'ASC' | 'DESC';
+  } = {}): Promise<{ data: Vehicle[]; total: number; page: number; limit: number }> {
+    const page = query.page || 1;
+    const limit = query.limit || 10;
+    const skip = (page - 1) * limit;
+
+    const where: any = {};
+    if (query.status) where.status = query.status;
+
+    let qb = this.vehicleRepo.createQueryBuilder('v');
+
+    if (query.search) {
+      qb = qb.where(
+        'v.plateNumber ILIKE :search OR v.manufacturer ILIKE :search',
+        { search: `%${query.search}%` },
+      );
+    }
+
+    if (query.status) {
+      qb = qb.andWhere('v.status = :status', { status: query.status });
+    }
+
+    const sortBy = ['plateNumber', 'status', 'year', 'createdAt'].includes(
+      query.sortBy ?? '',
+    )
+      ? query.sortBy
+      : 'createdAt';
+    const sortOrder = (query.sortOrder ?? 'DESC').toUpperCase();
+
+    const [data, total] = await qb
+      .orderBy(`v.${sortBy}`, sortOrder as 'ASC' | 'DESC')
+      .skip(skip)
+      .take(limit)
+      .getManyAndCount();
+
+    return { data, total, page, limit };
+  }
+
+  async findById(id: string): Promise<Vehicle> {
+    const vehicle = await this.vehicleRepo.findOne({ where: { id } });
+    if (!vehicle) {
+      throw new NotFoundException(`Vehicle ${id} not found`);
+    }
+    return vehicle;
+  }
+
+  async update(id: string, dto: UpdateVehicleDto): Promise<Vehicle> {
+    const vehicle = await this.findById(id);
+
+    if (dto.plateNumber && dto.plateNumber !== vehicle.plateNumber) {
+      const existing = await this.vehicleRepo.findOne({
+        where: { plateNumber: dto.plateNumber },
+      });
+      if (existing) {
+        throw new ConflictException(
+          `Vehicle with plate number ${dto.plateNumber} already exists`,
+        );
+      }
+    }
+
+    Object.assign(vehicle, dto);
+    return this.vehicleRepo.save(vehicle);
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.findById(id);
+    await this.vehicleRepo.softDelete(id);
+  }
+}