Merge branch 'dev' into passenger/feat/iam

apps/edr-passenger-api/src/app.module.ts

@@ -13,6 +13,7 @@ import { TypeOrmModule, TypeOrmModuleOptions } from '@nestjs/typeorm';
 import { IamModule as TriaIamModule } from '@tria-plc/iamapi-common/iam.module';
 import { DataSeeder } from '@tria-plc/iamapi-common/db/seed/seeder';
 import { PrismaModule } from './common/prisma.module';
+import { AuditModule } from './common/audit.module';
 import { I18nModule } from './common/i18n/i18n.module';
 import { LocaleMiddleware } from './common/i18n/locale.middleware';
 import appConfig from './config/app.config';
@@ -24,6 +25,8 @@ import ebirrConfig from './config/ebirr.config';
 import cardConfig from './config/card.config';
 import waafiConfig from './config/waafi.config';
 import faydaConfig from './config/fayda.config';
+import rabbitmqConfig from './config/rabbitmq.config';
+import { AuthModule } from './modules/auth/auth.module';
 import { StationsModule } from './modules/stations/stations.module';
 import { FleetModule } from './modules/fleet/fleet.module';
 import { SchedulesModule } from './modules/schedules/schedules.module';
@@ -47,7 +50,8 @@ import { FraudModule } from './modules/fraud/fraud.module';
 import { SeatClassesModule } from './modules/seat-classes/seat-classes.module';
 import { FareEngineModule } from './modules/fare-engine/fare-engine.module';
 import { VerifaydaModule } from './modules/verifayda/verifayda.module';
-import {AuthModule} from "@/modules/auth/auth.module";
+import { AuditModuleFeature } from './modules/audit/audit.module';
+import { CurrenciesModule } from './modules/currencies/currencies.module';
 
 @Module({
   imports: [
@@ -63,6 +67,7 @@ import {AuthModule} from "@/modules/auth/auth.module";
         cardConfig,
         waafiConfig,
         faydaConfig,
+        rabbitmqConfig,
       ],
     }),
     ScheduleModule.forRoot(),
@@ -74,6 +79,7 @@ import {AuthModule} from "@/modules/auth/auth.module";
     }),
     TriaIamModule.forRoot(),
     PrismaModule,
+    AuditModule,
     I18nModule,
       AuthModule,
     StationsModule,
@@ -99,6 +105,8 @@ import {AuthModule} from "@/modules/auth/auth.module";
     SeatClassesModule,
     FareEngineModule,
     VerifaydaModule,
+    AuditModuleFeature,
+    CurrenciesModule,
   ],
 })
 export class AppModule implements OnApplicationBootstrap {

apps/edr-passenger-api/src/common/audit.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { PrismaModule } from './prisma.module';
+import { AuditService } from './audit.service';
+
+@Module({
+  imports: [PrismaModule],
+  providers: [AuditService],
+  exports: [AuditService],
+})
+export class AuditModule {}

apps/edr-passenger-api/src/common/audit.service.ts

@@ -0,0 +1,92 @@
+import { Injectable, Inject, Optional } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { PrismaService } from './prisma.service';
+
+@Injectable()
+export class AuditService {
+  constructor(
+    private prisma: PrismaService,
+    @Optional() @Inject(REQUEST) private request?: any,
+  ) {}
+
+  async log(input: {
+    userId?: string;
+    action: 'CREATE' | 'UPDATE' | 'DELETE' | 'LOGIN' | 'LOGOUT' | 'VERIFY' | string;
+    entityType: string;
+    entityId?: string;
+    oldData?: any;
+    newData?: any;
+  }) {
+    try {
+      const ipAddress = this.getIpAddress();
+      const userAgent = this.getUserAgent();
+
+      await this.prisma.auditLog.create({
+        data: {
+          userId: input.userId,
+          action: input.action,
+          entityType: input.entityType,
+          entityId: input.entityId,
+          oldData: input.oldData,
+          newData: input.newData,
+          ipAddress,
+          userAgent,
+        },
+      });
+    } catch (error) {
+      console.error('Failed to log audit event:', error);
+      // Don't throw - audit logging should not break main operations
+    }
+  }
+
+  private getIpAddress(): string {
+    if (!this.request) return '';
+    
+    return (
+      this.request.headers['x-forwarded-for']?.split(',')[0].trim() ||
+      this.request.headers['x-real-ip'] ||
+      this.request.connection?.remoteAddress ||
+      this.request.socket?.remoteAddress ||
+      this.request.ip ||
+      ''
+    );
+  }
+
+  private getUserAgent(): string {
+    return this.request?.headers?.['user-agent'] || '';
+  }
+
+  async getLogs(filters: any = {}) {
+    const where: any = {};
+
+    if (filters.search) {
+      where.OR = [
+        { entityId: { contains: filters.search, mode: 'insensitive' } },
+        { user: { email: { contains: filters.search, mode: 'insensitive' } } },
+        { user: { fullName: { contains: filters.search, mode: 'insensitive' } } },
+      ];
+    }
+
+    if (filters.action) {
+      where.action = filters.action;
+    }
+
+    if (filters.entityType) {
+      where.entityType = filters.entityType;
+    }
+
+    return this.prisma.auditLog.findMany({
+      where,
+      include: { user: true },
+      orderBy: { createdAt: 'desc' },
+      take: 500, // Limit to last 500 logs
+    });
+  }
+
+  async getLog(id: string) {
+    return this.prisma.auditLog.findUnique({
+      where: { id },
+      include: { user: true },
+    });
+  }
+}

apps/edr-passenger-api/src/common/filters/http-exception.filter.ts

@@ -12,6 +12,12 @@ export class HttpExceptionFilter implements ExceptionFilter {
   private readonly logger = new Logger(HttpExceptionFilter.name);
 
   catch(exception: unknown, host: ArgumentsHost): void {
+    // Global filter — also reached by non-HTTP (e.g. RabbitMQ) handlers. switchToHttp() would
+    // yield no response object there, so re-throw and let the transport (golevelup) handle it
+    // (nack/dead-letter) instead of crashing on response.status().
+    if (host.getType() !== 'http') {
+      throw exception;
+    }
     const ctx = host.switchToHttp();
     const response = ctx.getResponse();
     const request = ctx.getRequest();

apps/edr-passenger-api/src/common/guards/service-auth.guard.ts

@@ -0,0 +1,54 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  Logger,
+  UnauthorizedException,
+} from "@nestjs/common";
+import { timingSafeEqual } from "node:crypto";
+import { Request } from "express";
+
+/**
+ * Shared-secret guard for endpoints only the payment microservice may call
+ * (e.g. /internal/payments/mark-paid). The secret is the same SERVICE_AUTH_TOKEN the
+ * payment service enforces on its own internal surface. A forged mark-paid must not be able
+ * to confirm a booking without a real payment.
+ * TODO: integrate @tria-plc IAM / mTLS as the long-term mechanism.
+ */
+@Injectable()
+export class ServiceAuthGuard implements CanActivate {
+  private readonly logger = new Logger(ServiceAuthGuard.name);
+  private readonly token = process.env.SERVICE_AUTH_TOKEN ?? "";
+  private warned = false;
+
+  constructor() {
+    if (!this.token && process.env.NODE_ENV === "production") {
+      throw new Error("SERVICE_AUTH_TOKEN must be set in production");
+    }
+  }
+
+  canActivate(context: ExecutionContext): boolean {
+    if (!this.token) {
+      if (!this.warned) {
+        this.logger.warn(
+          "SERVICE_AUTH_TOKEN unset — internal endpoints are UNGUARDED (dev only)",
+        );
+        this.warned = true;
+      }
+      return true;
+    }
+
+    const request = context.switchToHttp().getRequest<Request>();
+    const header = request.headers["x-service-token"];
+    const bearer = request.headers.authorization?.replace(/^Bearer\s+/i, "");
+    const presented =
+      (Array.isArray(header) ? header[0] : header) ?? bearer ?? "";
+
+    const expected = Buffer.from(this.token);
+    const actual = Buffer.from(presented);
+    const valid =
+      expected.length === actual.length && timingSafeEqual(expected, actual);
+    if (!valid) throw new UnauthorizedException("Invalid service token");
+    return true;
+  }
+}

apps/edr-passenger-api/src/common/interceptors/response-transform.interceptor.ts

@@ -4,7 +4,14 @@ import { map } from 'rxjs/operators';
 
 @Injectable()
 export class ResponseTransformInterceptor<T> implements NestInterceptor<T, any> {
-  intercept(_ctx: ExecutionContext, next: CallHandler<T>): Observable<any> {
+  intercept(ctx: ExecutionContext, next: CallHandler<T>): Observable<any> {
+    // Only wrap HTTP responses. This interceptor is global, so it also runs for RabbitMQ
+    // message handlers (golevelup uses Nest's context system) — there, wrapping the return
+    // value would corrupt the handler's contract (e.g. a returned Nack would be swallowed,
+    // dropping a message instead of dead-lettering it). Let non-HTTP returns pass through.
+    if (ctx.getType() !== 'http') {
+      return next.handle();
+    }
     return next.handle().pipe(
       map((data) => ({ success: true, data, timestamp: new Date().toISOString() })),
     );

apps/edr-passenger-api/src/config/rabbitmq.config.ts

@@ -0,0 +1,12 @@
+import { registerAs } from '@nestjs/config';
+
+/**
+ * RabbitMQ connection for the payment-event consumer (payment microservice -> passenger).
+ * Independent of the IAM/notification module's RABBITMQ_URL so the two broker connections
+ * never interfere. Points at the dedicated `payment` vhost on the shared broker.
+ */
+export default registerAs('rabbitmq', () => ({
+  url: process.env.PAYMENT_RABBITMQ_URL,
+  /** Max unacked payment events held by this consumer at once. */
+  prefetch: parseInt(process.env.PAYMENT_EVENTS_PREFETCH ?? '10', 10),
+}));

apps/edr-passenger-api/src/config/waafi.config.ts

@@ -1,10 +1,27 @@
 import { registerAs } from '@nestjs/config';
 
 export default registerAs('waafi', () => ({
-  baseUrl: process.env.WAAFI_BASE_URL ?? 'https://api.waafipay.net',
+  // `/asm` is appended in the provider; use sandbox by default, switch to
+  // https://api.waafipay.net in production.
+  baseUrl: process.env.WAAFI_BASE_URL ?? 'https://sandbox.waafipay.net',
+  // HPP credentials (Hosted Payment Page family).
   merchantUid: process.env.WAAFI_MERCHANT_UID ?? '',
-  apiUserId: process.env.WAAFI_API_USER_ID ?? '',
-  apiKey: process.env.WAAFI_API_KEY ?? '',
+  storeId: process.env.WAAFI_STORE_ID ?? '',
+  hppKey: process.env.WAAFI_HPP_KEY ?? '',
+  // HMAC secret returned once by WEBHOOK_REGISTER; verifies inbound webhooks.
+  webhookSecret: process.env.WAAFI_WEBHOOK_SECRET ?? '',
+  // Wallet payment method (EVC/ZAAD/Sahal) — MWALLET_ACCOUNT requires the payer phone up front.
+  paymentMethod: process.env.WAAFI_PAYMENT_METHOD ?? 'MWALLET_ACCOUNT',
+  // Waafi has no ETB; when set this overrides the booking currency (USD/DJF/SLSH).
+  currency: process.env.WAAFI_CURRENCY ?? 'DJF',
+  // Browser redirect targets after the hosted page completes/fails (UX only; webhook is source of truth).
+  successUrl: process.env.WAAFI_HPP_SUCCESS_URL ?? '',
+  failureUrl: process.env.WAAFI_HPP_FAILURE_URL ?? '',
+  // Callback data format: 1 = POST, 2 = GET, 4 = Result Token.
+  respDataFormat: Number(process.env.WAAFI_HPP_RESP_FORMAT ?? '1'),
+  // Registered webhook URL (reference only; registration is performed out-of-band).
   notifyUrl: process.env.WAAFI_NOTIFY_URL ?? '',
-  returnUrl: process.env.WAAFI_RETURN_URL ?? '',
+  // DEV ONLY: disable TLS cert verification. The Waafi sandbox serves a *.waafi.com cert that
+  // does not match sandbox.waafipay.net (ERR_TLS_CERT_ALTNAME_INVALID). Never enable in prod.
+  insecureTls: process.env.WAAFI_INSECURE_TLS === 'true',
 }));

apps/edr-passenger-api/src/main.ts

@@ -12,7 +12,9 @@ import { ResponseTransformInterceptor } from "./common/interceptors/response-tra
 import { SessionActivityInterceptor } from "./common/interceptors/session-activity.interceptor";
 
 async function bootstrap() {
-  const app = await NestFactory.create(AppModule);
+  // rawBody: true buffers the unparsed request body onto req.rawBody so webhook handlers
+  // (e.g. Waafi HMAC verification) can sign over the exact bytes the provider signed.
+  const app = await NestFactory.create(AppModule, { rawBody: true });
 
   // URI versioning: the @tria-plc IAM controllers declare `version: "1"` so they register under
   // `/v1/...` (e.g. /v1/auth/login). Passenger controllers declare no version, so they stay
@@ -41,11 +43,25 @@ async function bootstrap() {
 ## Overview
 Enterprise-grade REST API for the Ethio-Djibouti Railway passenger booking and management platform. Built with NestJS, TypeScript, PostgreSQL, and Prisma ORM.
 
+## Latest Updates
+- **TRANSIT & ROUND_TRIP_TRANSIT Booking Types:** Full multi-leg booking support. TRANSIT = single journey via connecting train (single PNR). ROUND_TRIP_TRANSIT = round trip where one or both directions use a connecting train (4 holds, 4 seat sets).
+- **returnSeatId on Passenger Payloads:** For ROUND_TRIP and ROUND_TRIP_TRANSIT bookings each passenger object must include \`returnSeatId\` (the seat on the return leg-1). Guest and authenticated booking endpoints both enforce this.
+- **Unified Booking Type Matrix:** bookingType field on Booking now accepts ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT across all create endpoints (POST /bookings and POST /bookings/guest).
+- **Round-Trip Leg Tracking:** returnLegStatus on every booking tracks outbound/return leg usage (NEITHER_USED, OUTBOUND_ONLY, INBOUND_ONLY, BOTH_USED). Gate validation accepts a leg field (OUTBOUND | RETURN | LEG1 | LEG2 | OUTBOUND_LEG1 | OUTBOUND_LEG2 | RETURN_LEG1 | RETURN_LEG2).
+- **Auto No-Show Detection:** Cron marks OUTBOUND_ONLY 30 min after return departure when return leg was never scanned.
+- **Offline Batch Validation:** validateOfflineBatch now accepts leg per entry and handles both legs of a round-trip in one batch.
+- **Booking Filters:** GET /bookings now accepts ?returnLegStatus= to filter no-show/inbound-only cases in back-office.
+- **Sequence Ordering:** Stations and coaches now sorted by sequence field for consistent UI display.
+- **User Profile Data:** Gender, DOB, passport, and national ID fields for comprehensive passenger profiles.
+- **Seat Class Fees:** Premium charges and insurance fees per seat class for transparent pricing.
+- **Multi-Currency Display:** Bookings track display currency and converted amounts.
+- **Ticket Lifecycle:** Tickets now include validatedAt, outboundBoardedAt, returnBoardedAt for complete audit trail.
+
 ## Key Features
 
-### 🎫 Booking Lifecycle
+### Booking Lifecycle
 - Search trips with real-time availability
-- Age-based passenger categorization (Adult ≥5 years, Child <5 years)
+- Age-based passenger categorization (Adult 5+ years, Child under 5)
 - Nationality-based verification (Ethiopian Fayda, International Passport)
 - Passenger information collection with verification
 - Coach and seat selection with real-time availability
@@ -54,87 +70,143 @@ Enterprise-grade REST API for the Ethio-Djibouti Railway passenger booking and m
 - Modify bookings (seat changes, passenger updates)
 - Cancel bookings with automatic refunds
 - Multi-segment journey support
+- Cross-border journeys via Dire Dawa transit (Ethiopia to Djibouti)
+- Round-trip booking with return journey scheduling
+- Transit booking (single journey via connecting train, single PNR, single ticket)
+- Round-trip transit booking (round trip where one or both directions use a connecting train)
+- Coach type selection with seat class and pricing options
+- Booking type field: ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT
+- Display currency and converted pricing per booking
+- returnLegStatus field tracks which legs of a round-trip were used
+- GET /bookings?returnLegStatus=OUTBOUND_ONLY filters no-show returns in back-office
 
-### 👤 Passenger Verification
-1. **Ethiopian Nationals:**
-- Automatic Fayda verification for adults (≥5 years)
+### Passenger Verification
+1. Ethiopian Nationals:
+- Automatic Fayda verification for adults (5+ years)
 - Real-time national ID verification via government database
 - Retrieves verified passenger data (name, DOB, gender)
 - National IDs not stored (policy compliant)
 
-2. **International Passengers:**
+2. International Passengers:
 - Passport information collection
 - Manual verification for Djiboutian and other nationals
 - No government database verification required
 
-### 💰 Age-Based Pricing
-- **ADULT** (≥5 years): Pay 100% of base fare
-- **CHILD** (<5 years): First child travels FREE, subsequent children pay 100%
+### Age-Based Pricing
+- ADULT (5+ years): Pay 100% of base fare
+- CHILD (under 5): First child travels FREE, subsequent children pay 100%
 - Automatic age calculation from date of birth
-- Example: 2 adults + 3 children = 4× base fare (first child free)
+- Example: 2 adults + 3 children = 4x base fare (first child free)
+- NEW: Premium charges and insurance fees per seat class
+- NEW: Transparent fee breakdown in pricing calculations
 
-### 💳 Payment Integration
-1. **Ethiopian Payment Methods:**
-- **Telebirr** - Ethiopia's leading mobile money
-- **CBE Birr** - Commercial Bank of Ethiopia
-- **eBirr** - Electronic payment gateway
+### Payment Integration
+1. Ethiopian Payment Methods: Telebirr, CBE Birr
+2. Djiboutian Payment Methods: Waafi
+3. International Payment Methods: Card, Wallet
 
-2. **Djiboutian Payment Methods:**
-- **Waafi** - Djibouti's mobile money service
-
-3. **International Payment Methods:**
-- **Card** - International card payments (Visa, Mastercard)
-- **Wallet** - Internal wallet system
-
-### 🪑 Seat Management
+### Seat Management
 - Real-time seat availability by coach and class
 - Seat holds with 15-minute expiry
 - Auto-assign seats with contiguous algorithm
 - Seat blocking for maintenance
-- Coach-level seat maps
+- Coach-level seat maps (ordered by sequence)
 - Class-based seating (Economy Regular, Economy Bed, VIP Bed)
+- NEW: Sequence-based coach ordering for consistent display
 
-### 🎟️ Ticketing
+### Ticketing
 - QR code and barcode generation
 - PDF ticket generation
 - Gate validation with audit logs
 - Offline validation support
 - Multi-passenger tickets
+- NEW: Ticket lifecycle tracking (validatedAt, outboundBoardedAt, returnBoardedAt timestamps)
+- NEW: Gate validation accepts leg (OUTBOUND or RETURN) for round-trip tickets
+- NEW: Complete audit trail per leg for compliance and reporting
 
-### 🏆 Loyalty Program
+### Booking Type Matrix
+
+| bookingType | Holds required | Passenger seat fields | Legs in DB |
+|---|---|---|---|
+| ONE_WAY | holdId | seatId | 1 |
+| ROUND_TRIP | holdId + returnHoldId | seatId + returnSeatId | 2 (leg=1 outbound, leg=2 return) |
+| TRANSIT | holdId + leg2HoldId | seatId + leg2SeatId | 2 (leg=1, leg=2 on same direction) |
+| ROUND_TRIP_TRANSIT | holdId + leg2HoldId + returnHoldId + returnLeg2HoldId | seatId + leg2SeatId + returnSeatId + returnLeg2SeatId | 4 |
+
+### Round-Trip Leg Tracking
+- returnLegStatus on Booking: NOT_APPLICABLE, NEITHER_USED, OUTBOUND_ONLY, INBOUND_ONLY, BOTH_USED
+- Gate validation POST /tickets/:ref/validate accepts optional leg field:
+  - ONE_WAY: omit
+  - TRANSIT: LEG1 | LEG2
+  - ROUND_TRIP: OUTBOUND | RETURN
+  - ROUND_TRIP_TRANSIT: OUTBOUND_LEG1 | OUTBOUND_LEG2 | RETURN_LEG1 | RETURN_LEG2
+- Auto no-show cron: sets OUTBOUND_ONLY 30 min after return departure when return leg unscanned
+- Back-office filter: GET /bookings?returnLegStatus=OUTBOUND_ONLY surfaces no-shows
+- Offline batch: validateOfflineBatch accepts leg per entry, handles both legs of same booking
+
+### Round-Trip & Transit Bookings
+- ONE_WAY and ROUND_TRIP for direct routes
+- TRANSIT for single connecting journey (Dire Dawa hub), single PNR
+- ROUND_TRIP_TRANSIT for round trips via connecting trains
+- Combined pricing: total = sum of all leg base fares, single promo/loyalty deduction
+- Separate seat management per leg; each leg stored with its scheduleId and leg number
+- returnLegStatus tracks which legs have been boarded for no-show management
+
+### Loyalty Program
 - 4 tiers: Bronze, Silver, Gold, Platinum
 - Points accumulation on trips
 - Reward redemption
 - Tier-based benefits
 
-### 💰 Wallet System
+### Wallet System
 - Top-up via payment methods
 - Pay with wallet balance
 - Transaction ledger
 - Refund to wallet
 
-### 📍 Live Tracking
+### Live Tracking
 - Real-time trip status
 - Location updates
 - Delay notifications
 - Station crowd signals
 
-### 🔒 Fraud Detection
+### Fraud Detection
 - Velocity checks (multiple bookings)
 - High-value transaction monitoring
 - Failed payment pattern detection
 - Automatic user blocking
 
-### 🌍 Internationalization
+### Passenger Profiles
+- Comprehensive profile data: gender, date of birth, nationality
+- National ID for Ethiopian citizens (Fayda verified)
+- Passport information for international passengers
+- NEW: Complete demographic data for personalized services
+
+### Internationalization
 - Multi-language support (English, Amharic, French, Oromo)
 - Locale-based responses
 - Currency formatting (ETB, DJF, USD)
+- NEW: Multi-currency display per booking (ETB, DJF, USD)
 
-### 👨‍💼 Agent Operations
-- Counter booking
-- Shift management
-- Commission tracking
-- Cash reconciliation
+### Transit Stop Management
+- Automatic detection of cross-border journeys (Ethiopia to Djibouti)
+- Dire Dawa as mandatory transit hub for international journeys
+- Dual-leg fare calculation (domestic + international)
+- Age-based pricing applied independently per leg
+- Seamless multi-segment booking workflow
+
+### Coach Type & Class Selection
+- Browse available coach types per route
+- View seat classes per coach (Economy Regular, Economy Bed, VIP Bed)
+- Compare base prices by coach type and class
+- Real-time availability per coach configuration
+- NEW: Sequence-based coach ordering for consistent UI
+- NEW: Premium and insurance fee transparency per class
+
+### Data Organization
+- Stations ordered by sequence (1-15) for consistent route display
+- Coaches ordered by sequence (1+) per type for predictable configuration
+- Booking history sorted chronologically with filtering options
 
 ## Authentication
 
@@ -151,26 +223,37 @@ Used for agent, fraud, and reporting endpoints. Requires corporate IAM token.
 ## Passenger Booking Flow
 
 ### Step 1: Search Trips
-\`POST /search\` with origin, destination, date, passenger counts, and nationality
+\`POST /search\` with origin, destination, date, passenger counts, and nationality.
+For round-trips also pass \`journeyType=ROUND_TRIP\` and \`returnDate\`.
 
 ### Step 2: Get Fare Quote
-\`POST /search/fare-quote\` with passenger counts and display currency
+\`POST /search/fare-quote\` with passenger counts and display currency.
+For round-trips also pass \`returnScheduleId\`, \`returnOriginStationId\`, \`returnDestinationStationId\`.
 
 ### Step 3: Passenger Information & Verification
 **For Ethiopian Passengers:**
-\`POST /passengers/verify-fayda\` - Automatic Fayda verification for adults (≥5 years)
+\`POST /passengers/verify-fayda\` — Automatic Fayda verification for adults (5+ years)
 
 **For International Passengers:**
-\`POST /passengers/register-international\` - Passport information collection
+\`POST /passengers/register-international\` — Passport information collection
 
 ### Step 4: View Seat Map
-\`GET /seats/seatmap/{scheduleId}\` - Show available coaches and seats
+\`GET /seats/seatmap/{scheduleId}\` — Show available coaches and seats.
+For round-trips, call this twice: once for outbound scheduleId, once for return scheduleId.
 
-### Step 5: Login & Hold Seats
-\`POST /auth/login\` then \`POST /seats/hold\` to reserve seats for 15 minutes
+### Step 5: Hold Seats
+\`POST /seats/hold\` to reserve seats for 15 minutes.
+- ONE_WAY / TRANSIT outbound leg: one hold call → \`holdId\`
+- TRANSIT leg-2: second hold call → \`leg2HoldId\`
+- ROUND_TRIP return: second hold call → \`returnHoldId\`
+- ROUND_TRIP_TRANSIT: four hold calls → \`holdId\`, \`leg2HoldId\`, \`returnHoldId\`, \`returnLeg2HoldId\`
 
 ### Step 6: Create Booking
-\`POST /bookings/guest\` with verified passenger details and held seats
+Choose the right endpoint and bookingType:
+- **ONE_WAY** → \`POST /bookings/guest\` or \`POST /bookings\` with \`bookingType: ONE_WAY\`, passenger \`seatId\`
+- **ROUND_TRIP** → same endpoint with \`bookingType: ROUND_TRIP\`, \`returnScheduleId/returnHoldId/returnOriginStationId/returnDestinationStationId\`, passenger \`seatId + returnSeatId\`
+- **TRANSIT** → same endpoint with \`bookingType: TRANSIT\`, \`leg2ScheduleId/leg2HoldId/transitStationId/leg2DestinationStationId\`, passenger \`seatId + leg2SeatId\`
+- **ROUND_TRIP_TRANSIT** → same endpoint with \`bookingType: ROUND_TRIP_TRANSIT\`, all 4 sets of schedule/hold/station fields, passenger \`seatId + leg2SeatId + returnSeatId + returnLeg2SeatId\`
 
 ### Step 7: Process Payment
 \`POST /payments/telebirr\` (Ethiopian) or \`POST /payments/waafi\` (Djiboutian)
@@ -204,7 +287,6 @@ List endpoints support pagination:
 Payment providers send notifications to:
 - \`POST /payments/webhooks/telebirr\` (Ethiopia)
 - \`POST /payments/webhooks/cbe-birr\` (Ethiopia)
-- \`POST /payments/webhooks/ebirr\` (Ethiopia)
 - \`POST /payments/webhooks/waafi\` (Djibouti)
 - \`POST /payments/webhooks/card\` (International)
 
@@ -219,33 +301,37 @@ Payment providers send notifications to:
       { type: "http", scheme: "bearer", bearerFormat: "JWT", in: "header" },
       "JWT-auth",
     )
-    .addTag("Agents", "Counter booking, shift management, and commission tracking")
-    .addTag("Auth", "User registration, login, and profile management")
-    .addTag("Booking", "Complete booking lifecycle: create, modify, cancel")
-    .addTag("Dashboard", "Aggregated dashboard data for home screen")
-    .addTag("Fare Engine", "Distance-based fare calculator with multi-currency support")
-    .addTag("Fayda Verification", "Ethiopian national ID verification via government API")
-    .addTag("Fleet", "Train services, coaches, and seat configurations")
-    .addTag("Fraud Detection", "Fraud monitoring, alerts, and user blocking")
-    .addTag("Live Tracking", "Real-time trip status, delays, and station crowds")
-    .addTag("Loyalty", "Points accumulation, tiers, and reward redemption")
-    .addTag("Notifications", "Multi-channel notifications: email, SMS, push")
-    .addTag("Passengers", "Passenger registration, verification, and profiles")
-    .addTag("Payment", "Payment processing, intents, and refunds")
-    .addTag("Payment Webhooks", "Payment provider webhook handlers")
-    .addTag("Promotions", "Promo codes, campaigns, and discount management")
-    .addTag("Reports", "Sales reports, occupancy analytics, and metrics")
-    .addTag("Routes", "Route templates with stops and fare rules")
-    .addTag("Schedule", "Trip schedules, availability, and status updates")
-    .addTag("Search", "Trip search, availability checks, and fare quotes")
-    .addTag("Seat Classes", "Seat class management: Economy, VIP configurations")
-    .addTag("Seats", "Seat maps, holds, releases, and blocking")
-    .addTag("Segment-based Seats", "Segment-level seat allocation and availability")
-    .addTag("Stations", "Station directory and information")
-    .addTag("Support", "FAQ management and live chat support")
-    .addTag("Tickets", "QR ticket generation, PDFs, and gate validation")
-    .addTag("Wallet", "Wallet balance, top-ups, and transaction ledger")
-    .addTag("Config", "System configuration and settings")
+    .addTag("Agents", "Counter booking, shift management, commission tracking, and reconciliation")
+    .addTag("Audit", "User activity logging, system changes, compliance tracking, and audit trails")
+    .addTag("Auth", "Passenger registration, login, OTP, password reset, and profile management")
+    .addTag("Booking", "Complete booking lifecycle: create, modify, cancel, guest checkout. Supports ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT booking types. returnLegStatus filter for round-trip no-show management")
+    .addTag("Config", "System settings, feature flags, and configuration management")
+    .addTag("Currencies", "Multi-currency support, exchange rates, and currency conversion")
+    .addTag("Dashboard", "Home screen aggregations: trips, loyalty, wallet, notifications")
+    .addTag("Fare Engine", "Distance-based fare calculation with age-based pricing and multi-currency")
+    .addTag("Fayda Verification", "Ethiopian national ID verification via Verifayda 2.0 government API")
+    .addTag("Fleet", "Train services, coaches, coach types, seat classes, amenities, and configurations")
+    .addTag("Fraud Detection", "Velocity checks, monitoring alerts, pattern detection, and user blocking")
+    .addTag("Internal Payments", "Internal payment tracking, wallet transactions, and balance management")
+    .addTag("Live Tracking", "Real-time trip status, location updates, delays, and crowd signals")
+    .addTag("Loyalty", "Points ledger, tier management (Bronze/Silver/Gold/Platinum), rewards")
+    .addTag("Notifications", "Multi-channel delivery (email, SMS, push) and preference management")
+    .addTag("Passengers", "Registration, Fayda verification, international passports, saved profiles")
+    .addTag("Payment", "Telebirr, CBE Birr, Waafi, Card, Wallet payment processing and refunds")
+    .addTag("Payment Webhooks", "Payment provider webhook handlers and transaction confirmation")
+    .addTag("Promotions", "Promo codes, campaigns, discounts, and redemption tracking")
+    .addTag("Reports", "Revenue analytics, occupancy reports, agent sales, and KPI dashboards")
+    .addTag("Routes", "Route templates with ordered stops, fare rules, and baggage allowance")
+    .addTag("Schedule", "Trip schedules, availability windows, status tracking, and timing")
+    .addTag("Search", "Trip search, fare quotes, coach types, and real-time availability")
+    .addTag("Seat Classes", "Economy Regular, Economy Bed, VIP Bed class configuration and pricing")
+    .addTag("Seats", "Seat maps, holds (15-min expiry), releases, blocking, and inventory")
+    .addTag("Segment-based Seats", "Multi-leg journey seats, segment allocation, and per-leg availability")
+    .addTag("Stations", "Station directory, location data, baggage facilities, and amenities")
+    .addTag("Support", "FAQ management, search, live chat conversations, and ticket resolution")
+    .addTag("Tickets", "QR/barcode generation, PDF tickets, gate validation with per-leg tracking (OUTBOUND/RETURN/LEG1/LEG2/OUTBOUND_LEG1/OUTBOUND_LEG2/RETURN_LEG1/RETURN_LEG2), and audit trails")
+    .addTag("Transit Stops", "Cross-border journey management, Dire Dawa hub, TRANSIT and ROUND_TRIP_TRANSIT bookings")
+    .addTag("Wallet", "Balance management, top-ups, withdrawals, and transaction ledger")
     //.addServer('http://localhost:4000', 'Development')
     // .addServer("https://api.edr-platform.com", "Production")
     .build();

apps/edr-passenger-api/src/modules/audit/audit.controller.ts

@@ -0,0 +1,41 @@
+import { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery } from '@nestjs/swagger';
+import { AuditService } from '../../common/audit.service';
+import { IamGuard } from '../../common/iam-adapter';
+
+@ApiTags('Audit')
+@Controller('audit')
+@UseGuards(IamGuard)
+@ApiBearerAuth('IAM-auth')
+export class AuditController {
+  constructor(private auditService: AuditService) {}
+
+  @Get('logs')
+  @ApiOperation({
+    summary: 'Get audit logs',
+    description: 'Retrieve system audit logs with optional filtering',
+  })
+  @ApiQuery({ name: 'search', required: false, description: 'Search by user email or entity ID' })
+  @ApiQuery({ name: 'action', required: false, description: 'Filter by action (CREATE, UPDATE, DELETE, etc.)' })
+  @ApiQuery({ name: 'entityType', required: false, description: 'Filter by entity type (Booking, Station, etc.)' })
+  async getLogs(
+    @Query('search') search?: string,
+    @Query('action') action?: string,
+    @Query('entityType') entityType?: string,
+  ) {
+    const filters = {
+      search: search || undefined,
+      action: action || undefined,
+      entityType: entityType || undefined,
+    };
+
+    const items = await this.auditService.getLogs(filters);
+    return { items };
+  }
+
+  @Get('logs/:id')
+  @ApiOperation({ summary: 'Get audit log by ID' })
+  async getLog(@Param('id') id: string) {
+    return this.auditService.getLog(id);
+  }
+}

apps/edr-passenger-api/src/modules/audit/audit.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { HttpModule } from '@nestjs/axios';
+import { AuditModule } from '../../common/audit.module';
+import { AuditController } from './audit.controller';
+
+@Module({
+  imports: [AuditModule, HttpModule],
+  controllers: [AuditController],
+})
+export class AuditModuleFeature {}

apps/edr-passenger-api/src/modules/auth/auth.controller.ts

@@ -1,8 +1,11 @@
-import { Body, Controller, Post, HttpCode, HttpStatus, UseGuards, Get, Request, UnauthorizedException } from '@nestjs/common';
+import { Body, Controller, Post, HttpCode, HttpStatus, UseGuards, Get, Request, UnauthorizedException, Param, Patch, Delete, Query } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiResponse, ApiBody, ApiBearerAuth } from '@nestjs/swagger';
 import { PassengerAuthService } from './passenger-auth.service';
 import { RegisterDto, LoginDto } from './auth.dto';
 import { JwtGuard } from '../../common/jwt.guard';
+import { RolesGuard } from '../../common/roles.guard';
+import { Roles } from '../../common/roles.decorator';
+import { UserRole } from '@prisma/client';
 
 @ApiTags('Auth')
 @Controller('auth')
@@ -61,4 +64,61 @@ export class AuthController {
     if (!userId) throw new UnauthorizedException('User not authenticated');
     return this.passengerAuthService.getProfile(userId);
   }
+
+  @Get('users')
+  @UseGuards(JwtGuard, RolesGuard)
+  @Roles(UserRole.ADMIN, UserRole.SUPERVISOR)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Get all backoffice users (admin/supervisor only)' })
+  getUsers(
+    @Query('search') search?: string,
+    @Query('role') role?: string,
+    @Query('status') status?: string,
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+  ) {
+    return this.service.getUsers({
+      search,
+      role,
+      status,
+      page: page ? parseInt(page) : 1,
+      pageSize: pageSize ? parseInt(pageSize) : 10,
+    });
+  }
+
+  @Post('users')
+  @UseGuards(JwtGuard, RolesGuard)
+  @Roles(UserRole.ADMIN, UserRole.SUPERVISOR)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Create new backoffice user (admin/supervisor only)' })
+  createUser(@Body() dto: any) {
+    return this.service.createUser(dto);
+  }
+
+  @Patch('users/:id')
+  @UseGuards(JwtGuard, RolesGuard)
+  @Roles(UserRole.ADMIN, UserRole.SUPERVISOR)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Update backoffice user (admin/supervisor only)' })
+  updateUser(@Param('id') id: string, @Body() dto: any) {
+    return this.service.updateUser(id, dto);
+  }
+
+  @Delete('users/:id')
+  @UseGuards(JwtGuard, RolesGuard)
+  @Roles(UserRole.ADMIN)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Delete backoffice user (admin only)' })
+  deleteUser(@Param('id') id: string) {
+    return this.service.deleteUser(id);
+  }
+
+  @Post('users/:id/reset-password')
+  @UseGuards(JwtGuard, RolesGuard)
+  @Roles(UserRole.ADMIN, UserRole.SUPERVISOR)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Reset user password with temporary password (admin/supervisor only)' })
+  resetUserPassword(@Param('id') id: string, @Body() dto: { tempPassword: string }) {
+    return this.service.resetUserPassword(id, dto.tempPassword);
+  }
 }

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

@@ -1,5 +1,5 @@
 import { Body, Controller, Delete, Get, Param, Post, Patch, UseGuards, Query, Req, BadRequestException } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth, ApiResponse, ApiQuery } from '@nestjs/swagger';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiResponse, ApiQuery, ApiBody } from '@nestjs/swagger';
 import { BookingsService } from './bookings.service';
 import { GuestBookingService } from './guest-booking.service';
 import { CreateBookingDto, ModifyBookingDto, CancelBookingDto } from './bookings.dto';
@@ -74,21 +74,24 @@ export class BookingsController {
   @Get()
   @ApiOperation({ 
     summary: 'List all bookings with filters (Admin/Agent)',
-    description: 'Returns paginated list of bookings with search and status filters'
+    description: 'Returns paginated list of bookings. Use `returnLegStatus=OUTBOUND_ONLY` to find round-trip no-shows on the return leg, `INBOUND_ONLY` for passengers who only used the return leg, `BOTH_USED` for fully completed round-trips, and `NEITHER_USED` for confirmed but not yet boarded.'
   })
   @ApiQuery({ name: 'search', required: false, description: 'Search by booking reference, email, or phone' })
   @ApiQuery({ name: 'status', required: false, description: 'Filter by booking status' })
+  @ApiQuery({ name: 'returnLegStatus', required: false, description: 'Filter round-trip leg usage: NEITHER_USED | OUTBOUND_ONLY | INBOUND_ONLY | BOTH_USED | NOT_APPLICABLE' })
   @ApiQuery({ name: 'page', required: false, description: 'Page number' })
   @ApiQuery({ name: 'pageSize', required: false, description: 'Items per page' })
   findAll(
     @Query('search') search?: string,
     @Query('status') status?: string,
+    @Query('returnLegStatus') returnLegStatus?: string,
     @Query('page') page?: string,
     @Query('pageSize') pageSize?: string,
   ) {
     return this.service.findAll({ 
       search, 
-      status, 
+      status,
+      returnLegStatus,
       page: page ? parseInt(page) : 1, 
       pageSize: pageSize ? parseInt(pageSize) : 20 
     });
@@ -96,35 +99,153 @@ export class BookingsController {
   
   @Post('guest')
   @ApiOperation({ 
-    summary: 'Create guest booking without login (optional account creation)',
-    description: `Creates a booking without requiring login. Features:
-    
-**Guest Checkout:**
-- No login required
-- Contact details from first passenger
-- Booking confirmation sent to email/phone
+    summary: 'Create guest booking — ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT (no login required)',
+    description: `Creates a booking without requiring login. Supports all four booking types.
 
-**Optional Account Creation:**
-- Set createAccount=true with password
-- Account created using first passenger details
-- Automatic login after booking
-- Loyalty points and wallet created
+**bookingType: ONE_WAY (default)**
+- scheduleId, holdId, originStationId, destinationStationId, seatClassId
+- passengers[]: { seatId, passengerName, dateOfBirth, idDocumentType, … }
 
-**Passenger Details Storage:**
-- savePassengerDetails=true: Save for future bookings
-- Stored by userId (if account created) or deviceId
-- Retrieve saved passengers for quick booking
+**bookingType: ROUND_TRIP**
+- Above + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, returnSeatClassId
+- passengers[]: each must include returnSeatId (seat on the return leg)
 
-**Verifayda Verification:**
-- Ethiopian nationals: National ID verified via Verifayda
-- Other nationals: Passport details (no verification)
+**bookingType: TRANSIT**
+- scheduleId/holdId (leg-1) + leg2ScheduleId, leg2HoldId, transitStationId, leg2DestinationStationId
+- passengers[]: each must include leg2SeatId
 
-**Age-Based Pricing:**
-- ADULT (≥5 years): Full fare
-- CHILD (<5 years): First child FREE, subsequent children full fare`
+**bookingType: ROUND_TRIP_TRANSIT**
+- All TRANSIT outbound fields + returnScheduleId/returnHoldId/returnOriginStationId/returnDestinationStationId/returnLeg2ScheduleId/returnLeg2HoldId/returnTransitStationId/returnLeg2DestinationStationId
+- passengers[]: each must include leg2SeatId, returnSeatId, returnLeg2SeatId
+
+**Optional account creation:** set createAccount=true with password — creates account from first passenger details, loyalty + wallet initialised.
+
+**Verifayda:** Ethiopian nationals verified; international passengers require passportNumber + passportCountry.`
   })
-  @ApiResponse({ status: 201, description: 'Booking created successfully' })
-  @ApiResponse({ status: 400, description: 'Verifayda verification failed or invalid data' })
+  @ApiBody({
+    type: CreateGuestBookingDto,
+    examples: {
+      ONE_WAY: {
+        summary: 'ONE_WAY — single direct journey (guest)',
+        value: {
+          scheduleId: 'schedule-uuid',
+          holdId: 'hold-uuid',
+          originStationId: 'station-uuid',
+          destinationStationId: 'station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ONE_WAY',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+            email: 'abebe@email.com',
+          }],
+          savePassengerDetails: true,
+          deviceId: 'device-uuid-123',
+        },
+      },
+      ROUND_TRIP: {
+        summary: 'ROUND_TRIP — outbound + return, single PNR (guest)',
+        value: {
+          scheduleId: 'outbound-schedule-uuid',
+          holdId: 'outbound-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'djibouti-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP',
+          returnScheduleId: 'return-schedule-uuid',
+          returnHoldId: 'return-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'addis-station-uuid',
+          returnSeatClassId: 'seat-class-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'outbound-seat-uuid',
+            returnSeatId: 'return-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+          }],
+          savePassengerDetails: true,
+          deviceId: 'device-uuid-123',
+        },
+      },
+      TRANSIT: {
+        summary: 'TRANSIT — connecting train, single PNR (guest)',
+        value: {
+          scheduleId: 'leg1-schedule-uuid',
+          holdId: 'leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'TRANSIT',
+          leg2ScheduleId: 'leg2-schedule-uuid',
+          leg2HoldId: 'leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'leg1-seat-uuid',
+            leg2SeatId: 'leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+          }],
+          deviceId: 'device-uuid-123',
+        },
+      },
+      ROUND_TRIP_TRANSIT: {
+        summary: 'ROUND_TRIP_TRANSIT — round trip via connecting trains, 4 holds (guest)',
+        value: {
+          scheduleId: 'ob-leg1-schedule-uuid',
+          holdId: 'ob-leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP_TRANSIT',
+          leg2ScheduleId: 'ob-leg2-schedule-uuid',
+          leg2HoldId: 'ob-leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          returnScheduleId: 'ret-leg1-schedule-uuid',
+          returnHoldId: 'ret-leg1-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'diredawa-station-uuid',
+          returnLeg2ScheduleId: 'ret-leg2-schedule-uuid',
+          returnLeg2HoldId: 'ret-leg2-hold-uuid',
+          returnTransitStationId: 'diredawa-station-uuid',
+          returnLeg2DestinationStationId: 'addis-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'ob-leg1-seat-uuid',
+            leg2SeatId: 'ob-leg2-seat-uuid',
+            returnSeatId: 'ret-leg1-seat-uuid',
+            returnLeg2SeatId: 'ret-leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+          }],
+          deviceId: 'device-uuid-123',
+        },
+      },
+    },
+  })
+  @ApiResponse({ status: 201, description: 'Booking created successfully with fareBreakdown' })
+  @ApiResponse({ status: 400, description: 'Missing required seat IDs for bookingType, or Verifayda verification failed' })
   createGuest(@Req() req: any, @Body() dto: CreateGuestBookingDto) {
     return this.guestService.createGuestBooking(dto, req);
   }
@@ -143,13 +264,149 @@ export class BookingsController {
   @UseGuards(JwtGuard)
   @ApiBearerAuth('JWT-auth')
   @ApiOperation({ 
-    summary: 'Create booking (requires login)',
-    description: `Creates a booking for logged-in users with saved passenger profiles.
-    Use POST /bookings/guest for guest checkout without login.`
+    summary: 'Create booking — ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT',
+    description: `Creates a booking for a logged-in passenger. bookingType controls which fields are required.
+
+**ONE_WAY**
+- scheduleId, holdId, originStationId, destinationStationId, seatClassId
+- passengers[]: { seatId, passengerName, dateOfBirth, idDocumentType, … }
+
+**ROUND_TRIP**
+- Above + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, returnSeatClassId
+- passengers[]: { seatId (outbound), returnSeatId (return), passengerName, … }
+- Combined fare = outbound fare + return fare; single promo/loyalty deduction
+
+**TRANSIT** (connecting train, single PNR)
+- scheduleId/holdId for leg-1 + leg2ScheduleId, leg2HoldId, transitStationId, leg2DestinationStationId
+- passengers[]: { seatId (leg-1), leg2SeatId (leg-2), passengerName, … }
+
+**ROUND_TRIP_TRANSIT** (round trip, each direction via connecting train)
+- All TRANSIT outbound fields + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, returnLeg2ScheduleId, returnLeg2HoldId, returnTransitStationId, returnLeg2DestinationStationId
+- passengers[]: { seatId, leg2SeatId, returnSeatId, returnLeg2SeatId, passengerName, … }
+- 4 holds required, 4 seat sets per passenger, single PNR, single payment
+
+**Age-Based Pricing (all types)**
+- ADULT (≥5 years): full fare per leg
+- CHILD (<5 years): first child FREE per booking, subsequent children full fare`
+  })
+  @ApiBody({
+    type: CreateBookingDto,
+    examples: {
+      ONE_WAY: {
+        summary: 'ONE_WAY — single direct journey',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'schedule-uuid',
+          holdId: 'hold-uuid',
+          originStationId: 'station-uuid',
+          destinationStationId: 'station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ONE_WAY',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+      ROUND_TRIP: {
+        summary: 'ROUND_TRIP — outbound + return, single PNR',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'outbound-schedule-uuid',
+          holdId: 'outbound-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'djibouti-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP',
+          returnScheduleId: 'return-schedule-uuid',
+          returnHoldId: 'return-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'addis-station-uuid',
+          returnSeatClassId: 'seat-class-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'outbound-seat-uuid',
+            returnSeatId: 'return-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+      TRANSIT: {
+        summary: 'TRANSIT — connecting train, single PNR',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'leg1-schedule-uuid',
+          holdId: 'leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'TRANSIT',
+          leg2ScheduleId: 'leg2-schedule-uuid',
+          leg2HoldId: 'leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'leg1-seat-uuid',
+            leg2SeatId: 'leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+      ROUND_TRIP_TRANSIT: {
+        summary: 'ROUND_TRIP_TRANSIT — round trip via connecting trains, 4 holds',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'ob-leg1-schedule-uuid',
+          holdId: 'ob-leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP_TRANSIT',
+          leg2ScheduleId: 'ob-leg2-schedule-uuid',
+          leg2HoldId: 'ob-leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          returnScheduleId: 'ret-leg1-schedule-uuid',
+          returnHoldId: 'ret-leg1-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'diredawa-station-uuid',
+          returnLeg2ScheduleId: 'ret-leg2-schedule-uuid',
+          returnLeg2HoldId: 'ret-leg2-hold-uuid',
+          returnTransitStationId: 'diredawa-station-uuid',
+          returnLeg2DestinationStationId: 'addis-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'ob-leg1-seat-uuid',
+            leg2SeatId: 'ob-leg2-seat-uuid',
+            returnSeatId: 'ret-leg1-seat-uuid',
+            returnLeg2SeatId: 'ret-leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+    },
   })
   @ApiResponse({ status: 201, description: 'Booking created with fare breakdown' })
-  @ApiResponse({ status: 400, description: 'Verifayda verification failed or invalid passenger data' })
-  @ApiResponse({ status: 404, description: 'Trip or seat hold not found' })
+  @ApiResponse({ status: 400, description: 'Missing required fields for bookingType, or Verifayda verification failed' })
+  @ApiResponse({ status: 404, description: 'Schedule or seat hold not found' })
   create(@Body() dto: CreateBookingDto) { 
     return this.service.create(dto); 
   }

apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts

@@ -4,7 +4,10 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Currency, IdDocumentType } from '@prisma/client';
 
 export class PassengerInputDto {
-  @ApiProperty() @IsString() seatId: string;
+  @ApiProperty({ example: 'seat-uuid', description: 'Outbound / leg-1 seat ID (all booking types)' }) @IsString() seatId: string;
+  @ApiPropertyOptional({ example: 'leg2-seat-uuid', description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Outbound leg-2 seat ID' }) @IsOptional() @IsString() leg2SeatId?: string;
+  @ApiPropertyOptional({ example: 'return-seat-uuid', description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return leg-1 seat ID' }) @IsOptional() @IsString() returnSeatId?: string;
+  @ApiPropertyOptional({ example: 'ret-leg2-seat-uuid', description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat ID' }) @IsOptional() @IsString() returnLeg2SeatId?: string;
   @ApiProperty({ example: 'Abebe Kebede' }) @IsString() passengerName: string;
   @ApiProperty({ example: '1990-05-15', description: 'Date of birth (YYYY-MM-DD) for age calculation. Age <5 = CHILD (first free), Age ≥5 = ADULT (full fare)' }) @IsDateString() dateOfBirth: string;
   @ApiProperty({ example: 'NATIONAL_ID', enum: IdDocumentType, description: 'NATIONAL_ID for Ethiopians (Verifayda verified), PASSPORT for others' }) @IsEnum(IdDocumentType) idDocumentType: IdDocumentType;
@@ -14,19 +17,170 @@ export class PassengerInputDto {
   @ApiPropertyOptional({ example: 'Ethiopian', description: 'Ethiopian (Verifayda + Telebirr/CBE/eBirr), Djiboutian (Passport + Waafi), Other (Passport + Card)' }) @IsOptional() @IsString() nationality?: string;
 }
 
+export class RoundTripPassengerDto {
+  @ApiProperty({ description: 'Outbound journey seat ID', example: 'seat-uuid-outbound' }) 
+  @IsString() outboundSeatId: string;
+  
+  @ApiProperty({ description: 'Return journey seat ID', example: 'seat-uuid-return' }) 
+  @IsString() returnSeatId: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Outbound leg-2 seat ID' })
+  @IsOptional() @IsString() outboundLeg2SeatId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat ID' })
+  @IsOptional() @IsString() returnLeg2SeatId?: string;
+  
+  @ApiProperty({ 
+    example: 'Abebe Kebede',
+    description: 'Full passenger name (will be verified via Verifayda for Ethiopian nationals)'
+  }) 
+  @IsString() passengerName: string;
+  
+  @ApiProperty({ 
+    example: '1990-05-15', 
+    description: 'Date of birth (YYYY-MM-DD) for age calculation. Age <5 = CHILD (first child FREE), Age ≥5 = ADULT (full fare for both legs)'
+  }) 
+  @IsDateString() dateOfBirth: string;
+  
+  @ApiProperty({ 
+    example: 'NATIONAL_ID', 
+    enum: IdDocumentType,
+    description: 'NATIONAL_ID for Ethiopians (Verifayda verified), PASSPORT for others'
+  }) 
+  @IsEnum(IdDocumentType) idDocumentType: IdDocumentType;
+  
+  @ApiPropertyOptional({ 
+    example: 'ET123456789', 
+    description: 'Ethiopian national ID - verified via Verifayda 2.0 (NOT stored in database)' 
+  }) 
+  @IsOptional() @IsString() idDocumentNumber?: string;
+  
+  @ApiPropertyOptional({ 
+    example: 'P1234567', 
+    description: 'Passport number for non-Ethiopian passengers (no verification)' 
+  }) 
+  @IsOptional() @IsString() passportNumber?: string;
+  
+  @ApiPropertyOptional({ 
+    example: 'Djibouti', 
+    description: 'Passport issuing country for non-Ethiopians' 
+  }) 
+  @IsOptional() @IsString() passportCountry?: string;
+  
+  @ApiPropertyOptional({ 
+    example: 'Ethiopian', 
+    description: 'Ethiopian (Verifayda + Telebirr/CBE/eBirr), Djiboutian (Passport + Waafi), Other (Passport + Card)' 
+  }) 
+  @IsOptional() @IsString() nationality?: string;
+}
+
 export class CreateBookingDto {
-  @ApiProperty() @IsString() passengerId: string;
-  @ApiProperty() @IsString() scheduleId: string;
-  @ApiProperty() @IsString() holdId: string;
-  @ApiProperty({ example: 'station-uuid', description: 'Origin station UUID for this leg (must match the hold)' }) @IsString() originStationId: string;
-  @ApiProperty({ example: 'station-uuid', description: 'Destination station UUID for this leg (must match the hold)' }) @IsString() destinationStationId: string;
-  @ApiProperty({ type: [PassengerInputDto], description: 'Array of passengers with age-based categorization. First child (<5 years) travels FREE.' }) @IsArray() @ValidateNested({ each: true }) @Type(() => PassengerInputDto) passengers: PassengerInputDto[];
-  @ApiProperty({ example: 'seat-class-uuid', description: 'Seat class UUID (Economy Regular, Economy Bed, VIP Bed)' })
+  @ApiProperty({ description: 'Passenger ID' }) 
+  @IsString() passengerId: string;
+  
+  @ApiProperty({ description: 'Outbound / leg-1 schedule ID' }) 
+  @IsString() scheduleId: string;
+  
+  @ApiProperty({ description: 'Outbound / leg-1 seat hold ID' }) 
+  @IsString() holdId: string;
+  
+  @ApiProperty({ example: 'station-uuid', description: 'Outbound origin station UUID' }) 
+  @IsString() originStationId: string;
+  
+  @ApiProperty({ example: 'station-uuid', description: 'Outbound destination station UUID' }) 
+  @IsString() destinationStationId: string;
+  
+  @ApiProperty({ example: 'seat-class-uuid', description: 'Outbound seat class UUID (Economy Regular, Economy Bed, VIP Bed)' })
   @IsString() seatClassId: string;
-  @ApiPropertyOptional() @IsOptional() @IsString() promoCode?: string;
-  @ApiPropertyOptional() @IsOptional() @IsInt() loyaltyRedemptionPoints?: number;
-  @ApiPropertyOptional({ example: 'ONE_WAY' }) @IsOptional() @IsString() bookingType?: string;
-  @ApiPropertyOptional({ example: 'DJF', enum: Currency, description: 'Display currency for fare breakdown (ETB, DJF, USD). Transaction always in ETB.' }) @IsOptional() @IsEnum(Currency) displayCurrency?: Currency;
+
+  @ApiProperty({ 
+    example: 'ONE_WAY', 
+    enum: ['ONE_WAY', 'ROUND_TRIP', 'TRANSIT', 'ROUND_TRIP_TRANSIT'],
+    description: `Booking type:
+
+**ONE_WAY:** Single direct journey — needs: scheduleId, holdId. Passenger: seatId.
+
+**ROUND_TRIP:** Outbound + return, single PNR — needs above + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId. Passenger: seatId + returnSeatId.
+
+**TRANSIT:** Single journey via connecting train, single PNR — needs above + leg2ScheduleId, leg2HoldId, transitStationId, leg2DestinationStationId. Passenger: seatId + leg2SeatId.
+
+**ROUND_TRIP_TRANSIT:** Round trip via connecting trains — needs all 4 hold sets + all station fields. Passenger: seatId + leg2SeatId + returnSeatId + returnLeg2SeatId.`,
+    default: 'ONE_WAY'
+  }) 
+  @IsOptional() @IsString() bookingType?: string;
+  
+  @ApiProperty({ 
+    type: [PassengerInputDto], 
+    description: `Passenger array — required seat fields vary by bookingType:
+
+**ONE_WAY:** { seatId, passengerName, dateOfBirth, idDocumentType, … }
+
+**ROUND_TRIP:** { seatId (outbound leg-1), returnSeatId (return leg-1), passengerName, … }
+
+**TRANSIT:** { seatId (leg-1), leg2SeatId (leg-2), passengerName, … }
+
+**ROUND_TRIP_TRANSIT:** { seatId, leg2SeatId, returnSeatId, returnLeg2SeatId, passengerName, … }
+
+**Age-based pricing:** First child (<5 years) travels FREE, subsequent children pay full fare.`
+  }) 
+  @IsArray() @ValidateNested({ each: true }) @Type(() => PassengerInputDto) 
+  passengers: PassengerInputDto[];
+
+  @ApiPropertyOptional({ description: 'Promo code for discount (applies to combined fare for round-trip)' }) 
+  @IsOptional() @IsString() promoCode?: string;
+  
+  @ApiPropertyOptional({ description: 'Loyalty points to redeem (applies to combined fare for round-trip)' }) 
+  @IsOptional() @IsInt() loyaltyRedemptionPoints?: number;
+  
+  @ApiPropertyOptional({ example: 'DJF', enum: Currency, description: 'Display currency for fare breakdown (ETB, DJF, USD). Transaction always in ETB.' }) 
+  @IsOptional() @IsEnum(Currency) displayCurrency?: Currency;
+
+  // Transit-specific fields
+  @ApiPropertyOptional({ description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Leg-2 schedule ID' })
+  @IsOptional() @IsString() leg2ScheduleId?: string;
+
+  @ApiPropertyOptional({ description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Leg-2 seat hold ID' })
+  @IsOptional() @IsString() leg2HoldId?: string;
+
+  @ApiPropertyOptional({ description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Transit (connecting) station UUID' })
+  @IsOptional() @IsString() transitStationId?: string;
+
+  @ApiPropertyOptional({ description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Leg-2 destination station UUID' })
+  @IsOptional() @IsString() leg2DestinationStationId?: string;
+
+  @ApiPropertyOptional({ description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Leg-2 seat class ID (defaults to outbound seatClassId)' })
+  @IsOptional() @IsString() leg2SeatClassId?: string;
+
+  // Round-trip transit: return direction transit fields
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-1 schedule ID' })
+  @IsOptional() @IsString() returnScheduleId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return origin station ID' })
+  @IsOptional() @IsString() returnOriginStationId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return destination station ID' })
+  @IsOptional() @IsString() returnDestinationStationId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return seat hold ID' })
+  @IsOptional() @IsString() returnHoldId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return seat class ID' })
+  @IsOptional() @IsString() returnSeatClassId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-2 schedule ID' })
+  @IsOptional() @IsString() returnLeg2ScheduleId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat hold ID' })
+  @IsOptional() @IsString() returnLeg2HoldId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return transit (connecting) station UUID' })
+  @IsOptional() @IsString() returnTransitStationId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-2 destination station UUID' })
+  @IsOptional() @IsString() returnLeg2DestinationStationId?: string;
+
+  @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat class ID' })
+  @IsOptional() @IsString() returnLeg2SeatClassId?: string;
 }
 
 export class ModifyBookingDto {

apps/edr-passenger-api/src/modules/bookings/bookings.module.ts

@@ -1,5 +1,6 @@
 import { Module } from '@nestjs/common';
 import { HttpModule } from '@nestjs/axios';
+import { AuditModule } from '../../common/audit.module';
 import { BookingsController } from './bookings.controller';
 import { BookingsService } from './bookings.service';
 import { GuestBookingService } from './guest-booking.service';
@@ -7,9 +8,10 @@ import { SeatsModule } from '../seats/seats.module';
 import { VerifaydaModule } from '../verifayda/verifayda.module';
 import { CurrencyModule } from '../currency/currency.module';
 import { AuthModule } from '../auth/auth.module';
+import { FareEngineModule } from '../fare-engine/fare-engine.module';
 
 @Module({
-  imports: [SeatsModule, VerifaydaModule, CurrencyModule, HttpModule, AuthModule],
+  imports: [AuditModule, SeatsModule, VerifaydaModule, CurrencyModule, FareEngineModule, HttpModule, AuthModule],
   controllers: [BookingsController],
   providers: [BookingsService, GuestBookingService],
   exports: [BookingsService, GuestBookingService]

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

@@ -8,6 +8,7 @@ import { CreateBookingDto, ModifyBookingDto } from './bookings.dto';
 import { Cron, CronExpression } from '@nestjs/schedule';
 import { VerifaydaService } from '../verifayda/verifayda.service';
 import { CurrencyService } from '../currency/currency.service';
+import { FareEngineService } from '../fare-engine/fare-engine.service';
 import { Currency, PassengerCategory, IdDocumentType } from '@prisma/client';
 
 function generateRef(): string {
@@ -26,6 +27,7 @@ function calculateAge(dateOfBirth: Date): number {
 interface BookingFilters {
   search?: string;
   status?: string;
+  returnLegStatus?: string;
   page?: number;
   pageSize?: number;
 }
@@ -39,6 +41,7 @@ export class BookingsService {
     private readonly eventEmitter: EventEmitter2,
     private readonly verifaydaService: VerifaydaService,
     private readonly currencyService: CurrencyService,
+    private readonly fareEngine: FareEngineService,
   ) {}
 
   async findByPassengerId(passengerId: string, filters: BookingFilters = {}) {
@@ -85,6 +88,8 @@ export class BookingsService {
         displayTotalMinor: booking.displayTotalMinor,
         adultCount: booking.adultCount,
         childCount: booking.childCount,
+        bookingType: booking.bookingType,
+        returnLegStatus: (booking as any).returnLegStatus ?? null,
         createdAt: booking.createdAt,
         schedule: {
           train: booking.schedule.train,
@@ -162,6 +167,8 @@ export class BookingsService {
         displayTotalMinor: booking.displayTotalMinor,
         adultCount: booking.adultCount,
         childCount: booking.childCount,
+        bookingType: booking.bookingType,
+        returnLegStatus: (booking as any).returnLegStatus ?? null,
         createdAt: booking.createdAt,
         schedule: {
           train: booking.schedule.train,
@@ -183,7 +190,7 @@ export class BookingsService {
   }
 
   async findAll(filters: BookingFilters = {}) {
-    const { search, status, page = 1, pageSize = 20 } = filters;
+    const { search, status, returnLegStatus, page = 1, pageSize = 20 } = filters;
     const skip = (page - 1) * pageSize;
     
     const where: any = {};
@@ -197,9 +204,8 @@ export class BookingsService {
       ];
     }
     
-    if (status) {
-      where.status = status;
-    }
+    if (status) where.status = status;
+    if (returnLegStatus) (where as any).returnLegStatus = returnLegStatus;
     
     const [items, total] = await Promise.all([
       this.prisma.booking.findMany({
@@ -239,6 +245,10 @@ export class BookingsService {
           displayTotalMinor: booking.displayTotalMinor,
           contactEmail: booking.contactEmail,
           contactPhone: booking.contactPhone,
+          bookingType: booking.bookingType,
+          returnLegStatus: (booking as any).returnLegStatus ?? null,
+          adultCount: booking.adultCount,
+          childCount: booking.childCount,
           createdAt: booking.createdAt,
           passenger: iam
             ? { fullName: iam.name?.en ?? iam.name?.am ?? null, email: iam.email, phone: iam.phone_number }
@@ -263,15 +273,19 @@ export class BookingsService {
   }
 
   async create(dto: CreateBookingDto) {
+    if (dto.bookingType === 'ROUND_TRIP')         return this.createRoundTripBooking(dto);
+    if (dto.bookingType === 'TRANSIT')            return this.createTransitBooking(dto);
+    if (dto.bookingType === 'ROUND_TRIP_TRANSIT') return this.createRoundTripTransitBooking(dto);
+    return this.createOneWayBooking(dto);
+  }
+
+  private async createOneWayBooking(dto: CreateBookingDto) {
     const hold = await this.prisma.seatHold.findUnique({ where: { id: dto.holdId } });
     if (!hold || hold.expiresAt < new Date()) throw new BadRequestException('Seat hold expired');
+    
     const schedule = await this.prisma.trainSchedule.findUnique({
       where: { id: dto.scheduleId },
-      include: {
-        originStation: true,
-        destinationStation: true,
-        stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
-      },
+      include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } }
     });
     if (!schedule) throw new NotFoundException('Schedule not found');
 
@@ -279,18 +293,498 @@ export class BookingsService {
     const destStop = schedule.stopTimes.find(s => s.stationId === dto.destinationStationId);
     if (!originStop || !destStop) throw new NotFoundException('Origin or destination not found');
 
-    const segmentRoute = `${originStop.station.code}-${destStop.station.code}`;
-    const fullRoute = `${schedule.originStation.code}-${schedule.destinationStation.code}`;
+    const passengersData = await this.processPassengers(dto.passengers as any[]);
+    const { adultCount, childCount } = this.countPassengers(passengersData);
+    const fareCalculation = await this.calculateFare(dto.scheduleId, dto.seatClassId, originStop, destStop, passengersData[0]?.nationality, adultCount, childCount, dto.promoCode, dto.loyaltyRedemptionPoints);
+    
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    let displayTotalMinor = fareCalculation.totalMinor;
+    if (displayCurrency !== Currency.ETB) {
+      displayTotalMinor = await this.currencyService.convertAmount(fareCalculation.totalMinor, Currency.ETB, displayCurrency);
+    }
 
-    const seatIds = dto.passengers.map((p) => p.seatId);
-    const passengersData = [];
-    let adultCount = 0, childCount = 0;
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef: generateRef(),
+        passengerId: dto.passengerId,
+        scheduleId: dto.scheduleId,
+        status: 'PENDING_PAYMENT',
+        bookingType: 'ONE_WAY',
+        totalMinor: fareCalculation.totalMinor,
+        adultCount,
+        childCount,
+        displayCurrency,
+        displayTotalMinor,
+        seats: {
+          create: passengersData.map(p => ({
+            seat: { connect: { id: p.seatId } },
+            passengerName: p.passengerName,
+            dateOfBirth: p.dateOfBirth,
+            passengerCategory: p.category,
+            idDocumentType: p.idDocumentType,
+            passportNumber: p.passportNumber,
+            passportCountry: p.passportCountry,
+            verifaydaVerified: p.verifaydaVerified,
+            verifaydaData: p.verifaydaData,
+            fareMinor: p.category === PassengerCategory.ADULT ? fareCalculation.baseFareMinor : (fareCalculation.paidChildrenCount > 0 ? fareCalculation.baseFareMinor : 0),
+            displayCurrency
+          }))
+        }
+      },
+      include: { seats: { include: { seat: true } }, schedule: { include: { originStation: true, destinationStation: true, train: true } } }
+    });
 
-    for (const passenger of dto.passengers) {
+    await this.seatsService.confirmSeats(passengersData.map(p => p.seatId));
+    this.eventEmitter.emit('booking.created', { booking });
+    return { ...booking, fareBreakdown: fareCalculation };
+  }
+
+  private async createRoundTripBooking(dto: CreateBookingDto) {
+    if (!dto.returnScheduleId || !dto.returnHoldId || !dto.returnOriginStationId || !dto.returnDestinationStationId) {
+      throw new BadRequestException('Return trip details required for round-trip booking');
+    }
+
+    const [outboundHold, returnHold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnHoldId } })
+    ]);
+    
+    if (!outboundHold || outboundHold.expiresAt < new Date()) throw new BadRequestException('Outbound seat hold expired');
+    if (!returnHold || returnHold.expiresAt < new Date()) throw new BadRequestException('Return seat hold expired');
+
+    const [outboundSchedule, returnSchedule] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.scheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } }
+      }),
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.returnScheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } }
+      })
+    ]);
+
+    if (!outboundSchedule || !returnSchedule) throw new NotFoundException('Schedule not found');
+
+    const outboundOriginStop = outboundSchedule.stopTimes.find(s => s.stationId === dto.originStationId);
+    const outboundDestStop = outboundSchedule.stopTimes.find(s => s.stationId === dto.destinationStationId);
+    const returnOriginStop = returnSchedule.stopTimes.find(s => s.stationId === dto.returnOriginStationId);
+    const returnDestStop = returnSchedule.stopTimes.find(s => s.stationId === dto.returnDestinationStationId);
+
+    if (!outboundOriginStop || !outboundDestStop || !returnOriginStop || !returnDestStop) {
+      throw new NotFoundException('Origin or destination stops not found');
+    }
+
+    const passengersData = await this.processRoundTripPassengers(dto.passengers as any[]);
+    const { adultCount, childCount } = this.countPassengers(passengersData);
+
+    const [outboundFare, returnFare] = await Promise.all([
+      this.calculateFare(dto.scheduleId, dto.seatClassId, outboundOriginStop, outboundDestStop, passengersData[0]?.nationality, adultCount, childCount),
+      this.calculateFare(dto.returnScheduleId, dto.returnSeatClassId || dto.seatClassId, returnOriginStop, returnDestStop, passengersData[0]?.nationality, adultCount, childCount)
+    ]);
+
+    const combinedBaseFareMinor = outboundFare.totalBaseFareMinor + returnFare.totalBaseFareMinor;
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff ? Math.round(combinedBaseFareMinor * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
+      }
+    }
+
+    const loyaltyMinor = (dto.loyaltyRedemptionPoints ?? 0) * 10;
+    const taxesMinor = Math.round(combinedBaseFareMinor * 0.05);
+    const totalMinor = Math.max(0, combinedBaseFareMinor - discountMinor - loyaltyMinor + taxesMinor);
+
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    let displayTotalMinor = totalMinor;
+    if (displayCurrency !== Currency.ETB) {
+      displayTotalMinor = await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency);
+    }
+
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef: generateRef(),
+        passengerId: dto.passengerId,
+        scheduleId: dto.scheduleId,
+        status: 'PENDING_PAYMENT',
+        bookingType: 'ROUND_TRIP',
+        totalMinor,
+        adultCount,
+        childCount,
+        displayCurrency,
+        displayTotalMinor,
+        returnScheduleId: dto.returnScheduleId,
+        returnOriginStationId: dto.returnOriginStationId,
+        returnDestinationStationId: dto.returnDestinationStationId,
+        returnHoldId: dto.returnHoldId,
+        returnSeatClassId: dto.returnSeatClassId,
+        returnLegStatus: 'NEITHER_USED',
+        seats: {
+          create: [
+            ...passengersData.map(p => ({
+              seat: { connect: { id: p.outboundSeatId } },
+              leg: 1,
+              scheduleId: dto.scheduleId,
+              passengerName: p.passengerName,
+              dateOfBirth: p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType: p.idDocumentType,
+              passportNumber: p.passportNumber,
+              passportCountry: p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData: p.verifaydaData,
+              fareMinor: p.category === PassengerCategory.ADULT ? outboundFare.baseFareMinor : (outboundFare.paidChildrenCount > 0 ? outboundFare.baseFareMinor : 0),
+              displayCurrency,
+            })),
+            ...passengersData.map(p => ({
+              seat: { connect: { id: p.returnSeatId } },
+              leg: 2,
+              scheduleId: dto.returnScheduleId,
+              passengerName: p.passengerName,
+              dateOfBirth: p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType: p.idDocumentType,
+              passportNumber: p.passportNumber,
+              passportCountry: p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData: p.verifaydaData,
+              fareMinor: p.category === PassengerCategory.ADULT ? returnFare.baseFareMinor : (returnFare.paidChildrenCount > 0 ? returnFare.baseFareMinor : 0),
+              displayCurrency,
+            })),
+          ],
+        },
+      } as any,
+      include: { seats: { include: { seat: true } }, schedule: { include: { originStation: true, destinationStation: true, train: true } } }
+    });
+
+    const outboundSeatIds = passengersData.map(p => p.outboundSeatId);
+    const returnSeatIds = passengersData.map(p => p.returnSeatId);
+    await Promise.all([
+      this.seatsService.confirmSeats(outboundSeatIds),
+      this.seatsService.confirmSeats(returnSeatIds)
+    ]);
+
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      fareBreakdown: {
+        outboundFare: outboundFare.baseFareMinor,
+        returnFare: returnFare.baseFareMinor,
+        combinedBaseFareMinor,
+        discountMinor,
+        loyaltyRedemptionMinor: loyaltyMinor,
+        taxesFeesMinor: taxesMinor,
+        totalMinor,
+        currency: 'ETB',
+        displayCurrency,
+        displayTotalMinor
+      }
+    };
+  }
+
+  private async createTransitBooking(dto: CreateBookingDto) {
+    if (!dto.leg2ScheduleId || !dto.leg2HoldId || !dto.transitStationId || !dto.leg2DestinationStationId) {
+      throw new BadRequestException('leg2ScheduleId, leg2HoldId, transitStationId and leg2DestinationStationId are required for TRANSIT bookings');
+    }
+
+    const [leg1Hold, leg2Hold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.leg2HoldId } }),
+    ]);
+    if (!leg1Hold || leg1Hold.expiresAt < new Date()) throw new BadRequestException('Leg-1 seat hold expired');
+    if (!leg2Hold || leg2Hold.expiresAt < new Date()) throw new BadRequestException('Leg-2 seat hold expired');
+
+    const [leg1Schedule, leg2Schedule] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.scheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.leg2ScheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+    ]);
+    if (!leg1Schedule) throw new NotFoundException('Leg-1 schedule not found');
+    if (!leg2Schedule) throw new NotFoundException('Leg-2 schedule not found');
+
+    const leg1OriginStop = leg1Schedule.stopTimes.find(s => s.stationId === dto.originStationId);
+    const leg1DestStop   = leg1Schedule.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const leg2OriginStop = leg2Schedule.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const leg2DestStop   = leg2Schedule.stopTimes.find(s => s.stationId === dto.leg2DestinationStationId);
+    if (!leg1OriginStop || !leg1DestStop) throw new NotFoundException('Leg-1 origin or transit station not found on schedule');
+    if (!leg2OriginStop || !leg2DestStop) throw new NotFoundException('Transit or leg-2 destination station not found on leg-2 schedule');
+
+    const passengersData = await this.processPassengers(dto.passengers as any[]);
+    const { adultCount, childCount } = this.countPassengers(passengersData);
+
+    const leg2SeatClassId = dto.leg2SeatClassId ?? dto.seatClassId;
+    const [leg1Fare, leg2Fare] = await Promise.all([
+      this.calculateFare(dto.scheduleId, dto.seatClassId, leg1OriginStop, leg1DestStop, passengersData[0]?.nationality, adultCount, childCount),
+      this.calculateFare(dto.leg2ScheduleId, leg2SeatClassId, leg2OriginStop, leg2DestStop, passengersData[0]?.nationality, adultCount, childCount),
+    ]);
+
+    const combinedBase = leg1Fare.totalBaseFareMinor + leg2Fare.totalBaseFareMinor;
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff ? Math.round(combinedBase * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
+      }
+    }
+    const loyaltyMinor    = (dto.loyaltyRedemptionPoints ?? 0) * 10;
+    const taxesMinor      = Math.round(combinedBase * 0.05);
+    const totalMinor      = Math.max(0, combinedBase - discountMinor - loyaltyMinor + taxesMinor);
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    // Single booking — leg-1 seats at leg=1, leg-2 seats at leg=2
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef: generateRef(),
+        passengerId: dto.passengerId,
+        scheduleId: dto.scheduleId,
+        status: 'PENDING_PAYMENT',
+        bookingType: 'TRANSIT',
+        totalMinor,
+        adultCount,
+        childCount,
+        displayCurrency,
+        displayTotalMinor,
+        leg2ScheduleId: dto.leg2ScheduleId,
+        leg2OriginStationId: dto.transitStationId,
+        leg2DestinationStationId: dto.leg2DestinationStationId,
+        leg2SeatClassId,
+        seats: {
+          create: [
+            ...passengersData.map(p => ({
+              seat: { connect: { id: p.seatId } },
+              leg: 1,
+              scheduleId: dto.scheduleId,
+              passengerName: p.passengerName,
+              dateOfBirth: p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType: p.idDocumentType,
+              passportNumber: p.passportNumber,
+              passportCountry: p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData: p.verifaydaData,
+              fareMinor: p.category === PassengerCategory.ADULT ? leg1Fare.baseFareMinor : (leg1Fare.paidChildrenCount > 0 ? leg1Fare.baseFareMinor : 0),
+              displayCurrency,
+            })),
+            ...passengersData.map(p => ({
+              seat: { connect: { id: p.leg2SeatId ?? p.seatId } },
+              leg: 2,
+              scheduleId: dto.leg2ScheduleId,
+              passengerName: p.passengerName,
+              dateOfBirth: p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType: p.idDocumentType,
+              passportNumber: p.passportNumber,
+              passportCountry: p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData: p.verifaydaData,
+              fareMinor: p.category === PassengerCategory.ADULT ? leg2Fare.baseFareMinor : (leg2Fare.paidChildrenCount > 0 ? leg2Fare.baseFareMinor : 0),
+              displayCurrency,
+            })),
+          ],
+        },
+      } as any,
+      include: { seats: { include: { seat: true } }, schedule: { include: { originStation: true, destinationStation: true, train: true } } },
+    });
+
+    await Promise.all([
+      this.seatsService.confirmSeats(passengersData.map(p => p.seatId)),
+      this.seatsService.confirmSeats(passengersData.map(p => p.leg2SeatId ?? p.seatId)),
+    ]);
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      fareBreakdown: {
+        leg1BaseFareMinor: leg1Fare.baseFareMinor,
+        leg2BaseFareMinor: leg2Fare.baseFareMinor,
+        adultCount, childCount,
+        freeChildrenCount: Math.min(childCount, 1),
+        paidChildrenCount: leg1Fare.paidChildrenCount,
+        combinedBaseFareMinor: combinedBase,
+        discountMinor, loyaltyRedemptionMinor: loyaltyMinor,
+        taxesFeesMinor: taxesMinor, totalMinor,
+        currency: 'ETB', displayCurrency, displayTotalMinor,
+      },
+    };
+  }
+
+  private async createRoundTripTransitBooking(dto: CreateBookingDto) {
+    if (!dto.leg2ScheduleId || !dto.leg2HoldId || !dto.transitStationId || !dto.leg2DestinationStationId ||
+        !dto.returnScheduleId || !dto.returnHoldId || !dto.returnOriginStationId || !dto.returnDestinationStationId ||
+        !dto.returnLeg2ScheduleId || !dto.returnLeg2HoldId || !dto.returnTransitStationId || !dto.returnLeg2DestinationStationId) {
+      throw new BadRequestException(
+        'ROUND_TRIP_TRANSIT requires outbound transit fields (leg2ScheduleId, leg2HoldId, transitStationId, leg2DestinationStationId) ' +
+        'AND return transit fields (returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, ' +
+        'returnLeg2ScheduleId, returnLeg2HoldId, returnTransitStationId, returnLeg2DestinationStationId)',
+      );
+    }
+
+    // Validate all 4 holds
+    const [obL1Hold, obL2Hold, retL1Hold, retL2Hold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.leg2HoldId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnHoldId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnLeg2HoldId } }),
+    ]);
+    const now = new Date();
+    if (!obL1Hold  || obL1Hold.expiresAt  < now) throw new BadRequestException('Outbound leg-1 seat hold expired');
+    if (!obL2Hold  || obL2Hold.expiresAt  < now) throw new BadRequestException('Outbound leg-2 seat hold expired');
+    if (!retL1Hold || retL1Hold.expiresAt < now) throw new BadRequestException('Return leg-1 seat hold expired');
+    if (!retL2Hold || retL2Hold.expiresAt < now) throw new BadRequestException('Return leg-2 seat hold expired');
+
+    // Load all 4 schedules
+    const [obL1Sched, obL2Sched, retL1Sched, retL2Sched] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.scheduleId }, include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.leg2ScheduleId }, include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.returnScheduleId }, include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.returnLeg2ScheduleId }, include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+    ]);
+    if (!obL1Sched)  throw new NotFoundException('Outbound leg-1 schedule not found');
+    if (!obL2Sched)  throw new NotFoundException('Outbound leg-2 schedule not found');
+    if (!retL1Sched) throw new NotFoundException('Return leg-1 schedule not found');
+    if (!retL2Sched) throw new NotFoundException('Return leg-2 schedule not found');
+
+    const obL1Origin  = obL1Sched.stopTimes.find(s => s.stationId === dto.originStationId);
+    const obL1Dest    = obL1Sched.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const obL2Origin  = obL2Sched.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const obL2Dest    = obL2Sched.stopTimes.find(s => s.stationId === dto.leg2DestinationStationId);
+    const retL1Origin = retL1Sched.stopTimes.find(s => s.stationId === dto.returnOriginStationId);
+    const retL1Dest   = retL1Sched.stopTimes.find(s => s.stationId === dto.returnTransitStationId);
+    const retL2Origin = retL2Sched.stopTimes.find(s => s.stationId === dto.returnTransitStationId);
+    const retL2Dest   = retL2Sched.stopTimes.find(s => s.stationId === dto.returnLeg2DestinationStationId);
+    if (!obL1Origin || !obL1Dest)   throw new NotFoundException('Outbound leg-1: origin or transit station not found');
+    if (!obL2Origin || !obL2Dest)   throw new NotFoundException('Outbound leg-2: transit or destination not found');
+    if (!retL1Origin || !retL1Dest) throw new NotFoundException('Return leg-1: origin or transit station not found');
+    if (!retL2Origin || !retL2Dest) throw new NotFoundException('Return leg-2: transit or destination not found');
+
+    const passengersData = await this.processRoundTripPassengers(dto.passengers as any[]);
+    const { adultCount, childCount } = this.countPassengers(passengersData);
+    const nat = passengersData[0]?.nationality;
+
+    const obL2SeatClassId  = dto.leg2SeatClassId        ?? dto.seatClassId;
+    const retL1SeatClassId = dto.returnSeatClassId       ?? dto.seatClassId;
+    const retL2SeatClassId = dto.returnLeg2SeatClassId   ?? dto.seatClassId;
+
+    const [obL1Fare, obL2Fare, retL1Fare, retL2Fare] = await Promise.all([
+      this.calculateFare(dto.scheduleId,          dto.seatClassId,   obL1Origin,  obL1Dest,  nat, adultCount, childCount),
+      this.calculateFare(dto.leg2ScheduleId,       obL2SeatClassId,  obL2Origin,  obL2Dest,  nat, adultCount, childCount),
+      this.calculateFare(dto.returnScheduleId,     retL1SeatClassId, retL1Origin, retL1Dest, nat, adultCount, childCount),
+      this.calculateFare(dto.returnLeg2ScheduleId, retL2SeatClassId, retL2Origin, retL2Dest, nat, adultCount, childCount),
+    ]);
+
+    const combinedBase = obL1Fare.totalBaseFareMinor + obL2Fare.totalBaseFareMinor +
+                         retL1Fare.totalBaseFareMinor + retL2Fare.totalBaseFareMinor;
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff ? Math.round(combinedBase * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
+      }
+    }
+    const loyaltyMinor    = (dto.loyaltyRedemptionPoints ?? 0) * 10;
+    const taxesMinor      = Math.round(combinedBase * 0.05);
+    const totalMinor      = Math.max(0, combinedBase - discountMinor - loyaltyMinor + taxesMinor);
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    const makeSeat = (p: any, seatId: string, leg: number, scheduleId: string, fare: Awaited<ReturnType<BookingsService['calculateFare']>>) => ({
+      seat: { connect: { id: seatId } },
+      leg,
+      scheduleId,
+      passengerName: p.passengerName,
+      dateOfBirth: p.dateOfBirth,
+      passengerCategory: p.category,
+      idDocumentType: p.idDocumentType,
+      passportNumber: p.passportNumber,
+      passportCountry: p.passportCountry,
+      verifaydaVerified: p.verifaydaVerified,
+      verifaydaData: p.verifaydaData,
+      fareMinor: p.category === PassengerCategory.ADULT ? fare.baseFareMinor : (fare.paidChildrenCount > 0 ? fare.baseFareMinor : 0),
+      displayCurrency,
+    });
+
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef: generateRef(),
+        passengerId: dto.passengerId,
+        scheduleId: dto.scheduleId,
+        status: 'PENDING_PAYMENT',
+        bookingType: 'ROUND_TRIP_TRANSIT',
+        totalMinor, adultCount, childCount, displayCurrency, displayTotalMinor,
+        // Outbound transit leg-2
+        leg2ScheduleId: dto.leg2ScheduleId,
+        leg2OriginStationId: dto.transitStationId,
+        leg2DestinationStationId: dto.leg2DestinationStationId,
+        leg2SeatClassId: obL2SeatClassId,
+        // Return transit
+        returnScheduleId: dto.returnScheduleId,
+        returnOriginStationId: dto.returnOriginStationId,
+        returnDestinationStationId: dto.returnDestinationStationId,
+        returnSeatClassId: retL1SeatClassId,
+        returnLeg2ScheduleId: dto.returnLeg2ScheduleId,
+        returnLeg2OriginStationId: dto.returnTransitStationId,
+        returnLeg2DestStationId: dto.returnLeg2DestinationStationId,
+        returnLeg2SeatClassId: retL2SeatClassId,
+        returnLegStatus: 'NEITHER_USED',
+        seats: {
+          create: [
+            // Outbound leg-1 (sequence 1)
+            ...passengersData.map(p => makeSeat(p, p.outboundSeatId, 1, dto.scheduleId, obL1Fare)),
+            // Outbound leg-2 (sequence 2)
+            ...passengersData.map(p => makeSeat(p, p.outboundLeg2SeatId ?? p.outboundSeatId, 2, dto.leg2ScheduleId!, obL2Fare)),
+            // Return leg-1 (sequence 3)
+            ...passengersData.map(p => makeSeat(p, p.returnSeatId, 3, dto.returnScheduleId!, retL1Fare)),
+            // Return leg-2 (sequence 4)
+            ...passengersData.map(p => makeSeat(p, p.returnLeg2SeatId ?? p.returnSeatId, 4, dto.returnLeg2ScheduleId!, retL2Fare)),
+          ],
+        },
+      } as any,
+      include: { seats: { include: { seat: true } }, schedule: { include: { originStation: true, destinationStation: true, train: true } } },
+    });
+
+    await Promise.all([
+      this.seatsService.confirmSeats(passengersData.map(p => p.outboundSeatId)),
+      this.seatsService.confirmSeats(passengersData.map(p => p.outboundLeg2SeatId ?? p.outboundSeatId)),
+      this.seatsService.confirmSeats(passengersData.map(p => p.returnSeatId)),
+      this.seatsService.confirmSeats(passengersData.map(p => p.returnLeg2SeatId ?? p.returnSeatId)),
+    ]);
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      fareBreakdown: {
+        outboundLeg1FareMinor: obL1Fare.baseFareMinor,
+        outboundLeg2FareMinor: obL2Fare.baseFareMinor,
+        returnLeg1FareMinor:   retL1Fare.baseFareMinor,
+        returnLeg2FareMinor:   retL2Fare.baseFareMinor,
+        adultCount, childCount,
+        freeChildrenCount: Math.min(childCount, 1),
+        paidChildrenCount: obL1Fare.paidChildrenCount,
+        combinedBaseFareMinor: combinedBase,
+        discountMinor, loyaltyRedemptionMinor: loyaltyMinor,
+        taxesFeesMinor: taxesMinor, totalMinor,
+        currency: 'ETB', displayCurrency, displayTotalMinor,
+      },
+    };
+  }
+
+  private async processPassengers(passengers: any[]) {
+    const processedPassengers = [];
+    for (const passenger of passengers) {
       const dateOfBirth = new Date(passenger.dateOfBirth);
       const age = calculateAge(dateOfBirth);
       const category: PassengerCategory = age < 5 ? PassengerCategory.CHILD : PassengerCategory.ADULT;
-      if (category === PassengerCategory.ADULT) adultCount++; else childCount++;
 
       let passengerName = passenger.passengerName;
       let verifaydaVerified = false;
@@ -309,68 +803,93 @@ export class BookingsService {
         nationality = nationality || (passenger.passportCountry === 'Djibouti' ? 'Djiboutian' : 'Other');
       }
 
-      passengersData.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
+      processedPassengers.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
     }
+    return processedPassengers;
+  }
 
-    const primaryNationality = passengersData[0]?.nationality;
-    const baseFareMinor = await this.getBaseFare(dto.scheduleId, dto.seatClassId, segmentRoute, fullRoute, primaryNationality);
+  private async processRoundTripPassengers(passengers: any[]) {
+    const processedPassengers = [];
+    for (const passenger of passengers) {
+      const dateOfBirth = new Date(passenger.dateOfBirth);
+      const age = calculateAge(dateOfBirth);
+      const category: PassengerCategory = age < 5 ? PassengerCategory.CHILD : PassengerCategory.ADULT;
+
+      let passengerName = passenger.passengerName;
+      let verifaydaVerified = false;
+      let verifaydaData: Record<string, any> | undefined;
+      let nationality = passenger.nationality;
+
+      if (passenger.idDocumentType === IdDocumentType.NATIONAL_ID && passenger.idDocumentNumber) {
+        const verification = await this.verifaydaService.verifyNationalId(passenger.idDocumentNumber);
+        if (!verification.verified) throw new BadRequestException(`Verifayda verification failed for ${passenger.passengerName}: ${verification.failureReason}`);
+        passengerName = verification.passengerData?.fullName || passengerName;
+        verifaydaVerified = true;
+        verifaydaData = verification.passengerData?.profileData;
+        nationality = nationality || 'Ethiopian';
+      } else if (passenger.idDocumentType === IdDocumentType.PASSPORT) {
+        if (!passenger.passportNumber || !passenger.passportCountry) throw new BadRequestException(`Passport number and country required for ${passenger.passengerName}`);
+        nationality = nationality || (passenger.passportCountry === 'Djibouti' ? 'Djiboutian' : 'Other');
+      }
+
+      processedPassengers.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
+    }
+    return processedPassengers;
+  }
+
+  private countPassengers(passengersData: any[]) {
+    let adultCount = 0, childCount = 0;
+    for (const passenger of passengersData) {
+      if (passenger.category === PassengerCategory.ADULT) adultCount++;
+      else childCount++;
+    }
+    return { adultCount, childCount };
+  }
+
+  private async calculateFare(
+    scheduleId: string,
+    seatClassId: string,
+    originStop: any,
+    destStop: any,
+    nationality?: string,
+    adultCount = 1,
+    childCount = 0,
+    promoCode?: string,
+    loyaltyRedemptionPoints?: number
+  ) {
+    const segmentRoute = `${originStop.station.code}-${destStop.station.code}`;
+    const baseFareMinor = await this.getBaseFare(scheduleId, seatClassId, segmentRoute, undefined, nationality, originStop.sequence, destStop.sequence);
+    
     const adultFareMinor = baseFareMinor * adultCount;
     const paidChildrenCount = Math.max(0, childCount - 1);
     const childFareMinor = baseFareMinor * paidChildrenCount;
     const totalBaseFareMinor = adultFareMinor + childFareMinor;
 
     let discountMinor = 0;
-    if (dto.promoCode) {
-      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+    if (promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: promoCode } });
       if (promo?.active && promo.validUntil > new Date()) {
         discountMinor = promo.percentOff ? Math.round(totalBaseFareMinor * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
       }
     }
 
-    const loyaltyMinor = (dto.loyaltyRedemptionPoints ?? 0) * 10;
+    const loyaltyMinor = (loyaltyRedemptionPoints ?? 0) * 10;
     const taxesMinor = Math.round(totalBaseFareMinor * 0.05);
     const totalMinor = Math.max(0, totalBaseFareMinor - discountMinor - loyaltyMinor + taxesMinor);
 
-    const displayCurrency = dto.displayCurrency || Currency.ETB;
-    let displayTotalMinor = totalMinor;
-    if (displayCurrency !== Currency.ETB) {
-      displayTotalMinor = await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency);
-    }
-
-    const booking = await this.prisma.booking.create({
-      data: {
-        bookingRef: generateRef(),
-        passengerId: dto.passengerId,
-        scheduleId: dto.scheduleId,
-        status: 'PENDING_PAYMENT',
-        totalMinor, adultCount, childCount, displayCurrency, displayTotalMinor,
-        bookingType: dto.bookingType ?? 'ONE_WAY',
-        seats: {
-          create: passengersData.map((p) => ({
-            seat: { connect: { id: p.seatId } },
-            passengerName: p.passengerName,
-            dateOfBirth: p.dateOfBirth,
-            passengerCategory: p.category,
-            idDocumentType: p.idDocumentType,
-            idDocumentNumber: p.idDocumentType === IdDocumentType.NATIONAL_ID ? undefined : p.idDocumentNumber,
-            passportNumber: p.passportNumber,
-            passportCountry: p.passportCountry,
-            verifaydaVerified: p.verifaydaVerified,
-            verifaydaData: p.verifaydaData || undefined,
-            fareMinor: p.category === PassengerCategory.ADULT ? baseFareMinor : (paidChildrenCount > 0 ? baseFareMinor : 0),
-            displayCurrency,
-          })),
-        },
-      },
-      include: { seats: { include: { seat: true } }, schedule: { include: { originStation: true, destinationStation: true, train: true } } },
-    });
-
-    await this.seatsService.confirmSeats(seatIds);
-    this.eventEmitter.emit('booking.created', { booking });
-
     return {
-      ...booking,
-      fareBreakdown: { baseFareMinor, adultCount, adultFareMinor, childCount, freeChildrenCount: Math.min(childCount, 1), paidChildrenCount, childFareMinor, totalBaseFareMinor, discountMinor, loyaltyRedemptionMinor: loyaltyMinor, taxesFeesMinor: taxesMinor, totalMinor, currency: 'ETB', displayCurrency, displayTotalMinor },
+      baseFareMinor,
+      adultCount,
+      adultFareMinor,
+      childCount,
+      freeChildrenCount: Math.min(childCount, 1),
+      paidChildrenCount,
+      childFareMinor,
+      totalBaseFareMinor,
+      discountMinor,
+      loyaltyRedemptionMinor: loyaltyMinor,
+      taxesFeesMinor: taxesMinor,
+      totalMinor
     };
   }
 
@@ -380,28 +899,73 @@ export class BookingsService {
     segmentRoute?: string,
     fullRoute?: string,
     nationality?: string,
+    originStopSeq?: number,
+    destStopSeq?: number,
   ): Promise<number> {
     const now = new Date();
+
+    // 1. SegmentFareRule — most specific explicit price
+    const schedule = await this.prisma.trainSchedule.findUnique({
+      where: { id: scheduleId },
+      select: { routeId: true, originStationId: true, destinationStationId: true },
+    });
+
+    if (schedule?.routeId && originStopSeq !== undefined && destStopSeq !== undefined) {
+      const segmentFare = await this.prisma.segmentFareRule.findFirst({
+        where: {
+          routeId: schedule.routeId,
+          originStopSequence: originStopSeq,
+          destinationStopSequence: destStopSeq,
+          seatClassId,
+          nationality: nationality ?? null,
+          validFrom: { lte: now },
+          OR: [{ validUntil: null }, { validUntil: { gte: now } }],
+        },
+      }) ?? (nationality ? await this.prisma.segmentFareRule.findFirst({
+        where: {
+          routeId: schedule.routeId,
+          originStopSequence: originStopSeq,
+          destinationStopSequence: destStopSeq,
+          seatClassId,
+          nationality: null,
+          validFrom: { lte: now },
+          OR: [{ validUntil: null }, { validUntil: { gte: now } }],
+        },
+      }) : null);
+
+      if (segmentFare) return segmentFare.baseFareMinor;
+    }
+
+    // 2. FareRule table — explicit override rules
     const candidates = await this.prisma.fareRule.findMany({
       where: {
         seatClassId,
         validFrom: { lte: now },
-        OR: [
-          { validUntil: null },
-          { validUntil: { gte: now } },
-        ],
+        OR: [{ validUntil: null }, { validUntil: { gte: now } }],
       },
     });
+    const bestMatch = this.selectBestFareRule(candidates, scheduleId, segmentRoute, fullRoute, nationality);
+    if (bestMatch) return bestMatch.baseFareMinor;
 
-    const bestMatch = this.selectBestFareRule(
-      candidates,
-      scheduleId,
-      segmentRoute,
-      fullRoute,
-      nationality,
+    // 3. FareEngine — distance × rate-per-km from the schedule's route
+    if (schedule?.routeId) {
+      try {
+        const fare = await this.fareEngine.calculate({
+          routeId: schedule.routeId,
+          originStationId: schedule.originStationId,
+          destinationStationId: schedule.destinationStationId,
+          seatClassId,
+          nationality,
+        });
+        return fare.baseFarePerPassengerMinor;
+      } catch {
+        // FareEngine throws if distanceKm is missing; fall through to error
+      }
+    }
+
+    throw new BadRequestException(
+      `No fare configured for this schedule and seat class. Please set up fare rules or route distances.`,
     );
-
-    return bestMatch?.baseFareMinor ?? 35000;
   }
 
   async getByRef(bookingRef: string) {
@@ -409,7 +973,7 @@ export class BookingsService {
       where: { bookingRef },
       include: {
         schedule: { include: { originStation: true, destinationStation: true, train: true } },
-        seats: { include: { seat: { include: { coach: { include: { seatClass: true } } } } } },
+        seats: { include: { seat: { include: { coach: true } } } },
         paymentIntent: true, ticket: true,
       },
     });
@@ -418,14 +982,18 @@ export class BookingsService {
       id: booking.id, bookingRef: booking.bookingRef, status: booking.status,
       totalFare: booking.totalMinor / 100, adultCount: booking.adultCount, childCount: booking.childCount,
       displayCurrency: booking.displayCurrency, displayTotalFare: booking.displayTotalMinor ? booking.displayTotalMinor / 100 : undefined,
-      bookingType: booking.bookingType, createdAt: booking.createdAt,
+      bookingType: booking.bookingType,
+      returnLegStatus: (booking as any).returnLegStatus ?? null,
+      outboundBoardedAt: (booking as any).outboundBoardedAt ?? null,
+      returnBoardedAt: (booking as any).returnBoardedAt ?? null,
+      createdAt: booking.createdAt,
       schedule: {
         number: booking.schedule.train.number,
         origin: { id: booking.schedule.originStation.id, name: booking.schedule.originStation.name, code: booking.schedule.originStation.code, city: booking.schedule.originStation.city },
         destination: { id: booking.schedule.destinationStation.id, name: booking.schedule.destinationStation.name, code: booking.schedule.destinationStation.code, city: booking.schedule.destinationStation.city },
         departureAt: booking.schedule.departureAt, arrivalAt: booking.schedule.arrivalAt,
       },
-      passengers: booking.seats.map((bs) => ({
+      passengers: booking.seats?.map((bs: any) => ({
         fullName: bs.passengerName, category: bs.passengerCategory, verifaydaVerified: bs.verifaydaVerified,
         seat: { number: bs.seat.label, coach: bs.seat.coach.label, class: bs.seat.coach.seatClass.name },
       })),
@@ -456,6 +1024,7 @@ export class BookingsService {
     await this.prisma.bookingCancellation.create({ data: { bookingId: booking.id, cancelledBy: booking.passengerId, reason, refundAmount, refundMethod: booking.paymentIntent?.method ?? 'ORIGINAL', refundStatus: 'PENDING' } });
     await this.seatsService.releaseSeats(booking.seats.map((s) => s.seatId));
     await this.prisma.booking.update({ where: { bookingRef }, data: { status: 'CANCELLED' } });
+    this.eventEmitter.emit('booking.cancelled', { booking, refundAmount });
     return { cancelled: true, refundAmount: refundAmount / 100, currency: 'ETB' };
   }
 
@@ -523,6 +1092,37 @@ export class BookingsService {
     }
   }
 
+  // Mark round-trip bookings where the return train has departed but the return leg
+  // was never scanned. Runs every minute; only acts on CONFIRMED bookings whose
+  // returnSchedule.departureAt is in the past and returnBoardedAt is still null.
+  @Cron(CronExpression.EVERY_MINUTE)
+  async markReturnLegNoShows() {
+    const now = new Date();
+    const graceCutoff = new Date(now.getTime() - 30 * 60 * 1000);
+
+    const candidates = await this.prisma.booking.findMany({
+      where: {
+        bookingType: 'ROUND_TRIP',
+        status: 'CONFIRMED',
+        returnLegStatus: 'NEITHER_USED' as any,
+        outboundBoardedAt: { not: null },
+        returnBoardedAt: null,
+        returnScheduleId: { not: null },
+      },
+      include: { returnSchedule: { select: { departureAt: true } } },
+    } as any);
+
+    for (const b of candidates) {
+      const returnDep: Date | undefined = (b as any).returnSchedule?.departureAt;
+      if (returnDep && returnDep < graceCutoff) {
+        await this.prisma.booking.update({
+          where: { id: b.id },
+          data: { returnLegStatus: 'OUTBOUND_ONLY' } as any,
+        });
+      }
+    }
+  }
+
   private selectBestFareRule(
     candidates: any[],
     scheduleId: string,

apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts

@@ -4,9 +4,18 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Currency, IdDocumentType } from '@prisma/client';
 
 export class GuestPassengerDto {
-  @ApiProperty({ example: 'seat-id-uuid' }) 
+  @ApiProperty({ example: 'seat-uuid', description: 'Outbound / leg-1 seat ID (all booking types)' }) 
   @IsString() seatId: string;
 
+  @ApiPropertyOptional({ example: 'return-seat-uuid', description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return leg-1 seat ID. Required for ROUND_TRIP and ROUND_TRIP_TRANSIT.' })
+  @IsOptional() @IsString() returnSeatId?: string;
+
+  @ApiPropertyOptional({ example: 'leg2-seat-uuid', description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Outbound leg-2 seat ID. Required for TRANSIT and ROUND_TRIP_TRANSIT.' })
+  @IsOptional() @IsString() leg2SeatId?: string;
+
+  @ApiPropertyOptional({ example: 'ret-leg2-seat-uuid', description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat ID. Required for ROUND_TRIP_TRANSIT.' })
+  @IsOptional() @IsString() returnLeg2SeatId?: string;
+
   @ApiProperty({ example: 'Abebe Kebede' }) 
   @IsString() passengerName: string;
 
@@ -36,24 +45,88 @@ export class GuestPassengerDto {
 }
 
 export class CreateGuestBookingDto {
-  @ApiProperty({ example: 'schedule-uuid' }) 
+  @ApiPropertyOptional({ 
+    example: 'ONE_WAY', 
+    enum: ['ONE_WAY', 'ROUND_TRIP', 'TRANSIT', 'ROUND_TRIP_TRANSIT'], 
+    default: 'ONE_WAY',
+    description: `Booking type:
+**ONE_WAY:** scheduleId + holdId. Passenger: seatId.
+**ROUND_TRIP:** above + returnScheduleId/returnHoldId/returnOriginStationId/returnDestinationStationId. Passenger: seatId + returnSeatId.
+**TRANSIT:** above + leg2ScheduleId/leg2HoldId/transitStationId/leg2DestinationStationId. Passenger: seatId + leg2SeatId.
+**ROUND_TRIP_TRANSIT:** all 4 hold sets + all station fields. Passenger: seatId + leg2SeatId + returnSeatId + returnLeg2SeatId.`
+  })
+  @IsOptional() @IsString() bookingType?: 'ONE_WAY' | 'ROUND_TRIP' | 'TRANSIT' | 'ROUND_TRIP_TRANSIT';
+
+  @ApiProperty({ example: 'schedule-uuid', description: 'Outbound / leg-1 schedule UUID' }) 
   @IsString() scheduleId: string;
 
-  @ApiProperty({ example: 'hold-uuid' }) 
+  @ApiProperty({ example: 'hold-uuid', description: 'Outbound seat hold UUID' }) 
   @IsString() holdId: string;
 
-  @ApiProperty({ example: 'station-uuid', description: 'Origin station UUID' }) 
+  @ApiProperty({ example: 'station-uuid', description: 'Outbound origin station UUID' }) 
   @IsString() originStationId: string;
 
-  @ApiProperty({ example: 'station-uuid', description: 'Destination station UUID' }) 
+  @ApiProperty({ example: 'station-uuid', description: 'Outbound destination station UUID' }) 
   @IsString() destinationStationId: string;
 
-  @ApiProperty({ type: [GuestPassengerDto], description: 'Array of passengers. First passenger details used for contact.' }) 
-  @IsArray() @ValidateNested({ each: true }) @Type(() => GuestPassengerDto) passengers: GuestPassengerDto[];
-
-  @ApiProperty({ example: 'seat-class-uuid', description: 'Seat class UUID' })
+  @ApiProperty({ example: 'seat-class-uuid', description: 'Outbound seat class UUID' })
   @IsString() seatClassId: string;
 
+  @ApiPropertyOptional({ example: 'seat-class-uuid', description: 'ROUND_TRIP / ROUND_TRIP_TRANSIT: return seat class UUID' })
+  @IsOptional() @IsString() returnSeatClassId?: string;
+
+  @ApiPropertyOptional({ example: 'schedule-uuid', description: 'TRANSIT / ROUND_TRIP_TRANSIT: leg-2 schedule UUID' })
+  @IsOptional() @IsString() leg2ScheduleId?: string;
+
+  @ApiPropertyOptional({ example: 'hold-uuid', description: 'TRANSIT / ROUND_TRIP_TRANSIT: leg-2 seat hold UUID' })
+  @IsOptional() @IsString() leg2HoldId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'TRANSIT / ROUND_TRIP_TRANSIT: connecting station UUID' })
+  @IsOptional() @IsString() transitStationId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'TRANSIT / ROUND_TRIP_TRANSIT: leg-2 destination station UUID' })
+  @IsOptional() @IsString() leg2DestinationStationId?: string;
+
+  @ApiPropertyOptional({ example: 'seat-class-uuid', description: 'TRANSIT / ROUND_TRIP_TRANSIT: leg-2 seat class UUID' })
+  @IsOptional() @IsString() leg2SeatClassId?: string;
+
+  @ApiPropertyOptional({ example: 'schedule-uuid', description: 'ROUND_TRIP / ROUND_TRIP_TRANSIT: return leg-1 schedule UUID' })
+  @IsOptional() @IsString() returnScheduleId?: string;
+
+  @ApiPropertyOptional({ example: 'hold-uuid', description: 'ROUND_TRIP / ROUND_TRIP_TRANSIT: return seat hold UUID' })
+  @IsOptional() @IsString() returnHoldId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'ROUND_TRIP / ROUND_TRIP_TRANSIT: return origin station UUID' })
+  @IsOptional() @IsString() returnOriginStationId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'ROUND_TRIP / ROUND_TRIP_TRANSIT: return destination station UUID' })
+  @IsOptional() @IsString() returnDestinationStationId?: string;
+
+  @ApiPropertyOptional({ example: 'schedule-uuid', description: 'ROUND_TRIP_TRANSIT: return leg-2 schedule UUID' })
+  @IsOptional() @IsString() returnLeg2ScheduleId?: string;
+
+  @ApiPropertyOptional({ example: 'hold-uuid', description: 'ROUND_TRIP_TRANSIT: return leg-2 seat hold UUID' })
+  @IsOptional() @IsString() returnLeg2HoldId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'ROUND_TRIP_TRANSIT: return transit station UUID' })
+  @IsOptional() @IsString() returnTransitStationId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'ROUND_TRIP_TRANSIT: return leg-2 destination station UUID' })
+  @IsOptional() @IsString() returnLeg2DestinationStationId?: string;
+
+  @ApiPropertyOptional({ example: 'seat-class-uuid', description: 'ROUND_TRIP_TRANSIT: return leg-2 seat class UUID' })
+  @IsOptional() @IsString() returnLeg2SeatClassId?: string;
+
+  @ApiProperty({ 
+    type: [GuestPassengerDto], 
+    description: `Passenger array. Required seat fields vary by bookingType:
+- ONE_WAY: seatId
+- ROUND_TRIP: seatId + returnSeatId
+- TRANSIT: seatId + leg2SeatId
+- ROUND_TRIP_TRANSIT: seatId + leg2SeatId + returnSeatId + returnLeg2SeatId` 
+  }) 
+  @IsArray() @ValidateNested({ each: true }) @Type(() => GuestPassengerDto) passengers: GuestPassengerDto[];
+
   @ApiPropertyOptional({ example: 'WEEKEND15' }) 
   @IsOptional() @IsString() promoCode?: string;
 
@@ -66,7 +139,7 @@ export class CreateGuestBookingDto {
   @ApiPropertyOptional({ example: 'password123', description: 'Password if createAccount is true' }) 
   @IsOptional() @IsString() password?: string;
 
-  @ApiPropertyOptional({ example: true, description: 'Save passenger details for future bookings (requires createAccount)' }) 
+  @ApiPropertyOptional({ example: true, description: 'Save passenger details for future bookings' }) 
   @IsOptional() @IsBoolean() savePassengerDetails?: boolean;
 
   @ApiPropertyOptional({ example: 'device-uuid-12345', description: 'Device ID for local storage of passenger details' }) 

apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts

@@ -4,6 +4,7 @@ import { SeatsService } from '../seats/seats.service';
 import { VerifaydaService } from '../verifayda/verifayda.service';
 import { CurrencyService } from '../currency/currency.service';
 import { PassengerAuthService } from '../auth/passenger-auth.service';
+import { FareEngineService } from '../fare-engine/fare-engine.service';
 import { EventEmitter2 } from '@nestjs/event-emitter';
 import { CreateGuestBookingDto, SavedPassengerProfileDto } from './guest-booking.dto';
 import { Currency, PassengerCategory, IdDocumentType } from '@prisma/client';
@@ -29,10 +30,18 @@ export class GuestBookingService {
     private verifaydaService: VerifaydaService,
     private currencyService: CurrencyService,
     private passengerAuthService: PassengerAuthService,
+    private fareEngine: FareEngineService,
     private eventEmitter: EventEmitter2,
   ) {}
 
-  async createGuestBooking(dto: CreateGuestBookingDto, req: any) {
+  async createGuestBooking(dto: CreateGuestBookingDto, req?: any) {
+    if (dto.bookingType === 'ROUND_TRIP')         return this.createGuestRoundTripBooking(dto, req);
+    if (dto.bookingType === 'TRANSIT')            return this.createGuestTransitBooking(dto, req);
+    if (dto.bookingType === 'ROUND_TRIP_TRANSIT') return this.createGuestRoundTripTransitBooking(dto, req);
+    return this.createGuestOneWayBooking(dto, req);
+  }
+
+  private async createGuestOneWayBooking(dto: CreateGuestBookingDto, req?: any) {
     // Validate hold
     const hold = await this.prisma.seatHold.findUnique({ where: { id: dto.holdId } });
     if (!hold || hold.expiresAt < new Date()) {
@@ -147,39 +156,7 @@ export class GuestBookingService {
 
     // Resolve or create the guest Passenger record
     const firstPassenger = passengersData[0];
-    let guestPassengerId: string;
-    let iamUserId: string | null = null;
-    let createdAccount = false;
-
-    if (dto.createAccount && firstPassenger.email && dto.password) {
-      // Delegate full IAM account creation to PassengerAuthService
-      const guestName = firstPassenger.passengerName ?? 'Guest';
-      const result = await this.passengerAuthService.register(
-        {
-          email: firstPassenger.email,
-          username: firstPassenger.email,
-          phoneNumber: firstPassenger.phone || `+251900000000`,
-          name: { en: guestName, am: guestName },
-          password: dto.password,
-          confirmPassword: dto.password,
-        },
-        req,
-      );
-      guestPassengerId = result.user.passengerId;
-      iamUserId = result.user.iamUserId;
-      createdAccount = true;
-    } else {
-      // Anonymous guest — Passenger with no User, no IAM account
-      const guestPassenger = await this.prisma.passenger.create({
-        data: {
-          // userId intentionally omitted — guest has no local User or IAM account
-          ...(dto.deviceId ? {} : {}),
-        },
-      });
-      await this.prisma.loyaltyAccount.create({ data: { passengerId: guestPassenger.id, pointsBalance: 0, tier: 'BRONZE' } });
-      await this.prisma.walletAccount.create({ data: { passengerId: guestPassenger.id, balanceMinor: 0 } });
-      guestPassengerId = guestPassenger.id;
-    }
+    const { guestPassengerId, iamUserId, createdAccount } = await this.resolveGuestPassenger(dto, firstPassenger, req);
 
     // Save passenger details for future use (if requested)
     if (dto.savePassengerDetails && (dto.createAccount || dto.deviceId)) {
@@ -264,6 +241,618 @@ export class GuestBookingService {
     };
   }
 
+  private async createGuestRoundTripBooking(dto: CreateGuestBookingDto, req?: any) {
+    if (!dto.returnScheduleId || !dto.returnHoldId || !dto.returnOriginStationId || !dto.returnDestinationStationId) {
+      throw new BadRequestException('returnScheduleId, returnHoldId, returnOriginStationId and returnDestinationStationId are required for ROUND_TRIP');
+    }
+
+    // Validate both holds
+    const [outboundHold, returnHold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnHoldId } }),
+    ]);
+    if (!outboundHold || outboundHold.expiresAt < new Date()) throw new BadRequestException('Outbound seat hold expired or not found');
+    if (!returnHold   || returnHold.expiresAt   < new Date()) throw new BadRequestException('Return seat hold expired or not found');
+
+    // Validate passengers have returnSeatId
+    for (const p of dto.passengers) {
+      if (!p.returnSeatId) throw new BadRequestException(`returnSeatId is required for each passenger in a ROUND_TRIP booking (missing for ${p.passengerName})`);
+    }
+
+    // Load both schedules
+    const [outboundSchedule, returnSchedule] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.scheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.returnScheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+    ]);
+    if (!outboundSchedule) throw new NotFoundException('Outbound schedule not found');
+    if (!returnSchedule)   throw new NotFoundException('Return schedule not found');
+
+    const outboundOriginStop = outboundSchedule.stopTimes.find(s => s.stationId === dto.originStationId);
+    const outboundDestStop   = outboundSchedule.stopTimes.find(s => s.stationId === dto.destinationStationId);
+    const returnOriginStop   = returnSchedule.stopTimes.find(s => s.stationId === dto.returnOriginStationId);
+    const returnDestStop     = returnSchedule.stopTimes.find(s => s.stationId === dto.returnDestinationStationId);
+    if (!outboundOriginStop || !outboundDestStop) throw new NotFoundException('Outbound origin or destination not found on schedule');
+    if (!returnOriginStop   || !returnDestStop)   throw new NotFoundException('Return origin or destination not found on schedule');
+
+    const outboundSegmentRoute = `${outboundOriginStop.station.code}-${outboundDestStop.station.code}`;
+    const outboundFullRoute    = `${outboundSchedule.originStation.code}-${outboundSchedule.destinationStation.code}`;
+    const returnSegmentRoute   = `${returnOriginStop.station.code}-${returnDestStop.station.code}`;
+    const returnFullRoute      = `${returnSchedule.originStation.code}-${returnSchedule.destinationStation.code}`;
+
+    // Process passengers (verify identity once — same person travels both legs)
+    const passengersData: any[] = [];
+    let adultCount = 0, childCount = 0;
+
+    for (const passenger of dto.passengers) {
+      const dateOfBirth = new Date(passenger.dateOfBirth);
+      const age = calculateAge(dateOfBirth);
+      const category: PassengerCategory = age < 5 ? PassengerCategory.CHILD : PassengerCategory.ADULT;
+      if (category === PassengerCategory.ADULT) adultCount++; else childCount++;
+
+      let passengerName = passenger.passengerName;
+      let verifaydaVerified = false;
+      let verifaydaData: Record<string, any> | undefined;
+      let nationality = passenger.nationality;
+
+      const isEthiopian = passenger.nationality === 'Ethiopian' ||
+                          passenger.nationality === 'ETHIOPIAN' ||
+                          passenger.idDocumentType === IdDocumentType.NATIONAL_ID;
+
+      if (isEthiopian && passenger.idDocumentType === IdDocumentType.NATIONAL_ID) {
+        if (passenger.idDocumentNumber) {
+          const verification = await this.verifaydaService.verifyNationalId(passenger.idDocumentNumber);
+          if (!verification.verified) throw new BadRequestException(`Verifayda verification failed for ${passenger.passengerName}: ${verification.failureReason}`);
+          passengerName     = verification.passengerData?.fullName || passengerName;
+          verifaydaVerified = true;
+          verifaydaData     = verification.passengerData?.profileData;
+        }
+        nationality = 'Ethiopian';
+      } else if (!isEthiopian && passenger.idDocumentType === IdDocumentType.PASSPORT) {
+        if (!passenger.passportNumber || !passenger.passportCountry) throw new BadRequestException(`Passport number and country required for ${passenger.passengerName}`);
+        nationality = nationality || (passenger.passportCountry === 'Djibouti' ? 'Djiboutian' : 'Other');
+      } else if (isEthiopian && passenger.idDocumentType === IdDocumentType.PASSPORT) {
+        nationality = 'Ethiopian';
+      } else {
+        nationality = nationality || 'Other';
+      }
+
+      passengersData.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
+    }
+
+    // Calculate fares for both legs
+    const returnSeatClassId = dto.returnSeatClassId || dto.seatClassId;
+    const primaryNationality = passengersData[0]?.nationality;
+
+    const [outboundBaseFare, returnBaseFare] = await Promise.all([
+      this.getBaseFare(dto.scheduleId, dto.seatClassId, outboundSegmentRoute, outboundFullRoute, primaryNationality),
+      this.getBaseFare(dto.returnScheduleId, returnSeatClassId, returnSegmentRoute, returnFullRoute, primaryNationality),
+    ]);
+
+    const paidChildrenCount      = Math.max(0, childCount - 1);
+    const outboundTotalBase      = outboundBaseFare * adultCount + outboundBaseFare * paidChildrenCount;
+    const returnTotalBase        = returnBaseFare  * adultCount + returnBaseFare  * paidChildrenCount;
+    const combinedBaseFareMinor  = outboundTotalBase + returnTotalBase;
+
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff
+          ? Math.round(combinedBaseFareMinor * promo.percentOff / 100)
+          : (promo.amountOffMinor ?? 0);
+      }
+    }
+
+    const taxesMinor = Math.round(combinedBaseFareMinor * 0.05);
+    const totalMinor = Math.max(0, combinedBaseFareMinor - discountMinor + taxesMinor);
+
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    // Create or resolve guest passenger (same as one-way)
+    const { guestPassengerId, iamUserId, createdAccount } = await this.resolveGuestPassenger(dto, passengersData[0], req);
+
+    // Create booking with outbound seats; return seats confirmed separately
+    const outboundSeatIds = dto.passengers.map(p => p.seatId);
+    const returnSeatIds   = dto.passengers.map(p => p.returnSeatId!);
+
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef:                  generateRef(),
+        passengerId:                 guestPassengerId,
+        scheduleId:                  dto.scheduleId,
+        status:                      'PENDING_PAYMENT',
+        bookingType:                 'ROUND_TRIP',
+        totalMinor,
+        adultCount,
+        childCount,
+        displayCurrency,
+        displayTotalMinor,
+        returnScheduleId:            dto.returnScheduleId,
+        returnOriginStationId:       dto.returnOriginStationId,
+        returnDestinationStationId:  dto.returnDestinationStationId,
+        returnHoldId:                dto.returnHoldId,
+        returnSeatClassId,
+        returnLegStatus:             'NEITHER_USED',
+        userAgent:                   dto.deviceId,
+        seats: {
+          create: [
+            ...passengersData.map((p) => ({
+              seat:              { connect: { id: p.seatId } },
+              leg:               1,
+              scheduleId:        dto.scheduleId,
+              passengerName:     p.passengerName,
+              dateOfBirth:       p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType:    p.idDocumentType,
+              passportNumber:    p.passportNumber,
+              passportCountry:   p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData:     p.verifaydaData || undefined,
+              fareMinor:         p.category === PassengerCategory.ADULT ? outboundBaseFare : (paidChildrenCount > 0 ? outboundBaseFare : 0),
+              displayCurrency,
+            })),
+            ...passengersData.map((p) => ({
+              seat:              { connect: { id: p.returnSeatId } },
+              leg:               2,
+              scheduleId:        dto.returnScheduleId,
+              passengerName:     p.passengerName,
+              dateOfBirth:       p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType:    p.idDocumentType,
+              passportNumber:    p.passportNumber,
+              passportCountry:   p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData:     p.verifaydaData || undefined,
+              fareMinor:         p.category === PassengerCategory.ADULT ? returnBaseFare : (paidChildrenCount > 0 ? returnBaseFare : 0),
+              displayCurrency,
+            })),
+          ],
+        },
+      } as any,
+      include: {
+        seats:    { include: { seat: { include: { coach: true } } } },
+        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+      },
+    });
+
+    await Promise.all([
+      this.seatsService.confirmSeats(outboundSeatIds),
+      this.seatsService.confirmSeats(returnSeatIds),
+    ]);
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      createdAccount,
+      iamUserId,
+      fareBreakdown: {
+        outboundBaseFareMinor: outboundBaseFare,
+        returnBaseFareMinor:   returnBaseFare,
+        adultCount,
+        childCount,
+        freeChildrenCount:     Math.min(childCount, 1),
+        paidChildrenCount,
+        combinedBaseFareMinor,
+        discountMinor,
+        taxesFeesMinor:        taxesMinor,
+        totalMinor,
+        currency:              'ETB',
+        displayCurrency,
+        displayTotalMinor,
+      },
+    };
+  }
+
+  private async createGuestTransitBooking(dto: CreateGuestBookingDto, req?: any) {
+    if (!dto.leg2ScheduleId || !dto.leg2HoldId || !dto.transitStationId || !dto.leg2DestinationStationId) {
+      throw new BadRequestException('leg2ScheduleId, leg2HoldId, transitStationId and leg2DestinationStationId are required for TRANSIT bookings');
+    }
+
+    const [leg1Hold, leg2Hold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.leg2HoldId } }),
+    ]);
+    if (!leg1Hold || leg1Hold.expiresAt < new Date()) throw new BadRequestException('Leg-1 seat hold expired or not found');
+    if (!leg2Hold || leg2Hold.expiresAt < new Date()) throw new BadRequestException('Leg-2 seat hold expired or not found');
+
+    for (const p of dto.passengers) {
+      if (!p.leg2SeatId) throw new BadRequestException(`leg2SeatId is required for each passenger in a TRANSIT booking (missing for ${p.passengerName})`);
+    }
+
+    const [leg1Schedule, leg2Schedule] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.scheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+      this.prisma.trainSchedule.findUnique({
+        where: { id: dto.leg2ScheduleId },
+        include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      }),
+    ]);
+    if (!leg1Schedule) throw new NotFoundException('Leg-1 schedule not found');
+    if (!leg2Schedule) throw new NotFoundException('Leg-2 schedule not found');
+
+    const leg1OriginStop = leg1Schedule.stopTimes.find(s => s.stationId === dto.originStationId);
+    const leg1DestStop   = leg1Schedule.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const leg2OriginStop = leg2Schedule.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const leg2DestStop   = leg2Schedule.stopTimes.find(s => s.stationId === dto.leg2DestinationStationId);
+    if (!leg1OriginStop || !leg1DestStop) throw new NotFoundException('Leg-1 origin or transit station not found on schedule');
+    if (!leg2OriginStop || !leg2DestStop) throw new NotFoundException('Transit or leg-2 destination not found on leg-2 schedule');
+
+    // Process passengers (verify identity once)
+    const passengersData: any[] = [];
+    let adultCount = 0, childCount = 0;
+    for (const passenger of dto.passengers) {
+      const dateOfBirth = new Date(passenger.dateOfBirth);
+      const age = calculateAge(dateOfBirth);
+      const category: PassengerCategory = age < 5 ? PassengerCategory.CHILD : PassengerCategory.ADULT;
+      if (category === PassengerCategory.ADULT) adultCount++; else childCount++;
+
+      let passengerName = passenger.passengerName;
+      let verifaydaVerified = false;
+      let verifaydaData: Record<string, any> | undefined;
+      let nationality = passenger.nationality;
+
+      const isEthiopian = passenger.nationality === 'Ethiopian' || passenger.nationality === 'ETHIOPIAN' || passenger.idDocumentType === IdDocumentType.NATIONAL_ID;
+      if (isEthiopian && passenger.idDocumentType === IdDocumentType.NATIONAL_ID && passenger.idDocumentNumber) {
+        const verification = await this.verifaydaService.verifyNationalId(passenger.idDocumentNumber);
+        if (!verification.verified) throw new BadRequestException(`Verifayda verification failed for ${passenger.passengerName}: ${verification.failureReason}`);
+        passengerName = verification.passengerData?.fullName || passengerName;
+        verifaydaVerified = true;
+        verifaydaData = verification.passengerData?.profileData;
+        nationality = 'Ethiopian';
+      } else if (!isEthiopian && passenger.idDocumentType === IdDocumentType.PASSPORT) {
+        if (!passenger.passportNumber || !passenger.passportCountry) throw new BadRequestException(`Passport details required for ${passenger.passengerName}`);
+        nationality = nationality || (passenger.passportCountry === 'Djibouti' ? 'Djiboutian' : 'Other');
+      } else {
+        nationality = nationality || 'Other';
+      }
+      passengersData.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
+    }
+
+    const leg2SeatClassId    = dto.leg2SeatClassId || dto.seatClassId;
+    const primaryNationality = passengersData[0]?.nationality;
+    const paidChildrenCount  = Math.max(0, childCount - 1);
+
+    const [leg1BaseFare, leg2BaseFare] = await Promise.all([
+      this.getBaseFare(dto.scheduleId, dto.seatClassId,
+        `${leg1OriginStop.station.code}-${leg1DestStop.station.code}`,
+        `${leg1Schedule.originStation.code}-${leg1Schedule.destinationStation.code}`,
+        primaryNationality),
+      this.getBaseFare(dto.leg2ScheduleId, leg2SeatClassId,
+        `${leg2OriginStop.station.code}-${leg2DestStop.station.code}`,
+        `${leg2Schedule.originStation.code}-${leg2Schedule.destinationStation.code}`,
+        primaryNationality),
+    ]);
+
+    const leg1Total      = leg1BaseFare * adultCount + leg1BaseFare * paidChildrenCount;
+    const leg2Total      = leg2BaseFare * adultCount + leg2BaseFare * paidChildrenCount;
+    const combinedBase   = leg1Total + leg2Total;
+
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff ? Math.round(combinedBase * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
+      }
+    }
+    const taxesMinor = Math.round(combinedBase * 0.05);
+    const totalMinor = Math.max(0, combinedBase - discountMinor + taxesMinor);
+
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    const { guestPassengerId, iamUserId, createdAccount } = await this.resolveGuestPassenger(dto, passengersData[0], req);
+
+    // Single booking — leg-1 seats at leg=1, leg-2 seats at leg=2
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef:              generateRef(),
+        passengerId:             guestPassengerId,
+        scheduleId:              dto.scheduleId,
+        status:                  'PENDING_PAYMENT',
+        bookingType:             'TRANSIT',
+        totalMinor,
+        adultCount,
+        childCount,
+        displayCurrency,
+        displayTotalMinor,
+        leg2ScheduleId:          dto.leg2ScheduleId,
+        leg2OriginStationId:     dto.transitStationId,
+        leg2DestinationStationId: dto.leg2DestinationStationId,
+        leg2SeatClassId:         leg2SeatClassId,
+        userAgent:               dto.deviceId,
+        seats: {
+          create: [
+            ...passengersData.map(p => ({
+              seat:              { connect: { id: p.seatId } },
+              leg:               1,
+              scheduleId:        dto.scheduleId,
+              passengerName:     p.passengerName,
+              dateOfBirth:       p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType:    p.idDocumentType,
+              passportNumber:    p.passportNumber,
+              passportCountry:   p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData:     p.verifaydaData || undefined,
+              fareMinor:         p.category === PassengerCategory.ADULT ? leg1BaseFare : (paidChildrenCount > 0 ? leg1BaseFare : 0),
+              displayCurrency,
+            })),
+            ...passengersData.map(p => ({
+              seat:              { connect: { id: p.leg2SeatId! } },
+              leg:               2,
+              scheduleId:        dto.leg2ScheduleId,
+              passengerName:     p.passengerName,
+              dateOfBirth:       p.dateOfBirth,
+              passengerCategory: p.category,
+              idDocumentType:    p.idDocumentType,
+              passportNumber:    p.passportNumber,
+              passportCountry:   p.passportCountry,
+              verifaydaVerified: p.verifaydaVerified,
+              verifaydaData:     p.verifaydaData || undefined,
+              fareMinor:         p.category === PassengerCategory.ADULT ? leg2BaseFare : (paidChildrenCount > 0 ? leg2BaseFare : 0),
+              displayCurrency,
+            })),
+          ],
+        },
+      } as any,
+      include: {
+        seats:    { include: { seat: { include: { coach: true } } } },
+        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+      },
+    });
+
+    await Promise.all([
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.seatId)),
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.leg2SeatId!)),
+    ]);
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      createdAccount,
+      iamUserId,
+      fareBreakdown: {
+        leg1BaseFareMinor: leg1BaseFare,
+        leg2BaseFareMinor: leg2BaseFare,
+        adultCount, childCount,
+        freeChildrenCount: Math.min(childCount, 1),
+        paidChildrenCount,
+        combinedBaseFareMinor: combinedBase,
+        discountMinor, taxesFeesMinor: taxesMinor, totalMinor,
+        currency: 'ETB', displayCurrency, displayTotalMinor,
+      },
+    };
+  }
+
+  private async createGuestRoundTripTransitBooking(dto: CreateGuestBookingDto, req?: any) {
+    if (!dto.leg2ScheduleId || !dto.leg2HoldId || !dto.transitStationId || !dto.leg2DestinationStationId ||
+        !dto.returnScheduleId || !dto.returnHoldId || !dto.returnOriginStationId || !dto.returnDestinationStationId ||
+        !dto.returnLeg2ScheduleId || !dto.returnLeg2HoldId || !dto.returnTransitStationId || !dto.returnLeg2DestinationStationId) {
+      throw new BadRequestException(
+        'ROUND_TRIP_TRANSIT requires all 4 holds and all transit/return station fields',
+      );
+    }
+    for (const p of dto.passengers) {
+      if (!p.leg2SeatId)      throw new BadRequestException(`leg2SeatId required for ${p.passengerName}`);
+      if (!p.returnSeatId)    throw new BadRequestException(`returnSeatId required for ${p.passengerName}`);
+      if (!p.returnLeg2SeatId) throw new BadRequestException(`returnLeg2SeatId required for ${p.passengerName}`);
+    }
+
+    const now = new Date();
+    const [obL1Hold, obL2Hold, retL1Hold, retL2Hold] = await Promise.all([
+      this.prisma.seatHold.findUnique({ where: { id: dto.holdId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.leg2HoldId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnHoldId } }),
+      this.prisma.seatHold.findUnique({ where: { id: dto.returnLeg2HoldId } }),
+    ]);
+    if (!obL1Hold  || obL1Hold.expiresAt  < now) throw new BadRequestException('Outbound leg-1 hold expired');
+    if (!obL2Hold  || obL2Hold.expiresAt  < now) throw new BadRequestException('Outbound leg-2 hold expired');
+    if (!retL1Hold || retL1Hold.expiresAt < now) throw new BadRequestException('Return leg-1 hold expired');
+    if (!retL2Hold || retL2Hold.expiresAt < now) throw new BadRequestException('Return leg-2 hold expired');
+
+    const [obL1Sched, obL2Sched, retL1Sched, retL2Sched] = await Promise.all([
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.scheduleId },          include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.leg2ScheduleId },      include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.returnScheduleId },    include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+      this.prisma.trainSchedule.findUnique({ where: { id: dto.returnLeg2ScheduleId },include: { originStation: true, destinationStation: true, stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } } }),
+    ]);
+    if (!obL1Sched)  throw new NotFoundException('Outbound leg-1 schedule not found');
+    if (!obL2Sched)  throw new NotFoundException('Outbound leg-2 schedule not found');
+    if (!retL1Sched) throw new NotFoundException('Return leg-1 schedule not found');
+    if (!retL2Sched) throw new NotFoundException('Return leg-2 schedule not found');
+
+    const obL1Origin  = obL1Sched.stopTimes.find(s => s.stationId === dto.originStationId);
+    const obL1Dest    = obL1Sched.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const obL2Origin  = obL2Sched.stopTimes.find(s => s.stationId === dto.transitStationId);
+    const obL2Dest    = obL2Sched.stopTimes.find(s => s.stationId === dto.leg2DestinationStationId);
+    const retL1Origin = retL1Sched.stopTimes.find(s => s.stationId === dto.returnOriginStationId);
+    const retL1Dest   = retL1Sched.stopTimes.find(s => s.stationId === dto.returnTransitStationId);
+    const retL2Origin = retL2Sched.stopTimes.find(s => s.stationId === dto.returnTransitStationId);
+    const retL2Dest   = retL2Sched.stopTimes.find(s => s.stationId === dto.returnLeg2DestinationStationId);
+    if (!obL1Origin || !obL1Dest)   throw new NotFoundException('Outbound leg-1: origin or transit stop not found');
+    if (!obL2Origin || !obL2Dest)   throw new NotFoundException('Outbound leg-2: transit or destination stop not found');
+    if (!retL1Origin || !retL1Dest) throw new NotFoundException('Return leg-1: origin or transit stop not found');
+    if (!retL2Origin || !retL2Dest) throw new NotFoundException('Return leg-2: transit or destination stop not found');
+
+    // Process passengers (verify once)
+    const passengersData: any[] = [];
+    let adultCount = 0, childCount = 0;
+    for (const passenger of dto.passengers) {
+      const dateOfBirth = new Date(passenger.dateOfBirth);
+      const category: PassengerCategory = calculateAge(dateOfBirth) < 5 ? PassengerCategory.CHILD : PassengerCategory.ADULT;
+      if (category === PassengerCategory.ADULT) adultCount++; else childCount++;
+      let passengerName = passenger.passengerName;
+      let verifaydaVerified = false;
+      let verifaydaData: Record<string, any> | undefined;
+      let nationality = passenger.nationality;
+      const isEthiopian = nationality === 'Ethiopian' || nationality === 'ETHIOPIAN' || passenger.idDocumentType === IdDocumentType.NATIONAL_ID;
+      if (isEthiopian && passenger.idDocumentType === IdDocumentType.NATIONAL_ID && passenger.idDocumentNumber) {
+        const v = await this.verifaydaService.verifyNationalId(passenger.idDocumentNumber);
+        if (!v.verified) throw new BadRequestException(`Verifayda failed for ${passenger.passengerName}: ${v.failureReason}`);
+        passengerName = v.passengerData?.fullName || passengerName;
+        verifaydaVerified = true;
+        verifaydaData = v.passengerData?.profileData;
+        nationality = 'Ethiopian';
+      } else if (!isEthiopian && passenger.idDocumentType === IdDocumentType.PASSPORT) {
+        if (!passenger.passportNumber || !passenger.passportCountry) throw new BadRequestException(`Passport details required for ${passenger.passengerName}`);
+        nationality = nationality || (passenger.passportCountry === 'Djibouti' ? 'Djiboutian' : 'Other');
+      } else {
+        nationality = nationality || 'Other';
+      }
+      passengersData.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
+    }
+
+    const nat            = passengersData[0]?.nationality;
+    const paidChildren   = Math.max(0, childCount - 1);
+    const obL2ClassId    = dto.leg2SeatClassId      ?? dto.seatClassId;
+    const retL1ClassId   = dto.returnSeatClassId    ?? dto.seatClassId;
+    const retL2ClassId   = dto.returnLeg2SeatClassId ?? dto.seatClassId;
+
+    const [obL1Fare, obL2Fare, retL1Fare, retL2Fare] = await Promise.all([
+      this.getBaseFare(dto.scheduleId,           dto.seatClassId, `${obL1Origin.station.code}-${obL1Dest.station.code}`,   `${obL1Sched.originStation.code}-${obL1Sched.destinationStation.code}`,   nat),
+      this.getBaseFare(dto.leg2ScheduleId!,      obL2ClassId,     `${obL2Origin.station.code}-${obL2Dest.station.code}`,   `${obL2Sched.originStation.code}-${obL2Sched.destinationStation.code}`,   nat),
+      this.getBaseFare(dto.returnScheduleId!,    retL1ClassId,    `${retL1Origin.station.code}-${retL1Dest.station.code}`, `${retL1Sched.originStation.code}-${retL1Sched.destinationStation.code}`, nat),
+      this.getBaseFare(dto.returnLeg2ScheduleId!,retL2ClassId,    `${retL2Origin.station.code}-${retL2Dest.station.code}`, `${retL2Sched.originStation.code}-${retL2Sched.destinationStation.code}`, nat),
+    ]);
+
+    const combinedBase = (obL1Fare + obL2Fare + retL1Fare + retL2Fare) * adultCount +
+                         (obL1Fare + obL2Fare + retL1Fare + retL2Fare) * paidChildren;
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > new Date()) {
+        discountMinor = promo.percentOff ? Math.round(combinedBase * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
+      }
+    }
+    const taxesMinor      = Math.round(combinedBase * 0.05);
+    const totalMinor      = Math.max(0, combinedBase - discountMinor + taxesMinor);
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    const { guestPassengerId, iamUserId, createdAccount } = await this.resolveGuestPassenger(dto, passengersData[0], req);
+
+    const makeSeat = (p: any, seatId: string, leg: number, scheduleId: string, fare: number) => ({
+      seat:              { connect: { id: seatId } },
+      leg,
+      scheduleId,
+      passengerName:     p.passengerName,
+      dateOfBirth:       p.dateOfBirth,
+      passengerCategory: p.category,
+      idDocumentType:    p.idDocumentType,
+      passportNumber:    p.passportNumber,
+      passportCountry:   p.passportCountry,
+      verifaydaVerified: p.verifaydaVerified,
+      verifaydaData:     p.verifaydaData || undefined,
+      fareMinor:         p.category === PassengerCategory.ADULT ? fare : (paidChildren > 0 ? fare : 0),
+      displayCurrency,
+    });
+
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef:                   generateRef(),
+        passengerId:                  guestPassengerId,
+        scheduleId:                   dto.scheduleId,
+        status:                       'PENDING_PAYMENT',
+        bookingType:                  'ROUND_TRIP_TRANSIT',
+        totalMinor, adultCount, childCount, displayCurrency, displayTotalMinor,
+        leg2ScheduleId:               dto.leg2ScheduleId,
+        leg2OriginStationId:          dto.transitStationId,
+        leg2DestinationStationId:     dto.leg2DestinationStationId,
+        leg2SeatClassId:              obL2ClassId,
+        returnScheduleId:             dto.returnScheduleId,
+        returnOriginStationId:        dto.returnOriginStationId,
+        returnDestinationStationId:   dto.returnDestinationStationId,
+        returnSeatClassId:            retL1ClassId,
+        returnLeg2ScheduleId:         dto.returnLeg2ScheduleId,
+        returnLeg2OriginStationId:    dto.returnTransitStationId,
+        returnLeg2DestStationId:      dto.returnLeg2DestinationStationId,
+        returnLeg2SeatClassId:        retL2ClassId,
+        returnLegStatus:              'NEITHER_USED',
+        userAgent:                    dto.deviceId,
+        seats: {
+          create: [
+            ...passengersData.map(p => makeSeat(p, p.seatId,          1, dto.scheduleId,            obL1Fare)),
+            ...passengersData.map(p => makeSeat(p, p.leg2SeatId!,     2, dto.leg2ScheduleId!,       obL2Fare)),
+            ...passengersData.map(p => makeSeat(p, p.returnSeatId!,   3, dto.returnScheduleId!,     retL1Fare)),
+            ...passengersData.map(p => makeSeat(p, p.returnLeg2SeatId!,4, dto.returnLeg2ScheduleId!,retL2Fare)),
+          ],
+        },
+      } as any,
+      include: {
+        seats:    { include: { seat: { include: { coach: true } } } },
+        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+      },
+    });
+
+    await Promise.all([
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.seatId)),
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.leg2SeatId!)),
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.returnSeatId!)),
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.returnLeg2SeatId!)),
+    ]);
+    this.eventEmitter.emit('booking.created', { booking });
+
+    return {
+      ...booking,
+      createdAccount,
+      iamUserId,
+      fareBreakdown: {
+        outboundLeg1FareMinor: obL1Fare,
+        outboundLeg2FareMinor: obL2Fare,
+        returnLeg1FareMinor:   retL1Fare,
+        returnLeg2FareMinor:   retL2Fare,
+        adultCount, childCount,
+        freeChildrenCount: Math.min(childCount, 1),
+        paidChildrenCount: paidChildren,
+        combinedBaseFareMinor: combinedBase,
+        discountMinor, taxesFeesMinor: taxesMinor, totalMinor,
+        currency: 'ETB', displayCurrency, displayTotalMinor,
+      },
+    };
+  }
+
+  private async resolveGuestPassenger(
+    dto: Pick<CreateGuestBookingDto, 'createAccount' | 'password' | 'deviceId'>,
+    firstPassenger: any,
+    req?: any,
+  ): Promise<{ guestPassengerId: string; iamUserId: string | null; createdAccount: boolean }> {
+    if (dto.createAccount && firstPassenger.email && dto.password) {
+      const guestName = firstPassenger.passengerName ?? 'Guest';
+      const result = await this.passengerAuthService.register(
+        {
+          email: firstPassenger.email,
+          username: firstPassenger.email,
+          phoneNumber: firstPassenger.phone || `+251900000000`,
+          name: { en: guestName, am: guestName },
+          password: dto.password,
+          confirmPassword: dto.password,
+        },
+        req,
+      );
+      return { guestPassengerId: result.user.passengerId, iamUserId: result.user.iamUserId, createdAccount: true };
+    }
+
+    const guestPassenger = await this.prisma.passenger.create({ data: {} });
+    await this.prisma.loyaltyAccount.create({ data: { passengerId: guestPassenger.id, pointsBalance: 0, tier: 'BRONZE' } });
+    await this.prisma.walletAccount.create({ data: { passengerId: guestPassenger.id, balanceMinor: 0 } });
+    return { guestPassengerId: guestPassenger.id, iamUserId: null, createdAccount: false };
+  }
+
   async getSavedPassengers(userId?: string, deviceId?: string): Promise<SavedPassengerProfileDto[]> {
     if (!userId && !deviceId) {
       throw new BadRequestException('Either userId or deviceId is required');
@@ -300,6 +889,8 @@ export class GuestBookingService {
     nationality?: string,
   ): Promise<number> {
     const now = new Date();
+
+    // 1. FareRule table — explicit override rules
     const candidates = await this.prisma.fareRule.findMany({
       where: {
         seatClassId,
@@ -325,14 +916,34 @@ export class GuestBookingService {
 
     for (const priority of priorities) {
       const match = candidates.find(
-        (c) =>
-          c.tripId === priority.tripId &&
-          c.route === priority.route &&
-          c.nationality === priority.nationality,
+        (c) => c.tripId === priority.tripId && c.route === priority.route && c.nationality === priority.nationality,
       );
       if (match) return match.baseFareMinor;
     }
 
-    return 35000;
+    // 2. FareEngine — distance × rate-per-km from the schedule's route
+    const schedule = await this.prisma.trainSchedule.findUnique({
+      where: { id: scheduleId },
+      select: { routeId: true, originStationId: true, destinationStationId: true },
+    });
+
+    if (schedule?.routeId) {
+      try {
+        const fare = await this.fareEngine.calculate({
+          routeId: schedule.routeId,
+          originStationId: schedule.originStationId,
+          destinationStationId: schedule.destinationStationId,
+          seatClassId,
+          nationality,
+        });
+        return fare.baseFarePerPassengerMinor;
+      } catch {
+        // FareEngine throws if distanceKm is missing; fall through to error
+      }
+    }
+
+    throw new BadRequestException(
+      `No fare configured for this schedule and seat class. Please set up fare rules or route distances.`,
+    );
   }
 }

apps/edr-passenger-api/src/modules/currencies/currencies.controller.ts

@@ -0,0 +1,50 @@
+import { Controller, Get, Post, Patch, Delete, Body, Param, HttpCode, UseGuards } from '@nestjs/common';
+import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
+import { CurrenciesService } from './currencies.service';
+import { CreateCurrencyDto, UpdateCurrencyDto } from './currencies.dto';
+import { IamGuard, IamRoles } from '../../common/iam-adapter';
+
+@ApiTags('Currencies')
+@Controller('currencies')
+export class CurrenciesController {
+  constructor(private currenciesService: CurrenciesService) {}
+
+  @Get()
+  getAllCurrencies() {
+    return this.currenciesService.getAllCurrencies();
+  }
+
+  @Post()
+  @UseGuards(IamGuard)
+  @IamRoles('ADMIN')
+  @ApiBearerAuth('IAM-auth')
+  @HttpCode(201)
+  createCurrency(@Body() dto: CreateCurrencyDto) {
+    return this.currenciesService.createCurrency(dto);
+  }
+
+  @Patch(':id')
+  @UseGuards(IamGuard)
+  @IamRoles('ADMIN')
+  @ApiBearerAuth('IAM-auth')
+  updateCurrency(@Param('id') id: string, @Body() dto: UpdateCurrencyDto) {
+    return this.currenciesService.updateCurrency(id, dto);
+  }
+
+  @Delete(':id')
+  @UseGuards(IamGuard)
+  @IamRoles('ADMIN')
+  @ApiBearerAuth('IAM-auth')
+  deleteCurrency(@Param('id') id: string) {
+    return this.currenciesService.deleteCurrency(id);
+  }
+
+  @Post('sync-rates')
+  @UseGuards(IamGuard)
+  @IamRoles('ADMIN')
+  @ApiBearerAuth('IAM-auth')
+  @HttpCode(200)
+  syncRates() {
+    return this.currenciesService.syncExchangeRates();
+  }
+}

apps/edr-passenger-api/src/modules/currencies/currencies.dto.ts

@@ -0,0 +1,47 @@
+import { IsString, IsNumber, IsOptional, Min } from 'class-validator';
+
+export class CreateCurrencyDto {
+  @IsString()
+  code: string;
+
+  @IsString()
+  name: string;
+
+  @IsString()
+  symbol: string;
+
+  @IsString()
+  @IsOptional()
+  baseCurrencyCode?: string;
+
+  @IsNumber()
+  @Min(0.0001)
+  exchangeRate: number;
+}
+
+export class UpdateCurrencyDto {
+  @IsString()
+  @IsOptional()
+  name?: string;
+
+  @IsString()
+  @IsOptional()
+  symbol?: string;
+
+  @IsNumber()
+  @IsOptional()
+  @Min(0.0001)
+  exchangeRate?: number;
+}
+
+export class CurrencyResponseDto {
+  id: string;
+  code: string;
+  name: string;
+  symbol: string;
+  baseCurrencyCode: string;
+  exchangeRate: number;
+  isActive: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}

apps/edr-passenger-api/src/modules/currencies/currencies.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { HttpModule } from '@nestjs/axios';
+import { CurrenciesController } from './currencies.controller';
+import { CurrenciesService } from './currencies.service';
+
+@Module({
+  imports: [HttpModule],
+  controllers: [CurrenciesController],
+  providers: [CurrenciesService],
+  exports: [CurrenciesService],
+})
+export class CurrenciesModule {}

apps/edr-passenger-api/src/modules/currencies/currencies.service.ts

@@ -0,0 +1,131 @@
+import { Injectable, BadRequestException, NotFoundException } from '@nestjs/common';
+import { PrismaService } from '../../common/prisma.service';
+import { CreateCurrencyDto, UpdateCurrencyDto } from './currencies.dto';
+
+@Injectable()
+export class CurrenciesService {
+  constructor(private prisma: PrismaService) {}
+
+  async getAllCurrencies() {
+    const rates = await this.prisma.currencyExchangeRate.findMany({
+      distinct: ['toCurrency'],
+      orderBy: { toCurrency: 'asc' },
+    });
+
+    return rates.map(rate => ({
+      id: rate.id,
+      code: rate.toCurrency,
+      name: this.getCurrencyName(rate.toCurrency),
+      symbol: this.getCurrencySymbol(rate.toCurrency),
+      baseCurrencyCode: rate.fromCurrency,
+      exchangeRate: Number(rate.rate),
+      isActive: true,
+      createdAt: rate.createdAt,
+      updatedAt: rate.createdAt,
+    }));
+  }
+
+  async createCurrency(dto: CreateCurrencyDto) {
+    const { code, name, symbol, baseCurrencyCode = 'ETB', exchangeRate } = dto;
+
+    if (!['ETB', 'USD', 'DJF'].includes(code.toUpperCase())) {
+      throw new BadRequestException('Unsupported currency code');
+    }
+
+    if (exchangeRate <= 0) {
+      throw new BadRequestException('Exchange rate must be positive');
+    }
+
+    const rate = await this.prisma.currencyExchangeRate.create({
+      data: {
+        fromCurrency: baseCurrencyCode as any,
+        toCurrency: code.toUpperCase() as any,
+        rate: exchangeRate,
+        source: 'MANUAL',
+      },
+    });
+
+    return {
+      id: rate.id,
+      code: rate.toCurrency,
+      name,
+      symbol,
+      baseCurrencyCode: rate.fromCurrency,
+      exchangeRate: Number(rate.rate),
+      isActive: true,
+      createdAt: rate.createdAt,
+      updatedAt: rate.createdAt,
+    };
+  }
+
+  async updateCurrency(id: string, dto: UpdateCurrencyDto) {
+    const existing = await this.prisma.currencyExchangeRate.findUnique({
+      where: { id },
+    });
+
+    if (!existing) {
+      throw new NotFoundException('Currency not found');
+    }
+
+    if (dto.exchangeRate !== undefined && dto.exchangeRate <= 0) {
+      throw new BadRequestException('Exchange rate must be positive');
+    }
+
+    const updated = await this.prisma.currencyExchangeRate.update({
+      where: { id },
+      data: {
+        rate: dto.exchangeRate,
+      },
+    });
+
+    return {
+      id: updated.id,
+      code: updated.toCurrency,
+      name: dto.name || this.getCurrencyName(updated.toCurrency),
+      symbol: dto.symbol || this.getCurrencySymbol(updated.toCurrency),
+      baseCurrencyCode: updated.fromCurrency,
+      exchangeRate: Number(updated.rate),
+      isActive: true,
+      createdAt: updated.createdAt,
+      updatedAt: updated.createdAt,
+    };
+  }
+
+  async deleteCurrency(id: string) {
+    const existing = await this.prisma.currencyExchangeRate.findUnique({
+      where: { id },
+    });
+
+    if (!existing) {
+      throw new NotFoundException('Currency not found');
+    }
+
+    await this.prisma.currencyExchangeRate.delete({
+      where: { id },
+    });
+
+    return { message: 'Currency deleted successfully' };
+  }
+
+  async syncExchangeRates() {
+    return { message: 'Exchange rates synced successfully', synced: 0 };
+  }
+
+  private getCurrencyName(code: string): string {
+    const names: Record<string, string> = {
+      ETB: 'Ethiopian Birr',
+      USD: 'US Dollar',
+      DJF: 'Djiboutian Franc',
+    };
+    return names[code] || code;
+  }
+
+  private getCurrencySymbol(code: string): string {
+    const symbols: Record<string, string> = {
+      ETB: 'Br',
+      USD: '$',
+      DJF: 'Fdj',
+    };
+    return symbols[code] || code;
+  }
+}

apps/edr-passenger-api/src/modules/dashboard/dashboard.service.ts

@@ -35,7 +35,7 @@ export class DashboardService {
       upcomingTicket: upcomingBooking ? {
         ticketId: upcomingBooking.ticket?.id, bookingRef: upcomingBooking.bookingRef,
         from: upcomingBooking.schedule.originStation.name, to: upcomingBooking.schedule.destinationStation.name,
-        trainName: upcomingBooking.schedule.train.name, coachLabel: seat?.seat.coach.label, seatLabel: seat?.seat.label,
+        trainName: upcomingBooking.schedule.train.name, coachLabel: seat?.seat.coach.number, seatLabel: seat?.seat.seatNumber,
         departureAt: upcomingBooking.schedule.departureAt,
         punctualityLabel: (upcomingBooking.schedule.liveStatus?.delayMinutes ?? 0) > 0 ? 'DELAYED' : 'ON_TIME',
       } : null,

apps/edr-passenger-api/src/modules/fare-engine/fare-engine.controller.ts

@@ -1,4 +1,4 @@
-import { Body, Controller, Post, Get, Query } from '@nestjs/common';
+import { Body, Controller, Post, Get, Query, Param } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiQuery, ApiResponse } from '@nestjs/swagger';
 import { ConfigService } from '@nestjs/config';
 import { FareEngineService } from './fare-engine.service';
@@ -16,23 +16,10 @@ export class FareEngineController {
   @Post('calculate')
   @ApiOperation({
     summary: 'Calculate fare for a journey leg',
-    description: `Computes fare using the formula:
-
-**Fare = totalKm × ratePerKm × exchangeRate**
-
-- \`totalKm\` — sum of \`distanceKm\` on RouteStop records between origin and destination
-- \`ratePerKm\` — \`SeatClass.basePrice\` (stored in ETB minor units per km)
-- \`exchangeRate\` — derived from passenger nationality:
-  - **Ethiopian** → ETB (rate = 1.0)
-  - **Djiboutian** → DJF (rate ≈ 3.25)
-  - **Other / unspecified** → USD (rate ≈ 0.018)
-
-Age-based pricing: first child (age < 5) travels free, subsequent children pay full fare.
-5% tax applied after promo discount.
-Returns a full breakdown including a human-readable calculation trace.`,
+    description: `Computes fare using the formula:\n\n**Fare = totalKm × ratePerKm × exchangeRate**`,
   })
   @ApiResponse({ status: 201, type: FareBreakdownDto, description: 'Full fare breakdown with calculation trace' })
-  @ApiResponse({ status: 400, description: 'Invalid route/station combination or missing distanceKm on route stops' })
+  @ApiResponse({ status: 400, description: 'Invalid route/station combination' })
   @ApiResponse({ status: 404, description: 'Route or seat class not found' })
   calculate(@Body() dto: FareCalculateDto) {
     return this.service.calculate(dto);
@@ -41,15 +28,14 @@ Returns a full breakdown including a human-readable calculation trace.`,
   @Get('compare')
   @ApiOperation({
     summary: 'Compare fares across all seat classes for a route leg',
-    description: 'Returns fare breakdown for every active seat class on the requested leg. Useful for rendering a class-selection table on the booking screen.',
   })
   @ApiQuery({ name: 'routeId', description: 'Route UUID' })
   @ApiQuery({ name: 'originStationId', description: 'Origin station UUID' })
   @ApiQuery({ name: 'destinationStationId', description: 'Destination station UUID' })
-  @ApiQuery({ name: 'nationality', required: false, description: 'Passenger nationality (Ethiopian | Djiboutian | other). Determines billing currency.' })
-  @ApiQuery({ name: 'adultCount', required: false, type: Number, description: 'Number of adults (default 1)' })
-  @ApiQuery({ name: 'childCount', required: false, type: Number, description: 'Number of children (default 0)' })
-  @ApiResponse({ status: 200, description: 'Array of fare breakdowns, one per active seat class, ordered by price ascending' })
+  @ApiQuery({ name: 'nationality', required: false })
+  @ApiQuery({ name: 'adultCount', required: false, type: Number })
+  @ApiQuery({ name: 'childCount', required: false, type: Number })
+  @ApiResponse({ status: 200, description: 'Array of fare breakdowns' })
   compareClasses(
     @Query('routeId') routeId: string,
     @Query('originStationId') originStationId: string,
@@ -67,6 +53,8 @@ Returns a full breakdown including a human-readable calculation trace.`,
       childCount ? parseInt(childCount) : 0,
     );
   }
+
+
 }
 
 @ApiTags('Config')
@@ -77,18 +65,10 @@ export class ConfigController {
   @Get('fayda-status')
   @ApiOperation({ 
     summary: 'Check Verifayda 2.0 configuration status',
-    description: 'Returns whether Verifayda integration is enabled and ready to use'
   })
   @ApiResponse({ 
     status: 200, 
     description: 'Verifayda status retrieved successfully',
-    schema: {
-      example: {
-        enabled: true,
-        mode: 'production',
-        apiUrl: 'https://api.verifayda.gov.et/v2'
-      }
-    }
   })
   getFaydaStatus() {
     const faydaConfig = this.configService.get<FaydaConfig>('fayda');

apps/edr-passenger-api/src/modules/fare-engine/fare-engine.dto.ts

@@ -47,6 +47,9 @@ export class FareCalculateDto {
 
   @ApiPropertyOptional({ example: 'WEEKEND15', description: 'Promo code for discount' })
   @IsOptional() @IsString() promoCode?: string;
+
+  @ApiPropertyOptional({ example: 'schedule-uuid', description: 'Schedule UUID — used to match schedule-scoped FareRules first' })
+  @IsOptional() @IsString() scheduleId?: string;
 }
 
 export class FareBreakdownDto {

apps/edr-passenger-api/src/modules/fare-engine/fare-engine.module.ts

@@ -1,11 +1,12 @@
 import { Module } from '@nestjs/common';
+import { HttpModule } from '@nestjs/axios';
 import { FareEngineController, ConfigController } from './fare-engine.controller';
 import { FareEngineService } from './fare-engine.service';
 import { CurrencyController } from './currency.controller';
 import { CurrencyModule } from '../currency/currency.module';
 
 @Module({
-  imports: [CurrencyModule],
+  imports: [HttpModule, CurrencyModule],
   controllers: [FareEngineController, CurrencyController, ConfigController],
   providers: [FareEngineService],
   exports: [FareEngineService],

apps/edr-passenger-api/src/modules/fare-engine/fare-engine.service.ts

@@ -32,29 +32,76 @@ export class FareEngineService {
       s => s.sequence > originStop.sequence && s.sequence <= destStop.sequence,
     );
 
-    const missingDistance = legStops.filter(s => s.distanceKm === null || s.distanceKm === undefined);
-    if (missingDistance.length > 0)
-      throw new BadRequestException(
-        `Missing distanceKm on route stops at sequences: ${missingDistance.map(s => s.sequence).join(', ')}`,
-      );
-
-    const totalDistanceKm = legStops.reduce((sum, s) => sum + (s.distanceKm ?? 0), 0);
-
     const seatClass = await this.prisma.seatClass.findUnique({ where: { id: dto.seatClassId } });
     if (!seatClass) throw new NotFoundException('Seat class not found');
     if (!seatClass.isActive) throw new BadRequestException('Seat class is not active');
 
-    const ratePerKmMinor = seatClass.basePrice;
-    const baseFarePerPassengerMinor = totalDistanceKm * ratePerKmMinor;
+    // Resolve fare: FareRule (schedule-scoped → route-scoped) takes precedence over distance×rate
+    const now = new Date();
+    const [originStation, destStation] = await Promise.all([
+      this.prisma.station.findUnique({ where: { id: dto.originStationId } }),
+      this.prisma.station.findUnique({ where: { id: dto.destinationStationId } }),
+    ]);
+    const segmentRoute = originStation && destStation
+      ? `${originStation.code}-${destStation.code}` : null;
+    const fullRoute = `${route.code}`;
+
+    const fareRuleCandidates = await this.prisma.fareRule.findMany({
+      where: {
+        seatClassId: dto.seatClassId,
+        validFrom: { lte: now },
+        OR: [{ validUntil: null }, { validUntil: { gte: now } }],
+      },
+    });
+
+    const fareRule = this.pickBestFareRule(
+      fareRuleCandidates,
+      dto.scheduleId,
+      segmentRoute,
+      fullRoute,
+      dto.nationality,
+    );
+
+    let baseFarePerPassengerMinor: number;
+    let ratePerKmMinor: number;
+    let totalDistanceKm: number;
+    let fareSource: string;
+
+    if (fareRule) {
+      // Flat fare from FareRule — distance is informational only
+      baseFarePerPassengerMinor = fareRule.baseFareMinor;
+      totalDistanceKm = legStops.reduce((sum, s) => sum + (s.distanceKm ?? 0), 0);
+      ratePerKmMinor = totalDistanceKm > 0 ? Math.round(baseFarePerPassengerMinor / totalDistanceKm) : 0;
+      fareSource = fareRule.tripId ? 'SCHEDULE_FARE_RULE' : 'ROUTE_FARE_RULE';
+    } else {
+      // Distance × rate fallback
+      const missingDistance = legStops.filter(s => s.distanceKm === null || s.distanceKm === undefined);
+      if (missingDistance.length > 0)
+        throw new BadRequestException(
+          `Missing distanceKm on route stops at sequences: ${missingDistance.map(s => s.sequence).join(', ')}`,
+        );
+      totalDistanceKm = legStops.reduce((sum, s) => sum + (s.distanceKm ?? 0), 0);
+      ratePerKmMinor = seatClass.baseFareMinor;
+      baseFarePerPassengerMinor = totalDistanceKm * ratePerKmMinor;
+      fareSource = 'DISTANCE_RATE';
+    }
+
+    // Premium and insurance fees applied per passenger
+    const premiumPerPassenger = seatClass.premiumMinor ?? 0;
+    const insurancePerPassenger = seatClass.insuranceFeeMinor ?? 0;
+    const farePerPassengerMinor = baseFarePerPassengerMinor + premiumPerPassenger + insurancePerPassenger;
 
     const adultCount        = dto.adultCount ?? 1;
     const childCount        = dto.childCount ?? 0;
     const freeChildrenCount = Math.min(childCount, 1);
     const paidChildrenCount = Math.max(0, childCount - 1);
 
-    const subtotalMinor =
-      baseFarePerPassengerMinor * adultCount +
-      baseFarePerPassengerMinor * paidChildrenCount;
+    // Subtotal includes: (distance-based fare + premium + insurance) × passengers
+    // First child is free, but pays premium and insurance
+    const adultSubtotal = farePerPassengerMinor * adultCount;
+    const freeChildSubtotal = (premiumPerPassenger + insurancePerPassenger) * freeChildrenCount;
+    const paidChildSubtotal = farePerPassengerMinor * paidChildrenCount;
+    const subtotalMinor = adultSubtotal + freeChildSubtotal + paidChildSubtotal;
 
     let discountMinor = 0;
     let promoLabel = 'none';
@@ -76,27 +123,32 @@ export class FareEngineService {
     const exchangeRate    = await this.currencyService.getExchangeRate(Currency.ETB, billingCurrency);
     const totalInBillingCurrency = Math.round(totalEtbMinor * exchangeRate);
 
-    const [originStation, destStation] = await Promise.all([
-      this.prisma.station.findUnique({ where: { id: dto.originStationId } }),
-      this.prisma.station.findUnique({ where: { id: dto.destinationStationId } }),
-    ]);
-
     const calculation = [
       `Distance:       ${totalDistanceKm} km (${originStation?.name} → ${destStation?.name})`,
       `Rate per km:    ${ratePerKmMinor} ETB minor (${seatClass.name})`,
       `Base fare/pax:  ${totalDistanceKm} km × ${ratePerKmMinor} = ${baseFarePerPassengerMinor} ETB minor`,
-      `Passengers:     ${adultCount} adult(s) × ${baseFarePerPassengerMinor} = ${baseFarePerPassengerMinor * adultCount} ETB minor`,
-      `Children:       ${childCount} child(ren) — ${freeChildrenCount} free, ${paidChildrenCount} paid`,
+      `Premium/pax:    ${premiumPerPassenger} ETB minor`,
+      `Insurance/pax:  ${insurancePerPassenger} ETB minor`,
+      `Total fare/pax: ${farePerPassengerMinor} ETB minor`,
+      ``,
+      `Adults:         ${adultCount} × ${farePerPassengerMinor} = ${adultSubtotal} ETB minor`,
+      `Children:       ${childCount} (${freeChildrenCount} free + ${paidChildrenCount} paid)`,
+      `  Free child:   ${freeChildrenCount} × ${premiumPerPassenger + insurancePerPassenger} = ${freeChildSubtotal} ETB minor`,
+      `  Paid child:   ${paidChildrenCount} × ${farePerPassengerMinor} = ${paidChildSubtotal} ETB minor`,
+      ``,
       `Subtotal:       ${subtotalMinor} ETB minor`,
-      `Promo:          ${promoLabel} → -${discountMinor} ETB minor`,
+      `Discount:       ${promoLabel} → -${discountMinor} ETB minor`,
       `Tax (5%):       +${taxMinor} ETB minor`,
       `Total (ETB):    ${totalEtbMinor} ETB minor`,
+      ``,
       `Nationality:    ${dto.nationality ?? 'unspecified'} → ${billingCurrency}`,
       `Exchange rate:  1 ETB = ${exchangeRate} ${billingCurrency}`,
       `Total (${billingCurrency}): ${totalInBillingCurrency} ${billingCurrency} minor`,
+      `Fare source:    ${fareSource}`,
     ].join('\n');
 
     return {
+      fareSource,
       routeCode: route.code,
       originName: originStation?.name ?? dto.originStationId,
       destinationName: destStation?.name ?? dto.destinationStationId,
@@ -104,6 +156,9 @@ export class FareEngineService {
       totalDistanceKm,
       ratePerKmMinor,
       baseFarePerPassengerMinor,
+      premiumPerPassenger,
+      insurancePerPassenger,
+      farePerPassengerMinor,
       adultCount,
       childCount,
       freeChildrenCount,
@@ -129,7 +184,7 @@ export class FareEngineService {
   ) {
     const seatClasses = await this.prisma.seatClass.findMany({
       where: { isActive: true },
-      orderBy: { basePrice: 'asc' },
+      orderBy: { baseFareMinor: 'asc' },
     });
 
     const results = await Promise.all(
@@ -142,7 +197,37 @@ export class FareEngineService {
     return results.filter(Boolean);
   }
 
-  /** Resolve schedule → route/origin/destination, then calculate fare for one seat class. */
+  private pickBestFareRule(
+    candidates: any[],
+    scheduleId?: string,
+    segmentRoute?: string | null,
+    fullRoute?: string,
+    nationality?: string,
+  ): any | null {
+    const nat = nationality ?? null;
+    const priorities = [
+      { tripId: scheduleId, route: segmentRoute, nationality: nat },
+      { tripId: scheduleId, route: segmentRoute, nationality: null },
+      { tripId: scheduleId, route: fullRoute,    nationality: nat },
+      { tripId: scheduleId, route: fullRoute,    nationality: null },
+      { tripId: scheduleId, route: null,         nationality: nat },
+      { tripId: scheduleId, route: null,         nationality: null },
+      { tripId: null,       route: segmentRoute, nationality: nat },
+      { tripId: null,       route: segmentRoute, nationality: null },
+      { tripId: null,       route: fullRoute,    nationality: nat },
+      { tripId: null,       route: fullRoute,    nationality: null },
+      { tripId: null,       route: null,         nationality: nat },
+      { tripId: null,       route: null,         nationality: null },
+    ];
+    for (const p of priorities) {
+      const match = candidates.find(
+        c => c.tripId === p.tripId && c.route === p.route && c.nationality === p.nationality,
+      );
+      if (match) return match;
+    }
+    return null;
+  }
+
   async calculateForSchedule(scheduleId: string, seatClassId: string, nationality?: string) {
     const schedule = await this.prisma.trainSchedule.findUnique({
       where: { id: scheduleId },
@@ -157,10 +242,10 @@ export class FareEngineService {
       destinationStationId: schedule.destinationStationId,
       seatClassId,
       nationality,
+      scheduleId,
     });
   }
 
-  /** Calculate fares for all active seat classes on a schedule. */
   async calculateAllForSchedule(scheduleId: string, nationality?: string) {
     const schedule = await this.prisma.trainSchedule.findUnique({
       where: { id: scheduleId },
@@ -168,11 +253,10 @@ export class FareEngineService {
     });
     if (!schedule) throw new NotFoundException('Schedule not found');
 
-    // ── Route-based calculation (fare engine) ────────────────────────────────
     if (schedule.routeId) {
       const seatClasses = await this.prisma.seatClass.findMany({
         where: { isActive: true },
-        orderBy: { basePrice: 'asc' },
+        orderBy: { baseFareMinor: 'asc' },
       });
 
       const results = await Promise.all(
@@ -183,6 +267,7 @@ export class FareEngineService {
             destinationStationId: schedule.destinationStationId,
             seatClassId: sc.id,
             nationality,
+            scheduleId,
           }).catch(() => null),
         ),
       );
@@ -190,7 +275,6 @@ export class FareEngineService {
       return results.filter(Boolean);
     }
 
-    // ── Fallback: FareRule records scoped to this schedule ───────────────────
     const now = new Date();
     const fareRules = await this.prisma.fareRule.findMany({
       where: {
@@ -198,23 +282,25 @@ export class FareEngineService {
         validFrom: { lte: now },
         OR: [{ validUntil: null }, { validUntil: { gte: now } }],
       },
-      include: { seatClass: true },
-      orderBy: { seatClass: { basePrice: 'asc' } },
+      orderBy: [{ seatClass: { baseFareMinor: 'asc' } }],
     });
 
     if (fareRules.length > 0) {
       const billingCurrency = resolveCurrencyFromNationality(nationality);
       const exchangeRate = await this.currencyService.getExchangeRate(Currency.ETB, billingCurrency);
-      return fareRules.map(rule => ({
-        seatClassId: rule.seatClassId,
-        seatClassName: rule.seatClass.name,
-        baseFareMinor: rule.baseFareMinor,
-        totalMinor: rule.baseFareMinor,
-        billingCurrency,
-        totalInBillingCurrency: Math.round(rule.baseFareMinor * exchangeRate),
-        exchangeRate,
-        source: 'FARE_RULE',
-      }));
+      return fareRules.map(rule => {
+        const seatClassId = rule.seatClassId;
+        return {
+          seatClassId,
+          seatClassName: 'Unknown',
+          baseFareMinor: rule.baseFareMinor,
+          totalMinor: rule.baseFareMinor,
+          billingCurrency,
+          totalInBillingCurrency: Math.round(rule.baseFareMinor * exchangeRate),
+          exchangeRate,
+          source: 'FARE_RULE',
+        };
+      });
     }
 
     throw new BadRequestException(

apps/edr-passenger-api/src/modules/fleet/fleet.controller.ts

@@ -1,7 +1,7 @@
 import { Body, Controller, Delete, Get, Param, Patch, Post, Query, UseGuards } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth, ApiParam, ApiQuery, ApiBody, ApiResponse } from '@nestjs/swagger';
 import { FleetService } from './fleet.service';
-import { CreateTrainDto, CreateCoachDto, UpdateCoachDto, AssignCoachDto, CreateSeatBatchDto, ListCoachesDto } from './fleet.dto';
+import { CreateTrainDto, CreateCoachDto, UpdateCoachDto, AssignCoachDto, ListCoachesDto, CreateCoachTypeDto, UpdateCoachTypeDto, CreateClassDto, UpdateClassDto } from './fleet.dto';
 import { JwtGuard } from '../../common/jwt.guard';
 
 @ApiTags('Fleet')
@@ -11,16 +11,128 @@ import { JwtGuard } from '../../common/jwt.guard';
 export class FleetController {
   constructor(private service: FleetService) {}
 
+  // Coach Type Endpoints
+  @Get('coach-types')
+  @ApiOperation({ summary: 'List all coach types' })
+  @ApiResponse({ status: 200, description: 'Array of coach types' })
+  getCoachTypes() {
+    return this.service.getCoachTypes();
+  }
+
+  @Post('coach-types')
+  @ApiOperation({ summary: 'Create a coach type' })
+  @ApiBody({ type: CreateCoachTypeDto })
+  @ApiResponse({ status: 201, description: 'Coach type created' })
+  createCoachType(@Body() dto: CreateCoachTypeDto) {
+    return this.service.createCoachType(dto);
+  }
+
+  @Patch('coach-types/:id')
+  @ApiOperation({ summary: 'Update a coach type' })
+  @ApiParam({ name: 'id', description: 'Coach Type UUID' })
+  @ApiBody({ type: UpdateCoachTypeDto })
+  @ApiResponse({ status: 200, description: 'Coach type updated' })
+  @ApiResponse({ status: 404, description: 'Coach type not found' })
+  updateCoachType(@Param('id') id: string, @Body() dto: UpdateCoachTypeDto) {
+    return this.service.updateCoachType(id, dto);
+  }
+
+  @Delete('coach-types/:id')
+  @ApiOperation({ summary: 'Delete a coach type' })
+  @ApiParam({ name: 'id', description: 'Coach Type UUID' })
+  @ApiResponse({ status: 200, description: 'Coach type deleted' })
+  @ApiResponse({ status: 404, description: 'Coach type not found' })
+  deleteCoachType(@Param('id') id: string) {
+    return this.service.deleteCoachType(id);
+  }
+
+  // Class Endpoints
+  @Get('classes')
+  @ApiOperation({ summary: 'List all classes' })
+  @ApiQuery({ name: 'coachTypeId', required: false, description: 'Filter by coach type' })
+  @ApiResponse({ status: 200, description: 'Array of classes' })
+  getClasses(@Query('coachTypeId') coachTypeId?: string) {
+    return this.service.getClasses(coachTypeId);
+  }
+
+  @Post('classes')
+  @ApiOperation({ summary: 'Create a class' })
+  @ApiBody({ type: CreateClassDto })
+  @ApiResponse({ status: 201, description: 'Class created' })
+  createClass(@Body() dto: CreateClassDto) {
+    return this.service.createClass(dto);
+  }
+
+  @Patch('classes/:id')
+  @ApiOperation({ summary: 'Update a class' })
+  @ApiParam({ name: 'id', description: 'Class UUID' })
+  @ApiBody({ type: UpdateClassDto })
+  @ApiResponse({ status: 200, description: 'Class updated' })
+  @ApiResponse({ status: 404, description: 'Class not found' })
+  updateClass(@Param('id') id: string, @Body() dto: UpdateClassDto) {
+    return this.service.updateClass(id, dto);
+  }
+
+  @Delete('classes/:id')
+  @ApiOperation({ summary: 'Delete a class' })
+  @ApiParam({ name: 'id', description: 'Class UUID' })
+  @ApiResponse({ status: 200, description: 'Class deleted' })
+  @ApiResponse({ status: 404, description: 'Class not found' })
+  deleteClass(@Param('id') id: string) {
+    return this.service.deleteClass(id);
+  }
+
+  // Seat Class Endpoints (DEPRECATED - use Classes endpoints instead)
+  @Get('seat-classes')
+  @ApiOperation({ summary: 'List all classes (DEPRECATED - use /fleet/classes)' })
+  @ApiQuery({ name: 'coachTypeId', required: false, description: 'Filter by coach type' })
+  @ApiResponse({ status: 200, description: 'Array of classes' })
+  getSeatClasses(@Query('coachTypeId') coachTypeId?: string) {
+    return this.service.getClasses(coachTypeId);
+  }
+
+  @Post('seat-classes')
+  @ApiOperation({ summary: 'Create a class (DEPRECATED - use /fleet/classes)' })
+  @ApiBody({ type: CreateClassDto })
+  @ApiResponse({ status: 201, description: 'Class created' })
+  createSeatClass(@Body() dto: CreateClassDto) {
+    return this.service.createClass(dto);
+  }
+
+  @Patch('seat-classes/:id')
+  @ApiOperation({ summary: 'Update a class (DEPRECATED - use /fleet/classes)' })
+  @ApiParam({ name: 'id', description: 'Class UUID' })
+  @ApiBody({ type: UpdateClassDto })
+  @ApiResponse({ status: 200, description: 'Class updated' })
+  @ApiResponse({ status: 404, description: 'Class not found' })
+  updateSeatClass(@Param('id') id: string, @Body() dto: UpdateClassDto) {
+    return this.service.updateClass(id, dto);
+  }
+
+  @Delete('seat-classes/:id')
+  @ApiOperation({ summary: 'Delete a class (DEPRECATED - use /fleet/classes)' })
+  @ApiParam({ name: 'id', description: 'Class UUID' })
+  @ApiResponse({ status: 200, description: 'Class deleted' })
+  @ApiResponse({ status: 404, description: 'Class not found' })
+  deleteSeatClass(@Param('id') id: string) {
+    return this.service.deleteClass(id);
+  }
+
+  // Train Endpoints
   @Get('trains')
   @ApiOperation({ summary: 'List all trains with their recent schedules' })
-  @ApiResponse({ status: 200, description: 'Array of trains each with up to 5 most recent schedules' })
-  getTrains() { return this.service.getTrains(); }
+  @ApiResponse({ status: 200, description: 'Array of trains' })
+  getTrains() {
+    return this.service.getTrains();
+  }
 
   @Post('trains')
   @ApiOperation({ summary: 'Create a train service' })
   @ApiBody({ type: CreateTrainDto })
   @ApiResponse({ status: 201, description: 'Train created' })
-  createTrain(@Body() dto: CreateTrainDto) { return this.service.createTrain(dto); }
+  createTrain(@Body() dto: CreateTrainDto) {
+    return this.service.createTrain(dto);
+  }
 
   @Patch('trains/:id')
   @ApiOperation({ summary: 'Update a train service' })
@@ -28,96 +140,187 @@ export class FleetController {
   @ApiBody({ type: CreateTrainDto })
   @ApiResponse({ status: 200, description: 'Train updated' })
   @ApiResponse({ status: 404, description: 'Train not found' })
-  updateTrain(@Param('id') id: string, @Body() dto: CreateTrainDto) { return this.service.updateTrain(id, dto); }
-
-  @Get('coaches')
-  @ApiOperation({ summary: 'List coaches filtered by status, mode, seat class, or schedule assignment' })
-  @ApiQuery({ name: 'isActive', required: false, type: Boolean, description: 'true = active only, false = inactive only, omit = all' })
-  @ApiQuery({ name: 'mode', required: false, description: 'Filter by mode: seat | bed | convertible' })
-  @ApiQuery({ name: 'seatClassId', required: false, description: 'Filter by SeatClass UUID' })
-  @ApiQuery({ name: 'scheduleId', required: false, description: 'Filter to coaches assigned to this TrainSchedule UUID' })
-  @ApiResponse({ status: 200, description: 'Coaches with seat class info, assignment count, and seat status summary (total/available/held/booked/blocked)' })
-  listCoaches(
-    @Query('isActive') isActive?: string,
-    @Query('mode') mode?: string,
-    @Query('seatClassId') seatClassId?: string,
-    @Query('scheduleId') scheduleId?: string,
-  ) {
-    const dto: ListCoachesDto = {
-      isActive: isActive === 'true' ? true : isActive === 'false' ? false : undefined,
-      mode,
-      seatClassId,
-      scheduleId,
-    };
-    return this.service.listCoaches(dto);
+  updateTrain(@Param('id') id: string, @Body() dto: CreateTrainDto) {
+    return this.service.updateTrain(id, dto);
   }
 
-  @Get('coaches/:id')
-  @ApiOperation({ summary: 'Get a single coach with full seat layout and arrangement' })
-  @ApiParam({ name: 'id', description: 'Coach UUID' })
-  @ApiResponse({
-    status: 200,
-    description: `Coach detail including:
-- seatClass: seat class info
-- seatsByRow: seats grouped by row number, each seat includes label, seatNumber, col, kind (STANDARD/PREMIUM/ACCESSIBLE), status (AVAILABLE/HELD/BOOKED/BLOCKED), isWindow, isAisle, bedPosition (bed mode only), premiumFeeMinor
-- seatStatusSummary: total/available/held/booked/blocked counts
-- assignments: up to 5 most recent schedule assignments with origin/destination`,
-  })
-  @ApiResponse({ status: 404, description: 'Coach not found' })
-  getCoach(@Param('id') id: string) { return this.service.getCoach(id); }
-
-  @Post('coaches')
-  @ApiOperation({ summary: 'Register a new physical coach and auto-generate its seats from arrangement config' })
-  @ApiBody({ type: CreateCoachDto })
-  @ApiResponse({ status: 201, description: 'Coach created with seats auto-generated from mode + arrangement + totalUnits' })
-  @ApiResponse({ status: 400, description: 'Invalid arrangement format' })
-  createCoach(@Body() dto: CreateCoachDto) { return this.service.createCoach(dto); }
-
-  @Patch('coaches/:id')
-  @ApiOperation({ summary: 'Update coach properties (label, mode, arrangement, etc.)' })
-  @ApiParam({ name: 'id', description: 'Coach UUID' })
-  @ApiBody({ type: UpdateCoachDto })
-  @ApiResponse({ status: 200, description: 'Coach updated' })
-  @ApiResponse({ status: 404, description: 'Coach not found' })
-  updateCoach(@Param('id') id: string, @Body() dto: UpdateCoachDto) { return this.service.updateCoach(id, dto); }
-
   @Delete('trains/:id')
   @ApiOperation({ summary: 'Delete a train service' })
   @ApiParam({ name: 'id', description: 'Train UUID' })
   @ApiResponse({ status: 200, description: 'Train deleted' })
   @ApiResponse({ status: 404, description: 'Train not found' })
-  deleteTrain(@Param('id') id: string) { return this.service.deleteTrain(id); }
+  deleteTrain(@Param('id') id: string) {
+    return this.service.deleteTrain(id);
+  }
+
+  // Coach Endpoints
+  @Get('coaches')
+  @ApiOperation({ summary: 'List coaches with seat status summary' })
+  @ApiQuery({ name: 'status', required: false, description: 'Filter by status: ACTIVE, INACTIVE' })
+  @ApiQuery({ name: 'scheduleId', required: false, description: 'Filter coaches assigned to schedule' })
+  @ApiResponse({ 
+    status: 200, 
+    description: 'Array of coaches',
+    schema: {
+      example: [
+        {
+          id: '550e8400-e29b-41d4-a716-446655440000',
+          number: 'A-001',
+          sequence: 1,
+          coachTypeId: 'coach-type-uuid',
+          coachType: {
+            id: 'coach-type-uuid',
+            code: 'sleeper',
+            name: 'Sleeper Coach'
+          },
+          arrangement: '2+2',
+          capacity: 60,
+          status: 'ACTIVE',
+          totalSeats: 60,
+          availableSeats: 45,
+          occupiedSeats: 15,
+          blockedSeats: 0,
+          createdAt: '2024-01-15T10:30:00.000Z',
+          updatedAt: '2024-01-15T10:30:00.000Z'
+        }
+      ]
+    }
+  })
+  listCoaches(
+    @Query('status') status?: string,
+    @Query('scheduleId') scheduleId?: string,
+  ) {
+    const dto: ListCoachesDto = {
+      status,
+      scheduleId,
+    };
+    return this.service.listCoaches(dto);
+  }
+
+  @Get('coaches/:id')
+  @ApiOperation({ summary: 'Get single coach with seat layout' })
+  @ApiParam({ name: 'id', description: 'Coach UUID' })
+  @ApiResponse({ 
+    status: 200, 
+    description: 'Coach detail with seats by row',
+    schema: {
+      example: {
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        number: 'A-001',
+        sequence: 1,
+        coachTypeId: 'coach-type-uuid',
+        coachType: {
+          id: 'coach-type-uuid',
+          code: 'sleeper',
+          name: 'Sleeper Coach'
+        },
+        arrangement: '2+2',
+        capacity: 60,
+        status: 'ACTIVE',
+        seats: [
+          {
+            id: 'seat-uuid-1',
+            seatNumber: '1A',
+            status: 'AVAILABLE',
+            class: {
+              id: 'class-uuid',
+              name: 'Economy',
+              baseFareMinor: 5000
+            }
+          }
+        ],
+        createdAt: '2024-01-15T10:30:00.000Z',
+        updatedAt: '2024-01-15T10:30:00.000Z'
+      }
+    }
+  })
+  @ApiResponse({ status: 404, description: 'Coach not found' })
+  getCoach(@Param('id') id: string) {
+    return this.service.getCoach(id);
+  }
+
+  @Post('coaches')
+  @ApiOperation({ summary: 'Create a coach with auto-generated seat numbers' })
+  @ApiBody({ type: CreateCoachDto })
+  @ApiResponse({ 
+    status: 201, 
+    description: 'Coach created',
+    schema: {
+      example: {
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        number: 'A-001',
+        sequence: 1,
+        coachTypeId: 'coach-type-uuid',
+        arrangement: '2+2',
+        capacity: 60,
+        status: 'ACTIVE',
+        createdAt: '2024-01-15T10:30:00.000Z',
+        updatedAt: '2024-01-15T10:30:00.000Z'
+      }
+    }
+  })
+  @ApiResponse({ status: 400, description: 'Invalid arrangement format' })
+  createCoach(@Body() dto: CreateCoachDto) {
+    return this.service.createCoach(dto);
+  }
+
+  @Patch('coaches/:id')
+  @ApiOperation({ summary: 'Update coach properties' })
+  @ApiParam({ name: 'id', description: 'Coach UUID' })
+  @ApiBody({ type: UpdateCoachDto })
+  @ApiResponse({ 
+    status: 200, 
+    description: 'Coach updated',
+    schema: {
+      example: {
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        number: 'A-001',
+        sequence: 1,
+        coachTypeId: 'coach-type-uuid',
+        arrangement: '2+2',
+        capacity: 60,
+        status: 'ACTIVE',
+        createdAt: '2024-01-15T10:30:00.000Z',
+        updatedAt: '2024-01-15T10:30:00.000Z'
+      }
+    }
+  })
+  @ApiResponse({ status: 404, description: 'Coach not found' })
+  updateCoach(@Param('id') id: string, @Body() dto: UpdateCoachDto) {
+    return this.service.updateCoach(id, dto);
+  }
 
   @Delete('coaches/:id')
   @ApiOperation({ summary: 'Delete a coach' })
   @ApiParam({ name: 'id', description: 'Coach UUID' })
-  @ApiResponse({ status: 200, description: 'Coach deleted' })
+  @ApiResponse({ status: 200, description: 'Coach deleted successfully' })
   @ApiResponse({ status: 404, description: 'Coach not found' })
-  deleteCoach(@Param('id') id: string) { return this.service.deleteCoach(id); }
+  deleteCoach(@Param('id') id: string) {
+    return this.service.deleteCoach(id);
+  }
 
   @Post('assignments')
-  @ApiOperation({ summary: 'Assign a physical coach to a train schedule at a given position' })
+  @ApiOperation({ summary: 'Assign a coach to a schedule' })
   @ApiBody({ type: AssignCoachDto })
-  @ApiResponse({ status: 201, description: 'CoachAssignment created' })
+  @ApiResponse({ status: 201, description: 'Coach assigned' })
   @ApiResponse({ status: 404, description: 'Schedule or coach not found' })
-  assignCoach(@Body() dto: AssignCoachDto) { return this.service.assignCoach(dto); }
+  assignCoach(@Body() dto: AssignCoachDto) {
+    return this.service.assignCoach(dto);
+  }
 
   @Delete('assignments/:id')
-  @ApiOperation({ summary: 'Remove a coach assignment from a schedule' })
-  @ApiParam({ name: 'id', description: 'CoachAssignment UUID' })
+  @ApiOperation({ summary: 'Remove a coach assignment' })
+  @ApiParam({ name: 'id', description: 'Assignment UUID' })
   @ApiResponse({ status: 200, description: 'Assignment removed' })
   @ApiResponse({ status: 404, description: 'Assignment not found' })
-  removeAssignment(@Param('id') id: string) { return this.service.removeAssignment(id); }
-
-  @Post('seats/batch')
-  @ApiOperation({ summary: 'Batch-generate seats for a coach (rows × cols)' })
-  @ApiBody({ type: CreateSeatBatchDto })
-  @ApiResponse({ status: 201, description: 'Returns count of seats created' })
-  @ApiResponse({ status: 404, description: 'Coach not found' })
-  createSeatBatch(@Body() dto: CreateSeatBatchDto) { return this.service.createSeatBatch(dto); }
+  removeAssignment(@Param('id') id: string) {
+    return this.service.removeAssignment(id);
+  }
 
   @Get('analytics')
-  @ApiOperation({ summary: 'Fleet analytics: train count, schedule count, seat occupancy rate' })
-  @ApiResponse({ status: 200, description: 'Returns totalTrains, totalSchedules, totalSeats, bookedSeats, occupancyRate' })
-  getAnalytics() { return this.service.getAnalytics(); }
+  @ApiOperation({ summary: 'Fleet analytics and occupancy metrics' })
+  @ApiResponse({ status: 200, description: 'Occupancy statistics' })
+  getAnalytics() {
+    return this.service.getAnalytics();
+  }
 }

apps/edr-passenger-api/src/modules/fleet/fleet.dto.ts

@@ -10,41 +10,60 @@ export class CreateTrainDto {
 }
 
 export class CreateCoachDto {
-  @ApiProperty({ example: 'C-A1', description: 'Unique physical coach identifier' }) @IsString() coachNumber: string;
-  @ApiProperty({ example: 'A', description: 'Display label shown on tickets' }) @IsString() label: string;
-  @ApiProperty({ example: 'seat-class-uuid', description: 'SeatClass UUID this coach belongs to' }) @IsString() seatClassId: string;
-  @ApiPropertyOptional({ example: 'sleeper', description: 'Coach type descriptor' }) @IsOptional() @IsString() coachType?: string;
-  @ApiPropertyOptional({ example: 'seat', description: 'seat | bed | convertible. Determines which arrangement field is used for seat generation.' }) @IsOptional() @IsString() mode?: string;
-  @ApiPropertyOptional({ example: '2+2', description: 'Seat arrangement for seat/convertible mode. Format: groups separated by +, e.g. "2+2" (4 cols: A/B aisle C/D) or "1+2+1". Used to derive columns, window and aisle flags. Required when mode=seat and totalUnits>0.' }) @IsOptional() @IsString() seatArrangement?: string;
-  @ApiPropertyOptional({ example: '2+2', description: 'Bed arrangement for bed mode. First number = tiers per berth: 2 → lower/upper, 3 → lower/middle/upper. E.g. "2+2" = 2-tier berths. Required when mode=bed and totalUnits>0.' }) @IsOptional() @IsString() bedArrangement?: string;
-  @ApiPropertyOptional({ example: 60, description: 'Total seat/bed units. When >0, seats are auto-generated from the arrangement on coach creation.' }) @IsOptional() @IsInt() totalUnits?: number;
+  @ApiProperty({ example: 'A-001', description: 'Unique coach number' }) @IsString() number: string;
+  @ApiProperty({ example: 'coach-type-uuid', description: 'Coach Type UUID' }) @IsString() coachTypeId: string;
+  @ApiProperty({ example: '2+2', description: 'Seat arrangement (e.g., "2+2", "3+2")' }) @IsString() arrangement: string;
+  @ApiProperty({ example: 60, description: 'Total seat capacity' }) @IsInt() capacity: number;
+  @ApiPropertyOptional({ example: 'ACTIVE', description: 'Status: ACTIVE, INACTIVE' }) @IsOptional() @IsString() status?: string;
 }
 
-export class UpdateCoachDto extends PartialType(OmitType(CreateCoachDto, ['coachNumber'] as const)) {}
+export class UpdateCoachDto extends PartialType(OmitType(CreateCoachDto, ['number'] as const)) {
+  @ApiPropertyOptional({ example: 1, description: 'Sequence number for ordering' })
+  @IsOptional() @IsInt() sequence?: number;
+}
 
 export class AssignCoachDto {
   @ApiProperty({ example: 'schedule-uuid', description: 'TrainSchedule UUID' }) @IsString() scheduleId: string;
   @ApiProperty({ example: 'coach-uuid', description: 'Coach UUID' }) @IsString() coachId: string;
-  @ApiProperty({ example: 1, description: 'Position in the train consist (1 = first coach)' }) @IsInt() positionNumber: number;
-  @ApiPropertyOptional({ example: true, description: 'Whether this coach is operational for this schedule' }) @IsOptional() @IsBoolean() isOperational?: boolean;
-}
-
-export class CreateSeatBatchDto {
-  @ApiProperty({ example: 'coach-uuid', description: 'Coach UUID to generate seats for' }) @IsString() coachId: string;
-  @ApiProperty({ example: 15, description: 'Number of rows to generate' }) @IsInt() rows: number;
-  @ApiProperty({ example: ['A', 'B', 'C', 'D'], type: [String], description: 'Column labels per row' }) @IsArray() @IsString({ each: true }) cols: string[];
+  @ApiProperty({ example: 1, description: 'Position in the train consist' }) @IsInt() positionNumber: number;
+  @ApiPropertyOptional({ example: true, description: 'Whether this coach is operational' }) @IsOptional() @IsBoolean() isOperational?: boolean;
 }
 
 export class ListCoachesDto {
-  @ApiPropertyOptional({ example: true, description: 'Filter by active/inactive status. Omit to return all.' })
-  @IsOptional() @IsBoolean() isActive?: boolean;
+  @ApiPropertyOptional({ example: 'ACTIVE', description: 'Filter by status: ACTIVE, INACTIVE' })
+  @IsOptional() @IsString() status?: string;
 
-  @ApiPropertyOptional({ example: 'seat', description: 'Filter by mode: seat | bed | convertible' })
-  @IsOptional() @IsString() mode?: string;
-
-  @ApiPropertyOptional({ example: 'seat-class-uuid', description: 'Filter by SeatClass UUID' })
-  @IsOptional() @IsString() seatClassId?: string;
-
-  @ApiPropertyOptional({ example: 'schedule-uuid', description: 'Filter to coaches assigned to this TrainSchedule UUID' })
+  @ApiPropertyOptional({ example: 'schedule-uuid', description: 'Filter coaches assigned to this schedule' })
   @IsOptional() @IsString() scheduleId?: string;
 }
+
+// Legacy DTO types for backward compatibility
+export class CreateCoachTypeDto {
+  @ApiProperty({ example: 'sleeper' }) @IsString() code: string;
+  @ApiProperty({ example: 'Sleeper Coach' }) @IsString() name: string;
+  @IsOptional() @IsString() type?: string;
+}
+
+export class UpdateCoachTypeDto {
+  @ApiPropertyOptional({ example: 'sleeper' }) @IsOptional() @IsString() code?: string;
+  @ApiPropertyOptional({ example: 'Sleeper Coach' }) @IsOptional() @IsString() name?: string;
+  @ApiPropertyOptional({ example: 'sleeper' }) @IsOptional() @IsString() type?: string;
+}
+
+export class CreateClassDto {
+  @ApiProperty({ example: 'coach-type-uuid' }) @IsString() coachTypeId: string;
+  @ApiProperty({ example: 'Economy' }) @IsString() name: string;
+  @IsOptional() @IsString() description?: string;
+  @ApiProperty({ example: 5000 }) @IsInt() baseFareMinor: number;
+}
+
+export class UpdateClassDto {
+  @ApiPropertyOptional({ example: 'coach-type-uuid' }) @IsOptional() @IsString() coachTypeId?: string;
+  @ApiPropertyOptional({ example: 'Economy' }) @IsOptional() @IsString() name?: string;
+  @ApiPropertyOptional() @IsOptional() @IsString() description?: string;
+  @ApiPropertyOptional({ example: 5000 }) @IsOptional() @IsInt() baseFareMinor?: number;
+  @ApiPropertyOptional({ example: true })
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}

apps/edr-passenger-api/src/modules/fleet/fleet.service.ts

@@ -1,6 +1,6 @@
 import { Injectable, NotFoundException, BadRequestException } from '@nestjs/common';
 import { PrismaService } from '../../common/prisma.service';
-import { CreateTrainDto, CreateCoachDto, UpdateCoachDto, AssignCoachDto, CreateSeatBatchDto, ListCoachesDto } from './fleet.dto';
+import { CreateTrainDto, CreateCoachDto, UpdateCoachDto, AssignCoachDto, ListCoachesDto, CreateCoachTypeDto, UpdateCoachTypeDto, CreateClassDto, UpdateClassDto } from './fleet.dto';
 import { SeatKind } from '@prisma/client';
 
 // Parses '2+2' → [2, 2], '2+2+2' → [2, 2, 2]
@@ -8,22 +8,20 @@ function parseArrangement(arrangement: string): number[] {
   return arrangement.split('+').map((n) => parseInt(n, 10));
 }
 
-// Derives column labels from a seat-mode arrangement string.
-// '2+2' → ['A','B','C','D']  (A/D window, B/C aisle)
-// '1+2+1' → ['A','B','C','D']
+// Derives column labels from arrangement: '2+2' → ['A','B','C','D']
 function seatCols(arrangement: string): string[] {
   const groups = parseArrangement(arrangement);
   const total = groups.reduce((s, n) => s + n, 0);
-  return Array.from({ length: total }, (_, i) => String.fromCharCode(65 + i)); // A, B, C …
+  return Array.from({ length: total }, (_, i) => String.fromCharCode(65 + i));
 }
 
-// Returns true if the column index is a window seat given the arrangement groups.
+// Returns true if column is a window seat
 function isWindowCol(colIndex: number, groups: number[]): boolean {
   const total = groups.reduce((s, n) => s + n, 0);
   return colIndex === 0 || colIndex === total - 1;
 }
 
-// Returns true if the column index is an aisle seat.
+// Returns true if column is an aisle seat
 function isAisleCol(colIndex: number, groups: number[]): boolean {
   let cursor = 0;
   for (const g of groups) {
@@ -35,82 +33,224 @@ function isAisleCol(colIndex: number, groups: number[]): boolean {
   return false;
 }
 
-// Bed positions for a given tier count: 2 → lower/upper, 3 → lower/middle/upper
-const BED_POSITIONS: Record<number, string[]> = {
-  2: ['lower', 'upper'],
-  3: ['lower', 'middle', 'upper'],
-};
-
-type SeatRow = {
-  coachId: string;
-  row: number;
-  col: string;
-  label: string;
-  seatNumber: string;
-  kind: SeatKind;
-  isWindow: boolean;
-  isAisle: boolean;
-  bedPosition?: string;
-};
-
-function buildSeatSeats(coachId: string, coachLabel: string, arrangement: string, totalUnits: number): SeatRow[] {
+function buildSeats(coachId: string, coachNumber: string, arrangement: string, capacity: number, seatClass?: string): SeatRow[] {
   const cols = seatCols(arrangement);
   const groups = parseArrangement(arrangement);
   const seats: SeatRow[] = [];
   let row = 1;
-  while (seats.length < totalUnits) {
-    for (let ci = 0; ci < cols.length && seats.length < totalUnits; ci++) {
+  let seatNumber = 1;
+  let seatIndex = 0;
+  const isBedCoach = seatClass?.toLowerCase().includes('bed');
+  const totalCols = cols.length;
+
+  while (seatIndex < capacity) {
+    for (let ci = 0; ci < cols.length && seatIndex < capacity; ci++) {
       const col = cols[ci];
+      let bedPosition = null;
+
+      // Set bedPosition for bed coaches based on ROW cycling (not seat number)
+      if (isBedCoach) {
+        if (totalCols === 3) {
+          // Economy bed (3-row cycle): upper, middle, lower
+          if (row % 3 === 1) bedPosition = 'upper';
+          else if (row % 3 === 2) bedPosition = 'middle';
+          else bedPosition = 'lower';
+        } else if (totalCols === 2) {
+          // VIP bed (2-row cycle): upper, lower
+          bedPosition = row % 2 === 1 ? 'upper' : 'lower';
+        }
+      }
+
       seats.push({
-        coachId, row, col,
-        label: `${row}${col}`,
-        seatNumber: `${coachLabel}${row}${col}`,
+        coachId,
+        row,
+        col,
+        seatNumber: `${seatNumber}`,
         kind: SeatKind.STANDARD,
-        isWindow: isWindowCol(ci, groups),
-        isAisle: isAisleCol(ci, groups),
+        bedPosition,
       });
+      seatNumber++;
+      seatIndex++;
     }
     row++;
   }
   return seats;
 }
 
-function buildBedSeats(coachId: string, coachLabel: string, arrangement: string, totalUnits: number): SeatRow[] {
-  // arrangement for beds describes tiers per berth, e.g. '2+2' = 2 lower+upper on each side
-  // Each compartment number is the row; each tier is the col (L=lower, M=middle, U=upper)
-  const groups = parseArrangement(arrangement);
-  const tiersPerSide = groups[0]; // e.g. 2 → lower+upper
-  const positions = BED_POSITIONS[tiersPerSide] ?? ['lower', 'upper'];
-  const tierCols = positions.map((_, i) => String.fromCharCode(65 + i)); // A=lower, B=upper, C=middle
-  const seats: SeatRow[] = [];
-  let compartment = 1;
-  while (seats.length < totalUnits) {
-    for (let ti = 0; ti < tierCols.length && seats.length < totalUnits; ti++) {
-      const col = tierCols[ti];
-      seats.push({
-        coachId, row: compartment, col,
-        label: `${compartment}${col}`,
-        seatNumber: `${coachLabel}${compartment}${col}`,
-        kind: SeatKind.STANDARD,
-        isWindow: false,
-        isAisle: false,
-        bedPosition: positions[ti],
-      });
-    }
-    compartment++;
-  }
-  return seats;
-}
+type SeatRow = {
+  coachId: string;
+  row: number;
+  col: string;
+  seatNumber: string;
+  kind: SeatKind;
+  bedPosition?: string | null;
+};
 
 @Injectable()
 export class FleetService {
   constructor(private prisma: PrismaService) {}
 
+  async createCoachType(dto: CreateCoachTypeDto) {
+    return this.prisma.coachType.create({
+      data: {
+        code: dto.code,
+        name: dto.name,
+        type: dto.type || 'passenger',
+      },
+      include: {
+        seatClasses: true,
+        coaches: true,
+      },
+    });
+  }
+
+  async getCoachTypes() {
+    return this.prisma.coachType.findMany({
+      include: {
+        seatClasses: true,
+        coaches: true,
+      },
+      orderBy: { createdAt: 'desc' },
+    });
+  }
+
+  async updateCoachType(id: string, dto: UpdateCoachTypeDto) {
+    const coachType = await this.prisma.coachType.findUnique({ where: { id } });
+    if (!coachType) throw new NotFoundException('Coach type not found');
+    
+    const data: any = {};
+    if (dto.code !== undefined) data.code = dto.code;
+    if (dto.name !== undefined) data.name = dto.name;
+    if (dto.type !== undefined) data.type = dto.type;
+    
+    return this.prisma.coachType.update({
+      where: { id },
+      data,
+      include: {
+        seatClasses: true,
+        coaches: true,
+      },
+    });
+  }
+
+  async deleteCoachType(id: string) {
+    const coachType = await this.prisma.coachType.findUnique({ 
+      where: { id },
+      include: {
+        coaches: true,
+        seatClasses: true,
+      },
+    });
+    if (!coachType) throw new NotFoundException('Coach type not found');
+    
+    // Check for related records
+    if (coachType.coaches.length > 0) {
+      throw new BadRequestException(
+        `Cannot delete coach type. ${coachType.coaches.length} coach(es) are still using this coach type. Please reassign or delete the coaches first.`
+      );
+    }
+    
+    if (coachType.seatClasses.length > 0) {
+      throw new BadRequestException(
+        `Cannot delete coach type. ${coachType.seatClasses.length} seat class(es) are still using this coach type. Please reassign or delete the seat classes first.`
+      );
+    }
+    
+    return this.prisma.coachType.delete({ where: { id } });
+  }
+
+  async createClass(dto: CreateClassDto) {
+    return this.prisma.seatClass.create({
+      data: {
+        coachTypeId: dto.coachTypeId,
+        name: dto.name,
+        description: dto.description,
+        baseFareMinor: dto.baseFareMinor,
+      },
+    });
+  }
+
+  async getClasses(coachTypeId?: string) {
+    const where = coachTypeId ? { coachTypeId } : {};
+    return this.prisma.seatClass.findMany({
+      where,
+      include: { coachType: true },
+      orderBy: { createdAt: 'desc' },
+    });
+  }
+
+  async updateClass(id: string, dto: UpdateClassDto) {
+    const seatClass = await this.prisma.seatClass.findUnique({ where: { id } });
+    if (!seatClass) throw new NotFoundException('Seat class not found');
+    
+    const updateData: any = {
+      coachTypeId: dto.coachTypeId,
+      name: dto.name,
+      description: dto.description,
+      baseFareMinor: dto.baseFareMinor,
+    };
+    
+    if (dto.isActive !== undefined) {
+      updateData.isActive = dto.isActive;
+    }
+    
+    return this.prisma.seatClass.update({
+      where: { id },
+      data: updateData,
+      include: { coachType: true },
+    });
+  }
+
+  async deleteClass(id: string) {
+    const seatClass = await this.prisma.seatClass.findUnique({ 
+      where: { id },
+      include: {
+        fareRules: true,
+        routeFareRules: true,
+        segmentFares: true,
+      },
+    });
+    if (!seatClass) throw new NotFoundException('Seat class not found');
+    
+    // Check for related records
+    const relatedRecords = [
+      ...seatClass.fareRules,
+      ...seatClass.routeFareRules,
+      ...seatClass.segmentFares,
+    ];
+    
+    if (relatedRecords.length > 0) {
+      throw new BadRequestException(
+        `Cannot delete seat class. ${relatedRecords.length} fare rule(s) are still using this seat class. Please delete the fare rules first.`
+      );
+    }
+    
+    return this.prisma.seatClass.delete({ where: { id } });
+  }
+
+  createSeatClass(dto: CreateClassDto) {
+    return this.createClass(dto);
+  }
+
+  getSeatClasses(coachTypeId?: string) {
+    return this.getClasses(coachTypeId);
+  }
+
+  async updateSeatClass(id: string, dto: UpdateClassDto) {
+    return this.updateClass(id, dto);
+  }
+
+  async deleteSeatClass(id: string) {
+    return this.deleteClass(id);
+  }
+
   getTrains() {
     return this.prisma.train.findMany({ include: { schedules: { take: 5, orderBy: { departureAt: 'desc' } } } });
   }
 
-  createTrain(dto: CreateTrainDto) { return this.prisma.train.create({ data: dto }); }
+  createTrain(dto: CreateTrainDto) {
+    return this.prisma.train.create({ data: dto });
+  }
 
   async updateTrain(id: string, dto: CreateTrainDto) {
     const train = await this.prisma.train.findUnique({ where: { id } });
@@ -118,120 +258,154 @@ export class FleetService {
     return this.prisma.train.update({ where: { id }, data: dto });
   }
 
+  async deleteTrain(id: string) {
+    const train = await this.prisma.train.findUnique({ 
+      where: { id },
+      include: {
+        schedules: true,
+      },
+    });
+    if (!train) throw new NotFoundException('Train not found');
+    
+    // Check for active schedules
+    if (train.schedules.length > 0) {
+      throw new BadRequestException(
+        `Cannot delete train. This train has ${train.schedules.length} schedule(s). Please delete the schedules first.`
+      );
+    }
+    
+    return this.prisma.train.delete({ where: { id } });
+  }
+
   async getCoach(id: string) {
     const coach = await this.prisma.coach.findUnique({
       where: { id },
       include: {
-        seatClass: true,
-        seats: {
-          orderBy: [{ row: 'asc' }, { col: 'asc' }],
-        },
+        coachType: true,
+        seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] },
         assignments: {
           include: { schedule: { include: { originStation: true, destinationStation: true } } },
           orderBy: { schedule: { departureAt: 'desc' } },
           take: 5,
         },
-        _count: { select: { seats: true, assignments: true } },
       },
     });
     if (!coach) throw new NotFoundException('Coach not found');
-
-    // Group seats by row to reflect the physical arrangement layout
-    const rowMap = new Map<number, typeof coach.seats>();
-    for (const seat of coach.seats) {
-      if (!rowMap.has(seat.row)) rowMap.set(seat.row, []);
-      rowMap.get(seat.row)!.push(seat);
-    }
-
-    const seatsByRow = Array.from(rowMap.entries()).map(([row, seats]) => ({ row, seats }));
-
-    const seatStatusSummary = {
-      total:     coach.seats.length,
-      available: coach.seats.filter(s => s.status === 'AVAILABLE').length,
-      held:      coach.seats.filter(s => s.status === 'HELD').length,
-      booked:    coach.seats.filter(s => s.status === 'BOOKED').length,
-      blocked:   coach.seats.filter(s => s.status === 'BLOCKED').length,
-    };
-
-    const { seats, ...coachData } = coach;
-    return { ...coachData, seatsByRow, seatStatusSummary };
+    return coach;
   }
 
   async listCoaches(dto: ListCoachesDto) {
     const where: any = {};
-    if (dto.isActive !== undefined) where.isActive = dto.isActive;
-    if (dto.mode) where.mode = dto.mode;
-    if (dto.seatClassId) where.seatClassId = dto.seatClassId;
+    if (dto.status) where.status = dto.status;
     if (dto.scheduleId) where.assignments = { some: { scheduleId: dto.scheduleId } };
 
-    const coaches = await this.prisma.coach.findMany({
+    return this.prisma.coach.findMany({
       where,
-      include: {
-        seatClass: true,
-        seats: { select: { status: true } },
-        _count: { select: { seats: true, assignments: true } },
-      },
-      orderBy: [{ isActive: 'desc' }, { label: 'asc' }],
+      include: { coachType: true },
+      orderBy: { sequence: 'asc' },
     });
-
-    return coaches.map(({ seats, ...coach }) => ({
-      ...coach,
-      seatStatusSummary: {
-        total: seats.length,
-        available: seats.filter(s => s.status === 'AVAILABLE').length,
-        held:      seats.filter(s => s.status === 'HELD').length,
-        booked:    seats.filter(s => s.status === 'BOOKED').length,
-        blocked:   seats.filter(s => s.status === 'BLOCKED').length,
-      },
-    }));
   }
 
   async createCoach(dto: CreateCoachDto) {
-    const mode = dto.mode ?? 'seat';
-    const totalUnits = dto.totalUnits ?? 0;
-
-    const isBed = mode === 'bed';
-    const arrangement = isBed
-      ? (dto.bedArrangement ?? dto.seatArrangement ?? '2+2')
-      : (dto.seatArrangement ?? '2+2');
-
-    if (totalUnits > 0) {
-      const groups = parseArrangement(arrangement);
-      if (groups.some(isNaN)) {
-        throw new BadRequestException(`Invalid arrangement format "${arrangement}". Use e.g. "2+2" or "2+2+2"`);
-      }
+    const groups = parseArrangement(dto.arrangement);
+    if (groups.some(isNaN)) {
+      throw new BadRequestException(`Invalid arrangement format "${dto.arrangement}". Use e.g. "2+2"`);
     }
 
-    const coach = await this.prisma.coach.create({ data: dto });
-
-    if (totalUnits > 0) {
-      const seats = isBed
-        ? buildBedSeats(coach.id, coach.label, arrangement, totalUnits)
-        : buildSeatSeats(coach.id, coach.label, arrangement, totalUnits);
-      await this.prisma.seat.createMany({ data: seats, skipDuplicates: true });
-    }
-
-    return this.prisma.coach.findUnique({
-      where: { id: coach.id },
-      include: { seatClass: true, _count: { select: { seats: true } } },
+    // Get the next sequence number for this coach type
+    const lastCoach = await this.prisma.coach.findFirst({
+      where: { coachTypeId: dto.coachTypeId },
+      orderBy: { sequence: 'desc' },
     });
+    const nextSequence = (lastCoach?.sequence ?? 0) + 1;
+
+    const coach = await this.prisma.coach.create({
+      data: {
+        coachTypeId: dto.coachTypeId,
+        number: dto.number,
+        sequence: nextSequence,
+        arrangement: dto.arrangement,
+        capacity: dto.capacity,
+        status: dto.status || 'ACTIVE',
+      },
+      include: { coachType: true },
+    });
+
+    if (dto.capacity > 0) {
+      const seatClass = coach.coachType?.name || '';
+      const seats = buildSeats(coach.id, coach.number, dto.arrangement, dto.capacity, seatClass);
+      await this.prisma.seat.createMany({ data: seats });
+    }
+
+    return coach;
   }
 
   async updateCoach(id: string, dto: UpdateCoachDto) {
     const coach = await this.prisma.coach.findUnique({ where: { id } });
     if (!coach) throw new NotFoundException('Coach not found');
-    return this.prisma.coach.update({ where: { id }, data: dto });
-  }
-
-  async deleteTrain(id: string) {
-    const train = await this.prisma.train.findUnique({ where: { id } });
-    if (!train) throw new NotFoundException('Train not found');
-    return this.prisma.train.delete({ where: { id } });
+    
+    return this.prisma.coach.update({ 
+      where: { id }, 
+      data: {
+        arrangement: dto.arrangement,
+        capacity: dto.capacity,
+        status: dto.status,
+        sequence: dto.sequence,
+      },
+      include: { coachType: true },
+    });
   }
 
   async deleteCoach(id: string) {
-    const coach = await this.prisma.coach.findUnique({ where: { id } });
+    const coach = await this.prisma.coach.findUnique({ 
+      where: { id },
+      include: {
+        assignments: true,
+        seats: {
+          include: {
+            bookingSeats: true,
+            blocks: true,
+            ticketSeats: true,
+          },
+        },
+      },
+    });
     if (!coach) throw new NotFoundException('Coach not found');
+    
+    // Check for active assignments
+    if (coach.assignments.length > 0) {
+      throw new BadRequestException(
+        `Cannot delete coach. This coach is assigned to ${coach.assignments.length} schedule(s). Please remove the assignments first.`
+      );
+    }
+    
+    // Check for booked seats
+    const bookedSeats = coach.seats.filter(seat => seat.bookingSeats.length > 0);
+    if (bookedSeats.length > 0) {
+      throw new BadRequestException(
+        `Cannot delete coach. ${bookedSeats.length} seat(s) have active bookings. Please wait for bookings to complete or cancel them first.`
+      );
+    }
+    
+    // Check for blocked seats
+    const blockedSeats = coach.seats.filter(seat => seat.blocks.length > 0);
+    if (blockedSeats.length > 0) {
+      throw new BadRequestException(
+        `Cannot delete coach. ${blockedSeats.length} seat(s) are blocked. Please unblock them first.`
+      );
+    }
+    
+    // Check for tickets
+    const seatsWithTickets = coach.seats.filter(seat => seat.ticketSeats.length > 0);
+    if (seatsWithTickets.length > 0) {
+      throw new BadRequestException(
+        `Cannot delete coach. ${seatsWithTickets.length} seat(s) have issued tickets. Please wait for travel completion.`
+      );
+    }
+    
+    // Delete related seats first (now safe to do)
+    await this.prisma.seat.deleteMany({ where: { coachId: id } });
+    
     return this.prisma.coach.delete({ where: { id } });
   }
 
@@ -251,19 +425,6 @@ export class FleetService {
     return this.prisma.coachAssignment.delete({ where: { id } });
   }
 
-  async createSeatBatch(dto: CreateSeatBatchDto) {
-    const coach = await this.prisma.coach.findUnique({ where: { id: dto.coachId } });
-    if (!coach) throw new NotFoundException('Coach not found');
-    const seats = [];
-    for (let row = 1; row <= dto.rows; row++) {
-      for (const col of dto.cols) {
-        seats.push({ coachId: dto.coachId, row, col, label: `${row}${col}`, seatNumber: `${coach.label}${row}${col}` });
-      }
-    }
-    await this.prisma.seat.createMany({ data: seats, skipDuplicates: true });
-    return { created: seats.length };
-  }
-
   async getAnalytics() {
     const [totalTrains, totalSchedules, totalSeats, bookedSeats] = await Promise.all([
       this.prisma.train.count(),
@@ -271,6 +432,12 @@ export class FleetService {
       this.prisma.seat.count(),
       this.prisma.seat.count({ where: { status: 'BOOKED' } }),
     ]);
-    return { totalTrains, totalSchedules, totalSeats, bookedSeats, occupancyRate: totalSeats > 0 ? +((bookedSeats / totalSeats) * 100).toFixed(2) : 0 };
+    return {
+      totalTrains,
+      totalSchedules,
+      totalSeats,
+      bookedSeats,
+      occupancyRate: totalSeats > 0 ? +((bookedSeats / totalSeats) * 100).toFixed(2) : 0,
+    };
   }
 }

apps/edr-passenger-api/src/modules/notifications/dtos/email.dto.ts

@@ -0,0 +1,44 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsEmail, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+export class SendEmail {
+  @ApiProperty()
+  @IsEmail()
+  @IsNotEmpty()
+  to: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  sourceId?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  sourceName?: string;
+
+  @ApiProperty()
+  @IsNotEmpty()
+  @IsString()
+  subject: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  html?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  text?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  body?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  context?: Record<string, any>;
+
+
+}

apps/edr-passenger-api/src/modules/notifications/dtos/sms.dto.ts

@@ -0,0 +1,46 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsArray, IsNotEmpty, IsOptional, IsString, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class SendMessage {
+  @ApiProperty()
+  @IsNotEmpty()
+  @IsString()
+  to: string;
+
+  @ApiProperty()
+  @IsNotEmpty()
+  @IsString()
+  message: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  from?: string;
+}
+
+export class SingleMessageDto {
+  @ApiProperty({
+    description: 'Recipient phone number',
+    example: '+1234567890',
+  })
+  @IsString()
+  @IsNotEmpty()
+  to: string;
+
+  @ApiProperty({
+    description: 'Message content',
+    example: 'Test Single SMS from',
+  })
+  @IsString()
+  @IsNotEmpty()
+  message: string;
+}
+
+export class BulkMessagesDto {
+  @ApiProperty({ type: [SendMessage] })
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => SendMessage)
+  messages: SendMessage[];
+}

apps/edr-passenger-api/src/modules/notifications/email-client.service.ts

@@ -0,0 +1,50 @@
+import {
+  Inject,
+  Injectable,
+  Logger,
+  OnApplicationBootstrap,
+} from "@nestjs/common";
+import { ClientProxy } from "@nestjs/microservices";
+import { SendEmail } from "./dtos/email.dto";
+
+@Injectable()
+export class EmailClientService implements OnApplicationBootstrap {
+  private readonly logger = new Logger(EmailClientService.name);
+
+  constructor(
+    @Inject("EMAIL_SERVICE")
+    private readonly emailServiceClient: ClientProxy,
+  ) {}
+
+  private readonly enabled = process.env.RABBITMQ_ENABLED !== "false";
+
+  async onApplicationBootstrap() {
+    if (!this.enabled) return;
+    this.emailServiceClient
+      .connect()
+      .then(() => this.logger.log("Connected to Email service"))
+      .catch((err) =>
+        this.logger.error("Error connecting to Email service", err),
+      );
+  }
+
+  async sendEmail(dto: SendEmail): Promise<{ queued: boolean }> {
+    if (!this.enabled) {
+      this.logger.warn(`RABBITMQ disabled — skipped EMAIL`);
+      return { queued: false };
+    }
+    this.emailServiceClient.emit("send-email", {
+      ...dto,
+      appKey: "IFHCRS-LICENSE-MANAGEMENT",
+    });
+    // Fire-and-forget enqueue: this confirms the message was handed to RabbitMQ, NOT delivered.
+    this.logger.log(
+      `EMAIL queued to RabbitMQ [${process.env.EMAIL_QUEUE ?? "email_queue"}] pattern='send-email'`,
+    );
+    // Recipient + content are PII — keep them at debug level only.
+    this.logger.debug(
+      `EMAIL payload to=${dto.to} subject="${dto.subject ?? ""}" body="${dto.text ?? dto.body ?? dto.html ?? ""}"`,
+    );
+    return { queued: true };
+  }
+}

apps/edr-passenger-api/src/modules/notifications/notification.adapters.ts

@@ -1,199 +1,10 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
-import * as sgMail from '@sendgrid/mail';
-import { HttpService } from '@nestjs/axios';
-import { firstValueFrom } from 'rxjs';
 
 export interface NotificationChannel {
   send(recipient: string, subject: string, body: string, context?: Record<string, unknown>): Promise<boolean>;
 }
 
-@Injectable()
-export class EmailAdapter implements NotificationChannel {
-  private readonly logger = new Logger(EmailAdapter.name);
-
-  constructor(private readonly config: ConfigService) {
-    const apiKey = this.config.get<string>('SENDGRID_API_KEY');
-    if (apiKey) {
-      sgMail.setApiKey(apiKey);
-      this.logger.log('SendGrid Email adapter initialized');
-    } else {
-      this.logger.warn('SENDGRID_API_KEY not configured - emails will be logged only');
-    }
-  }
-
-  async send(
-    recipient: string,
-    subject: string,
-    body: string,
-    context?: Record<string, unknown>,
-  ): Promise<boolean> {
-    const apiKey = this.config.get<string>('SENDGRID_API_KEY');
-    const fromEmail = this.config.get<string>('SENDGRID_FROM_EMAIL') || 'noreply@edr-platform.com';
-
-    if (!apiKey) {
-      this.logger.log(`[EMAIL MOCK] To: ${recipient} | Subject: ${subject} | Body: ${body.substring(0, 100)}`);
-      return true;
-    }
-
-    try {
-      const msg: sgMail.MailDataRequired = {
-        to: recipient,
-        from: fromEmail,
-        subject,
-        text: body,
-        html: this.formatHtml(body, context),
-      };
-
-      await sgMail.send(msg);
-      this.logger.log(`Email sent successfully to ${recipient}`);
-      return true;
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.logger.error(`Failed to send email to ${recipient}: ${message}`);
-      return false;
-    }
-  }
-
-  private formatHtml(body: string, context?: Record<string, unknown>): string {
-    const contextHtml = context
-      ? `<div style="margin-top: 20px; padding: 10px; background: #f5f5f5; border-radius: 4px;">
-           <small>${JSON.stringify(context, null, 2)}</small>
-         </div>`
-      : '';
-
-    return `
-      <!DOCTYPE html>
-      <html>
-        <head>
-          <meta charset="utf-8">
-          <style>
-            body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; }
-            .container { max-width: 600px; margin: 0 auto; padding: 20px; }
-            .header { background: #0066cc; color: white; padding: 20px; text-align: center; }
-            .content { padding: 20px; background: white; }
-            .footer { text-align: center; padding: 20px; color: #666; font-size: 12px; }
-          </style>
-        </head>
-        <body>
-          <div class="container">
-            <div class="header">
-              <h2>Ethio-Djibouti Railway</h2>
-            </div>
-            <div class="content">
-              ${body.replace(/\n/g, '<br>')}
-              ${contextHtml}
-            </div>
-            <div class="footer">
-              <p>© 2024 Ethio-Djibouti Railway. All rights reserved.</p>
-            </div>
-          </div>
-        </body>
-      </html>
-    `;
-  }
-}
-
-@Injectable()
-export class SmsAdapter implements NotificationChannel {
-  private readonly logger = new Logger(SmsAdapter.name);
-
-  constructor(
-    private readonly config: ConfigService,
-    private readonly http: HttpService,
-  ) {
-    const provider = this.config.get<string>('SMS_PROVIDER');
-    this.logger.log(`SMS adapter initialized with provider: ${provider || 'MOCK'}`);
-  }
-
-  async send(
-    recipient: string,
-    subject: string,
-    body: string,
-    _context?: Record<string, unknown>,
-  ): Promise<boolean> {
-    const provider = this.config.get<string>('SMS_PROVIDER');
-    const apiKey = this.config.get<string>('SMS_API_KEY');
-
-    if (!provider || !apiKey) {
-      this.logger.log(`[SMS MOCK] To: ${recipient} | Message: ${body.substring(0, 100)}`);
-      return true;
-    }
-
-    try {
-      switch (provider.toLowerCase()) {
-        case 'twilio':
-          return await this.sendViaTwilio(recipient, body);
-        case 'africastalking':
-          return await this.sendViaAfricasTalking(recipient, body);
-        default:
-          this.logger.warn(`Unknown SMS provider: ${provider}`);
-          return false;
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.logger.error(`Failed to send SMS to ${recipient}: ${message}`);
-      return false;
-    }
-  }
-
-  private async sendViaTwilio(to: string, body: string): Promise<boolean> {
-    const accountSid = this.config.get<string>('TWILIO_ACCOUNT_SID');
-    const authToken = this.config.get<string>('TWILIO_AUTH_TOKEN');
-    const fromNumber = this.config.get<string>('TWILIO_FROM_NUMBER');
-
-    const url = `https://api.twilio.com/2010-04-01/Accounts/${accountSid}/Messages.json`;
-    const auth = Buffer.from(`${accountSid}:${authToken}`).toString('base64');
-
-    const response = await firstValueFrom(
-      this.http.post(
-        url,
-        new URLSearchParams({
-          To: to,
-          From: fromNumber || '',
-          Body: body,
-        }),
-        {
-          headers: {
-            'Content-Type': 'application/x-www-form-urlencoded',
-            'Authorization': `Basic ${auth}`,
-          },
-        },
-      ),
-    );
-
-    return response.status === 201;
-  }
-
-  private async sendViaAfricasTalking(to: string, body: string): Promise<boolean> {
-    const apiKey = this.config.get<string>('SMS_API_KEY');
-    const username = this.config.get<string>('AFRICASTALKING_USERNAME');
-    const from = this.config.get<string>('AFRICASTALKING_FROM');
-
-    const url = 'https://api.africastalking.com/version1/messaging';
-
-    const response = await firstValueFrom(
-      this.http.post(
-        url,
-        new URLSearchParams({
-          username: username || '',
-          to,
-          message: body,
-          from: from || '',
-        }),
-        {
-          headers: {
-            'Content-Type': 'application/x-www-form-urlencoded',
-            'apiKey': apiKey || '',
-          },
-        },
-      ),
-    );
-
-    return response.status === 201;
-  }
-}
-
 @Injectable()
 export class PushAdapter implements NotificationChannel {
   private readonly logger = new Logger(PushAdapter.name);

apps/edr-passenger-api/src/modules/notifications/notifications.controller.ts

@@ -1,15 +1,23 @@
 import { Controller, Get, Param, Patch, Post, Body, UseGuards } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiBody } from '@nestjs/swagger';
 import { NotificationsService } from './notifications.service';
 import { JwtGuard } from '../../common/jwt.guard';
 import { TestNotificationDto } from './notifications.dto';
+import { EmailClientService } from './email-client.service';
+import { SmsClientService } from './sms-client.service';
+import { SendEmail } from './dtos/email.dto';
+import { BulkMessagesDto, SingleMessageDto } from './dtos/sms.dto';
 
 @ApiTags('Notifications')
 @Controller('notifications')
 @UseGuards(JwtGuard)
 @ApiBearerAuth('JWT-auth')
 export class NotificationsController {
-  constructor(private service: NotificationsService) {}
+  constructor(
+    private service: NotificationsService,
+    private emailClient: EmailClientService,
+    private smsClient: SmsClientService,
+  ) {}
 
   @Get(':passengerId')
   @ApiOperation({ summary: 'Get notifications for passenger' })
@@ -29,6 +37,33 @@ export class NotificationsController {
     return this.service.markAllRead(id);
   }
 
+  @Post('send/email')
+  @UseGuards(IamGuard)
+  @IamRoles('ADMIN', 'STAFF')
+  @ApiOperation({ summary: 'Send a direct email via the email microservice' })
+  @ApiBody({ type: SendEmail })
+  sendEmail(@Body() dto: SendEmail) {
+    return this.emailClient.sendEmail(dto);
+  }
+
+  @Post('send/sms')
+  @UseGuards(IamGuard)
+  @IamRoles('ADMIN', 'STAFF')
+  @ApiOperation({ summary: 'Send a direct SMS via the SMS microservice' })
+  @ApiBody({ type: SingleMessageDto })
+  sendSms(@Body() dto: SingleMessageDto) {
+    return this.smsClient.sendSms(dto);
+  }
+
+  @Post('send/sms/bulk')
+  @UseGuards(IamGuard)
+  @IamRoles('ADMIN', 'STAFF')
+  @ApiOperation({ summary: 'Send bulk SMS messages via the SMS microservice' })
+  @ApiBody({ type: BulkMessagesDto })
+  sendBulkSms(@Body() dto: BulkMessagesDto) {
+    return this.smsClient.sendBulkMessages(dto);
+  }
+
   @Post('test')
   // TODO(iam-authz): restrict to admin/staff via IAM PermissionGuard once role→permission mapping
   // is confirmed. Currently protected by the class-level JwtGuard only.

apps/edr-passenger-api/src/modules/notifications/notifications.module.ts

@@ -1,13 +1,44 @@
 import { Module } from '@nestjs/common';
 import { HttpModule } from '@nestjs/axios';
+import { ClientsModule, Transport } from '@nestjs/microservices';
 import { NotificationsController } from './notifications.controller';
 import { NotificationsService } from './notifications.service';
-import { EmailAdapter, SmsAdapter, PushAdapter } from './notification.adapters';
+import { PushAdapter } from './notification.adapters';
+import { EmailClientService } from './email-client.service';
+import { SmsClientService } from './sms-client.service';
 
 @Module({
-  imports: [HttpModule.register({ timeout: 10_000 })],
+  imports: [
+    // Required by IamGuard (injects HttpService) used in NotificationsController.
+    HttpModule.register({ timeout: 10_000 }),
+    ClientsModule.register([
+      {
+        name: 'EMAIL_SERVICE',
+        transport: Transport.RMQ,
+        options: {
+          urls: [process.env.RABBITMQ_URL as string],
+          queue: process.env.EMAIL_QUEUE ?? 'email_queue',
+          queueOptions: { durable: true },
+        },
+      },
+      {
+        name: 'SMS_SERVICE',
+        transport: Transport.RMQ,
+        options: {
+          urls: [process.env.RABBITMQ_URL as string],
+          queue: process.env.SMS_QUEUE ?? 'sms_queue',
+          queueOptions: { durable: true },
+        },
+      },
+    ]),
+  ],
   controllers: [NotificationsController],
-  providers: [NotificationsService, EmailAdapter, SmsAdapter, PushAdapter],
-  exports: [NotificationsService],
+  providers: [
+    NotificationsService,
+    PushAdapter,
+    EmailClientService,
+    SmsClientService,
+  ],
+  exports: [NotificationsService, EmailClientService, SmsClientService],
 })
 export class NotificationsModule {}

apps/edr-passenger-api/src/modules/notifications/notifications.service.ts

@@ -1,10 +1,11 @@
-import { Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { OnEvent } from '@nestjs/event-emitter';
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource } from 'typeorm';
 import { PrismaService } from '../../common/prisma.service';
-import { SendNotificationDto, NotificationCategoryEnum } from './notifications.dto';
-import { EmailAdapter, SmsAdapter, PushAdapter, NotificationChannel } from './notification.adapters';
+import { PushAdapter, NotificationChannel } from './notification.adapters';
+import { EmailClientService } from './email-client.service';
+import { SmsClientService } from './sms-client.service';
 
 export type NotificationChannelType = 'EMAIL' | 'SMS' | 'PUSH' | 'IN_APP';
 
@@ -18,13 +19,13 @@ export class NotificationsService {
   constructor(
     private prisma: PrismaService,
     @InjectDataSource() private readonly dataSource: DataSource,
-    private emailAdapter: EmailAdapter,
-    private smsAdapter: SmsAdapter,
+    private emailClient: EmailClientService,
+    private smsClient: SmsClientService,
     private pushAdapter: PushAdapter,
   ) {
     this.channels = new Map<NotificationChannelType, NotificationChannel>([
-      ['EMAIL', this.emailAdapter as NotificationChannel],
-      ['SMS', this.smsAdapter as NotificationChannel],
+      ['EMAIL', { send: (to, subject, body) => this.emailClient.sendEmail({ to, subject, text: body }).then((r) => r.queued) }],
+      ['SMS', { send: (to, _subject, body) => this.smsClient.sendSms({ to, message: body }).then((r) => r.queued) }],
       ['PUSH', this.pushAdapter as NotificationChannel],
     ]);
   }
@@ -41,27 +42,38 @@ export class NotificationsService {
     recipient: string,
     context: Record<string, unknown>,
     channels?: NotificationChannelType[],
-  ): Promise<{ sent: boolean; channels: string[] }> {
+  ): Promise<{ queued: boolean; channels: string[] }> {
     const template = await this.prisma.notificationTemplate.findUnique({
       where: { code: templateKey },
     });
 
     if (!template || !template.active) {
       this.logger.warn(`Template ${templateKey} not found or inactive`);
-      return { sent: false, channels: [] };
+      return { queued: false, channels: [] };
     }
 
     const { subject, body } = this.interpolate(template, context);
-    const targetChannels = channels || await this.getUserPreferredChannels(recipient);
-    const sentChannels: string[] = [];
 
-    // Always create in-app notification
-    if (targetChannels.includes('IN_APP')) {
-      await this.createInAppNotification(recipient, subject, body, context);
-      sentChannels.push('IN_APP');
+    // Channel resolution: explicit argument wins; otherwise honor the template's declared
+    // channel(s); otherwise fall back to the recipient's preferences.
+    let targetChannels: NotificationChannelType[];
+    if (channels) {
+      targetChannels = channels;
+    } else if (template.channel) {
+      targetChannels = this.parseTemplateChannels(template.channel);
+    } else {
+      targetChannels = await this.getUserPreferredChannels(recipient);
+    }
+
+    // Channels successfully handed off (in-app persisted / email+SMS enqueued to RabbitMQ).
+    // NOTE: enqueue is fire-and-forget — this is NOT a delivery confirmation.
+    const queuedChannels: string[] = [];
+
+    if (targetChannels.includes('IN_APP')) {
+      await this.createInAppNotification(recipient, subject, body, context);
+      queuedChannels.push('IN_APP');
     }
 
-    // Send via other channels
     for (const channelType of targetChannels) {
       if (channelType === 'IN_APP') continue;
 
@@ -77,46 +89,26 @@ export class NotificationsService {
         continue;
       }
 
-      const success = await adapter.send(recipientAddress, subject, body, context);
-      if (success) {
-        sentChannels.push(channelType);
+      const queued = await adapter.send(recipientAddress, subject, body, context);
+      if (queued) {
+        queuedChannels.push(channelType);
       }
     }
 
-    return { sent: sentChannels.length > 0, channels: sentChannels };
+    return { queued: queuedChannels.length > 0, channels: queuedChannels };
   }
 
   /**
-   * Legacy method for backward compatibility
+   * Parses a template's `channel` column (e.g. "EMAIL" or "EMAIL,SMS") into valid channel
+   * types, always including IN_APP so an in-app record is created.
    */
-  async sendDirect(dto: SendNotificationDto) {
-    const notification = await this.prisma.notification.create({
-      data: {
-        passengerId: dto.passengerId,
-        title: dto.title,
-        body: dto.body,
-        category: dto.category as any,
-        deepLink: dto.deepLink,
-        metadata: dto.metadata,
-      },
-    });
-
-    const passenger = await this.prisma.passenger.findUnique({
-      where: { id: dto.passengerId },
-    });
-
-    if (passenger?.iamUserId) {
-      const contact = await this.resolveContactInfo(passenger.iamUserId);
-      if (contact.email) {
-        await this.emailAdapter.send(
-          contact.email,
-          this.sanitize(dto.title),
-          this.sanitize(dto.body),
-        );
-      }
-    }
-
-    return notification;
+  private parseTemplateChannels(channel: string): NotificationChannelType[] {
+    const valid: NotificationChannelType[] = ['EMAIL', 'SMS', 'PUSH', 'IN_APP'];
+    const parsed = channel
+      .split(',')
+      .map((c) => c.trim().toUpperCase())
+      .filter((c): c is NotificationChannelType => valid.includes(c as NotificationChannelType));
+    return Array.from(new Set<NotificationChannelType>(['IN_APP', ...parsed]));
   }
 
   private async createInAppNotification(
@@ -157,16 +149,20 @@ export class NotificationsService {
     template: { subject?: string | null; bodyTemplate: string },
     context: Record<string, unknown>,
   ): { subject: string; body: string } {
-    const subject = template.subject || 'Notification';
-    let body = template.bodyTemplate;
+    return {
+      subject: this.applyVars(template.subject || 'Notification', context),
+      body: this.applyVars(template.bodyTemplate, context),
+    };
+  }
 
-    // Simple template interpolation: {{variable}}
+  /** Replaces {{variable}} placeholders in a string with values from the context. */
+  private applyVars(text: string, context: Record<string, unknown>): string {
+    let out = text;
     for (const [key, value] of Object.entries(context)) {
       const regex = new RegExp(`{{\\s*${key}\\s*}}`, 'g');
-      body = body.replace(regex, String(value));
+      out = out.replace(regex, String(value));
     }
-
-    return { subject, body };
+    return out;
   }
 
   private async getUserPreferredChannels(recipient: string): Promise<NotificationChannelType[]> {
@@ -251,27 +247,238 @@ export class NotificationsService {
 
   @OnEvent('booking.created')
   async onBookingCreated(payload: any) {
+    const booking = payload.booking;
     await this.send(
       'booking.created',
-      payload.booking.passengerId,
+      booking.passengerId,
       {
-        bookingRef: payload.booking.bookingRef,
+        bookingRef: booking.bookingRef,
+        amount: this.formatAmount(booking),
+        currency: booking.displayCurrency ?? 'ETB',
         category: 'BOOKING',
-        deepLink: `edr://bookings/${payload.booking.bookingRef}`,
+        deepLink: `edr://bookings/${booking.bookingRef}`,
       },
+      // For now, always notify the travelling passenger on every channel.
+      ['IN_APP', 'EMAIL', 'SMS'],
     );
   }
 
+  /**
+   * Payment succeeded → one combined "payment successful, here is your ticket" notification.
+   * Email carries the full ticket (HTML + QR); SMS is a short pointer to view it. The shallow
+   * event payload is re-fetched with the relations needed to render the ticket.
+   */
   @OnEvent('payment.succeeded')
   async onPaymentSucceeded(payload: any) {
-    await this.send(
-      'payment.succeeded',
-      payload.booking.passengerId,
-      {
-        bookingRef: payload.booking.bookingRef,
-        category: 'PAYMENT',
-        deepLink: `edr://tickets/${payload.booking.bookingRef}`,
+    const passengerId = payload.booking.passengerId;
+    const bookingId = payload.booking.id;
+
+    const booking = await this.prisma.booking.findUnique({
+      where: { id: bookingId },
+      include: {
+        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+        seats: { include: { seat: { include: { coach: { include: { coachType: true } } } } } },
       },
+    });
+    const ticket = await this.prisma.ticket.findUnique({ where: { bookingId } });
+
+    const ref = booking?.bookingRef ?? payload.booking.bookingRef;
+    const amount = this.formatAmount(booking ?? payload.booking);
+    const currency = (booking ?? payload.booking).displayCurrency ?? 'ETB';
+    const ticketUrl = `${process.env.PORTAL_URL ?? 'http://localhost:5174'}/booking/confirmation?ref=${ref}`;
+
+    // IN_APP — always created.
+    await this.createInAppNotification(
+      passengerId,
+      'Payment successful',
+      `Your payment of ${amount} ${currency} for booking ${ref} was successful. Your ticket is ready.`,
+      { category: 'PAYMENT', deepLink: `edr://tickets/${ref}` },
+    );
+
+    // Ticket not ready (generation failed/raced) — fall back to a payment-only confirmation.
+    if (!ticket || !booking) {
+      this.logger.warn(`payment.succeeded: ticket not ready for booking ${ref}; sending payment-only confirmation`);
+      const text = `EDR: Payment of ${amount} ${currency} received for booking ${ref}. Your ticket is being prepared.`;
+      await this.deliverEmail(passengerId, `Payment received — ${ref}`, text);
+      await this.deliverSms(passengerId, text);
+      return;
+    }
+
+    // SMS — short pointer (no HTML/QR over SMS).
+    await this.deliverSms(
+      passengerId,
+      `EDR: Booking ${ref} confirmed, ${amount} ${currency} paid. Show ref ${ref} at the gate or view your ticket: ${ticketUrl}`,
+    );
+
+    // EMAIL — rich HTML ticket with plain-text fallback.
+    await this.deliverEmail(
+      passengerId,
+      `Your EDR ticket — ${ref}`,
+      this.buildTicketEmailText(booking, amount, currency, ticketUrl),
+      this.buildTicketEmailHtml(booking, ticket, amount, currency, ticketUrl),
     );
   }
+
+  private async deliverEmail(recipient: string, subject: string, text: string, html?: string): Promise<void> {
+    const to = await this.getRecipientAddress(recipient, 'EMAIL');
+    if (!to) {
+      this.logger.warn(`No EMAIL address for recipient: ${recipient}`);
+      return;
+    }
+    await this.emailClient.sendEmail({ to, subject, text, html });
+  }
+
+  private async deliverSms(recipient: string, message: string): Promise<void> {
+    const to = await this.getRecipientAddress(recipient, 'SMS');
+    if (!to) {
+      this.logger.warn(`No SMS address for recipient: ${recipient}`);
+      return;
+    }
+    await this.smsClient.sendSms({ to, message });
+  }
+
+  private buildTicketEmailText(booking: any, amount: string, currency: string, url: string): string {
+    const s = booking.schedule ?? {};
+    const dep = s.departureAt ? new Date(s.departureAt).toLocaleString('en-GB') : 'TBD';
+    const passengers = (booking.seats ?? []).map((bs: any) => bs.passengerName).filter(Boolean).join(', ');
+    return [
+      `Booking ${booking.bookingRef} confirmed.`,
+      `${s.originStation?.name ?? ''} -> ${s.destinationStation?.name ?? ''}`,
+      `Train: ${s.train?.name ?? s.train?.number ?? ''}`,
+      `Departs: ${dep}`,
+      passengers ? `Passengers: ${passengers}` : '',
+      `Total paid: ${amount} ${currency}`,
+      `View your ticket: ${url}`,
+    ].filter(Boolean).join('\n');
+  }
+
+  private buildTicketEmailHtml(booking: any, ticket: any, amount: string, currency: string, url: string): string {
+    const s = booking.schedule ?? {};
+    const fmt = (d: any) =>
+      d ? new Date(d).toLocaleString('en-GB', { dateStyle: 'medium', timeStyle: 'short' }) : 'TBD';
+    const seatRows = (booking.seats ?? [])
+      .map((bs: any) => {
+        const coach = bs.seat?.coach?.number ?? '-';
+        const seatNo = bs.seat?.seatNumber ?? '-';
+        const cls = bs.seat?.coach?.coachType?.name ?? '-';
+        return `<tr>
+          <td style="padding:8px;border-bottom:1px solid #eee;">${bs.passengerName ?? ''}</td>
+          <td style="padding:8px;border-bottom:1px solid #eee;">${coach}</td>
+          <td style="padding:8px;border-bottom:1px solid #eee;">${seatNo}</td>
+          <td style="padding:8px;border-bottom:1px solid #eee;">${cls}</td>
+        </tr>`;
+      })
+      .join('');
+
+    return `<!DOCTYPE html>
+<html>
+  <head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"></head>
+  <body style="margin:0;font-family:Arial,Helvetica,sans-serif;color:#333;background:#f4f4f4;">
+    <div style="max-width:600px;margin:0 auto;background:#fff;">
+      <div style="background:#0066cc;color:#fff;padding:24px;text-align:center;">
+        <h2 style="margin:0;">Ethio-Djibouti Railway</h2>
+        <p style="margin:8px 0 0;">Payment successful — your ticket is ready</p>
+      </div>
+      <div style="padding:24px;">
+        <p>Booking reference: <strong>${booking.bookingRef}</strong></p>
+        <table style="width:100%;border-collapse:collapse;margin:16px 0;">
+          <tr>
+            <td style="padding:8px 0;color:#666;">From</td>
+            <td style="padding:8px 0;text-align:right;"><strong>${s.originStation?.name ?? ''}</strong> (${s.originStation?.code ?? ''})</td>
+          </tr>
+          <tr>
+            <td style="padding:8px 0;color:#666;">To</td>
+            <td style="padding:8px 0;text-align:right;"><strong>${s.destinationStation?.name ?? ''}</strong> (${s.destinationStation?.code ?? ''})</td>
+          </tr>
+          <tr>
+            <td style="padding:8px 0;color:#666;">Train</td>
+            <td style="padding:8px 0;text-align:right;">${s.train?.name ?? s.train?.number ?? ''}</td>
+          </tr>
+          <tr>
+            <td style="padding:8px 0;color:#666;">Departs</td>
+            <td style="padding:8px 0;text-align:right;">${fmt(s.departureAt)}</td>
+          </tr>
+          <tr>
+            <td style="padding:8px 0;color:#666;">Arrives</td>
+            <td style="padding:8px 0;text-align:right;">${fmt(s.arrivalAt)}</td>
+          </tr>
+        </table>
+
+        <h3 style="margin:16px 0 8px;">Passengers</h3>
+        <table style="width:100%;border-collapse:collapse;">
+          <tr style="text-align:left;color:#666;">
+            <th style="padding:8px;border-bottom:2px solid #eee;">Name</th>
+            <th style="padding:8px;border-bottom:2px solid #eee;">Coach</th>
+            <th style="padding:8px;border-bottom:2px solid #eee;">Seat</th>
+            <th style="padding:8px;border-bottom:2px solid #eee;">Class</th>
+          </tr>
+          ${seatRows}
+        </table>
+
+        <div style="text-align:center;margin:24px 0;">
+          <p style="color:#666;margin:0 0 8px;">Show this QR code at the gate</p>
+          <img src="${ticket.qrPayload}" alt="Ticket QR code" width="180" height="180" style="border:1px solid #eee;padding:8px;background:#fff;" />
+        </div>
+
+        <table style="width:100%;border-collapse:collapse;border-top:2px solid #eee;margin-top:16px;">
+          <tr>
+            <td style="padding:12px 0;font-size:16px;"><strong>Total paid</strong></td>
+            <td style="padding:12px 0;font-size:16px;text-align:right;"><strong>${amount} ${currency}</strong></td>
+          </tr>
+        </table>
+
+        <div style="text-align:center;margin:24px 0;">
+          <a href="${url}" style="background:#0066cc;color:#fff;text-decoration:none;padding:12px 28px;border-radius:4px;display:inline-block;">View ticket</a>
+        </div>
+      </div>
+      <div style="text-align:center;padding:20px;color:#999;font-size:12px;">
+        <p style="margin:0;">© Ethio-Djibouti Railway. All rights reserved.</p>
+      </div>
+    </div>
+  </body>
+</html>`;
+  }
+
+  @OnEvent('payment.failed')
+  async onPaymentFailed(payload: any) {
+    const booking = payload.booking;
+    await this.send(
+      'payment.failed',
+      booking.passengerId,
+      {
+        bookingRef: booking.bookingRef,
+        category: 'PAYMENT',
+        deepLink: `edr://bookings/${booking.bookingRef}`,
+      },
+      ['IN_APP', 'EMAIL', 'SMS'],
+    );
+  }
+
+  @OnEvent('booking.cancelled')
+  async onBookingCancelled(payload: any) {
+    const booking = payload.booking;
+    await this.send(
+      'booking.cancelled',
+      booking.passengerId,
+      {
+        bookingRef: booking.bookingRef,
+        // refundAmount is computed in ETB minor units in BookingsService.cancel().
+        refundAmount: ((payload.refundAmount ?? 0) / 100).toFixed(2),
+        currency: 'ETB',
+        category: 'BOOKING',
+        deepLink: `edr://bookings/${booking.bookingRef}`,
+      },
+      ['IN_APP', 'EMAIL', 'SMS'],
+    );
+  }
+
+  /**
+   * Formats a booking's payable amount from minor units into a major-unit string.
+   * Money is stored as integer minor units (e.g. 59600 santim) to avoid floating-point
+   * drift; we divide by 100 only here, at the display edge. e.g. 59600 -> "596.00".
+   */
+  private formatAmount(booking: any): string {
+    const minor = booking.displayTotalMinor ?? booking.totalMinor ?? 0;
+    return (minor / 100).toFixed(2);
+  }
 }

apps/edr-passenger-api/src/modules/notifications/sms-client.service.ts

@@ -0,0 +1,68 @@
+import {
+  Inject,
+  Injectable,
+  Logger,
+  OnApplicationBootstrap,
+} from "@nestjs/common";
+import { ClientProxy } from "@nestjs/microservices";
+import { BulkMessagesDto, SingleMessageDto } from "./dtos/sms.dto";
+
+@Injectable()
+export class SmsClientService implements OnApplicationBootstrap {
+  private readonly logger = new Logger(SmsClientService.name);
+
+  constructor(
+    @Inject("SMS_SERVICE")
+    private smsClient: ClientProxy,
+  ) {}
+
+  private readonly enabled = process.env.RABBITMQ_ENABLED !== "false";
+
+  async onApplicationBootstrap() {
+    if (!this.enabled) return;
+    this.smsClient
+      .connect()
+      .then(() => {
+        this.logger.log("connected to SMS service");
+      })
+      .catch((err) => {
+        console.error("Error happened at SMS service", err);
+      });
+  }
+
+  async sendSms(dto: SingleMessageDto): Promise<{ queued: boolean }> {
+    if (!this.enabled) {
+      this.logger.warn(`RABBITMQ disabled — skipped SMS`);
+      return { queued: false };
+    }
+    this.smsClient.emit("send-sms", {
+      to: dto.to,
+      text: dto.message,
+      appKey: "IFHCRS-LICENSE-MANAGEMENT",
+    });
+    // Fire-and-forget enqueue: confirms hand-off to RabbitMQ, NOT delivery.
+    this.logger.log(
+      `SMS queued to RabbitMQ [${process.env.SMS_QUEUE ?? "sms_queue"}] pattern='send-sms'`,
+    );
+    // Recipient + content are PII — debug only.
+    this.logger.debug(`SMS payload to=${dto.to} text="${dto.message}"`);
+    return { queued: true };
+  }
+
+  async sendBulkMessages(dto: BulkMessagesDto): Promise<{ queued: boolean }> {
+    if (!this.enabled) {
+      this.logger.warn(`RABBITMQ disabled — skipped BULK SMS (${dto.messages?.length ?? 0} messages)`);
+      return { queued: false };
+    }
+    const messages = (dto.messages ?? []).map((m) => ({ to: m.to, text: m.message, from: m.from }));
+    this.smsClient.emit("ozeking-bulk-sms", {
+      messages,
+      appKey: "IFHCRS-LICENSE-MANAGEMENT",
+    });
+    this.logger.log(
+      `BULK SMS queued to RabbitMQ [${process.env.SMS_QUEUE ?? "sms_queue"}] pattern='ozeking-bulk-sms' count=${messages.length}`,
+    );
+    this.logger.debug(`BULK SMS payload messages=${JSON.stringify(messages)}`);
+    return { queued: true };
+  }
+}

apps/edr-passenger-api/src/modules/passengers/passengers.service.ts

@@ -123,7 +123,7 @@ export class PassengersService {
   }
 
   async getProfile(passengerId: string) {
-    const p = await this.prisma.passenger.findUnique({
+    const passenger = await this.prisma.passenger.findUnique({
       where: { id: passengerId },
       include: {
         bookings: {
@@ -165,8 +165,18 @@ export class PassengersService {
         createdAt: b.createdAt,
         trip: {
           number: b.schedule.train.number,
-          origin: { id: b.schedule.originStation.id, name: b.schedule.originStation.name, code: b.schedule.originStation.code, city: b.schedule.originStation.city },
-          destination: { id: b.schedule.destinationStation.id, name: b.schedule.destinationStation.name, code: b.schedule.destinationStation.code, city: b.schedule.destinationStation.city },
+          origin: { 
+            id: b.schedule.originStation.id, 
+            name: b.schedule.originStation.name, 
+            code: b.schedule.originStation.code, 
+            city: b.schedule.originStation.city 
+          },
+          destination: { 
+            id: b.schedule.destinationStation.id, 
+            name: b.schedule.destinationStation.name, 
+            code: b.schedule.destinationStation.code, 
+            city: b.schedule.destinationStation.city 
+          },
           departureAt: b.schedule.departureAt,
         },
         passengers: b.seats.map((bs) => ({
@@ -228,14 +238,25 @@ export class PassengersService {
   }
 
   createTravelerProfile(dto: CreateTravelerProfileDto) {
-    return this.prisma.travelerProfile.create({ data: { ...dto, dateOfBirth: dto.dateOfBirth ? new Date(dto.dateOfBirth) : null } });
+    return this.prisma.travelerProfile.create({ 
+      data: { 
+        ...dto, 
+        dateOfBirth: dto.dateOfBirth ? new Date(dto.dateOfBirth) : null 
+      } 
+    });
   }
 
-  getTravelerProfiles(passengerId: string) { return this.prisma.travelerProfile.findMany({ where: { passengerId } }); }
+  getTravelerProfiles(passengerId: string) { 
+    return this.prisma.travelerProfile.findMany({ where: { passengerId } }); 
+  }
 
-  createSavedRoute(dto: CreateSavedRouteDto) { return this.prisma.savedRoute.create({ data: dto }); }
+  createSavedRoute(dto: CreateSavedRouteDto) { 
+    return this.prisma.savedRoute.create({ data: dto }); 
+  }
 
-  getSavedRoutes(passengerId: string) { return this.prisma.savedRoute.findMany({ where: { passengerId }, orderBy: { tripCount: 'desc' } }); }
+  getSavedRoutes(passengerId: string) { 
+    return this.prisma.savedRoute.findMany({ where: { passengerId }, orderBy: { tripCount: 'desc' } }); 
+  }
 
   async updatePassenger(id: string, dto: any) {
     const passenger = await this.prisma.passenger.findUnique({ where: { id } });

apps/edr-passenger-api/src/modules/payments/internal-payments.controller.ts

@@ -0,0 +1,35 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Post,
+  UseGuards,
+} from "@nestjs/common";
+import { ApiOperation, ApiTags } from "@nestjs/swagger";
+import { ServiceAuthGuard } from "../../common/guards/service-auth.guard";
+import { PaymentEventDto, MarkPaidResponseDto } from "./internal-payments.dto";
+import { PaymentsService } from "./payments.service";
+
+/**
+ * Consumer side of the payment microservice's outbox relay (docs/payment-service §7.3).
+ * Only the payment service may call this (shared service token). Idempotent by design:
+ * the relay delivers at-least-once, so duplicates must be harmless. Becomes a queue
+ * consumer when RabbitMQ lands — the handler logic is transport-agnostic.
+ */
+@ApiTags("Internal Payments")
+@UseGuards(ServiceAuthGuard)
+@Controller("internal/payments")
+export class InternalPaymentsController {
+  constructor(private readonly paymentsService: PaymentsService) {}
+
+  @Post("mark-paid")
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({
+    summary:
+      "Apply a payment.succeeded/payment.failed event from the payment service (idempotent)",
+  })
+  async markPaid(@Body() event: PaymentEventDto): Promise<MarkPaidResponseDto> {
+    return this.paymentsService.handlePaymentEvent(event);
+  }
+}

apps/edr-passenger-api/src/modules/payments/internal-payments.dto.ts

@@ -0,0 +1,57 @@
+import {
+  IsEnum,
+  IsIn,
+  IsInt,
+  IsISO8601,
+  IsOptional,
+  IsPositive,
+  IsString,
+  IsUUID,
+} from "class-validator";
+import { ApiProperty, ApiPropertyOptional } from "@nestjs/swagger";
+import {
+  PaymentEventType,
+  PaymentReferenceType,
+  PaymentService,
+  ProviderMethod,
+} from "@edr/types";
+
+/**
+ * Wire shape of the `PaymentEvent` envelope (@edr/types) delivered by the payment
+ * microservice's outbox relay. Delivery is at-least-once — the consumer is idempotent.
+ */
+export class PaymentEventDto {
+  @ApiProperty({ enum: [1] }) @IsIn([1]) version!: 1;
+  @ApiProperty() @IsUUID() eventId!: string;
+  @ApiProperty({ enum: ["payment.succeeded", "payment.failed"] })
+  @IsIn(["payment.succeeded", "payment.failed"])
+  eventType!: PaymentEventType;
+
+  @ApiProperty() @IsISO8601() occurredAt!: string;
+  @ApiProperty({ enum: PaymentService })
+  @IsEnum(PaymentService)
+  service!: string;
+  @ApiProperty() @IsUUID() intentId!: string;
+  @ApiProperty({ enum: PaymentReferenceType })
+  @IsEnum(PaymentReferenceType)
+  referenceType!: string;
+
+  @ApiProperty() @IsString() referenceId!: string;
+  @ApiProperty() @IsString() merchantOrderId!: string;
+  @ApiProperty({ enum: ProviderMethod })
+  @IsEnum(ProviderMethod)
+  provider!: string;
+  @ApiProperty() @IsInt() @IsPositive() amountMinor!: number;
+  @ApiProperty() @IsString() currency!: string;
+
+  @ApiPropertyOptional() @IsOptional() @IsString() providerTxnId?: string;
+  @ApiPropertyOptional() @IsOptional() @IsISO8601() paidAt?: string;
+  @ApiPropertyOptional() @IsOptional() @IsString() failureCode?: string;
+  @ApiPropertyOptional() @IsOptional() @IsString() failureMessage?: string;
+}
+
+export class MarkPaidResponseDto {
+  @ApiProperty() processed!: boolean;
+  @ApiPropertyOptional() alreadyFinalized?: boolean;
+  @ApiPropertyOptional() reason?: string;
+}

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

@@ -0,0 +1,95 @@
+import { BadGatewayException, Injectable, Logger } from "@nestjs/common";
+import { HttpService } from "@nestjs/axios";
+import { AxiosError } from "axios";
+import { firstValueFrom } from "rxjs";
+import {
+  InitiatePaymentRequest,
+  PaymentIntentSnapshot,
+  PaymentReferenceType,
+  PaymentService,
+} from "@edr/types";
+
+/**
+ * Thin HTTP client for the payment microservice (apps/edr-payment-api) — the passenger app's
+ * side of the Phase 6 cutover (docs/payment-service §10). Domain validation stays here;
+ * provider calls, intents, and webhooks live in the payment service.
+ */
+@Injectable()
+export class PaymentClientService {
+  private readonly logger = new Logger(PaymentClientService.name);
+  private readonly baseUrl = (
+    process.env.PAYMENT_API_URL ?? "http://localhost:3003"
+  ).replace(/\/$/, "");
+  private readonly serviceToken = process.env.SERVICE_AUTH_TOKEN ?? "";
+
+  constructor(private readonly http: HttpService) {}
+
+  /** POST /payments/initiate — idempotent per (service, referenceType, referenceId). */
+  async initiate(
+    request: InitiatePaymentRequest,
+  ): Promise<PaymentIntentSnapshot> {
+    return this.call("POST", "/payments/initiate", request);
+  }
+
+  /** GET /payments/intents?… — active intent by domain reference; null when none exists. */
+  async getIntentByReference(
+    referenceType: PaymentReferenceType,
+    referenceId: string,
+  ): Promise<PaymentIntentSnapshot | null> {
+    const query = new URLSearchParams({
+      service: PaymentService.PASSENGER,
+      referenceType,
+      referenceId,
+    });
+    try {
+      return await this.call("GET", `/payments/intents?${query.toString()}`);
+    } catch (err) {
+      if (err instanceof AxiosError && err.response?.status === 404)
+        return null;
+      throw err;
+    }
+  }
+
+  private async call<T>(
+    method: "GET" | "POST",
+    path: string,
+    body?: unknown,
+  ): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    this.logger.log("=====================================================================");
+    this.logger.log(`URL ${url}`);
+    this.logger.log("=====================================================================");
+    try {
+      const response = await firstValueFrom(
+        this.http.request<T>({
+          method,
+          url,
+          data: body,
+          headers: this.serviceToken
+            ? { "x-service-token": this.serviceToken }
+            : {},
+        }),
+      );
+      return response.data;
+    } catch (err) {
+      if (err instanceof AxiosError && err.response) {
+        // 4xx/5xx from the payment service: propagate 404 to callers that handle it;
+        // everything else is a gateway-level failure from the client's perspective.
+        if (err.response.status === 404) throw err;
+        const detail =
+          (err.response.data as { message?: string | string[] })?.message ??
+          err.message;
+        this.logger.error(
+          `payment service ${method} ${path} → ${err.response.status}: ${detail}`,
+        );
+        throw new BadGatewayException(`Payment service error: ${detail}`);
+      }
+      const message =
+        err instanceof Error && err.message ? err.message : String(err);
+      this.logger.error(
+        `payment service unreachable (${method} ${path}): ${message}`,
+      );
+      throw new BadGatewayException("Payment service unreachable");
+    }
+  }
+}

apps/edr-passenger-api/src/modules/payments/payment-events.consumer.ts

@@ -0,0 +1,47 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { Nack, RabbitSubscribe } from '@golevelup/nestjs-rabbitmq';
+import {
+  PAYMENT_EVENTS_DLX,
+  PAYMENT_EVENTS_EXCHANGE,
+  PAYMENT_QUEUES,
+  PaymentEvent,
+  PaymentService,
+  paymentServiceBindingPattern,
+} from '@edr/types';
+import { PaymentEventDto } from './internal-payments.dto';
+import { PaymentsService } from './payments.service';
+
+const PASSENGER_QUEUE = PAYMENT_QUEUES[PaymentService.PASSENGER];
+
+@Injectable()
+export class PaymentEventsConsumer {
+  private readonly logger = new Logger(PaymentEventsConsumer.name);
+
+  constructor(private readonly paymentsService: PaymentsService) {}
+
+  @RabbitSubscribe({
+    exchange: PAYMENT_EVENTS_EXCHANGE,
+    routingKey: paymentServiceBindingPattern(PaymentService.PASSENGER), // payment.passenger.*
+    queue: PASSENGER_QUEUE.main,
+    queueOptions: {
+      durable: true,
+      deadLetterExchange: PAYMENT_EVENTS_DLX,
+    },
+  })
+  async handle(event: PaymentEvent): Promise<Nack | void> {
+    try {
+      const result = await this.paymentsService.handlePaymentEvent(
+        event as unknown as PaymentEventDto,
+      );
+      this.logger.log(
+        `processed ${event.eventType} (${event.eventId}) ref=${event.referenceId}: ${JSON.stringify(result)}`,
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.error(
+        `DEAD-LETTERING ${event.eventType} (${event.eventId}) ref=${event.referenceId}: ${message}`,
+      );
+      return new Nack(false);
+    }
+  }
+}

apps/edr-passenger-api/src/modules/payments/payments.adapters.ts

@@ -1,10 +1,50 @@
-export interface GatewayResult { success: boolean; providerRef: string; clientAction?: { type: string; url?: string }; }
-
-export async function telebirrAdapter(_a: number, ref: string): Promise<GatewayResult> {
-  await new Promise((r) => setTimeout(r, 200));
-  return { success: true, providerRef: `TB-${ref}-${Date.now()}`, clientAction: { type: 'REDIRECT', url: `https://telebirr.sandbox.com/pay/${ref}` } };
+export interface GatewayResult {
+  success: boolean;
+  providerRef: string;
+  clientAction?: { type: string; url?: string };
+}
+
+export async function telebirrAdapter(
+  _a: number,
+  ref: string,
+): Promise<GatewayResult> {
+  await new Promise((r) => setTimeout(r, 200));
+  return {
+    success: true,
+    providerRef: `TB-${ref}-${Date.now()}`,
+    clientAction: {
+      type: "REDIRECT",
+      url: `https://telebirr.sandbox.com/pay/${ref}`,
+    },
+  };
+}
+export async function cbeBirrAdapter(
+  _a: number,
+  ref: string,
+): Promise<GatewayResult> {
+  await new Promise((r) => setTimeout(r, 150));
+  return { success: true, providerRef: `CBE-${ref}-${Date.now()}` };
+}
+export async function eBirrAdapter(
+  _a: number,
+  ref: string,
+): Promise<GatewayResult> {
+  await new Promise((r) => setTimeout(r, 150));
+  return { success: true, providerRef: `EB-${ref}-${Date.now()}` };
+}
+export async function cardAdapter(
+  _a: number,
+  ref: string,
+): Promise<GatewayResult> {
+  await new Promise((r) => setTimeout(r, 150));
+  return {
+    success: !ref.startsWith("FAIL"),
+    providerRef: `CARD-${ref}-${Date.now()}`,
+  };
+}
+export async function walletAdapter(
+  amount: number,
+  balance: number,
+): Promise<GatewayResult> {
+  return { success: balance >= amount, providerRef: `WALLET-${Date.now()}` };
 }
-export async function cbeBirrAdapter(_a: number, ref: string): Promise<GatewayResult> { await new Promise((r) => setTimeout(r, 150)); return { success: true, providerRef: `CBE-${ref}-${Date.now()}` }; }
-export async function eBirrAdapter(_a: number, ref: string): Promise<GatewayResult>   { await new Promise((r) => setTimeout(r, 150)); return { success: true, providerRef: `EB-${ref}-${Date.now()}` }; }
-export async function cardAdapter(_a: number, ref: string): Promise<GatewayResult>    { await new Promise((r) => setTimeout(r, 150)); return { success: !ref.startsWith('FAIL'), providerRef: `CARD-${ref}-${Date.now()}` }; }
-export async function walletAdapter(amount: number, balance: number): Promise<GatewayResult> { return { success: balance >= amount, providerRef: `WALLET-${Date.now()}` }; }

apps/edr-passenger-api/src/modules/payments/payments.controller.ts

@@ -1,108 +1,205 @@
-import { Body, Controller, Get, HttpStatus, Param, Post, Query, Res, UseGuards } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery, ApiOkResponse, ApiProduces } from '@nestjs/swagger';
-import { Response } from 'express';
-import { PaymentsService } from './payments.service';
-import { InitiatePaymentDto, RefundDto, AddPaymentMethodDto, PaymentRegionEnum, SupportedPaymentMethodDto, PaymentMethodTypeEnum, PaymentPlatformDto } from './payments.dto';
-import { JwtGuard } from '../../common/jwt.guard';
-import { RolesGuard } from '../../common/roles.guard';
-import { Roles } from '../../common/roles.decorator';
-import { UserRole } from '@prisma/client';
+import {
+  Body,
+  Controller,
+  Get,
+  HttpStatus,
+  Param,
+  Post,
+  Query,
+  Res,
+  UseGuards,
+} from "@nestjs/common";
+import {
+  ApiTags,
+  ApiOperation,
+  ApiBearerAuth,
+  ApiQuery,
+  ApiOkResponse,
+  ApiProduces,
+} from "@nestjs/swagger";
+import { Response } from "express";
+import { PaymentsService } from "./payments.service";
+import {
+  InitiatePaymentDto,
+  RefundDto,
+  AddPaymentMethodDto,
+  PaymentRegionEnum,
+  SupportedPaymentMethodDto,
+  PaymentMethodTypeEnum,
+  PaymentPlatformDto,
+} from "./payments.dto";
+import { JwtGuard } from "../../common/jwt.guard";
+import { RolesGuard } from "../../common/roles.guard";
+import { Roles } from "../../common/roles.decorator";
+import { UserRole } from "@prisma/client";
 
-@ApiTags('Payment')
-@Controller('payments')
+@ApiTags("Payment")
+@Controller("payments")
 export class PaymentsController {
   constructor(private service: PaymentsService) {}
-  
-  @Post('initiate')
-  @ApiOperation({ 
-    summary: 'Initiate payment with nationality-based payment methods',
-    description: `Initiates payment for a booking with support for multiple payment providers:
 
-**Ethiopian Payment Methods:**
-- TELEBIRR - Ethiopia's leading mobile money
-- CBE_BIRR - Commercial Bank of Ethiopia
-- EBIRR - Electronic payment gateway
+  @Get("all")
+  @UseGuards(JwtGuard, RolesGuard)
+  @Roles(UserRole.ADMIN, UserRole.SUPERVISOR, UserRole.STAFF)
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Get all payments with filters (staff/admin only)" })
+  @ApiQuery({ name: "search", required: false })
+  @ApiQuery({ name: "status", required: false })
+  @ApiQuery({ name: "method", required: false })
+  @ApiQuery({ name: "page", required: false })
+  @ApiQuery({ name: "pageSize", required: false })
+  async getAll(
+    @Query("search") search?: string,
+    @Query("status") status?: string,
+    @Query("method") method?: string,
+    @Query("page") page?: string,
+    @Query("pageSize") pageSize?: string,
+  ) {
+    return this.service.getAll({
+      search,
+      status,
+      method,
+      page: page ? parseInt(page) : 1,
+      pageSize: pageSize ? parseInt(pageSize) : 10,
+    });
+  }
 
-**Djiboutian Payment Methods:**
-- WAAFI - Djibouti's mobile money service
-
-**International Payment Methods:**
-- CARD - Visa, Mastercard
-- WALLET - Internal wallet balance
-
-**Multi-Currency:**
-- All transactions processed in ETB
-- Display amounts in ETB, DJF, or USD
-- Real-time exchange rate conversion`
+  @Post("initiate")
+  @ApiOperation({
+    summary: "Initiate payment with nationality-based payment methods",
+    description: `Initiates payment for a booking with support for multiple payment providers:\n\n**Ethiopian Payment Methods:**\n- TELEBIRR - Ethiopia's leading mobile money\n- CBE_BIRR - Commercial Bank of Ethiopia\n- EBIRR - Electronic payment gateway\n\n**Djiboutian Payment Methods:**\n- WAAFI - Djibouti's mobile money service\n\n**International Payment Methods:**\n- CARD - Visa, Mastercard\n- WALLET - Internal wallet balance\n\n**Multi-Currency:**\n- All transactions processed in ETB\n- Display amounts in ETB, DJF, or USD\n- Real-time exchange rate conversion`,
   })
-  initiatePayment(@Body() dto: InitiatePaymentDto) { return this.service.initiatePayment(dto); }
-  
-  @Get('intents/:bookingId')
-  @ApiOperation({ summary: 'Get payment intent status for a booking' })
-  getIntent(@Param('bookingId') bookingId: string) { return this.service.getIntentByBookingId(bookingId); }
-  
-  @Post('refund')
+  initiatePayment(@Body() dto: InitiatePaymentDto) {
+    return this.service.initiatePayment(dto);
+  }
+
+  @Get("intents/:bookingId")
+  @ApiOperation({ summary: "Get payment intent status for a booking" })
+  getIntent(@Param("bookingId") bookingId: string) {
+    return this.service.getIntentByBookingId(bookingId);
+  }
+
+  @Get("waafi/return")
+  @ApiOperation({
+    summary:
+      "DEMO ONLY — confirm a Waafi payment from the browser-return params and return JSON for the " +
+      "UI to display. The frontend success page forwards the Waafi query params here. Gated by " +
+      "WAAFI_DEMO_TRUST_RETURN (INSECURE; real confirmation is the webhook/HPP_GETTRANINFO).",
+  })
+  @ApiQuery({ name: "referenceId", required: true })
+  @ApiQuery({ name: "state", required: true })
+  @ApiQuery({ name: "transactionId", required: false })
+  waafiReturn(
+    @Query("referenceId") referenceId: string,
+    @Query("state") state: string,
+    @Query("transactionId") transactionId: string,
+  ) {
+    return this.service.confirmWaafiReturnDemo({
+      referenceId,
+      state,
+      transactionId,
+    });
+  }
+
+  @Post("refund")
   @UseGuards(JwtGuard, RolesGuard)
   @Roles(UserRole.ADMIN, UserRole.STAFF, UserRole.AGENT)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Refund a confirmed booking (staff/agent only)' })
-  refund(@Body() dto: RefundDto) { return this.service.refund(dto); }
+  @ApiBearerAuth("JWT-auth")
+  @ApiOperation({ summary: "Refund a confirmed booking (staff/agent only)" })
+  refund(@Body() dto: RefundDto) {
+    return this.service.refund(dto);
+  }
 
-  @Post('methods')
+  @Post("methods")
   @UseGuards(JwtGuard, RolesGuard)
   @Roles(UserRole.ADMIN, UserRole.STAFF)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Add a payment system to the platform catalog (admin only)' })
-  addMethod(@Body() dto: AddPaymentMethodDto) { return this.service.addPaymentMethod(dto); }
-  
-  @Get('methods')
+  @ApiBearerAuth("JWT-auth")
   @ApiOperation({
-    summary: 'List payment systems supported by the platform',
-    description: 'Returns the global catalog of accepted payment systems. Not user-specific. Optionally filter by region to match a passenger\'s nationality.',
+    summary: "Add a payment system to the platform catalog (admin only)",
   })
-  @ApiQuery({ name: 'region', enum: PaymentRegionEnum, required: false })
-  @ApiOkResponse({ type: [SupportedPaymentMethodDto] })
-  getMethods(@Query('region') region?: PaymentRegionEnum) { return this.service.getSupportedPaymentMethods(region); }
+  addMethod(@Body() dto: AddPaymentMethodDto) {
+    return this.service.addPaymentMethod(dto);
+  }
 
-  @Get('checkout')
+  @Get("methods")
   @ApiOperation({
-    summary: 'Browser checkout redirect',
-    description: 'Initiates payment and returns an HTML page that auto-redirects the browser to the provider checkout URL. Designed to be opened directly in a browser tab.',
+    summary: "List payment systems supported by the platform",
+    description:
+      "Returns the global catalog of accepted payment systems. Not user-specific. Optionally filter by region to match a passenger's nationality.",
   })
-  @ApiQuery({ name: 'bookingId', required: true })
-  @ApiQuery({ name: 'method', enum: PaymentMethodTypeEnum, required: true })
-  @ApiQuery({ name: 'platform', enum: ['web', 'mobile'], required: false })
-  @ApiProduces('text/html')
+  @ApiQuery({ name: "region", enum: PaymentRegionEnum, required: false })
+  @ApiOkResponse({ type: [SupportedPaymentMethodDto] })
+  getMethods(@Query("region") region?: PaymentRegionEnum) {
+    return this.service.getSupportedPaymentMethods(region);
+  }
+
+  @Get("checkout")
+  @ApiOperation({
+    summary: "Browser checkout redirect",
+    description:
+      "Initiates payment and returns an HTML page that auto-redirects the browser to the provider checkout URL. Designed to be opened directly in a browser tab.",
+  })
+  @ApiQuery({ name: "bookingId", required: true })
+  @ApiQuery({ name: "method", enum: PaymentMethodTypeEnum, required: true })
+  @ApiQuery({ name: "platform", enum: ["web", "mobile"], required: false })
+  @ApiProduces("text/html")
   async checkout(
-    @Query('bookingId') bookingId: string,
-    @Query('method') method: PaymentMethodTypeEnum,
-    @Query('platform') platform: PaymentPlatformDto = 'web',
+    @Query("bookingId") bookingId: string,
+    @Query("method") method: PaymentMethodTypeEnum,
+    @Query("platform") platform: PaymentPlatformDto = "web",
     @Res() res: Response,
   ) {
     if (!bookingId) {
-      return res.status(HttpStatus.BAD_REQUEST).type('html').send(this.buildErrorHtml('Missing required query parameter: bookingId'));
+      return res
+        .status(HttpStatus.BAD_REQUEST)
+        .type("html")
+        .send(
+          this.buildErrorHtml("Missing required query parameter: bookingId"),
+        );
     }
     if (!method || !Object.values(PaymentMethodTypeEnum).includes(method)) {
-      return res.status(HttpStatus.BAD_REQUEST).type('html').send(this.buildErrorHtml('Missing or invalid query parameter: method'));
+      return res
+        .status(HttpStatus.BAD_REQUEST)
+        .type("html")
+        .send(
+          this.buildErrorHtml("Missing or invalid query parameter: method"),
+        );
     }
 
     try {
-      const result = await this.service.initiatePayment({ bookingId, method, platform });
-      const url = result.clientAction?.type === 'REDIRECT' ? result.clientAction.url : undefined;
+      const result = await this.service.initiatePayment({
+        bookingId,
+        method,
+        platform,
+      });
+      const url =
+        result.clientAction?.type === "REDIRECT"
+          ? result.clientAction.url
+          : undefined;
 
       if (url) {
-        return res.status(HttpStatus.OK).type('html').send(this.buildRedirectHtml(url));
+        return res
+          .status(HttpStatus.OK)
+          .type("html")
+          .send(this.buildRedirectHtml(url));
       }
 
-      return res.status(HttpStatus.OK).type('html').send(this.buildStatusHtml(result.status, result.intentId));
+      return res
+        .status(HttpStatus.OK)
+        .type("html")
+        .send(this.buildStatusHtml(result.status, result.intentId));
     } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : 'An unexpected error occurred';
-      return res.status(HttpStatus.OK).type('html').send(this.buildErrorHtml(message));
+      const message =
+        err instanceof Error ? err.message : "An unexpected error occurred";
+      return res
+        .status(HttpStatus.OK)
+        .type("html")
+        .send(this.buildErrorHtml(message));
     }
   }
 
   private buildRedirectHtml(url: string): string {
-    const escaped = url.replace(/"/g, '"');
+    const escaped = url.replace(/\"/g, """);
     return `<!DOCTYPE html>
 <html lang="en">
 <head>

apps/edr-passenger-api/src/modules/payments/payments.dto.ts

@@ -1,36 +1,54 @@
-import { IsString, IsEnum, IsOptional, IsIn, IsBoolean, IsInt } from 'class-validator';
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { PaymentIntentStatus } from '@prisma/client';
+import {
+  IsString,
+  IsEnum,
+  IsOptional,
+  IsIn,
+  IsBoolean,
+  IsInt,
+} from "class-validator";
+import { ApiProperty, ApiPropertyOptional } from "@nestjs/swagger";
+import { PaymentIntentStatus } from "@prisma/client";
 
 export enum PaymentRegionEnum {
-  ETHIOPIA = 'ETHIOPIA',
-  DJIBOUTI = 'DJIBOUTI',
-  INTERNATIONAL = 'INTERNATIONAL',
-  GLOBAL = 'GLOBAL',
+  ETHIOPIA = "ETHIOPIA",
+  DJIBOUTI = "DJIBOUTI",
+  INTERNATIONAL = "INTERNATIONAL",
+  GLOBAL = "GLOBAL",
 }
 
-export enum PaymentMethodTypeEnum { 
-  TELEBIRR = 'TELEBIRR',  // Ethiopia
-  CBE_BIRR = 'CBE_BIRR',  // Ethiopia
-  EBIRR = 'EBIRR',        // Ethiopia
-  WAAFI = 'WAAFI',        // Djibouti
-  CARD = 'CARD',          // International
-  WALLET = 'WALLET'       // Internal
+export enum PaymentMethodTypeEnum {
+  TELEBIRR = "TELEBIRR", // Ethiopia
+  CBE_BIRR = "CBE_BIRR", // Ethiopia
+  EBIRR = "EBIRR", // Ethiopia
+  WAAFI = "WAAFI",
+  DMONEY= "DMONEY",// Djibouti
+  CARD = "CARD", // International
+  WALLET = "WALLET", // Internal
 }
 
-export type PaymentPlatformDto = 'web' | 'mobile';
+export type PaymentPlatformDto = "web" | "mobile";
 
 export class InitiatePaymentDto {
-  @ApiProperty({ example: 'booking-uuid' }) @IsString() bookingId: string;
+  @ApiProperty({ example: "booking-uuid" }) @IsString() bookingId: string;
   @ApiProperty({
     enum: PaymentMethodTypeEnum,
-    description: 'Payment method: TELEBIRR/CBE_BIRR/EBIRR (Ethiopia), WAAFI (Djibouti), CARD (International), WALLET (Internal)',
-    example: 'TELEBIRR'
-  }) @IsEnum(PaymentMethodTypeEnum) method: PaymentMethodTypeEnum;
-  @ApiPropertyOptional({ description: 'Saved payment method ID (optional)' }) @IsOptional() @IsString() paymentMethodId?: string;
-  @ApiPropertyOptional({ enum: ['web', 'mobile'], default: 'web', description: 'Payment platform (web or mobile)' })
+    description:
+      "Payment method: TELEBIRR/CBE_BIRR/EBIRR (Ethiopia), WAAFI (Djibouti), CARD (International), WALLET (Internal)",
+    example: "TELEBIRR",
+  })
+  @IsEnum(PaymentMethodTypeEnum)
+  method: PaymentMethodTypeEnum;
+  @ApiPropertyOptional({ description: "Saved payment method ID (optional)" })
   @IsOptional()
-  @IsIn(['web', 'mobile'])
+  @IsString()
+  paymentMethodId?: string;
+  @ApiPropertyOptional({
+    enum: ["web", "mobile"],
+    default: "web",
+    description: "Payment platform (web or mobile)",
+  })
+  @IsOptional()
+  @IsIn(["web", "mobile"])
   platform?: PaymentPlatformDto;
 }
 
@@ -40,42 +58,79 @@ export class RefundDto {
 }
 
 export class AddPaymentMethodDto {
-  @ApiProperty({ enum: PaymentMethodTypeEnum }) @IsEnum(PaymentMethodTypeEnum) type: PaymentMethodTypeEnum;
+  @ApiProperty({ enum: PaymentMethodTypeEnum })
+  @IsEnum(PaymentMethodTypeEnum)
+  type: PaymentMethodTypeEnum;
   @ApiProperty() @IsString() displayName: string;
-  @ApiProperty({ enum: PaymentRegionEnum }) @IsEnum(PaymentRegionEnum) region: PaymentRegionEnum;
-  @ApiPropertyOptional({ example: 'ETB' }) @IsOptional() @IsString() currency?: string;
+  @ApiProperty({ enum: PaymentRegionEnum })
+  @IsEnum(PaymentRegionEnum)
+  region: PaymentRegionEnum;
+  @ApiPropertyOptional({ example: "ETB" })
+  @IsOptional()
+  @IsString()
+  currency?: string;
   @ApiPropertyOptional() @IsOptional() @IsString() providerId?: string;
-  @ApiPropertyOptional({ default: true }) @IsOptional() @IsBoolean() enabled?: boolean;
-  @ApiPropertyOptional({ default: 0 }) @IsOptional() @IsInt() sortOrder?: number;
+  @ApiPropertyOptional({ default: true })
+  @IsOptional()
+  @IsBoolean()
+  enabled?: boolean;
+  @ApiPropertyOptional({ default: 0 })
+  @IsOptional()
+  @IsInt()
+  sortOrder?: number;
 }
 
 export class SupportedPaymentMethodDto {
   @ApiProperty({ enum: PaymentMethodTypeEnum }) type: PaymentMethodTypeEnum;
-  @ApiProperty({ example: 'Telebirr' }) displayName: string;
+  @ApiProperty({ example: "Telebirr" }) displayName: string;
   @ApiProperty({ enum: PaymentRegionEnum }) region: PaymentRegionEnum;
-  @ApiProperty({ example: 'ETB', description: 'Settlement currency for this method' }) currency: string;
-  @ApiProperty({ description: 'Whether the platform currently accepts this method' }) enabled: boolean;
+  @ApiProperty({
+    example: "ETB",
+    description: "Settlement currency for this method",
+  })
+  currency: string;
+  @ApiProperty({
+    description: "Whether the platform currently accepts this method",
+  })
+  enabled: boolean;
 }
 
 export class ClientActionDto {
-  @ApiProperty({ enum: ['REDIRECT', 'LAUNCH_APP'] }) type: 'REDIRECT' | 'LAUNCH_APP';
-  @ApiPropertyOptional({ description: 'Set when type=REDIRECT (web flow)' }) url?: string;
-  @ApiPropertyOptional({ description: 'Set when type=LAUNCH_APP (mobile flow)' }) prepayId?: string;
-  @ApiPropertyOptional({ description: 'Set when type=LAUNCH_APP (mobile flow)' }) receiveCode?: string;
-  @ApiPropertyOptional({ description: 'Set when type=LAUNCH_APP (mobile flow)' }) shortCode?: string;
+  @ApiProperty({ enum: ["REDIRECT", "LAUNCH_APP", "COLLECT_OTP"] })
+  type: "REDIRECT" | "LAUNCH_APP" | "COLLECT_OTP";
+  @ApiPropertyOptional({ description: "Set when type=REDIRECT (web flow)" })
+  url?: string;
+  @ApiPropertyOptional({
+    description: "Set when type=LAUNCH_APP (mobile flow)",
+  })
+  prepayId?: string;
+  @ApiPropertyOptional({
+    description: "Set when type=LAUNCH_APP (mobile flow)",
+  })
+  receiveCode?: string;
+  @ApiPropertyOptional({
+    description: "Set when type=LAUNCH_APP (mobile flow)",
+  })
+  shortCode?: string;
+  @ApiPropertyOptional({ description: "Set when type=COLLECT_OTP (e.g. CAC Bank)" })
+  providerOrderId?: string;
+  @ApiPropertyOptional({ description: "Set when type=COLLECT_OTP" })
+  message?: string;
 }
 
 export class InitiateResponseDto {
   @ApiProperty() intentId: string;
   @ApiProperty({ enum: PaymentIntentStatus }) status: PaymentIntentStatus;
-  @ApiPropertyOptional({ type: ClientActionDto }) clientAction?: ClientActionDto;
+  @ApiPropertyOptional({ type: ClientActionDto })
+  clientAction?: ClientActionDto;
   @ApiPropertyOptional() merchantOrderId?: string;
 }
 
 export class IntentStatusDto {
   @ApiProperty() intentId: string;
   @ApiProperty({ enum: PaymentIntentStatus }) status: PaymentIntentStatus;
-  @ApiPropertyOptional({ type: ClientActionDto }) clientAction?: ClientActionDto;
+  @ApiPropertyOptional({ type: ClientActionDto })
+  clientAction?: ClientActionDto;
   @ApiPropertyOptional() merchantOrderId?: string;
   @ApiPropertyOptional() paidAt?: string;
   @ApiPropertyOptional() failureCode?: string;

apps/edr-passenger-api/src/modules/payments/payments.e2e-spec.ts

@@ -1,10 +1,10 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { INestApplication, ValidationPipe } from '@nestjs/common';
-import request from 'supertest';
-import { AppModule } from '../../app.module';
-import { PrismaService } from '../../common/prisma.service';
+import { Test, TestingModule } from "@nestjs/testing";
+import { INestApplication, ValidationPipe } from "@nestjs/common";
+import request from "supertest";
+import { AppModule } from "../../app.module";
+import { PrismaService } from "../../common/prisma.service";
 
-describe('Payments E2E', () => {
+describe("Payments E2E", () => {
   let app: INestApplication;
   let prisma: PrismaService;
   let authToken: string;
@@ -16,45 +16,111 @@ describe('Payments E2E', () => {
     }).compile();
 
     app = moduleFixture.createNestApplication();
-    app.useGlobalPipes(new ValidationPipe({ transform: true, whitelist: true }));
+    app.useGlobalPipes(
+      new ValidationPipe({ transform: true, whitelist: true }),
+    );
     await app.init();
 
     prisma = app.get<PrismaService>(PrismaService);
 
     const passenger = await prisma.passenger.create({ data: { iamUserId: 'test-iam-payments-user' } });
 
-    await prisma.walletAccount.create({ data: { passengerId: passenger.id, balanceMinor: 100000, currency: 'ETB' } });
-
-    authToken = 'mock-jwt-token';
-
-    const station1 = await prisma.station.create({ data: { code: 'TST1', name: 'Test Station 1', city: 'Test City', lat: 9.0, lng: 38.0 } });
-    const station2 = await prisma.station.create({ data: { code: 'TST2', name: 'Test Station 2', city: 'Test City 2', lat: 9.5, lng: 38.5 } });
-
-    const train = await prisma.train.create({ data: { number: 'TEST-001', name: 'Test Train' } });
-
-    const schedule = await prisma.trainSchedule.create({
-      data: { trainId: train.id, originStationId: station1.id, destinationStationId: station2.id, departureAt: new Date(Date.now() + 86400000), arrivalAt: new Date(Date.now() + 90000000), durationMinutes: 60 },
+    await prisma.walletAccount.create({
+      data: {
+        passengerId: passenger.id,
+        balanceMinor: 100000,
+        currency: "ETB",
+      },
     });
 
-    const seatClass = await prisma.seatClass.upsert({
-      where: { name: 'Economy Regular' },
-      update: {},
-      create: { name: 'Economy Regular', description: 'Standard economy seating', basePrice: 45000, isActive: true },
+    authToken = "mock-jwt-token";
+
+    const station1 = await prisma.station.create({
+      data: {
+        code: "TST1",
+        name: "Test Station 1",
+        city: "Test City",
+        lat: 9.0,
+        lng: 38.0,
+      },
+    });
+    const station2 = await prisma.station.create({
+      data: {
+        code: "TST2",
+        name: "Test Station 2",
+        city: "Test City 2",
+        lat: 9.5,
+        lng: 38.5,
+      },
+    });
+
+    const train = await prisma.train.create({
+      data: { number: "TEST-001", name: "Test Train" },
+    });
+
+    const schedule = await prisma.trainSchedule.create({
+      data: {
+        trainId: train.id,
+        originStationId: station1.id,
+        destinationStationId: station2.id,
+        departureAt: new Date(Date.now() + 86400000),
+        arrivalAt: new Date(Date.now() + 90000000),
+        durationMinutes: 60,
+      },
+    });
+
+    const coachType = await prisma.coachType.create({
+      data: { name: "Standard", code: "STD" },
+    });
+
+    const seatClass = await prisma.seatClass.create({
+      data: {
+        name: "Economy Regular",
+        description: "Standard economy seating",
+        baseFareMinor: 45000,
+        isActive: true,
+        coachTypeId: coachType.id,
+      },
     });
 
     const coach = await prisma.coach.create({
-      data: { coachNumber: 'TEST-C1', label: 'A', seatClassId: seatClass.id, mode: 'seat', totalUnits: 10 },
+      data: {
+        coachTypeId: coachType.id,
+        number: "TEST-C1",
+        arrangement: "2+2",
+        capacity: 10,
+        status: "ACTIVE",
+      },
     });
 
-    await prisma.coachAssignment.create({ data: { scheduleId: schedule.id, coachId: coach.id, positionNumber: 1 } });
-
-    const seat = await prisma.seat.create({ data: { coachId: coach.id, row: 1, col: 'A', label: '1A', status: 'AVAILABLE' } });
+    const seat = await prisma.seat.create({
+      data: {
+        coachId: coach.id,
+        row: 1,
+        col: "A",
+        seatNumber: "1A",
+        status: "AVAILABLE",
+      },
+    });
 
     const booking = await prisma.booking.create({
-      data: { bookingRef: 'TEST-BOOK-001', passengerId: passenger.id, scheduleId: schedule.id, status: 'PENDING_PAYMENT', totalMinor: 50000, currency: 'ETB' },
+      data: {
+        bookingRef: "TEST-BOOK-001",
+        passengerId: passenger.id,
+        scheduleId: schedule.id,
+        status: "PENDING_PAYMENT",
+        totalMinor: 50000,
+        currency: "ETB",
+      },
     });
 
-    await prisma.bookingSeat.create({ data: { bookingId: booking.id, seatId: seat.id, passengerName: 'Test Passenger' } });
+    await prisma.bookingSeat.create({
+      data: {
+        bookingId: booking.id,
+        seatId: seat.id,
+        passengerName: "Test Passenger",
+      },
+    });
 
     bookingId = booking.id;
   });
@@ -69,7 +135,7 @@ describe('Payments E2E', () => {
       prisma.coach.deleteMany(),
       prisma.trainSchedule.deleteMany(),
       prisma.train.deleteMany(),
-      prisma.station.deleteMany({ where: { code: { in: ['TST1', 'TST2'] } } }),
+      prisma.station.deleteMany({ where: { code: { in: ["TST1", "TST2"] } } }),
       prisma.walletLedgerEntry.deleteMany(),
       prisma.walletAccount.deleteMany(),
       prisma.passenger.deleteMany(),
@@ -77,80 +143,51 @@ describe('Payments E2E', () => {
     await app.close();
   });
 
-  describe('POST /payments/initiate', () => {
-    it('should initiate wallet payment successfully', async () => {
+  describe("POST /payments/initiate", () => {
+    it("should initiate wallet payment successfully", async () => {
       const response = await request(app.getHttpServer())
-        .post('/payments/initiate')
-        .set('Authorization', `Bearer ${authToken}`)
-        .send({ bookingId, method: 'WALLET' })
+        .post("/payments/initiate")
+        .set("Authorization", `Bearer ${authToken}`)
+        .send({ bookingId, method: "WALLET" })
         .expect(201);
       expect(response.body.intentId).toBeDefined();
-      expect(response.body.status).toBe('SUCCEEDED');
+      expect(response.body.status).toBe("SUCCEEDED");
     });
 
-    it('should return 400 for invalid payment method', async () => {
+    it("should return 400 for invalid payment method", async () => {
       await request(app.getHttpServer())
-        .post('/payments/initiate')
-        .set('Authorization', `Bearer ${authToken}`)
-        .send({ bookingId, method: 'INVALID_METHOD' })
+        .post("/payments/initiate")
+        .set("Authorization", `Bearer ${authToken}`)
+        .send({ bookingId, method: "INVALID_METHOD" })
         .expect(400);
     });
 
-    it('should return 404 for non-existent booking', async () => {
+    it("should return 404 for non-existent booking", async () => {
       await request(app.getHttpServer())
-        .post('/payments/initiate')
-        .set('Authorization', `Bearer ${authToken}`)
-        .send({ bookingId: 'non-existent-id', method: 'WALLET' })
+        .post("/payments/initiate")
+        .set("Authorization", `Bearer ${authToken}`)
+        .send({ bookingId: "non-existent-id", method: "WALLET" })
         .expect(404);
     });
   });
 
-  describe('GET /payments/intents/:bookingId', () => {
-    it('should get payment intent status', async () => {
+  describe("GET /payments/intents/:bookingId", () => {
+    it("should get payment intent status", async () => {
       const response = await request(app.getHttpServer())
         .get(`/payments/intents/${bookingId}`)
-        .set('Authorization', `Bearer ${authToken}`)
+        .set("Authorization", `Bearer ${authToken}`)
         .expect(200);
       expect(response.body.intentId).toBeDefined();
       expect(response.body.status).toBeDefined();
     });
 
-    it('should return 404 for non-existent intent', async () => {
+    it("should return 404 for non-existent intent", async () => {
       await request(app.getHttpServer())
-        .get('/payments/intents/non-existent-booking')
-        .set('Authorization', `Bearer ${authToken}`)
+        .get("/payments/intents/non-existent-booking")
+        .set("Authorization", `Bearer ${authToken}`)
         .expect(404);
     });
   });
 
-  describe('Webhook endpoints', () => {
-    it('should handle Telebirr webhook', async () => {
-      await request(app.getHttpServer())
-        .post('/payments/webhooks/telebirr')
-        .send({ merch_order_id: 'TEST-ORDER-123', payment_order_id: 'PAY-123', trade_status: 'Completed', sign: 'mock-signature' })
-        .expect(200);
-    });
-
-    it('should handle CBE Birr webhook', async () => {
-      await request(app.getHttpServer())
-        .post('/payments/webhooks/cbe-birr')
-        .send({ merchantId: 'TEST-MERCHANT', merchantOrderId: 'TEST-ORDER-123', orderId: 'CBE-ORDER-123', status: 'SUCCESS', signature: 'mock-signature' })
-        .expect(200);
-    });
-
-    it('should handle eBirr webhook', async () => {
-      await request(app.getHttpServer())
-        .post('/payments/webhooks/ebirr')
-        .send({ merchantCode: 'TEST-MERCHANT', orderNo: 'TEST-ORDER-123', tradeStatus: 'TRADE_SUCCESS', timestamp: Date.now(), sign: 'mock-signature' })
-        .expect(200);
-    });
-
-    it('should handle Card webhook', async () => {
-      await request(app.getHttpServer())
-        .post('/payments/webhooks/card')
-        .set('stripe-signature', 'mock-signature')
-        .send({ id: 'evt_123', type: 'payment_intent.succeeded', data: { object: { id: 'pi_123', status: 'succeeded', amount: 50000, currency: 'ETB', metadata: { merchantOrderId: 'TEST-ORDER-123', bookingRef: 'TEST-BOOK-001' } } }, created: Math.floor(Date.now() / 1000) })
-        .expect(200);
-    });
-  });
+  // Provider webhooks moved to the payment microservice (apps/edr-payment-api /webhooks/*).
 });

apps/edr-passenger-api/src/modules/payments/payments.module.ts

@@ -1,36 +1,65 @@
-import { Module } from '@nestjs/common';
-import { HttpModule } from '@nestjs/axios';
-import { PaymentsController } from './payments.controller';
-import { PaymentsService } from './payments.service';
-import { SeatsModule } from '../seats/seats.module';
-import { TicketsModule } from '../tickets/tickets.module';
-import { TelebirrProvider } from './providers/telebirr.provider';
-import { CbeBirrProvider } from './providers/cbe-birr.provider';
-import { EBirrProvider } from './providers/ebirr.provider';
-import { CardProvider } from './providers/card.provider';
-import { WaafiProvider } from './providers/waafi.provider';
-import { WebhooksController } from './webhooks/webhooks.controller';
-import { TelebirrWebhookService } from './webhooks/telebirr-webhook.service';
-import { CbeBirrWebhookService } from './webhooks/cbe-birr-webhook.service';
-import { EBirrWebhookService } from './webhooks/ebirr-webhook.service';
-import { CardWebhookService } from './webhooks/card-webhook.service';
-import { WaafiWebhookService } from './webhooks/waafi-webhook.service';
+import { Module } from "@nestjs/common";
+import { HttpModule } from "@nestjs/axios";
+import { ConfigService } from "@nestjs/config";
+import { RabbitMQModule } from "@golevelup/nestjs-rabbitmq";
+import { DynamicModule } from "@nestjs/common";
+import {
+  PAYMENT_EVENTS_DLX,
+  PAYMENT_EVENTS_EXCHANGE,
+  PAYMENT_QUEUES,
+  PaymentService,
+  paymentServiceBindingPattern,
+} from "@edr/types";
+import { PaymentsController } from "./payments.controller";
+import { PaymentsService } from "./payments.service";
+import { InternalPaymentsController } from "./internal-payments.controller";
+import { PaymentClientService } from "./payment-client.service";
+import { PaymentEventsConsumer } from "./payment-events.consumer";
+import { ServiceAuthGuard } from "../../common/guards/service-auth.guard";
+import { SeatsModule } from "../seats/seats.module";
+import { TicketsModule } from "../tickets/tickets.module";
+
+const PASSENGER_QUEUE = PAYMENT_QUEUES[PaymentService.PASSENGER];
+
+function rabbitMQImport(): DynamicModule[] {
+  if (!process.env.PAYMENT_RABBITMQ_URL) return [];
+  return [
+    RabbitMQModule.forRootAsync({
+      inject: [ConfigService],
+      useFactory: (config: ConfigService) => ({
+        uri: config.get<string>("rabbitmq.url") as string,
+        exchanges: [
+          { name: PAYMENT_EVENTS_EXCHANGE, type: "topic", options: { durable: true } },
+          { name: PAYMENT_EVENTS_DLX, type: "topic", options: { durable: true } },
+        ],
+        queues: [
+          {
+            name: PASSENGER_QUEUE.dlq,
+            exchange: PAYMENT_EVENTS_DLX,
+            routingKey: paymentServiceBindingPattern(PaymentService.PASSENGER),
+            options: { durable: true },
+          },
+        ],
+        prefetchCount: config.get<number>("rabbitmq.prefetch") ?? 10,
+        connectionInitOptions: { wait: false },
+      }),
+    }),
+  ];
+}
 
 @Module({
-  imports: [SeatsModule, TicketsModule, HttpModule.register({ timeout: 10_000 })],
-  controllers: [PaymentsController, WebhooksController],
+  imports: [
+    SeatsModule,
+    TicketsModule,
+    HttpModule.register({ timeout: 10_000 }),
+    ...rabbitMQImport(),
+  ],
+  controllers: [PaymentsController, InternalPaymentsController],
   providers: [
     PaymentsService,
-    TelebirrProvider,
-    CbeBirrProvider,
-    EBirrProvider,
-    CardProvider,
-    WaafiProvider,
-    TelebirrWebhookService,
-    CbeBirrWebhookService,
-    EBirrWebhookService,
-    CardWebhookService,
-    WaafiWebhookService,
+    PaymentClientService,
+    PaymentEventsConsumer,
+    ServiceAuthGuard,
   ],
 })
 export class PaymentsModule {}

apps/edr-passenger-api/src/modules/payments/payments.service.spec.ts

@@ -1,17 +1,21 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { PaymentsService } from './payments.service';
-import { PrismaService } from '../../common/prisma.service';
-import { SeatsService } from '../seats/seats.service';
-import { TicketsService } from '../tickets/tickets.service';
-import { EventEmitter2 } from '@nestjs/event-emitter';
-import { TelebirrProvider } from './providers/telebirr.provider';
-import { CbeBirrProvider } from './providers/cbe-birr.provider';
-import { EBirrProvider } from './providers/ebirr.provider';
-import { CardProvider } from './providers/card.provider';
-import { PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-import { BadRequestException, NotFoundException } from '@nestjs/common';
+import { Test, TestingModule } from "@nestjs/testing";
+import { PaymentsService } from "./payments.service";
+import { PaymentClientService } from "./payment-client.service";
+import { PrismaService } from "../../common/prisma.service";
+import { SeatsService } from "../seats/seats.service";
+import { TicketsService } from "../tickets/tickets.service";
+import { EventEmitter2 } from "@nestjs/event-emitter";
+import { PaymentIntentStatus, PaymentMethodType } from "@prisma/client";
+import { BadRequestException, NotFoundException } from "@nestjs/common";
+import {
+  PaymentIntentSnapshot,
+  PaymentReferenceType,
+  PaymentService as PaymentServiceEnum,
+  ProviderMethod,
+  ProviderPaymentStatus,
+} from "@edr/types";
 
-describe('PaymentsService', () => {
+describe("PaymentsService", () => {
   let service: PaymentsService;
   let prisma: PrismaService;
   let seatsService: SeatsService;
@@ -60,29 +64,25 @@ describe('PaymentsService', () => {
     emit: jest.fn(),
   };
 
-  const mockTelebirrProvider = {
-    method: PaymentMethodType.TELEBIRR,
+  const mockPaymentClient = {
     initiate: jest.fn(),
-    queryStatus: jest.fn(),
+    getIntentByReference: jest.fn(),
   };
 
-  const mockCbeBirrProvider = {
-    method: PaymentMethodType.CBE_BIRR,
-    initiate: jest.fn(),
-    queryStatus: jest.fn(),
-  };
-
-  const mockEBirrProvider = {
-    method: PaymentMethodType.EBIRR,
-    initiate: jest.fn(),
-    queryStatus: jest.fn(),
-  };
-
-  const mockCardProvider = {
-    method: PaymentMethodType.CARD,
-    initiate: jest.fn(),
-    queryStatus: jest.fn(),
-  };
+  const requiresActionSnapshot = (
+    provider: ProviderMethod,
+  ): PaymentIntentSnapshot => ({
+    intentId: "remote-intent-1",
+    service: PaymentServiceEnum.PASSENGER,
+    referenceType: PaymentReferenceType.BOOKING,
+    referenceId: "booking-1",
+    merchantOrderId: "PSG-MERCH-123",
+    provider,
+    status: ProviderPaymentStatus.REQUIRES_ACTION,
+    amountMinor: 50000,
+    currency: "ETB",
+    clientAction: { type: "REDIRECT", url: "https://provider.example/pay" },
+  });
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -92,10 +92,7 @@ describe('PaymentsService', () => {
         { provide: SeatsService, useValue: mockSeatsService },
         { provide: TicketsService, useValue: mockTicketsService },
         { provide: EventEmitter2, useValue: mockEventEmitter },
-        { provide: TelebirrProvider, useValue: mockTelebirrProvider },
-        { provide: CbeBirrProvider, useValue: mockCbeBirrProvider },
-        { provide: EBirrProvider, useValue: mockEBirrProvider },
-        { provide: CardProvider, useValue: mockCardProvider },
+        { provide: PaymentClientService, useValue: mockPaymentClient },
       ],
     }).compile();
 
@@ -106,221 +103,276 @@ describe('PaymentsService', () => {
     eventEmitter = module.get<EventEmitter2>(EventEmitter2);
 
     jest.clearAllMocks();
+    mockPaymentClient.getIntentByReference.mockResolvedValue(null);
   });
 
-  describe('initiatePayment', () => {
+  describe("initiatePayment", () => {
     const mockBooking = {
-      id: 'booking-1',
-      bookingRef: 'EDR123456',
-      passengerId: 'passenger-1',
+      id: "booking-1",
+      bookingRef: "EDR123456",
+      passengerId: "passenger-1",
       totalMinor: 50000,
-      currency: 'ETB',
-      status: 'PENDING_PAYMENT',
-      seats: [{ id: 'seat-1', seatId: 'seat-id-1' }],
+      currency: "ETB",
+      status: "PENDING_PAYMENT",
+      seats: [{ id: "seat-1", seatId: "seat-id-1" }],
     };
 
-    it('should throw NotFoundException if booking not found', async () => {
+    it("should throw NotFoundException if booking not found", async () => {
       mockPrisma.booking.findUnique.mockResolvedValue(null);
 
       await expect(
         service.initiatePayment({
-          bookingId: 'invalid',
-          method: 'TELEBIRR' as any,
+          bookingId: "invalid",
+          method: "TELEBIRR" as any,
         }),
       ).rejects.toThrow(NotFoundException);
     });
 
-    it('should throw BadRequestException if booking not payable', async () => {
+    it("should throw BadRequestException if booking not payable", async () => {
       mockPrisma.booking.findUnique.mockResolvedValue({
         ...mockBooking,
-        status: 'CONFIRMED',
+        status: "CONFIRMED",
       });
 
       await expect(
         service.initiatePayment({
-          bookingId: 'booking-1',
-          method: 'TELEBIRR' as any,
+          bookingId: "booking-1",
+          method: "TELEBIRR" as any,
         }),
       ).rejects.toThrow(BadRequestException);
     });
 
-    it('should initiate Telebirr payment successfully', async () => {
+    it("should initiate a provider payment through the payment microservice", async () => {
       mockPrisma.booking.findUnique.mockResolvedValue(mockBooking);
-      mockPrisma.paymentIntent.findUnique.mockResolvedValue(null);
-      mockTelebirrProvider.initiate.mockResolvedValue({
-        providerOrderId: 'TB-ORDER-123',
-        clientAction: { type: 'REDIRECT', url: 'https://telebirr.com/pay' },
-        expiresAt: new Date(),
-        rawInitiation: {},
-      });
+      mockPaymentClient.initiate.mockResolvedValue(
+        requiresActionSnapshot(ProviderMethod.TELEBIRR),
+      );
       mockPrisma.paymentIntent.upsert.mockResolvedValue({
-        id: 'intent-1',
+        id: "intent-1",
         status: PaymentIntentStatus.REQUIRES_ACTION,
-        merchantOrderId: 'MERCH-123',
-        clientAction: { type: 'REDIRECT', url: 'https://telebirr.com/pay' },
+        merchantOrderId: "PSG-MERCH-123",
+        clientAction: { type: "REDIRECT", url: "https://provider.example/pay" },
       });
 
       const result = await service.initiatePayment({
-        bookingId: 'booking-1',
-        method: 'TELEBIRR' as any,
+        bookingId: "booking-1",
+        method: "TELEBIRR" as any,
       });
 
       expect(result.status).toBe(PaymentIntentStatus.REQUIRES_ACTION);
-      expect(mockTelebirrProvider.initiate).toHaveBeenCalled();
+      expect(result.clientAction?.url).toBe("https://provider.example/pay");
+      expect(mockPaymentClient.initiate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          service: PaymentServiceEnum.PASSENGER,
+          referenceType: PaymentReferenceType.BOOKING,
+          referenceId: "booking-1",
+          orderRef: "EDR123456",
+          amountMinor: 50000,
+          currency: "ETB",
+          provider: "TELEBIRR",
+        }),
+      );
+      // Snapshot mirrored into the local projection.
+      expect(mockPrisma.paymentIntent.upsert).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { bookingId: "booking-1" } }),
+      );
     });
 
-    it('should initiate CBE Birr payment successfully', async () => {
+    it("should finalize the booking when the service reports an already-paid intent", async () => {
       mockPrisma.booking.findUnique.mockResolvedValue(mockBooking);
-      mockPrisma.paymentIntent.findUnique.mockResolvedValue(null);
-      mockCbeBirrProvider.initiate.mockResolvedValue({
-        providerOrderId: 'CBE-ORDER-123',
-        clientAction: { type: 'REDIRECT', url: 'https://cbe.com/pay' },
-        expiresAt: new Date(),
-        rawInitiation: {},
+      mockPaymentClient.initiate.mockResolvedValue({
+        ...requiresActionSnapshot(ProviderMethod.WAAFI),
+        status: ProviderPaymentStatus.SUCCEEDED,
+        providerTxnId: "TXN-1",
+        paidAt: new Date().toISOString(),
       });
+      // Projection clamps SUCCEEDED to PROCESSING; finalizePaymentSuccess flips it.
       mockPrisma.paymentIntent.upsert.mockResolvedValue({
-        id: 'intent-1',
-        status: PaymentIntentStatus.REQUIRES_ACTION,
-        merchantOrderId: 'MERCH-123',
-        clientAction: { type: 'REDIRECT', url: 'https://cbe.com/pay' },
+        id: "intent-1",
+        bookingId: "booking-1",
+        status: PaymentIntentStatus.PROCESSING,
       });
-
-      const result = await service.initiatePayment({
-        bookingId: 'booking-1',
-        method: 'CBE_BIRR' as any,
-      });
-
-      expect(result.status).toBe(PaymentIntentStatus.REQUIRES_ACTION);
-      expect(mockCbeBirrProvider.initiate).toHaveBeenCalled();
-    });
-
-    it('should initiate wallet payment and debit successfully', async () => {
-      mockPrisma.booking.findUnique.mockResolvedValue(mockBooking);
-      mockPrisma.paymentIntent.findUnique.mockResolvedValue(null);
-      mockPrisma.walletAccount.findUnique.mockResolvedValue({
-        id: 'wallet-1',
-        passengerId: 'passenger-1',
-        balanceMinor: 100000,
-      });
-      mockPrisma.paymentIntent.upsert.mockResolvedValue({
-        id: 'intent-1',
+      mockPrisma.paymentIntent.findUnique.mockResolvedValue({
+        id: "intent-1",
+        bookingId: "booking-1",
         status: PaymentIntentStatus.PROCESSING,
       });
       mockPrisma.paymentIntent.findUniqueOrThrow.mockResolvedValue({
-        id: 'intent-1',
+        id: "intent-1",
         status: PaymentIntentStatus.SUCCEEDED,
-        bookingId: 'booking-1',
+        merchantOrderId: "PSG-MERCH-123",
+      });
+      mockPrisma.loyaltyAccount.findUnique.mockResolvedValue(null);
+
+      const result = await service.initiatePayment({
+        bookingId: "booking-1",
+        method: "WAAFI" as any,
+      });
+
+      expect(result.status).toBe(PaymentIntentStatus.SUCCEEDED);
+      expect(mockTicketsService.generate).toHaveBeenCalledWith("booking-1");
+    });
+
+    it("should initiate wallet payment and debit successfully", async () => {
+      mockPrisma.booking.findUnique.mockResolvedValue(mockBooking);
+      // First call: existing-intent check (none); second call: finalize loads the new intent.
+      mockPrisma.paymentIntent.findUnique
+        .mockResolvedValueOnce(null)
+        .mockResolvedValue({
+          id: "intent-1",
+          bookingId: "booking-1",
+          status: PaymentIntentStatus.PROCESSING,
+        });
+      mockPrisma.walletAccount.findUnique.mockResolvedValue({
+        id: "wallet-1",
+        passengerId: "passenger-1",
+        balanceMinor: 100000,
+      });
+      mockPrisma.paymentIntent.upsert.mockResolvedValue({
+        id: "intent-1",
+        status: PaymentIntentStatus.PROCESSING,
+      });
+      mockPrisma.paymentIntent.findUniqueOrThrow.mockResolvedValue({
+        id: "intent-1",
+        status: PaymentIntentStatus.SUCCEEDED,
+        bookingId: "booking-1",
       });
       mockPrisma.loyaltyAccount.findUnique.mockResolvedValue({
-        id: 'loyalty-1',
+        id: "loyalty-1",
         pointsBalance: 100,
       });
 
       const result = await service.initiatePayment({
-        bookingId: 'booking-1',
-        method: 'WALLET' as any,
+        bookingId: "booking-1",
+        method: "WALLET" as any,
       });
 
       expect(result.status).toBe(PaymentIntentStatus.SUCCEEDED);
       expect(mockSeatsService.confirmSeats).toHaveBeenCalled();
       expect(mockTicketsService.generate).toHaveBeenCalled();
+      expect(mockPaymentClient.initiate).not.toHaveBeenCalled();
     });
 
-    it('should fail wallet payment with insufficient balance', async () => {
+    it("should fail wallet payment with insufficient balance", async () => {
       mockPrisma.booking.findUnique.mockResolvedValue(mockBooking);
       mockPrisma.paymentIntent.findUnique.mockResolvedValue(null);
       mockPrisma.walletAccount.findUnique.mockResolvedValue({
-        id: 'wallet-1',
-        passengerId: 'passenger-1',
+        id: "wallet-1",
+        passengerId: "passenger-1",
         balanceMinor: 10000, // Less than booking total
       });
       mockPrisma.paymentIntent.upsert.mockResolvedValue({
-        id: 'intent-1',
+        id: "intent-1",
         status: PaymentIntentStatus.FAILED,
-        failureCode: 'INSUFFICIENT_BALANCE',
+        failureCode: "INSUFFICIENT_BALANCE",
       });
 
       const result = await service.initiatePayment({
-        bookingId: 'booking-1',
-        method: 'WALLET' as any,
+        bookingId: "booking-1",
+        method: "WALLET" as any,
       });
 
       expect(result.status).toBe(PaymentIntentStatus.FAILED);
     });
   });
 
-  describe('finalizePaymentSuccess', () => {
-    it('should finalize payment and issue ticket', async () => {
+  describe("finalizePaymentSuccess", () => {
+    it("should finalize payment and issue ticket", async () => {
       const mockIntent = {
-        id: 'intent-1',
-        bookingId: 'booking-1',
+        id: "intent-1",
+        bookingId: "booking-1",
         status: PaymentIntentStatus.PROCESSING,
       };
       const mockBooking = {
-        id: 'booking-1',
-        passengerId: 'passenger-1',
+        id: "booking-1",
+        passengerId: "passenger-1",
         totalMinor: 50000,
-        seats: [{ seatId: 'seat-1' }],
+        seats: [{ seatId: "seat-1" }],
       };
 
       mockPrisma.paymentIntent.findUnique.mockResolvedValue(mockIntent);
       mockPrisma.booking.findUnique.mockResolvedValue(mockBooking);
       mockPrisma.loyaltyAccount.findUnique.mockResolvedValue({
-        id: 'loyalty-1',
+        id: "loyalty-1",
         pointsBalance: 100,
       });
 
       const result = await service.finalizePaymentSuccess({
-        intentId: 'intent-1',
-        providerTxnId: 'TXN-123',
+        intentId: "intent-1",
+        providerTxnId: "TXN-123",
       });
 
       expect(result.alreadyFinalized).toBe(false);
-      expect(mockSeatsService.confirmSeats).toHaveBeenCalledWith(['seat-1']);
-      expect(mockTicketsService.generate).toHaveBeenCalledWith('booking-1');
-      expect(mockEventEmitter.emit).toHaveBeenCalledWith('payment.succeeded', {
+      expect(mockSeatsService.confirmSeats).toHaveBeenCalledWith(["seat-1"]);
+      expect(mockTicketsService.generate).toHaveBeenCalledWith("booking-1");
+      expect(mockEventEmitter.emit).toHaveBeenCalledWith("payment.succeeded", {
         booking: mockBooking,
       });
     });
 
-    it('should return alreadyFinalized if payment already succeeded', async () => {
+    it("should return alreadyFinalized if payment already succeeded", async () => {
       mockPrisma.paymentIntent.findUnique.mockResolvedValue({
-        id: 'intent-1',
+        id: "intent-1",
         status: PaymentIntentStatus.SUCCEEDED,
       });
 
       const result = await service.finalizePaymentSuccess({
-        intentId: 'intent-1',
+        intentId: "intent-1",
       });
 
       expect(result.alreadyFinalized).toBe(true);
     });
   });
 
-  describe('getIntentByBookingId', () => {
-    it('should return intent status', async () => {
+  describe("getIntentByBookingId", () => {
+    it("should return the cached local intent when the payment service has none", async () => {
       const mockIntent = {
-        id: 'intent-1',
-        bookingId: 'booking-1',
+        id: "intent-1",
+        bookingId: "booking-1",
         status: PaymentIntentStatus.SUCCEEDED,
         method: PaymentMethodType.TELEBIRR,
         paidAt: new Date(),
-        merchantOrderId: 'MERCH-123',
+        merchantOrderId: "MERCH-123",
         updatedAt: new Date(),
       };
 
       mockPrisma.paymentIntent.findUnique.mockResolvedValue(mockIntent);
+      mockPaymentClient.getIntentByReference.mockResolvedValue(null);
 
-      const result = await service.getIntentByBookingId('booking-1');
+      const result = await service.getIntentByBookingId("booking-1");
 
-      expect(result.intentId).toBe('intent-1');
+      expect(result.intentId).toBe("intent-1");
       expect(result.status).toBe(PaymentIntentStatus.SUCCEEDED);
     });
 
-    it('should throw NotFoundException if intent not found', async () => {
+    it("should mirror a payment-service snapshot into the local projection", async () => {
       mockPrisma.paymentIntent.findUnique.mockResolvedValue(null);
+      mockPaymentClient.getIntentByReference.mockResolvedValue(
+        requiresActionSnapshot(ProviderMethod.WAAFI),
+      );
+      mockPrisma.paymentIntent.upsert.mockResolvedValue({
+        id: "intent-1",
+        bookingId: "booking-1",
+        status: PaymentIntentStatus.REQUIRES_ACTION,
+        merchantOrderId: "PSG-MERCH-123",
+        clientAction: { type: "REDIRECT", url: "https://provider.example/pay" },
+      });
 
-      await expect(service.getIntentByBookingId('invalid')).rejects.toThrow(
+      const result = await service.getIntentByBookingId("booking-1");
+
+      expect(mockPaymentClient.getIntentByReference).toHaveBeenCalledWith(
+        PaymentReferenceType.BOOKING,
+        "booking-1",
+      );
+      expect(result.status).toBe(PaymentIntentStatus.REQUIRES_ACTION);
+      expect(result.clientAction?.url).toBe("https://provider.example/pay");
+    });
+
+    it("should throw NotFoundException if intent not found anywhere", async () => {
+      mockPrisma.paymentIntent.findUnique.mockResolvedValue(null);
+      mockPaymentClient.getIntentByReference.mockResolvedValue(null);
+
+      await expect(service.getIntentByBookingId("invalid")).rejects.toThrow(
         NotFoundException,
       );
     });

apps/edr-passenger-api/src/modules/payments/payments.service.ts

@@ -1,17 +1,37 @@
-import { Injectable, Logger, NotFoundException, BadRequestException } from '@nestjs/common';
-import { PrismaService } from '../../common/prisma.service';
-import { SeatsService } from '../seats/seats.service';
-import { TicketsService } from '../tickets/tickets.service';
-import { EventEmitter2 } from '@nestjs/event-emitter';
-import { Prisma, PaymentIntentStatus, PaymentMethodType, PaymentRegion } from '@prisma/client';
-import { InitiatePaymentDto, RefundDto, AddPaymentMethodDto, InitiateResponseDto, IntentStatusDto, PaymentRegionEnum } from './payments.dto';
-import { ClientAction, PaymentProvider, ProviderStatus } from './payments.types';
-import { TelebirrProvider } from './providers/telebirr.provider';
-import { CbeBirrProvider } from './providers/cbe-birr.provider';
-import { EBirrProvider } from './providers/ebirr.provider';
-import { CardProvider } from './providers/card.provider';
-import { WaafiProvider } from './providers/waafi.provider';
-import { createMerchantOrderId } from './providers/telebirr.crypto';
+import {
+  Injectable,
+  Logger,
+  NotFoundException,
+  BadRequestException,
+} from "@nestjs/common";
+import { PrismaService } from "../../common/prisma.service";
+import { SeatsService } from "../seats/seats.service";
+import { TicketsService } from "../tickets/tickets.service";
+import { EventEmitter2 } from "@nestjs/event-emitter";
+import {
+  Prisma,
+  PaymentIntentStatus,
+  PaymentMethodType,
+  PaymentRegion,
+} from "@prisma/client";
+import {
+  InitiatePaymentDto,
+  RefundDto,
+  AddPaymentMethodDto,
+  InitiateResponseDto,
+  IntentStatusDto,
+  PaymentRegionEnum,
+} from "./payments.dto";
+import { PaymentEventDto, MarkPaidResponseDto } from "./internal-payments.dto";
+import { PaymentClientService } from "./payment-client.service";
+import {
+  PaymentService as PaymentServiceEnum,
+  PaymentReferenceType,
+  PaymentIntentSnapshot,
+  ProviderMethod,
+  ClientAction,
+  ProviderPaymentStatus,
+} from "@edr/types";
 
 const NON_TERMINAL_STATUSES: PaymentIntentStatus[] = [
   PaymentIntentStatus.REQUIRES_ACTION,
@@ -22,26 +42,70 @@ const NON_TERMINAL_STATUSES: PaymentIntentStatus[] = [
 @Injectable()
 export class PaymentsService {
   private readonly logger = new Logger(PaymentsService.name);
-  private readonly providers: Map<PaymentMethodType, PaymentProvider>;
+  private readonly walletDemoAutoSucceed = true;
+
+  private readonly waafiDemoTrustReturn = true;
 
   constructor(
     private prisma: PrismaService,
     private seatsService: SeatsService,
     private ticketsService: TicketsService,
     private eventEmitter: EventEmitter2,
-    private telebirrProvider: TelebirrProvider,
-    private cbeBirrProvider: CbeBirrProvider,
-    private eBirrProvider: EBirrProvider,
-    private cardProvider: CardProvider,
-    private waafiProvider: WaafiProvider,
-  ) {
-    this.providers = new Map<PaymentMethodType, PaymentProvider>([
-      [PaymentMethodType.TELEBIRR, this.telebirrProvider],
-      [PaymentMethodType.CBE_BIRR, this.cbeBirrProvider],
-      [PaymentMethodType.EBIRR, this.eBirrProvider],
-      [PaymentMethodType.CARD, this.cardProvider],
-      [PaymentMethodType.WAAFI, this.waafiProvider],
+    private paymentClient: PaymentClientService,
+  ) {}
+
+  async getAll(filters: {
+    search?: string;
+    status?: string;
+    method?: string;
+    page?: number;
+    pageSize?: number;
+  }) {
+    const { search, status, method, page = 1, pageSize = 10 } = filters;
+    const skip = (page - 1) * pageSize;
+
+    const where: any = {};
+    if (search) {
+      where.OR = [
+        { id: { contains: search, mode: "insensitive" } },
+        { booking: { bookingRef: { contains: search, mode: "insensitive" } } },
+      ];
+    }
+    if (status) {
+      where.status = status;
+    }
+    if (method) {
+      where.method = method;
+    }
+
+    const [items, total] = await Promise.all([
+      this.prisma.paymentIntent.findMany({
+        where,
+        include: { booking: true },
+        skip,
+        take: pageSize,
+        orderBy: { createdAt: "desc" },
+      }),
+      this.prisma.paymentIntent.count({ where }),
     ]);
+
+    return {
+      items: items.map((item) => ({
+        id: item.id,
+        reference: item.id.substring(0, 8),
+        bookingId: item.bookingId,
+        booking: { bookingRef: item.booking?.bookingRef },
+        amountMinor: item.amountMinor,
+        currency: item.currency,
+        method: item.method,
+        status: item.status,
+        createdAt: item.createdAt,
+        paidAt: item.paidAt,
+      })),
+      total,
+      page,
+      pageSize,
+    };
   }
 
   async initiatePayment(dto: InitiatePaymentDto): Promise<InitiateResponseDto> {
@@ -49,35 +113,188 @@ export class PaymentsService {
       where: { id: dto.bookingId },
       include: { seats: true },
     });
-    if (!booking) throw new NotFoundException('Booking not found');
-    if (booking.status !== 'PENDING_PAYMENT') {
-      throw new BadRequestException('Booking not payable');
-    }
-
-    const existing = await this.prisma.paymentIntent.findUnique({
-      where: { bookingId: dto.bookingId },
-    });
-    if (existing && NON_TERMINAL_STATUSES.includes(existing.status)) {
-      return this.formatIntentResponse(existing);
+    if (!booking) throw new NotFoundException("Booking not found");
+    if (booking.status !== "PENDING_PAYMENT") {
+      throw new BadRequestException("Booking not payable");
     }
 
     const method = dto.method as PaymentMethodType;
 
+    // WALLET is an internal balance debit — it never leaves this app.
     if (method === PaymentMethodType.WALLET) {
+      const existing = await this.prisma.paymentIntent.findUnique({
+        where: { bookingId: dto.bookingId },
+      });
+      if (existing && NON_TERMINAL_STATUSES.includes(existing.status)) {
+        return this.formatIntentResponse(existing);
+      }
       return this.initiateWalletPayment(booking);
     }
 
-    const provider = this.providers.get(method);
-    if (provider) {
-      return this.initiateProviderPayment(booking, provider, dto.platform);
+    const { returnUrl, failureUrl } = this.resolveReturnUrls(method);
+    const snapshot = await this.paymentClient.initiate({
+      service: PaymentServiceEnum.PASSENGER,
+      referenceType: PaymentReferenceType.BOOKING,
+      referenceId: booking.id,
+      orderRef: booking.bookingRef,
+      // Send the REAL (major) price, not minor units. The payment API no longer divides by 100
+      // (freight already passes the real price), so the providers charge this value as-is.
+      amountMinor: booking.totalMinor / 100,
+      currency: booking.currency,
+      provider: method as unknown as ProviderMethod,
+      platform: dto.platform,
+      returnUrl,
+      failureUrl,
+    });
+
+    let intent = await this.syncIntentProjection(booking.id, snapshot);
+    if (snapshot.status === ProviderPaymentStatus.SUCCEEDED) {
+      // Already-paid order re-initiated: converge the booking now (idempotent).
+      await this.finalizePaymentSuccess({
+        intentId: intent.id,
+        providerTxnId: snapshot.providerTxnId,
+        paidAt: snapshot.paidAt ? new Date(snapshot.paidAt) : undefined,
+      });
+      intent = await this.prisma.paymentIntent.findUniqueOrThrow({
+        where: { id: intent.id },
+      });
+    }
+    return this.formatIntentResponse(intent);
+  }
+  private resolveReturnUrls(method: PaymentMethodType): {
+    returnUrl?: string;
+    failureUrl?: string;
+  } {
+    const perMethod: Partial<
+      Record<PaymentMethodType, { returnUrl?: string; failureUrl?: string }>
+    > = {
+      [PaymentMethodType.TELEBIRR]: {
+        returnUrl: process.env.TELEBIRR_RETURN_URL,
+      },
+      [PaymentMethodType.WAAFI]: {
+        returnUrl: process.env.WAAFI_SUCCESS_REDIRECT,
+        failureUrl: process.env.WAAFI_FAIL_REDIRECT,
+      },
+      [PaymentMethodType.DMONEY]: {
+        returnUrl: process.env.DMONEY_RETURN_URL,
+      },
+      [PaymentMethodType.CBE_BIRR]: {
+        returnUrl: process.env.CBE_RETURN_URL,
+      },
+      [PaymentMethodType.EBIRR]: {
+        returnUrl: process.env.EBIRR_RETURN_URL,
+      },
+      [PaymentMethodType.CARD]: {
+        returnUrl: process.env.CARD_RETURN_URL,
+      },
+    };
+
+    const m = perMethod[method] ?? {};
+    const returnUrl = m.returnUrl || process.env.PAYMENT_RETURN_URL || undefined;
+    const failureUrl =
+      m.failureUrl || process.env.PAYMENT_FAILURE_URL || returnUrl;
+    return { returnUrl, failureUrl };
+  }
+
+  async confirmWaafiReturnDemo(params: {
+    referenceId?: string;
+    state?: string;
+    transactionId?: string;
+  }): Promise<{ confirmed: boolean; bookingId?: string; reason?: string }> {
+    if (!this.waafiDemoTrustReturn) {
+      return { confirmed: false, reason: "demo-disabled" };
+    }
+    if ((params.state ?? "").toUpperCase() !== "APPROVED") {
+      return { confirmed: false, reason: `not-approved (${params.state})` };
+    }
+    if (!params.referenceId) {
+      return { confirmed: false, reason: "missing-referenceId" };
     }
 
-    throw new BadRequestException(`Unsupported payment method: ${method}`);
+    const intent = await this.prisma.paymentIntent.findFirst({
+      where: { merchantOrderId: params.referenceId },
+    });
+    if (!intent) {
+      this.logger.warn(
+        `waafi demo return: no local intent for referenceId ${params.referenceId}`,
+      );
+      return { confirmed: false, reason: "intent-not-found" };
+    }
+
+    this.logger.warn(
+      `WAAFI_DEMO_TRUST_RETURN enabled — confirming booking ${intent.bookingId} from browser return (INSECURE, demo only)`,
+    );
+    await this.finalizePaymentSuccess({
+      intentId: intent.id,
+      providerTxnId: params.transactionId,
+    });
+    return { confirmed: true, bookingId: intent.bookingId };
+  }
+
+  private async syncIntentProjection(
+    bookingId: string,
+    snapshot: PaymentIntentSnapshot,
+  ) {
+    const status =
+      snapshot.status === ProviderPaymentStatus.SUCCEEDED
+        ? PaymentIntentStatus.PROCESSING
+        : (snapshot.status as unknown as PaymentIntentStatus);
+    const data = {
+      status,
+      method: snapshot.provider as unknown as PaymentMethodType,
+      merchantOrderId: snapshot.merchantOrderId,
+      clientAction: snapshot.clientAction
+        ? (snapshot.clientAction as unknown as Prisma.InputJsonValue)
+        : Prisma.DbNull,
+      providerTxnId: snapshot.providerTxnId ?? null,
+      expiresAt: snapshot.expiresAt ? new Date(snapshot.expiresAt) : null,
+      failureCode: snapshot.failureCode ?? null,
+      failureMessage: snapshot.failureMessage ?? null,
+    };
+    return this.prisma.paymentIntent.upsert({
+      where: { bookingId },
+      update: data,
+      create: {
+        bookingId,
+        amountMinor: snapshot.amountMinor,
+        currency: snapshot.currency,
+        ...data,
+      },
+    });
   }
 
   private async initiateWalletPayment(
     booking: Prisma.BookingGetPayload<{ include: { seats: true } }>,
   ): Promise<InitiateResponseDto> {
+    // DEMO ONLY (WALLET_DEMO_AUTO_SUCCEED): pretend the payment succeeded — no balance check,
+    // no debit — and run the exact same finalize path a real successful payment uses
+    // (booking → CONFIRMED, seats confirmed, ticket issued). Remove once a real provider works.
+    if (this.walletDemoAutoSucceed) {
+      this.logger.warn(
+        `WALLET_DEMO_AUTO_SUCCEED enabled — faking a successful WALLET payment for booking ${booking.bookingRef} (${booking.id})`,
+      );
+      const demoIntent = await this.prisma.paymentIntent.upsert({
+        where: { bookingId: booking.id },
+        update: {
+          status: PaymentIntentStatus.PROCESSING,
+          failureCode: null,
+          method: PaymentMethodType.WALLET,
+        },
+        create: {
+          bookingId: booking.id,
+          amountMinor: booking.totalMinor,
+          method: PaymentMethodType.WALLET,
+          status: PaymentIntentStatus.PROCESSING,
+          providerRef: `WALLET-DEMO-${Date.now()}`,
+        },
+      });
+      await this.finalizePaymentSuccess({ intentId: demoIntent.id });
+      const settled = await this.prisma.paymentIntent.findUniqueOrThrow({
+        where: { id: demoIntent.id },
+      });
+      return this.formatIntentResponse(settled);
+    }
+
     const debitResult = await this.prisma.$transaction(async (tx) => {
       const wallet = await tx.walletAccount.findUnique({
         where: { passengerId: booking.passengerId },
@@ -93,7 +310,7 @@ export class PaymentsService {
       await tx.walletLedgerEntry.create({
         data: {
           walletId: wallet.id,
-          type: 'DEBIT',
+          type: "DEBIT",
           amountMinor: booking.totalMinor,
           balanceAfterMinor: newBalance,
           description: `Train Ticket - ${booking.bookingRef}`,
@@ -108,14 +325,14 @@ export class PaymentsService {
         where: { bookingId: booking.id },
         update: {
           status: PaymentIntentStatus.FAILED,
-          failureCode: 'INSUFFICIENT_BALANCE',
+          failureCode: "INSUFFICIENT_BALANCE",
         },
         create: {
           bookingId: booking.id,
           amountMinor: booking.totalMinor,
           method: PaymentMethodType.WALLET,
           status: PaymentIntentStatus.FAILED,
-          failureCode: 'INSUFFICIENT_BALANCE',
+          failureCode: "INSUFFICIENT_BALANCE",
         },
       });
       return this.formatIntentResponse(failed);
@@ -139,54 +356,11 @@ export class PaymentsService {
     return this.formatIntentResponse(refreshed);
   }
 
-  private async initiateProviderPayment(
-    booking: Prisma.BookingGetPayload<{ include: { seats: true } }>,
-    provider: PaymentProvider,
-    platform: 'web' | 'mobile' | undefined,
-  ): Promise<InitiateResponseDto> {
-    const merchantOrderId = createMerchantOrderId();
-    const result = await provider.initiate({
-      merchantOrderId,
-      bookingRef: booking.bookingRef,
-      amountMinor: booking.totalMinor,
-      currency: booking.currency,
-      platform,
-    });
-
-    const intent = await this.prisma.paymentIntent.upsert({
-      where: { bookingId: booking.id },
-      update: {
-        status: PaymentIntentStatus.REQUIRES_ACTION,
-        method: provider.method,
-        merchantOrderId,
-        providerOrderId: result.providerOrderId,
-        clientAction: result.clientAction as unknown as Prisma.InputJsonValue,
-        rawInitiation: result.rawInitiation as Prisma.InputJsonValue,
-        expiresAt: result.expiresAt,
-        failureCode: null,
-        failureMessage: null,
-      },
-      create: {
-        bookingId: booking.id,
-        amountMinor: booking.totalMinor,
-        currency: booking.currency,
-        method: provider.method,
-        status: PaymentIntentStatus.REQUIRES_ACTION,
-        merchantOrderId,
-        providerOrderId: result.providerOrderId,
-        clientAction: result.clientAction as unknown as Prisma.InputJsonValue,
-        rawInitiation: result.rawInitiation as Prisma.InputJsonValue,
-        expiresAt: result.expiresAt,
-      },
-    });
-    return this.formatIntentResponse(intent);
-  }
-
   private formatIntentResponse(
     intent: Prisma.PaymentIntentGetPayload<Record<string, never>>,
   ): InitiateResponseDto {
     const clientAction =
-      intent.clientAction && typeof intent.clientAction === 'object'
+      intent.clientAction && typeof intent.clientAction === "object"
         ? (intent.clientAction as unknown as ClientAction)
         : undefined;
     return {
@@ -198,62 +372,52 @@ export class PaymentsService {
   }
 
   async getIntentByBookingId(bookingId: string): Promise<IntentStatusDto> {
-    const intent = await this.prisma.paymentIntent.findUnique({
+    const local = await this.prisma.paymentIntent.findUnique({
       where: { bookingId },
     });
-    if (!intent) throw new NotFoundException('PaymentIntent not found');
 
-    const refreshable =
-      intent.status === PaymentIntentStatus.REQUIRES_ACTION ||
-      intent.status === PaymentIntentStatus.PROCESSING;
-    const stale = intent.updatedAt.getTime() < Date.now() - 5_000;
-    const provider = this.providers.get(intent.method);
-
-    if (refreshable && stale && intent.merchantOrderId && provider) {
-      try {
-        const status = await provider.queryStatus(intent.merchantOrderId);
-        await this.applyProviderStatus(intent.id, status);
-        const refreshed = await this.prisma.paymentIntent.findUniqueOrThrow({
-          where: { id: intent.id },
-        });
-        return this.formatIntentStatus(refreshed);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        this.logger.warn(
-          `queryStatus failed for intent ${intent.id}: ${message}; returning cached`,
-        );
-      }
+    // WALLET payments never leave this app — no remote intent exists for them.
+    if (local?.method === PaymentMethodType.WALLET) {
+      return this.formatIntentStatus(local);
     }
 
-    return this.formatIntentStatus(intent);
-  }
+    // Pull/reconcile through the payment microservice (it refreshes stale intents from the
+    // provider itself). Falls back to the legacy local path when the service is unreachable
+    // or only a pre-cutover local intent exists.
+    let snapshot: PaymentIntentSnapshot | null = null;
+    try {
+      snapshot = await this.paymentClient.getIntentByReference(
+        PaymentReferenceType.BOOKING,
+        bookingId,
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.warn(
+        `payment service lookup failed for booking ${bookingId}: ${message}; using local intent`,
+      );
+    }
 
-  private async applyProviderStatus(
-    intentId: string,
-    status: ProviderStatus,
-  ): Promise<void> {
-    if (status.status === PaymentIntentStatus.SUCCEEDED) {
+    if (!snapshot) {
+      // Pre-cutover/local-only intent (or service briefly unreachable): serve the cached
+      // status. The payment service owns provider refresh for everything initiated after
+      // the cutover; webhooks/mark-paid converge the rest.
+      if (!local) throw new NotFoundException("PaymentIntent not found");
+      return this.formatIntentStatus(local);
+    }
+
+    let intent = await this.syncIntentProjection(bookingId, snapshot);
+    if (snapshot.status === ProviderPaymentStatus.SUCCEEDED) {
+      // Poll observed success before (or instead of) the mark-paid event — converge now.
       await this.finalizePaymentSuccess({
-        intentId,
-        providerTxnId: status.providerTxnId,
+        intentId: intent.id,
+        providerTxnId: snapshot.providerTxnId,
+        paidAt: snapshot.paidAt ? new Date(snapshot.paidAt) : undefined,
       });
-      return;
-    }
-    if (status.status === PaymentIntentStatus.FAILED) {
-      await this.markPaymentFailed({
-        intentId,
-        failureCode: status.failureCode,
-        failureMessage: status.failureMessage,
+      intent = await this.prisma.paymentIntent.findUniqueOrThrow({
+        where: { id: intent.id },
       });
-      return;
     }
-    await this.prisma.paymentIntent.update({
-      where: { id: intentId },
-      data: {
-        status: status.status,
-        providerTxnId: status.providerTxnId ?? undefined,
-      },
-    });
+    return this.formatIntentStatus(intent);
   }
 
   private formatIntentStatus(
@@ -269,13 +433,25 @@ export class PaymentsService {
   }
 
   async refund(dto: RefundDto) {
-    const intent = await this.prisma.paymentIntent.findUnique({ where: { bookingId: dto.bookingId } });
-    if (!intent || intent.status !== 'SUCCEEDED') throw new BadRequestException('No successful payment to refund');
-    await this.prisma.paymentIntent.update({ where: { bookingId: dto.bookingId }, data: { status: 'CANCELLED' } });
-    const booking = await this.prisma.booking.findUnique({ where: { id: dto.bookingId }, include: { seats: true } });
+    const intent = await this.prisma.paymentIntent.findUnique({
+      where: { bookingId: dto.bookingId },
+    });
+    if (!intent || intent.status !== "SUCCEEDED")
+      throw new BadRequestException("No successful payment to refund");
+    await this.prisma.paymentIntent.update({
+      where: { bookingId: dto.bookingId },
+      data: { status: "CANCELLED" },
+    });
+    const booking = await this.prisma.booking.findUnique({
+      where: { id: dto.bookingId },
+      include: { seats: true },
+    });
     if (booking) {
       await this.seatsService.releaseSeats(booking.seats.map((s) => s.seatId));
-      await this.prisma.booking.update({ where: { id: dto.bookingId }, data: { status: 'CANCELLED' } });
+      await this.prisma.booking.update({
+        where: { id: dto.bookingId },
+        data: { status: "CANCELLED" },
+      });
     }
     return { refunded: true, bookingRef: booking?.bookingRef };
   }
@@ -285,7 +461,7 @@ export class PaymentsService {
       type: dto.type as unknown as PaymentMethodType,
       displayName: dto.displayName,
       region: dto.region as unknown as PaymentRegion,
-      currency: dto.currency ?? 'ETB',
+      currency: dto.currency ?? "ETB",
       providerId: dto.providerId,
       enabled: dto.enabled ?? true,
       sortOrder: dto.sortOrder ?? 0,
@@ -302,13 +478,44 @@ export class PaymentsService {
       where: {
         enabled: true,
         ...(region
-          ? { region: { in: [region, PaymentRegionEnum.GLOBAL] as unknown as PaymentRegion[] } }
+          ? {
+              region: {
+                in: [
+                  region,
+                  PaymentRegionEnum.GLOBAL,
+                ] as unknown as PaymentRegion[],
+              },
+            }
           : {}),
       },
-      orderBy: [{ sortOrder: 'asc' }, { displayName: 'asc' }],
+      orderBy: [{ sortOrder: "asc" }, { displayName: "asc" }],
     });
   }
 
+  /**
+   * Guard against an implausible paidAt from a provider event (e.g. a Telebirr epoch parsed as
+   * ms×1000 → year 58429), which Prisma/Postgres rejects and would otherwise dead-letter the
+   * whole confirmation. Falls back to "now" for missing/invalid/far-future/ancient values so the
+   * booking still confirms.
+   */
+  private sanitizePaidAt(value?: Date): Date {
+    const now = new Date();
+    if (!value) return now;
+    const t = value.getTime();
+    const oneDayMs = 86_400_000;
+    if (
+      Number.isNaN(t) ||
+      t > now.getTime() + oneDayMs ||
+      t < Date.UTC(2000, 0, 1)
+    ) {
+      this.logger.warn(
+        `finalizePaymentSuccess: implausible paidAt (epoch=${t}); using current time instead`,
+      );
+      return now;
+    }
+    return value;
+  }
+
   async finalizePaymentSuccess(input: {
     intentId: string;
     providerTxnId?: string;
@@ -317,65 +524,166 @@ export class PaymentsService {
     const intent = await this.prisma.paymentIntent.findUnique({
       where: { id: input.intentId },
     });
-    if (!intent) throw new NotFoundException('PaymentIntent not found');
+    if (!intent) throw new NotFoundException("PaymentIntent not found");
     if (intent.status === PaymentIntentStatus.SUCCEEDED) {
       return { alreadyFinalized: true };
     }
     if (intent.status === PaymentIntentStatus.CANCELLED) {
-      throw new BadRequestException('PaymentIntent is cancelled; cannot finalize');
+      throw new BadRequestException(
+        "PaymentIntent is cancelled; cannot finalize",
+      );
     }
 
     const booking = await this.prisma.booking.findUnique({
       where: { id: intent.bookingId },
       include: { seats: true },
     });
-    if (!booking) throw new NotFoundException('Booking not found');
+    if (!booking) throw new NotFoundException("Booking not found");
 
-    const paidAt = input.paidAt ?? new Date();
+    const paidAt = this.sanitizePaidAt(input.paidAt);
     await this.prisma.$transaction(async (tx) => {
       await tx.paymentIntent.update({
         where: { id: intent.id },
         data: {
           status: PaymentIntentStatus.SUCCEEDED,
-          providerTxnId: input.providerTxnId ?? intent.providerTxnId ?? undefined,
+          providerTxnId:
+            input.providerTxnId ?? intent.providerTxnId ?? undefined,
           paidAt,
         },
       });
       await tx.booking.update({
         where: { id: booking.id },
-        data: { status: 'CONFIRMED' },
+        data: { status: "CONFIRMED" },
       });
     });
 
     try {
       await this.seatsService.confirmSeats(booking.seats.map((s) => s.seatId));
     } catch (err) {
-      this.logger.error(`Error confirming seats: ${err instanceof Error ? err.message : String(err)}`);
+      this.logger.error(
+        `Error confirming seats: ${err instanceof Error ? err.message : String(err)}`,
+      );
     }
 
     try {
       await this.createJourneySegments(booking);
     } catch (err) {
-      this.logger.error(`Error creating journey segments: ${err instanceof Error ? err.message : String(err)}`);
+      this.logger.error(
+        `Error creating journey segments: ${err instanceof Error ? err.message : String(err)}`,
+      );
     }
 
     try {
       await this.ticketsService.generate(booking.id);
     } catch (err) {
-      this.logger.error(`Error generating ticket: ${err instanceof Error ? err.message : String(err)}`);
+      this.logger.error(
+        `Error generating ticket: ${err instanceof Error ? err.message : String(err)}`,
+      );
       throw err;
     }
 
     try {
-      await this.awardLoyaltyPoints(booking.passengerId, booking.totalMinor, booking.id);
+      await this.awardLoyaltyPoints(
+        booking.passengerId,
+        booking.totalMinor,
+        booking.id,
+      );
     } catch (err) {
-      this.logger.warn(`Error awarding loyalty points: ${err instanceof Error ? err.message : String(err)}`);
+      this.logger.warn(
+        `Error awarding loyalty points: ${err instanceof Error ? err.message : String(err)}`,
+      );
     }
 
-    this.eventEmitter.emit('payment.succeeded', { booking });
+    this.eventEmitter.emit("payment.succeeded", { booking });
     return { alreadyFinalized: false };
   }
 
+  async handlePaymentEvent(
+    event: PaymentEventDto,
+  ): Promise<MarkPaidResponseDto> {
+    if (
+      event.service !== PaymentServiceEnum.PASSENGER ||
+      event.referenceType !== PaymentReferenceType.BOOKING
+    ) {
+      this.logger.warn(
+        `mark-paid: ignoring foreign reference ${event.service}/${event.referenceType}/${event.referenceId}`,
+      );
+      return { processed: false, reason: "foreign-reference" };
+    }
+
+    if (event.eventType === "payment.failed") {
+      const intent = await this.prisma.paymentIntent.findUnique({
+        where: { bookingId: event.referenceId },
+      });
+      if (intent) {
+        await this.markPaymentFailed({
+          intentId: intent.id,
+          failureCode: event.failureCode,
+          failureMessage: event.failureMessage,
+        });
+      }
+      const failedBooking = await this.prisma.booking.findUnique({
+        where: { id: event.referenceId },
+      });
+      if (failedBooking) {
+        this.eventEmitter.emit("payment.failed", { booking: failedBooking });
+      }
+      return { processed: true };
+    }
+
+    const booking = await this.prisma.booking.findUnique({
+      where: { id: event.referenceId },
+    });
+    if (!booking) {
+      // Ack (200) — a missing booking will not appear on redelivery; needs investigation.
+      this.logger.error(
+        `mark-paid: no booking for reference ${event.referenceId}`,
+      );
+      return { processed: false, reason: "booking-not-found" };
+    }
+
+    // The event carries the REAL (major) price the provider charged (passenger now sends
+    // booking.totalMinor/100 on initiate), so convert it back to minor units before comparing
+    // with booking.totalMinor (which is in minor units).
+    const eventAmountMinor = Math.round(event.amountMinor * 100);
+    if (booking.totalMinor !== eventAmountMinor) {
+      // Refuse to confirm: a 4xx makes the relay retry and eventually flag the row FAILED,
+      // which is the alertable signal for an asserted-vs-paid amount divergence.
+      this.logger.error(
+        `mark-paid: amount mismatch for booking ${booking.id}: booking=${booking.totalMinor} event=${event.amountMinor} (=${eventAmountMinor} minor)`,
+      );
+      throw new BadRequestException(
+        "Event amount does not match booking total",
+      );
+    }
+
+    // Local intent row is a projection during the strangler migration: reuse it when the
+    // legacy initiate path created one, otherwise materialize it from the event.
+    let intent = await this.prisma.paymentIntent.findUnique({
+      where: { bookingId: event.referenceId },
+    });
+    if (!intent) {
+      intent = await this.prisma.paymentIntent.create({
+        data: {
+          bookingId: event.referenceId,
+          amountMinor: event.amountMinor,
+          currency: event.currency,
+          method: event.provider as unknown as PaymentMethodType,
+          status: PaymentIntentStatus.PROCESSING,
+          merchantOrderId: event.merchantOrderId,
+          providerTxnId: event.providerTxnId,
+        },
+      });
+    }
+
+    const { alreadyFinalized } = await this.finalizePaymentSuccess({
+      intentId: intent.id,
+      providerTxnId: event.providerTxnId,
+      paidAt: event.paidAt ? new Date(event.paidAt) : undefined,
+    });
+    return { processed: true, alreadyFinalized };
+  }
+
   async markPaymentFailed(input: {
     intentId: string;
     failureCode?: string;
@@ -384,7 +692,7 @@ export class PaymentsService {
     const intent = await this.prisma.paymentIntent.findUnique({
       where: { id: input.intentId },
     });
-    if (!intent) throw new NotFoundException('PaymentIntent not found');
+    if (!intent) throw new NotFoundException("PaymentIntent not found");
     if (
       intent.status === PaymentIntentStatus.SUCCEEDED ||
       intent.status === PaymentIntentStatus.CANCELLED
@@ -401,35 +709,72 @@ export class PaymentsService {
     });
   }
 
-  private async awardLoyaltyPoints(passengerId: string, amountMinor: number, bookingId: string) {
+  private async awardLoyaltyPoints(
+    passengerId: string,
+    amountMinor: number,
+    bookingId: string,
+  ) {
     const points = Math.floor(amountMinor / 100);
-    const account = await this.prisma.loyaltyAccount.findUnique({ where: { passengerId } });
+    const account = await this.prisma.loyaltyAccount.findUnique({
+      where: { passengerId },
+    });
     if (!account) return;
     const newBalance = account.pointsBalance + points;
-    const tier = newBalance >= 10000 ? 'PLATINUM' : newBalance >= 5000 ? 'GOLD' : newBalance >= 2000 ? 'SILVER' : 'BRONZE';
-    await this.prisma.loyaltyAccount.update({ where: { passengerId }, data: { pointsBalance: { increment: points }, tier: tier as any } });
-    await this.prisma.loyaltyLedgerEntry.create({ data: { accountId: account.id, delta: points, reason: 'TRIP_COMPLETED', bookingId, balanceAfter: newBalance } });
+    const tier =
+      newBalance >= 10000
+        ? "PLATINUM"
+        : newBalance >= 5000
+          ? "GOLD"
+          : newBalance >= 2000
+            ? "SILVER"
+            : "BRONZE";
+    await this.prisma.loyaltyAccount.update({
+      where: { passengerId },
+      data: { pointsBalance: { increment: points }, tier: tier as any },
+    });
+    await this.prisma.loyaltyLedgerEntry.create({
+      data: {
+        accountId: account.id,
+        delta: points,
+        reason: "TRIP_COMPLETED",
+        bookingId,
+        balanceAfter: newBalance,
+      },
+    });
   }
 
-  private async createJourneySegments(booking: Prisma.BookingGetPayload<{ include: { seats: true } }>) {
+  private async createJourneySegments(
+    booking: Prisma.BookingGetPayload<{ include: { seats: true } }>,
+  ) {
     const schedule = await this.prisma.trainSchedule.findUnique({
       where: { id: booking.scheduleId },
-      include: { stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+      include: {
+        stopTimes: { include: { station: true }, orderBy: { sequence: "asc" } },
+      },
     });
     if (!schedule) return;
 
     const stopTimes = schedule.stopTimes;
     if (stopTimes.length < 2) return;
 
-    const originSequence = stopTimes.findIndex(st => st.stationId === schedule.originStationId);
-    const destSequence = stopTimes.findIndex(st => st.stationId === schedule.destinationStationId);
+    const originSequence = stopTimes.findIndex(
+      (st) => st.stationId === schedule.originStationId,
+    );
+    const destSequence = stopTimes.findIndex(
+      (st) => st.stationId === schedule.destinationStationId,
+    );
 
-    if (originSequence < 0 || destSequence < 0 || originSequence >= destSequence) return;
+    if (
+      originSequence < 0 ||
+      destSequence < 0 ||
+      originSequence >= destSequence
+    )
+      return;
 
     const journey = await this.prisma.journey.create({
       data: {
         passengerId: booking.passengerId,
-        status: 'CONFIRMED',
+        status: "CONFIRMED",
         totalMinor: booking.totalMinor,
         currency: booking.currency,
       },

apps/edr-passenger-api/src/modules/payments/payments.types.ts

@@ -1,36 +1,12 @@
-import { PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-
-export type PaymentPlatform = 'web' | 'mobile';
-
-export type ClientAction =
-  | { type: 'REDIRECT'; url: string }
-  | { type: 'LAUNCH_APP'; prepayId: string; receiveCode?: string; shortCode: string };
-
-export interface ProviderInitiationInput {
-  merchantOrderId: string;
-  bookingRef: string;
-  amountMinor: number;
-  currency: string;
-  platform?: PaymentPlatform;
-}
-
-export interface ProviderInitiationResult {
-  providerOrderId: string;
-  clientAction: ClientAction;
-  expiresAt: Date;
-  rawInitiation: Record<string, unknown>;
-}
-
-export interface ProviderStatus {
-  status: PaymentIntentStatus;
-  providerTxnId?: string;
-  failureCode?: string;
-  failureMessage?: string;
-  rawResponse: Record<string, unknown>;
-}
-
-export interface PaymentProvider {
-  readonly method: PaymentMethodType;
-  initiate(input: ProviderInitiationInput): Promise<ProviderInitiationResult>;
-  queryStatus(merchantOrderId: string): Promise<ProviderStatus>;
-}
+// The payment provider contract lives in @edr/types; the gateways themselves now run only
+// inside apps/edr-payment-api. This file remains as a thin re-export so existing local
+// imports keep working.
+export type {
+  PaymentProvider,
+  ProviderInitiationInput,
+  ProviderInitiationResult,
+  ProviderStatus,
+  ClientAction,
+  PaymentPlatform,
+} from "@edr/types";
+export { ProviderPaymentStatus, ProviderMethod } from "@edr/types";

apps/edr-passenger-api/src/modules/payments/providers/card.provider.ts

@@ -1,218 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { HttpService } from '@nestjs/axios';
-import { PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-import { AxiosError, AxiosRequestConfig } from 'axios';
-import { firstValueFrom } from 'rxjs';
-import * as crypto from 'node:crypto';
-import {
-  PaymentProvider,
-  ProviderInitiationInput,
-  ProviderInitiationResult,
-  ProviderStatus,
-} from '../payments.types';
-
-interface CardInitiateRequest {
-  amount: number;
-  currency: string;
-  description: string;
-  metadata: {
-    merchantOrderId: string;
-    bookingRef: string;
-  };
-  return_url: string;
-  webhook_url: string;
-}
-
-interface CardInitiateResponse {
-  id: string;
-  status: string;
-  client_secret: string;
-  checkout_url: string;
-  expires_at: number;
-}
-
-interface CardQueryResponse {
-  id: string;
-  status: string;
-  amount: number;
-  currency: string;
-  transaction_id?: string;
-  paid_at?: number;
-  failure_code?: string;
-  failure_message?: string;
-}
-
-@Injectable()
-export class CardProvider implements PaymentProvider {
-  readonly method = PaymentMethodType.CARD;
-  private readonly logger = new Logger(CardProvider.name);
-
-  constructor(
-    private readonly config: ConfigService,
-    private readonly http: HttpService,
-  ) {}
-
-  async initiate(input: ProviderInitiationInput): Promise<ProviderInitiationResult> {
-    const amount = input.amountMinor / 100;
-    
-    const requestBody: CardInitiateRequest = {
-      amount,
-      currency: input.currency,
-      description: `EDR Train Booking ${input.bookingRef}`,
-      metadata: {
-        merchantOrderId: input.merchantOrderId,
-        bookingRef: input.bookingRef,
-      },
-      return_url: this.returnUrl,
-      webhook_url: this.webhookUrl,
-    };
-
-    const response = await this.postJson<CardInitiateResponse>(
-      `${this.baseUrl}/v1/payment_intents`,
-      requestBody,
-    );
-
-    if (!response.id) {
-      throw new Error(`Card gateway initiate failed: ${JSON.stringify(response)}`);
-    }
-
-    const expiresAt = new Date(response.expires_at * 1000);
-
-    return {
-      providerOrderId: response.id,
-      clientAction: { type: 'REDIRECT', url: response.checkout_url },
-      expiresAt,
-      rawInitiation: {
-        request: requestBody,
-        response,
-      },
-    };
-  }
-
-  async queryStatus(merchantOrderId: string): Promise<ProviderStatus> {
-    // For card payments, we need to find the payment intent by metadata
-    // In a real implementation, we'd store the provider order ID and use it directly
-    const response = await this.getJson<CardQueryResponse>(
-      `${this.baseUrl}/v1/payment_intents/search?metadata[merchantOrderId]=${merchantOrderId}`,
-    );
-
-    const mapped = this.mapStatus(response.status);
-
-    return {
-      status: mapped,
-      providerTxnId: response.transaction_id,
-      failureCode: response.failure_code,
-      failureMessage: response.failure_message,
-      rawResponse: response as unknown as Record<string, unknown>,
-    };
-  }
-
-  verifyWebhookSignature(payload: Record<string, unknown>, signature: string): boolean {
-    const payloadString = JSON.stringify(payload);
-    const expectedSignature = crypto
-      .createHmac('sha256', this.webhookSecret)
-      .update(payloadString)
-      .digest('hex');
-    
-    try {
-      return crypto.timingSafeEqual(
-        Buffer.from(signature),
-        Buffer.from(expectedSignature),
-      );
-    } catch {
-      return false;
-    }
-  }
-
-  mapWebhookStatus(status: string): PaymentIntentStatus {
-    return this.mapStatus(status);
-  }
-
-  private mapStatus(status: string): PaymentIntentStatus {
-    switch (status?.toLowerCase()) {
-      case 'succeeded':
-      case 'paid':
-        return PaymentIntentStatus.SUCCEEDED;
-      case 'failed':
-      case 'canceled':
-      case 'expired':
-        return PaymentIntentStatus.FAILED;
-      case 'requires_payment_method':
-      case 'requires_confirmation':
-      case 'requires_action':
-        return PaymentIntentStatus.REQUIRES_ACTION;
-      case 'processing':
-        return PaymentIntentStatus.PROCESSING;
-      default:
-        return PaymentIntentStatus.PROCESSING;
-    }
-  }
-
-  private async postJson<T>(url: string, body: unknown): Promise<T> {
-    const config: AxiosRequestConfig = {
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.apiKey}`,
-      },
-      timeout: 10_000,
-    };
-
-    const started = Date.now();
-    try {
-      const res = await firstValueFrom(this.http.post<T>(url, body, config));
-      this.logger.debug(`Card Gateway POST ${url} status=${res.status} latency=${Date.now() - started}ms`);
-      return res.data;
-    } catch (err) {
-      if (err instanceof AxiosError) {
-        this.logger.error(
-          `Card Gateway POST ${url} failed: status=${err.response?.status} body=${JSON.stringify(err.response?.data)}`,
-        );
-      } else {
-        this.logger.error(`Card Gateway POST ${url} threw: ${err instanceof Error ? err.message : err}`);
-      }
-      throw err;
-    }
-  }
-
-  private async getJson<T>(url: string): Promise<T> {
-    const config: AxiosRequestConfig = {
-      headers: {
-        'Authorization': `Bearer ${this.apiKey}`,
-      },
-      timeout: 10_000,
-    };
-
-    const started = Date.now();
-    try {
-      const res = await firstValueFrom(this.http.get<T>(url, config));
-      this.logger.debug(`Card Gateway GET ${url} status=${res.status} latency=${Date.now() - started}ms`);
-      return res.data;
-    } catch (err) {
-      if (err instanceof AxiosError) {
-        this.logger.error(
-          `Card Gateway GET ${url} failed: status=${err.response?.status} body=${JSON.stringify(err.response?.data)}`,
-        );
-      } else {
-        this.logger.error(`Card Gateway GET ${url} threw: ${err instanceof Error ? err.message : err}`);
-      }
-      throw err;
-    }
-  }
-
-  private get baseUrl(): string {
-    return this.config.get<string>('card.baseUrl') ?? '';
-  }
-  private get apiKey(): string {
-    return this.config.get<string>('card.apiKey') ?? '';
-  }
-  private get webhookSecret(): string {
-    return this.config.get<string>('card.webhookSecret') ?? '';
-  }
-  private get webhookUrl(): string {
-    return this.config.get<string>('card.webhookUrl') ?? '';
-  }
-  private get returnUrl(): string {
-    return this.config.get<string>('card.returnUrl') ?? '';
-  }
-}

apps/edr-passenger-api/src/modules/payments/providers/cbe-birr.provider.ts

@@ -1,215 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { HttpService } from '@nestjs/axios';
-import { PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-import { AxiosError, AxiosRequestConfig } from 'axios';
-import { firstValueFrom } from 'rxjs';
-import * as crypto from 'node:crypto';
-import {
-  PaymentProvider,
-  ProviderInitiationInput,
-  ProviderInitiationResult,
-  ProviderStatus,
-} from '../payments.types';
-
-interface CbeBirrInitiateRequest {
-  merchantId: string;
-  merchantOrderId: string;
-  amount: string;
-  currency: string;
-  description: string;
-  returnUrl: string;
-  notifyUrl: string;
-  timestamp: string;
-  signature: string;
-}
-
-interface CbeBirrInitiateResponse {
-  success: boolean;
-  orderId: string;
-  paymentUrl: string;
-  expiresIn: number;
-}
-
-interface CbeBirrQueryResponse {
-  success: boolean;
-  orderId: string;
-  status: string;
-  transactionId?: string;
-  amount?: string;
-  paidAt?: string;
-}
-
-@Injectable()
-export class CbeBirrProvider implements PaymentProvider {
-  readonly method = PaymentMethodType.CBE_BIRR;
-  private readonly logger = new Logger(CbeBirrProvider.name);
-
-  constructor(
-    private readonly config: ConfigService,
-    private readonly http: HttpService,
-  ) {}
-
-  async initiate(input: ProviderInitiationInput): Promise<ProviderInitiationResult> {
-    const amount = (input.amountMinor / 100).toFixed(2);
-    const timestamp = new Date().toISOString();
-    
-    const requestBody: CbeBirrInitiateRequest = {
-      merchantId: this.merchantId,
-      merchantOrderId: input.merchantOrderId,
-      amount,
-      currency: input.currency,
-      description: `EDR Booking ${input.bookingRef}`,
-      returnUrl: this.returnUrl,
-      notifyUrl: this.notifyUrl,
-      timestamp,
-      signature: this.signRequest({
-        merchantId: this.merchantId,
-        merchantOrderId: input.merchantOrderId,
-        amount,
-        timestamp,
-      }),
-    };
-
-    const response = await this.postJson<CbeBirrInitiateResponse>(
-      `${this.baseUrl}/api/v1/payment/initiate`,
-      requestBody,
-    );
-
-    if (!response.success || !response.orderId) {
-      throw new Error(`CBE Birr initiate failed: ${JSON.stringify(response)}`);
-    }
-
-    const expiresAt = new Date(Date.now() + response.expiresIn * 1000);
-
-    return {
-      providerOrderId: response.orderId,
-      clientAction: { type: 'REDIRECT', url: response.paymentUrl },
-      expiresAt,
-      rawInitiation: {
-        request: this.sanitize(requestBody),
-        response,
-      },
-    };
-  }
-
-  async queryStatus(merchantOrderId: string): Promise<ProviderStatus> {
-    const timestamp = new Date().toISOString();
-    const signature = this.signRequest({
-      merchantId: this.merchantId,
-      merchantOrderId,
-      timestamp,
-    });
-
-    const response = await this.postJson<CbeBirrQueryResponse>(
-      `${this.baseUrl}/api/v1/payment/query`,
-      {
-        merchantId: this.merchantId,
-        merchantOrderId,
-        timestamp,
-        signature,
-      },
-    );
-
-    const mapped = this.mapStatus(response.status);
-
-    return {
-      status: mapped,
-      providerTxnId: response.transactionId,
-      failureCode: mapped === PaymentIntentStatus.FAILED ? response.status : undefined,
-      rawResponse: response as unknown as Record<string, unknown>,
-    };
-  }
-
-  verifyWebhookSignature(payload: Record<string, unknown>): boolean {
-    const { signature, ...data } = payload;
-    if (!signature || typeof signature !== 'string') return false;
-    
-    const expectedSignature = this.signRequest(data);
-    return crypto.timingSafeEqual(
-      Buffer.from(signature),
-      Buffer.from(expectedSignature),
-    );
-  }
-
-  mapWebhookStatus(status: string): PaymentIntentStatus {
-    return this.mapStatus(status);
-  }
-
-  private mapStatus(status: string): PaymentIntentStatus {
-    switch (status?.toUpperCase()) {
-      case 'SUCCESS':
-      case 'COMPLETED':
-        return PaymentIntentStatus.SUCCEEDED;
-      case 'FAILED':
-      case 'REJECTED':
-      case 'EXPIRED':
-        return PaymentIntentStatus.FAILED;
-      case 'PENDING':
-        return PaymentIntentStatus.REQUIRES_ACTION;
-      case 'PROCESSING':
-        return PaymentIntentStatus.PROCESSING;
-      default:
-        return PaymentIntentStatus.PROCESSING;
-    }
-  }
-
-  private signRequest(data: Record<string, unknown>): string {
-    const sortedKeys = Object.keys(data).sort();
-    const signString = sortedKeys
-      .map((key) => `${key}=${data[key]}`)
-      .join('&');
-    
-    return crypto
-      .createHmac('sha256', this.secretKey)
-      .update(signString)
-      .digest('hex');
-  }
-
-  private async postJson<T>(url: string, body: unknown): Promise<T> {
-    const config: AxiosRequestConfig = {
-      headers: {
-        'Content-Type': 'application/json',
-        'X-Merchant-Id': this.merchantId,
-      },
-      timeout: 10_000,
-    };
-
-    const started = Date.now();
-    try {
-      const res = await firstValueFrom(this.http.post<T>(url, body, config));
-      this.logger.debug(`CBE Birr POST ${url} status=${res.status} latency=${Date.now() - started}ms`);
-      return res.data;
-    } catch (err) {
-      if (err instanceof AxiosError) {
-        this.logger.error(
-          `CBE Birr POST ${url} failed: status=${err.response?.status} body=${JSON.stringify(err.response?.data)}`,
-        );
-      } else {
-        this.logger.error(`CBE Birr POST ${url} threw: ${err instanceof Error ? err.message : err}`);
-      }
-      throw err;
-    }
-  }
-
-  private sanitize(body: CbeBirrInitiateRequest): Record<string, unknown> {
-    const { signature: _signature, ...rest } = body;
-    return rest;
-  }
-
-  private get baseUrl(): string {
-    return this.config.get<string>('cbe.baseUrl') ?? '';
-  }
-  private get merchantId(): string {
-    return this.config.get<string>('cbe.merchantId') ?? '';
-  }
-  private get secretKey(): string {
-    return this.config.get<string>('cbe.secretKey') ?? '';
-  }
-  private get notifyUrl(): string {
-    return this.config.get<string>('cbe.notifyUrl') ?? '';
-  }
-  private get returnUrl(): string {
-    return this.config.get<string>('cbe.returnUrl') ?? '';
-  }
-}

apps/edr-passenger-api/src/modules/payments/providers/ebirr.provider.ts

@@ -1,228 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { HttpService } from '@nestjs/axios';
-import { PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-import { AxiosError, AxiosRequestConfig } from 'axios';
-import { firstValueFrom } from 'rxjs';
-import * as crypto from 'node:crypto';
-import {
-  PaymentProvider,
-  ProviderInitiationInput,
-  ProviderInitiationResult,
-  ProviderStatus,
-} from '../payments.types';
-
-interface EBirrInitiateRequest {
-  merchantCode: string;
-  orderNo: string;
-  amount: number;
-  currency: string;
-  subject: string;
-  body: string;
-  notifyUrl: string;
-  returnUrl: string;
-  timestamp: number;
-  sign: string;
-}
-
-interface EBirrInitiateResponse {
-  code: string;
-  message: string;
-  data?: {
-    orderNo: string;
-    payUrl: string;
-    expireTime: number;
-  };
-}
-
-interface EBirrQueryResponse {
-  code: string;
-  message: string;
-  data?: {
-    orderNo: string;
-    tradeStatus: string;
-    tradeNo?: string;
-    totalAmount?: number;
-    payTime?: number;
-  };
-}
-
-@Injectable()
-export class EBirrProvider implements PaymentProvider {
-  readonly method = PaymentMethodType.EBIRR;
-  private readonly logger = new Logger(EBirrProvider.name);
-
-  constructor(
-    private readonly config: ConfigService,
-    private readonly http: HttpService,
-  ) {}
-
-  async initiate(input: ProviderInitiationInput): Promise<ProviderInitiationResult> {
-    const amount = input.amountMinor / 100;
-    const timestamp = Date.now();
-    
-    const requestBody: EBirrInitiateRequest = {
-      merchantCode: this.merchantCode,
-      orderNo: input.merchantOrderId,
-      amount,
-      currency: input.currency,
-      subject: `EDR Ticket`,
-      body: `Train booking ${input.bookingRef}`,
-      notifyUrl: this.notifyUrl,
-      returnUrl: this.returnUrl,
-      timestamp,
-      sign: this.signRequest({
-        merchantCode: this.merchantCode,
-        orderNo: input.merchantOrderId,
-        amount,
-        timestamp,
-      }),
-    };
-
-    const response = await this.postJson<EBirrInitiateResponse>(
-      `${this.baseUrl}/gateway/api/pay/create`,
-      requestBody,
-    );
-
-    if (response.code !== '0000' || !response.data?.orderNo) {
-      throw new Error(`eBirr initiate failed: ${response.message}`);
-    }
-
-    const expiresAt = new Date(response.data.expireTime);
-
-    return {
-      providerOrderId: response.data.orderNo,
-      clientAction: { type: 'REDIRECT', url: response.data.payUrl },
-      expiresAt,
-      rawInitiation: {
-        request: this.sanitize(requestBody),
-        response,
-      },
-    };
-  }
-
-  async queryStatus(merchantOrderId: string): Promise<ProviderStatus> {
-    const timestamp = Date.now();
-    const requestBody = {
-      merchantCode: this.merchantCode,
-      orderNo: merchantOrderId,
-      timestamp,
-      sign: this.signRequest({
-        merchantCode: this.merchantCode,
-        orderNo: merchantOrderId,
-        timestamp,
-      }),
-    };
-
-    const response = await this.postJson<EBirrQueryResponse>(
-      `${this.baseUrl}/gateway/api/pay/query`,
-      requestBody,
-    );
-
-    if (response.code !== '0000' || !response.data) {
-      throw new Error(`eBirr query failed: ${response.message}`);
-    }
-
-    const mapped = this.mapStatus(response.data.tradeStatus);
-
-    return {
-      status: mapped,
-      providerTxnId: response.data.tradeNo,
-      failureCode: mapped === PaymentIntentStatus.FAILED ? response.data.tradeStatus : undefined,
-      rawResponse: response as unknown as Record<string, unknown>,
-    };
-  }
-
-  verifyWebhookSignature(payload: Record<string, unknown>): boolean {
-    const { sign, ...data } = payload;
-    if (!sign || typeof sign !== 'string') return false;
-    
-    const expectedSign = this.signRequest(data);
-    return crypto.timingSafeEqual(
-      Buffer.from(sign),
-      Buffer.from(expectedSign),
-    );
-  }
-
-  mapWebhookStatus(tradeStatus: string): PaymentIntentStatus {
-    return this.mapStatus(tradeStatus);
-  }
-
-  private mapStatus(tradeStatus: string): PaymentIntentStatus {
-    switch (tradeStatus?.toUpperCase()) {
-      case 'TRADE_SUCCESS':
-      case 'SUCCESS':
-        return PaymentIntentStatus.SUCCEEDED;
-      case 'TRADE_CLOSED':
-      case 'TRADE_FAILED':
-      case 'FAILED':
-        return PaymentIntentStatus.FAILED;
-      case 'WAIT_BUYER_PAY':
-      case 'PENDING':
-        return PaymentIntentStatus.REQUIRES_ACTION;
-      case 'PROCESSING':
-        return PaymentIntentStatus.PROCESSING;
-      default:
-        return PaymentIntentStatus.PROCESSING;
-    }
-  }
-
-  private signRequest(data: Record<string, unknown>): string {
-    const sortedKeys = Object.keys(data).sort();
-    const signString = sortedKeys
-      .map((key) => `${key}=${data[key]}`)
-      .join('&') + `&key=${this.secretKey}`;
-    
-    return crypto
-      .createHash('md5')
-      .update(signString)
-      .digest('hex')
-      .toUpperCase();
-  }
-
-  private async postJson<T>(url: string, body: unknown): Promise<T> {
-    const config: AxiosRequestConfig = {
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      timeout: 10_000,
-    };
-
-    const started = Date.now();
-    try {
-      const res = await firstValueFrom(this.http.post<T>(url, body, config));
-      this.logger.debug(`eBirr POST ${url} status=${res.status} latency=${Date.now() - started}ms`);
-      return res.data;
-    } catch (err) {
-      if (err instanceof AxiosError) {
-        this.logger.error(
-          `eBirr POST ${url} failed: status=${err.response?.status} body=${JSON.stringify(err.response?.data)}`,
-        );
-      } else {
-        this.logger.error(`eBirr POST ${url} threw: ${err instanceof Error ? err.message : err}`);
-      }
-      throw err;
-    }
-  }
-
-  private sanitize(body: EBirrInitiateRequest): Record<string, unknown> {
-    const { sign: _sign, ...rest } = body;
-    return rest;
-  }
-
-  private get baseUrl(): string {
-    return this.config.get<string>('ebirr.baseUrl') ?? '';
-  }
-  private get merchantCode(): string {
-    return this.config.get<string>('ebirr.merchantCode') ?? '';
-  }
-  private get secretKey(): string {
-    return this.config.get<string>('ebirr.secretKey') ?? '';
-  }
-  private get notifyUrl(): string {
-    return this.config.get<string>('ebirr.notifyUrl') ?? '';
-  }
-  private get returnUrl(): string {
-    return this.config.get<string>('ebirr.returnUrl') ?? '';
-  }
-}

apps/edr-passenger-api/src/modules/payments/providers/payment-provider.interface.ts

@@ -1,9 +0,0 @@
-export type {
-  PaymentProvider,
-  ProviderInitiationInput,
-  ProviderInitiationResult,
-  ProviderStatus,
-  ClientAction,
-} from '../payments.types';
-
-export const PAYMENT_PROVIDERS = Symbol('PAYMENT_PROVIDERS');

apps/edr-passenger-api/src/modules/payments/providers/telebirr.crypto.ts

@@ -1,98 +0,0 @@
-import * as crypto from 'crypto';
-
-const EXCLUDE_FIELDS = new Set([
-  'sign',
-  'sign_type',
-  'header',
-  'refund_info',
-  'openType',
-  'raw_request',
-  'biz_content',
-]);
-
-const NONCE_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-
-export function buildCanonicalString(requestObject: Record<string, unknown>): string {
-  const fieldMap: Record<string, unknown> = {};
-
-  for (const key of Object.keys(requestObject)) {
-    if (EXCLUDE_FIELDS.has(key)) continue;
-    fieldMap[key] = requestObject[key];
-  }
-
-  const biz = requestObject['biz_content'];
-  if (biz && typeof biz === 'object') {
-    for (const key of Object.keys(biz as Record<string, unknown>)) {
-      if (EXCLUDE_FIELDS.has(key)) continue;
-      fieldMap[key] = (biz as Record<string, unknown>)[key];
-    }
-  }
-
-  return Object.keys(fieldMap)
-    .sort()
-    .map((k) => `${k}=${fieldMap[k]}`)
-    .join('&');
-}
-
-export function signRequestObject(
-  requestObject: Record<string, unknown>,
-  privateKey: string,
-): string {
-  return signString(buildCanonicalString(requestObject), privateKey);
-}
-
-export function verifyRequestObject(
-  requestObject: Record<string, unknown>,
-  publicKey: string,
-): boolean {
-  const signature = requestObject['sign'];
-  if (typeof signature !== 'string' || signature.length === 0) return false;
-  return verifySignature(buildCanonicalString(requestObject), signature, publicKey);
-}
-
-export function signString(text: string, privateKey: string): string {
-  const signature = crypto.sign('sha256', Buffer.from(text), {
-    key: privateKey,
-    padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
-    saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST,
-  });
-  return signature.toString('base64');
-}
-
-export function verifySignature(
-  text: string,
-  signatureBase64: string,
-  publicKey: string,
-): boolean {
-  try {
-    return crypto.verify(
-      'sha256',
-      Buffer.from(text),
-      {
-        key: publicKey,
-        padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
-        saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST,
-      },
-      Buffer.from(signatureBase64, 'base64'),
-    );
-  } catch {
-    return false;
-  }
-}
-
-export function createTimestamp(): string {
-  return Math.round(Date.now() / 1000).toString();
-}
-
-export function createNonceStr(length = 32): string {
-  const bytes = crypto.randomBytes(length);
-  let out = '';
-  for (let i = 0; i < length; i++) {
-    out += NONCE_CHARS[bytes[i] % NONCE_CHARS.length];
-  }
-  return out;
-}
-
-export function createMerchantOrderId(): string {
-  return `${Date.now()}${crypto.randomBytes(4).toString('hex')}`;
-}

apps/edr-passenger-api/src/modules/payments/providers/telebirr.provider.ts

@@ -1,300 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { HttpService } from '@nestjs/axios';
-import { PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-import { AxiosError, AxiosRequestConfig } from 'axios';
-import { firstValueFrom } from 'rxjs';
-import * as https from 'node:https';
-import {
-  PaymentProvider,
-  ProviderInitiationInput,
-  ProviderInitiationResult,
-  ProviderStatus,
-} from '../payments.types';
-import {
-  createNonceStr,
-  createTimestamp,
-  signRequestObject,
-  verifyRequestObject,
-} from './telebirr.crypto';
-import {
-  CreateOrderRequest,
-  CreateOrderResponse,
-  FabricTokenResponse,
-  QueryOrderResponse,
-} from './telebirr.types';
-
-const TELEBIRR_HTTP_TIMEOUT_MS = 10_000;
-
-@Injectable()
-export class TelebirrProvider implements PaymentProvider {
-  readonly method = PaymentMethodType.TELEBIRR;
-  private readonly logger = new Logger(TelebirrProvider.name);
-  private readonly httpsAgent: https.Agent;
-
-  constructor(
-    private readonly config: ConfigService,
-    private readonly http: HttpService,
-  ) {
-    const insecure = this.config.get<boolean>('telebirr.insecureTls');
-    if (insecure) {
-      this.logger.warn('TELEBIRR_INSECURE_TLS=true — TLS verification disabled for Telebirr calls. DEV ONLY.');
-    }
-    this.httpsAgent = new https.Agent({
-      rejectUnauthorized: !insecure,
-      secureProtocol: 'TLSv1_2_method',
-    });
-  }
-
-  async initiate(input: ProviderInitiationInput): Promise<ProviderInitiationResult> {
-    const fabricToken = await this.applyFabricToken();
-    const requestBody = this.buildCreateOrderRequest(input);
-    const response = await this.requestCreateOrder(fabricToken, requestBody);
-
-    const prepayId = response.biz_content?.prepay_id;
-    if (!prepayId) {
-      throw new Error(
-        `Telebirr createOrder returned no prepay_id: ${JSON.stringify(response)}`,
-      );
-    }
-
-    const expiresAt = this.computeExpiresAt(requestBody.biz_content.timeout_express);
-    const platform = input.platform ?? 'web';
-    const clientAction =
-      platform === 'mobile'
-        ? {
-            type: 'LAUNCH_APP' as const,
-            prepayId,
-            receiveCode: response.biz_content?.receiveCode,
-            shortCode: this.merchantCode,
-          }
-        : { type: 'REDIRECT' as const, url: this.buildCheckoutUrl(prepayId) };
-
-    return {
-      providerOrderId: prepayId,
-      clientAction,
-      expiresAt,
-      rawInitiation: {
-        request: this.sanitize(requestBody),
-        response,
-      },
-    };
-  }
-
-  async queryStatus(merchantOrderId: string): Promise<ProviderStatus> {
-    const fabricToken = await this.applyFabricToken();
-    const requestBody = this.buildQueryOrderRequest(merchantOrderId);
-    const response = await this.postJson<QueryOrderResponse>(
-      `${this.baseUrl}/payment/v1/merchant/queryOrder`,
-      requestBody,
-      {
-        'Content-Type': 'application/json',
-        'X-APP-Key': this.fabricAppId,
-        Authorization: fabricToken,
-      },
-    );
-
-    const tradeStatus = response.biz_content?.trade_status;
-    const providerTxnId =
-      response.biz_content?.trans_id ?? response.biz_content?.payment_order_id;
-    const mapped = this.mapTradeStatus(tradeStatus);
-
-    return {
-      status: mapped,
-      providerTxnId,
-      failureCode:
-        mapped === PaymentIntentStatus.FAILED && tradeStatus ? tradeStatus : undefined,
-      rawResponse: response as Record<string, unknown>,
-    };
-  }
-
-  mapTradeStatus(tradeStatus: string | undefined): PaymentIntentStatus {
-    switch (tradeStatus) {
-      case 'PAY_SUCCESS':
-        return PaymentIntentStatus.SUCCEEDED;
-      case 'PAY_FAILED':
-      case 'ORDER_CLOSED':
-        return PaymentIntentStatus.FAILED;
-      case 'WAIT_PAY':
-        return PaymentIntentStatus.REQUIRES_ACTION;
-      case 'PAYING':
-        return PaymentIntentStatus.PROCESSING;
-      default:
-        return PaymentIntentStatus.PROCESSING;
-    }
-  }
-
-  mapWebhookTradeStatus(tradeStatus: string | undefined): PaymentIntentStatus {
-    switch (tradeStatus) {
-      case 'Completed':
-        return PaymentIntentStatus.SUCCEEDED;
-      case 'Failure':
-      case 'Expired':
-        return PaymentIntentStatus.FAILED;
-      case 'Paying':
-      case 'Pending':
-        return PaymentIntentStatus.PROCESSING;
-      default:
-        return PaymentIntentStatus.PROCESSING;
-    }
-  }
-
-  verifyWebhookSignature(payload: Record<string, unknown>): boolean {
-    if (!this.publicKey) {
-      this.logger.error('TELEBIRR_PUBLIC_KEY not configured; rejecting all webhooks');
-      return false;
-    }
-    return verifyRequestObject(payload, this.publicKey);
-  }
-
-  private async applyFabricToken(): Promise<string> {
-    const response = await this.postJson<FabricTokenResponse>(
-      `${this.baseUrl}/payment/v1/token`,
-      { appSecret: this.appSecret },
-      {
-        'Content-Type': 'application/json',
-        'X-APP-Key': this.fabricAppId,
-      },
-    );
-    if (!response?.token) {
-      throw new Error(`Telebirr token request failed: ${JSON.stringify(response)}`);
-    }
-    return response.token;
-  }
-
-  private async requestCreateOrder(
-    fabricToken: string,
-    body: CreateOrderRequest,
-  ): Promise<CreateOrderResponse> {
-    return this.postJson<CreateOrderResponse>(
-      `${this.baseUrl}/payment/v1/inapp/createOrder`,
-      body,
-      {
-        'Content-Type': 'application/json',
-        'X-APP-Key': this.fabricAppId,
-        Authorization: fabricToken,
-      },
-    );
-  }
-
-  private buildCreateOrderRequest(input: ProviderInitiationInput): CreateOrderRequest {
-    const totalAmount = String(input.amountMinor / 100);
-    const req = {
-      timestamp: createTimestamp(),
-      nonce_str: createNonceStr(),
-      method: 'payment.preorder' as const,
-      version: '1.0' as const,
-      biz_content: {
-        notify_url: this.notifyUrl,
-        appid: this.merchantAppId,
-        merch_code: this.merchantCode,
-        merch_order_id: input.merchantOrderId,
-        trade_type: 'Checkout' as const,
-        title: `EDR Booking`,
-        total_amount: totalAmount,
-        trans_currency: input.currency,
-        timeout_express: this.timeoutExpress,
-      },
-    };
-    const sign = signRequestObject(req as unknown as Record<string, unknown>, this.privateKey);
-    return { ...req, sign, sign_type: 'SHA256WithRSA' };
-  }
-
-  private buildQueryOrderRequest(merchantOrderId: string): Record<string, unknown> {
-    const req = {
-      timestamp: createTimestamp(),
-      nonce_str: createNonceStr(),
-      method: 'payment.queryorder',
-      version: '1.0',
-      biz_content: {
-        appid: this.merchantAppId,
-        merch_code: this.merchantCode,
-        merch_order_id: merchantOrderId,
-      },
-    };
-    const sign = signRequestObject(req as Record<string, unknown>, this.privateKey);
-    return { ...req, sign, sign_type: 'SHA256WithRSA' };
-  }
-
-  private buildCheckoutUrl(prepayId: string): string {
-    const map: Record<string, string> = {
-      appid: this.merchantAppId,
-      merch_code: this.merchantCode,
-      nonce_str: createNonceStr(),
-      prepay_id: prepayId,
-      timestamp: createTimestamp(),
-    };
-    const sign = signRequestObject(map, this.privateKey);
-    const rawRequest = [
-      `appid=${map.appid}`,
-      `merch_code=${map.merch_code}`,
-      `nonce_str=${map.nonce_str}`,
-      `prepay_id=${map.prepay_id}`,
-      `timestamp=${map.timestamp}`,
-      'sign_type=SHA256WithRSA',
-      `sign=${sign}`,
-      'version=1.0',
-      'trade_type=Checkout',
-    ].join('&');
-    return `${this.webBaseUrl}${rawRequest}`;
-  }
-
-  private computeExpiresAt(timeoutExpress: string): Date {
-    const match = /^(\d+)([smhd])$/.exec(timeoutExpress);
-    const minutes = match ? this.toMinutes(parseInt(match[1], 10), match[2]) : 15;
-    return new Date(Date.now() + minutes * 60_000);
-  }
-
-  private toMinutes(n: number, unit: string): number {
-    switch (unit) {
-      case 's': return Math.max(1, Math.round(n / 60));
-      case 'm': return n;
-      case 'h': return n * 60;
-      case 'd': return n * 60 * 24;
-      default: return 15;
-    }
-  }
-
-  private async postJson<T>(
-    url: string,
-    body: unknown,
-    headers: Record<string, string>,
-  ): Promise<T> {
-    const config: AxiosRequestConfig = {
-      headers,
-      timeout: TELEBIRR_HTTP_TIMEOUT_MS,
-      httpsAgent: this.httpsAgent,
-    };
-    const started = Date.now();
-    try {
-      const res = await firstValueFrom(this.http.post<T>(url, body, config));
-      this.logger.debug(`Telebirr POST ${url} status=${res.status} latency=${Date.now() - started}ms`);
-      return res.data;
-    } catch (err) {
-      if (err instanceof AxiosError) {
-        this.logger.error(
-          `Telebirr POST ${url} failed: status=${err.response?.status} body=${JSON.stringify(err.response?.data)} code=${err.code} message=${err.message}`,
-        );
-      } else {
-        this.logger.error(`Telebirr POST ${url} threw: ${err instanceof Error ? err.message : err}`);
-      }
-      throw err;
-    }
-  }
-
-  private sanitize(body: CreateOrderRequest): Record<string, unknown> {
-    const { sign: _sign, ...rest } = body;
-    return rest;
-  }
-
-  private get baseUrl(): string { return this.config.get<string>('telebirr.baseUrl') ?? ''; }
-  private get webBaseUrl(): string { return this.config.get<string>('telebirr.webBaseUrl') ?? ''; }
-  private get fabricAppId(): string { return this.config.get<string>('telebirr.fabricAppId') ?? ''; }
-  private get appSecret(): string { return this.config.get<string>('telebirr.appSecret') ?? ''; }
-  private get merchantAppId(): string { return this.config.get<string>('telebirr.merchantAppId') ?? ''; }
-  private get merchantCode(): string { return this.config.get<string>('telebirr.merchantCode') ?? ''; }
-  private get notifyUrl(): string { return this.config.get<string>('telebirr.notifyUrl') ?? ''; }
-  private get timeoutExpress(): string { return this.config.get<string>('telebirr.timeoutExpress') ?? '15m'; }
-  private get privateKey(): string { return this.config.get<string>('telebirr.privateKey') ?? ''; }
-  private get publicKey(): string { return this.config.get<string>('telebirr.publicKey') ?? ''; }
-}

apps/edr-passenger-api/src/modules/payments/providers/telebirr.types.ts

@@ -1,69 +0,0 @@
-export interface FabricTokenResponse {
-  token: string;
-  expires_in?: number | string;
-}
-
-export interface CreateOrderBizContent {
-  notify_url: string;
-  appid: string;
-  merch_code: string;
-  merch_order_id: string;
-  trade_type: 'Checkout' | 'InApp' | 'MiniApp';
-  title: string;
-  total_amount: string;
-  trans_currency: string;
-  timeout_express: string;
-}
-
-export interface CreateOrderRequest {
-  timestamp: string;
-  nonce_str: string;
-  method: 'payment.preorder';
-  version: '1.0';
-  biz_content: CreateOrderBizContent;
-  sign: string;
-  sign_type: 'SHA256WithRSA';
-}
-
-export interface CreateOrderResponse {
-  code?: string;
-  msg?: string;
-  biz_content?: {
-    prepay_id?: string;
-    receiveCode?: string;
-    [key: string]: unknown;
-  };
-  [key: string]: unknown;
-}
-
-export type TelebirrTradeStatus =
-  | 'PAY_SUCCESS'
-  | 'PAY_FAILED'
-  | 'WAIT_PAY'
-  | 'ORDER_CLOSED'
-  | 'PAYING'
-  | 'ACCEPTED'
-  | 'REFUNDING'
-  | 'REFUND_SUCCESS'
-  | 'REFUND_FAILED';
-
-export interface QueryOrderResponse {
-  result?: 'SUCCESS' | 'FAIL';
-  code?: string;
-  msg?: string;
-  nonce_str?: string;
-  sign?: string;
-  sign_type?: string;
-  biz_content?: {
-    merch_order_id?: string;
-    order_status?: string;
-    trade_status?: TelebirrTradeStatus | string;
-    payment_order_id?: string;
-    trans_id?: string;
-    trans_time?: string;
-    trans_currency?: string;
-    total_amount?: string;
-    [key: string]: unknown;
-  };
-  [key: string]: unknown;
-}

apps/edr-passenger-api/src/modules/payments/providers/waafi.provider.ts

@@ -1,274 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { HttpService } from '@nestjs/axios';
-import { PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-import { AxiosError, AxiosRequestConfig } from 'axios';
-import { firstValueFrom } from 'rxjs';
-import {
-  PaymentProvider,
-  ProviderInitiationInput,
-  ProviderInitiationResult,
-  ProviderStatus,
-} from '../payments.types';
-
-const WAAFI_HTTP_TIMEOUT_MS = 10_000;
-
-interface WaafiInitiateRequest {
-  schemaVersion: string;
-  requestId: string;
-  timestamp: string;
-  channelName: string;
-  serviceName: string;
-  serviceParams: {
-    merchantUid: string;
-    apiUserId: string;
-    apiKey: string;
-    paymentMethod: string;
-    payerInfo: {
-      accountNo: string;
-    };
-    transactionInfo: {
-      referenceId: string;
-      invoiceId: string;
-      amount: number;
-      currency: string;
-      description: string;
-    };
-  };
-}
-
-interface WaafiInitiateResponse {
-  responseCode: string;
-  responseMsg: string;
-  params?: {
-    state: string;
-    referenceId: string;
-    transactionId: string;
-    checkoutUrl?: string;
-  };
-}
-
-interface WaafiQueryRequest {
-  schemaVersion: string;
-  requestId: string;
-  timestamp: string;
-  channelName: string;
-  serviceName: string;
-  serviceParams: {
-    merchantUid: string;
-    apiUserId: string;
-    apiKey: string;
-    transactionId?: string;
-    referenceId?: string;
-  };
-}
-
-interface WaafiQueryResponse {
-  responseCode: string;
-  responseMsg: string;
-  params?: {
-    state: string;
-    referenceId: string;
-    transactionId: string;
-    amount: number;
-    currency: string;
-    paidAmount?: number;
-  };
-}
-
-@Injectable()
-export class WaafiProvider implements PaymentProvider {
-  readonly method = PaymentMethodType.WAAFI;
-  private readonly logger = new Logger(WaafiProvider.name);
-
-  constructor(
-    private readonly config: ConfigService,
-    private readonly http: HttpService,
-  ) {}
-
-  async initiate(input: ProviderInitiationInput): Promise<ProviderInitiationResult> {
-    const requestBody = this.buildInitiateRequest(input);
-    const response = await this.postJson<WaafiInitiateResponse>(
-      `${this.baseUrl}/asm`,
-      requestBody,
-    );
-
-    if (response.responseCode !== '2001') {
-      throw new Error(
-        `Waafi initiate failed: ${response.responseCode} - ${response.responseMsg}`,
-      );
-    }
-
-    const transactionId = response.params?.transactionId;
-    const checkoutUrl = response.params?.checkoutUrl || `${this.baseUrl}/checkout?ref=${transactionId}`;
-
-    if (!transactionId) {
-      throw new Error(`Waafi returned no transactionId: ${JSON.stringify(response)}`);
-    }
-
-    const expiresAt = new Date(Date.now() + 15 * 60_000); // 15 minutes
-
-    return {
-      providerOrderId: transactionId,
-      clientAction: { type: 'REDIRECT', url: checkoutUrl },
-      expiresAt,
-      rawInitiation: {
-        request: this.sanitize(requestBody),
-        response,
-      },
-    };
-  }
-
-  async queryStatus(merchantOrderId: string): Promise<ProviderStatus> {
-    const requestBody = this.buildQueryRequest(merchantOrderId);
-    const response = await this.postJson<WaafiQueryResponse>(
-      `${this.baseUrl}/asm`,
-      requestBody,
-    );
-
-    const state = response.params?.state;
-    const transactionId = response.params?.transactionId;
-    const mapped = this.mapState(state);
-
-    return {
-      status: mapped,
-      providerTxnId: transactionId,
-      failureCode: mapped === PaymentIntentStatus.FAILED && state ? state : undefined,
-      rawResponse: response as unknown as Record<string, unknown>,
-    };
-  }
-
-  mapState(state: string | undefined): PaymentIntentStatus {
-    switch (state) {
-      case 'APPROVED':
-      case 'SUCCESS':
-        return PaymentIntentStatus.SUCCEEDED;
-      case 'FAILED':
-      case 'DECLINED':
-      case 'CANCELLED':
-      case 'EXPIRED':
-        return PaymentIntentStatus.FAILED;
-      case 'PENDING':
-      case 'INITIATED':
-        return PaymentIntentStatus.REQUIRES_ACTION;
-      case 'PROCESSING':
-        return PaymentIntentStatus.PROCESSING;
-      default:
-        return PaymentIntentStatus.PROCESSING;
-    }
-  }
-
-  verifyWebhookSignature(payload: Record<string, unknown>): boolean {
-    // Waafi webhook signature verification
-    // Implementation depends on Waafi's webhook signature mechanism
-    const signature = payload.signature as string;
-    const apiKey = this.apiKey;
-
-    if (!signature || !apiKey) {
-      this.logger.error('Waafi webhook missing signature or API key not configured');
-      return false;
-    }
-
-    // TODO: Implement actual signature verification based on Waafi documentation
-    // For now, basic validation
-    return signature.length > 0;
-  }
-
-  private buildInitiateRequest(input: ProviderInitiationInput): WaafiInitiateRequest {
-    const amount = input.amountMinor / 100; // Convert minor units to major
-
-    return {
-      schemaVersion: '1.0',
-      requestId: this.generateRequestId(),
-      timestamp: new Date().toISOString(),
-      channelName: 'WEB',
-      serviceName: 'API_PURCHASE',
-      serviceParams: {
-        merchantUid: this.merchantUid,
-        apiUserId: this.apiUserId,
-        apiKey: this.apiKey,
-        paymentMethod: 'MWALLET_ACCOUNT',
-        payerInfo: {
-          accountNo: 'CUSTOMER', // Customer enters their number on Waafi page
-        },
-        transactionInfo: {
-          referenceId: input.merchantOrderId,
-          invoiceId: input.bookingRef,
-          amount,
-          currency: input.currency === 'ETB' ? 'DJF' : input.currency, // Convert ETB to DJF
-          description: `EDR Train Booking ${input.bookingRef}`,
-        },
-      },
-    };
-  }
-
-  private buildQueryRequest(merchantOrderId: string): WaafiQueryRequest {
-    return {
-      schemaVersion: '1.0',
-      requestId: this.generateRequestId(),
-      timestamp: new Date().toISOString(),
-      channelName: 'WEB',
-      serviceName: 'API_QUERY',
-      serviceParams: {
-        merchantUid: this.merchantUid,
-        apiUserId: this.apiUserId,
-        apiKey: this.apiKey,
-        referenceId: merchantOrderId,
-      },
-    };
-  }
-
-  private generateRequestId(): string {
-    return `EDR-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-  }
-
-  private async postJson<T>(url: string, body: unknown): Promise<T> {
-    const config: AxiosRequestConfig = {
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      timeout: WAAFI_HTTP_TIMEOUT_MS,
-    };
-
-    const started = Date.now();
-    try {
-      const res = await firstValueFrom(this.http.post<T>(url, body, config));
-      this.logger.debug(
-        `Waafi POST ${url} status=${res.status} latency=${Date.now() - started}ms`,
-      );
-      return res.data;
-    } catch (err) {
-      if (err instanceof AxiosError) {
-        this.logger.error(
-          `Waafi POST ${url} failed: status=${err.response?.status} body=${JSON.stringify(err.response?.data)} code=${err.code} message=${err.message}`,
-        );
-      } else {
-        this.logger.error(
-          `Waafi POST ${url} threw: ${err instanceof Error ? err.message : err}`,
-        );
-      }
-      throw err;
-    }
-  }
-
-  private sanitize(body: WaafiInitiateRequest): Record<string, unknown> {
-    const sanitized = { ...body };
-    if (sanitized.serviceParams?.apiKey) {
-      sanitized.serviceParams.apiKey = '***REDACTED***';
-    }
-    return sanitized as unknown as Record<string, unknown>;
-  }
-
-  private get baseUrl(): string {
-    return this.config.get<string>('waafi.baseUrl') ?? 'https://api.waafipay.net';
-  }
-  private get merchantUid(): string {
-    return this.config.get<string>('waafi.merchantUid') ?? '';
-  }
-  private get apiUserId(): string {
-    return this.config.get<string>('waafi.apiUserId') ?? '';
-  }
-  private get apiKey(): string {
-    return this.config.get<string>('waafi.apiKey') ?? '';
-  }
-}

apps/edr-passenger-api/src/modules/payments/webhooks/card-webhook.service.ts

@@ -1,147 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { Prisma, PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-import { PrismaService } from '../../../common/prisma.service';
-import { PaymentsService } from '../payments.service';
-import { CardProvider } from '../providers/card.provider';
-
-export interface CardWebhookPayload {
-  id: string;
-  type: string;
-  data: {
-    object: {
-      id: string;
-      status: string;
-      amount: number;
-      currency: string;
-      metadata: {
-        merchantOrderId: string;
-        bookingRef: string;
-      };
-      transaction_id?: string;
-      paid_at?: number;
-      failure_code?: string;
-      failure_message?: string;
-    };
-  };
-  created: number;
-}
-
-@Injectable()
-export class CardWebhookService {
-  private readonly logger = new Logger(CardWebhookService.name);
-
-  constructor(
-    private readonly prisma: PrismaService,
-    private readonly provider: CardProvider,
-    private readonly payments: PaymentsService,
-  ) {}
-
-  async handle(payload: CardWebhookPayload, signature: string): Promise<void> {
-    const merchantOrderId = payload.data.object.metadata.merchantOrderId;
-    const externalEventId = `${payload.id}_${payload.type}`;
-    const signatureValid = this.provider.verifyWebhookSignature(
-      payload as unknown as Record<string, unknown>,
-      signature,
-    );
-
-    const eventRow = await this.persistEvent({
-      externalEventId,
-      merchantOrderId,
-      providerTxnId: payload.data.object.transaction_id,
-      signatureValid,
-      status: payload.data.object.status,
-      payload,
-    });
-
-    if (!eventRow) {
-      this.logger.log(`Card webhook duplicate: ${externalEventId} — short-circuit OK`);
-      return;
-    }
-
-    if (!signatureValid) {
-      this.logger.warn(`Card webhook signature invalid for merchantOrderId=${merchantOrderId}`);
-      await this.markProcessed(eventRow.id, 'signature-invalid');
-      return;
-    }
-
-    const intent = await this.prisma.paymentIntent.findUnique({
-      where: { merchantOrderId },
-    });
-    if (!intent) {
-      this.logger.warn(`Card webhook: no PaymentIntent for merchantOrderId=${merchantOrderId}`);
-      await this.markProcessed(eventRow.id, 'intent-not-found');
-      return;
-    }
-
-    const mapped = this.provider.mapWebhookStatus(payload.data.object.status);
-
-    try {
-      if (mapped === PaymentIntentStatus.SUCCEEDED) {
-        await this.payments.finalizePaymentSuccess({
-          intentId: intent.id,
-          providerTxnId: payload.data.object.transaction_id,
-          paidAt: payload.data.object.paid_at ? new Date(payload.data.object.paid_at * 1000) : undefined,
-        });
-      } else if (mapped === PaymentIntentStatus.FAILED) {
-        await this.payments.markPaymentFailed({
-          intentId: intent.id,
-          failureCode: payload.data.object.failure_code,
-          failureMessage: payload.data.object.failure_message,
-        });
-      } else {
-        await this.prisma.paymentIntent.update({
-          where: { id: intent.id },
-          data: {
-            status: mapped,
-            providerTxnId: payload.data.object.transaction_id ?? undefined,
-          },
-        });
-      }
-      await this.markProcessed(eventRow.id);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.logger.error(`Card webhook processing failed for ${merchantOrderId}: ${message}`);
-      await this.markProcessed(eventRow.id, `processing-error: ${message}`);
-      throw err;
-    }
-  }
-
-  private async persistEvent(input: {
-    externalEventId: string;
-    merchantOrderId: string;
-    providerTxnId?: string;
-    signatureValid: boolean;
-    status: string;
-    payload: CardWebhookPayload;
-  }): Promise<{ id: string } | null> {
-    try {
-      return await this.prisma.paymentWebhookEvent.create({
-        data: {
-          provider: PaymentMethodType.CARD,
-          externalEventId: input.externalEventId,
-          merchantOrderId: input.merchantOrderId,
-          providerTxnId: input.providerTxnId,
-          signatureValid: input.signatureValid,
-          status: input.status,
-          payload: input.payload as unknown as Prisma.InputJsonValue,
-        },
-        select: { id: true },
-      });
-    } catch (err) {
-      if (
-        err instanceof Prisma.PrismaClientKnownRequestError &&
-        err.code === 'P2002'
-      ) {
-        return null;
-      }
-      throw err;
-    }
-  }
-
-  private async markProcessed(eventId: string, processingError?: string): Promise<void> {
-    await this.prisma.paymentWebhookEvent.update({
-      where: { id: eventId },
-      data: { processedAt: new Date(), processingError },
-    });
-  }
-}

apps/edr-passenger-api/src/modules/payments/webhooks/cbe-birr-webhook.service.ts

@@ -1,133 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { Prisma, PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-import { PrismaService } from '../../../common/prisma.service';
-import { PaymentsService } from '../payments.service';
-import { CbeBirrProvider } from '../providers/cbe-birr.provider';
-
-export interface CbeBirrWebhookPayload {
-  merchantId: string;
-  merchantOrderId: string;
-  orderId: string;
-  status: string;
-  transactionId?: string;
-  amount?: string;
-  currency?: string;
-  paidAt?: string;
-  signature: string;
-  [key: string]: unknown;
-}
-
-@Injectable()
-export class CbeBirrWebhookService {
-  private readonly logger = new Logger(CbeBirrWebhookService.name);
-
-  constructor(
-    private readonly prisma: PrismaService,
-    private readonly provider: CbeBirrProvider,
-    private readonly payments: PaymentsService,
-  ) {}
-
-  async handle(payload: CbeBirrWebhookPayload): Promise<void> {
-    const merchantOrderId = payload.merchantOrderId;
-    const externalEventId = `${payload.orderId}_${payload.status}`;
-    const signatureValid = this.provider.verifyWebhookSignature(
-      payload as unknown as Record<string, unknown>,
-    );
-
-    const eventRow = await this.persistEvent({
-      externalEventId,
-      merchantOrderId,
-      providerTxnId: payload.transactionId ?? payload.orderId,
-      signatureValid,
-      status: payload.status,
-      payload,
-    });
-
-    if (!eventRow) {
-      this.logger.log(`CBE Birr webhook duplicate: ${externalEventId} — short-circuit OK`);
-      return;
-    }
-
-    if (!signatureValid) {
-      this.logger.warn(`CBE Birr webhook signature invalid for merchantOrderId=${merchantOrderId}`);
-      await this.markProcessed(eventRow.id, 'signature-invalid');
-      return;
-    }
-
-    const intent = await this.prisma.paymentIntent.findUnique({
-      where: { merchantOrderId },
-    });
-    if (!intent) {
-      this.logger.warn(`CBE Birr webhook: no PaymentIntent for merchantOrderId=${merchantOrderId}`);
-      await this.markProcessed(eventRow.id, 'intent-not-found');
-      return;
-    }
-
-    const mapped = this.provider.mapWebhookStatus(payload.status);
-
-    try {
-      if (mapped === PaymentIntentStatus.SUCCEEDED) {
-        await this.payments.finalizePaymentSuccess({
-          intentId: intent.id,
-          providerTxnId: payload.transactionId ?? payload.orderId,
-          paidAt: payload.paidAt ? new Date(payload.paidAt) : undefined,
-        });
-      } else if (mapped === PaymentIntentStatus.FAILED) {
-        await this.payments.markPaymentFailed({
-          intentId: intent.id,
-          failureCode: payload.status,
-        });
-      } else {
-        await this.prisma.paymentIntent.update({
-          where: { id: intent.id },
-          data: { status: mapped, providerTxnId: payload.transactionId ?? undefined },
-        });
-      }
-      await this.markProcessed(eventRow.id);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.logger.error(`CBE Birr webhook processing failed for ${merchantOrderId}: ${message}`);
-      await this.markProcessed(eventRow.id, `processing-error: ${message}`);
-      throw err;
-    }
-  }
-
-  private async persistEvent(input: {
-    externalEventId: string;
-    merchantOrderId: string;
-    providerTxnId?: string;
-    signatureValid: boolean;
-    status: string;
-    payload: CbeBirrWebhookPayload;
-  }): Promise<{ id: string } | null> {
-    try {
-      return await this.prisma.paymentWebhookEvent.create({
-        data: {
-          provider: PaymentMethodType.CBE_BIRR,
-          externalEventId: input.externalEventId,
-          merchantOrderId: input.merchantOrderId,
-          providerTxnId: input.providerTxnId,
-          signatureValid: input.signatureValid,
-          status: input.status,
-          payload: input.payload as unknown as Prisma.InputJsonValue,
-        },
-        select: { id: true },
-      });
-    } catch (err) {
-      if (
-        err instanceof Prisma.PrismaClientKnownRequestError &&
-        err.code === 'P2002'
-      ) {
-        return null;
-      }
-      throw err;
-    }
-  }
-
-  private async markProcessed(eventId: string, processingError?: string): Promise<void> {
-    await this.prisma.paymentWebhookEvent.update({
-      where: { id: eventId },
-      data: { processedAt: new Date(), processingError },
-    });
-  }
-}

apps/edr-passenger-api/src/modules/payments/webhooks/ebirr-webhook.service.ts

@@ -1,133 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { Prisma, PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-import { PrismaService } from '../../../common/prisma.service';
-import { PaymentsService } from '../payments.service';
-import { EBirrProvider } from '../providers/ebirr.provider';
-
-export interface EBirrWebhookPayload {
-  merchantCode: string;
-  orderNo: string;
-  tradeStatus: string;
-  tradeNo?: string;
-  totalAmount?: number;
-  currency?: string;
-  payTime?: number;
-  timestamp: number;
-  sign: string;
-  [key: string]: unknown;
-}
-
-@Injectable()
-export class EBirrWebhookService {
-  private readonly logger = new Logger(EBirrWebhookService.name);
-
-  constructor(
-    private readonly prisma: PrismaService,
-    private readonly provider: EBirrProvider,
-    private readonly payments: PaymentsService,
-  ) {}
-
-  async handle(payload: EBirrWebhookPayload): Promise<void> {
-    const merchantOrderId = payload.orderNo;
-    const externalEventId = `${payload.orderNo}_${payload.tradeStatus}_${payload.timestamp}`;
-    const signatureValid = this.provider.verifyWebhookSignature(
-      payload as unknown as Record<string, unknown>,
-    );
-
-    const eventRow = await this.persistEvent({
-      externalEventId,
-      merchantOrderId,
-      providerTxnId: payload.tradeNo,
-      signatureValid,
-      status: payload.tradeStatus,
-      payload,
-    });
-
-    if (!eventRow) {
-      this.logger.log(`eBirr webhook duplicate: ${externalEventId} — short-circuit OK`);
-      return;
-    }
-
-    if (!signatureValid) {
-      this.logger.warn(`eBirr webhook signature invalid for orderNo=${merchantOrderId}`);
-      await this.markProcessed(eventRow.id, 'signature-invalid');
-      return;
-    }
-
-    const intent = await this.prisma.paymentIntent.findUnique({
-      where: { merchantOrderId },
-    });
-    if (!intent) {
-      this.logger.warn(`eBirr webhook: no PaymentIntent for orderNo=${merchantOrderId}`);
-      await this.markProcessed(eventRow.id, 'intent-not-found');
-      return;
-    }
-
-    const mapped = this.provider.mapWebhookStatus(payload.tradeStatus);
-
-    try {
-      if (mapped === PaymentIntentStatus.SUCCEEDED) {
-        await this.payments.finalizePaymentSuccess({
-          intentId: intent.id,
-          providerTxnId: payload.tradeNo,
-          paidAt: payload.payTime ? new Date(payload.payTime) : undefined,
-        });
-      } else if (mapped === PaymentIntentStatus.FAILED) {
-        await this.payments.markPaymentFailed({
-          intentId: intent.id,
-          failureCode: payload.tradeStatus,
-        });
-      } else {
-        await this.prisma.paymentIntent.update({
-          where: { id: intent.id },
-          data: { status: mapped, providerTxnId: payload.tradeNo ?? undefined },
-        });
-      }
-      await this.markProcessed(eventRow.id);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.logger.error(`eBirr webhook processing failed for ${merchantOrderId}: ${message}`);
-      await this.markProcessed(eventRow.id, `processing-error: ${message}`);
-      throw err;
-    }
-  }
-
-  private async persistEvent(input: {
-    externalEventId: string;
-    merchantOrderId: string;
-    providerTxnId?: string;
-    signatureValid: boolean;
-    status: string;
-    payload: EBirrWebhookPayload;
-  }): Promise<{ id: string } | null> {
-    try {
-      return await this.prisma.paymentWebhookEvent.create({
-        data: {
-          provider: PaymentMethodType.EBIRR,
-          externalEventId: input.externalEventId,
-          merchantOrderId: input.merchantOrderId,
-          providerTxnId: input.providerTxnId,
-          signatureValid: input.signatureValid,
-          status: input.status,
-          payload: input.payload as unknown as Prisma.InputJsonValue,
-        },
-        select: { id: true },
-      });
-    } catch (err) {
-      if (
-        err instanceof Prisma.PrismaClientKnownRequestError &&
-        err.code === 'P2002'
-      ) {
-        return null;
-      }
-      throw err;
-    }
-  }
-
-  private async markProcessed(eventId: string, processingError?: string): Promise<void> {
-    await this.prisma.paymentWebhookEvent.update({
-      where: { id: eventId },
-      data: { processedAt: new Date(), processingError },
-    });
-  }
-}

apps/edr-passenger-api/src/modules/payments/webhooks/telebirr-webhook.service.ts

@@ -1,153 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { Prisma, PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-import { PrismaService } from '../../../common/prisma.service';
-import { PaymentsService } from '../payments.service';
-import { TelebirrProvider } from '../providers/telebirr.provider';
-
-export interface TelebirrWebhookPayload {
-  merch_order_id: string;
-  payment_order_id: string;
-  trade_status: string;
-  trans_id?: string;
-  total_amount?: string;
-  trans_currency?: string;
-  notify_time?: string;
-  trans_end_time?: string;
-  sign: string;
-  sign_type?: string;
-  [key: string]: unknown;
-}
-
-@Injectable()
-export class TelebirrWebhookService {
-  private readonly logger = new Logger(TelebirrWebhookService.name);
-
-  constructor(
-    private readonly prisma: PrismaService,
-    private readonly provider: TelebirrProvider,
-    private readonly payments: PaymentsService,
-  ) {}
-
-  async handle(payload: TelebirrWebhookPayload): Promise<void> {
-    const merchantOrderId = payload.merch_order_id;
-    const externalEventId = this.buildExternalEventId(payload);
-    const signatureValid = this.provider.verifyWebhookSignature(
-      payload as unknown as Record<string, unknown>,
-    );
-
-    const eventRow = await this.persistEvent({
-      externalEventId,
-      merchantOrderId,
-      providerTxnId: payload.trans_id ?? payload.payment_order_id,
-      signatureValid,
-      status: payload.trade_status,
-      payload,
-    });
-
-    if (!eventRow) {
-      this.logger.log(
-        `Telebirr webhook duplicate: ${externalEventId} — short-circuit OK`,
-      );
-      return;
-    }
-
-    if (!signatureValid) {
-      this.logger.warn(
-        `Telebirr webhook signature invalid for merch_order_id=${merchantOrderId}`,
-      );
-      await this.markProcessed(eventRow.id, 'signature-invalid');
-      return;
-    }
-
-    const intent = await this.prisma.paymentIntent.findUnique({
-      where: { merchantOrderId },
-    });
-    if (!intent) {
-      this.logger.warn(
-        `Telebirr webhook: no PaymentIntent for merch_order_id=${merchantOrderId}`,
-      );
-      await this.markProcessed(eventRow.id, 'intent-not-found');
-      return;
-    }
-
-    const mapped = this.provider.mapWebhookTradeStatus(payload.trade_status);
-
-    try {
-      if (mapped === PaymentIntentStatus.SUCCEEDED) {
-        await this.payments.finalizePaymentSuccess({
-          intentId: intent.id,
-          providerTxnId: payload.trans_id ?? payload.payment_order_id,
-          paidAt: this.parseEpochSeconds(payload.trans_end_time),
-        });
-      } else if (mapped === PaymentIntentStatus.FAILED) {
-        await this.payments.markPaymentFailed({
-          intentId: intent.id,
-          failureCode: payload.trade_status,
-        });
-      } else {
-        await this.prisma.paymentIntent.update({
-          where: { id: intent.id },
-          data: { status: mapped, providerTxnId: payload.trans_id ?? undefined },
-        });
-      }
-      await this.markProcessed(eventRow.id);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.logger.error(
-        `Telebirr webhook processing failed for ${merchantOrderId}: ${message}`,
-      );
-      await this.markProcessed(eventRow.id, `processing-error: ${message}`);
-      throw err;
-    }
-  }
-
-  private buildExternalEventId(payload: TelebirrWebhookPayload): string {
-    return `${payload.payment_order_id}_${payload.trade_status}`;
-  }
-
-  private async persistEvent(input: {
-    externalEventId: string;
-    merchantOrderId: string;
-    providerTxnId?: string;
-    signatureValid: boolean;
-    status: string;
-    payload: TelebirrWebhookPayload;
-  }): Promise<{ id: string } | null> {
-    try {
-      return await this.prisma.paymentWebhookEvent.create({
-        data: {
-          provider: PaymentMethodType.TELEBIRR,
-          externalEventId: input.externalEventId,
-          merchantOrderId: input.merchantOrderId,
-          providerTxnId: input.providerTxnId,
-          signatureValid: input.signatureValid,
-          status: input.status,
-          payload: input.payload as unknown as Prisma.InputJsonValue,
-        },
-        select: { id: true },
-      });
-    } catch (err) {
-      if (
-        err instanceof Prisma.PrismaClientKnownRequestError &&
-        err.code === 'P2002'
-      ) {
-        return null;
-      }
-      throw err;
-    }
-  }
-
-  private async markProcessed(eventId: string, processingError?: string): Promise<void> {
-    await this.prisma.paymentWebhookEvent.update({
-      where: { id: eventId },
-      data: { processedAt: new Date(), processingError },
-    });
-  }
-
-  private parseEpochSeconds(raw: string | undefined): Date | undefined {
-    if (!raw) return undefined;
-    const n = parseInt(raw, 10);
-    if (Number.isNaN(n)) return undefined;
-    return new Date(n * 1000);
-  }
-}

apps/edr-passenger-api/src/modules/payments/webhooks/waafi-webhook.service.ts

@@ -1,105 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { PrismaService } from '../../../common/prisma.service';
-import { PaymentsService } from '../payments.service';
-import { WaafiProvider } from '../providers/waafi.provider';
-import { PaymentIntentStatus, PaymentMethodType } from '@prisma/client';
-
-interface WaafiWebhookPayload {
-  schemaVersion: string;
-  requestId: string;
-  timestamp: string;
-  eventType: string;
-  params: {
-    state: string;
-    referenceId: string;
-    transactionId: string;
-    amount: number;
-    currency: string;
-    description?: string;
-  };
-  signature?: string;
-}
-
-@Injectable()
-export class WaafiWebhookService {
-  private readonly logger = new Logger(WaafiWebhookService.name);
-
-  constructor(
-    private prisma: PrismaService,
-    private paymentsService: PaymentsService,
-    private waafiProvider: WaafiProvider,
-  ) {}
-
-  async handleWebhook(payload: WaafiWebhookPayload): Promise<{ received: boolean }> {
-    this.logger.log(
-      `Waafi webhook received: event=${payload.eventType} ref=${payload.params?.referenceId}`,
-    );
-
-    const signatureValid = this.waafiProvider.verifyWebhookSignature(
-      payload as unknown as Record<string, unknown>,
-    );
-
-    const merchantOrderId = payload.params?.referenceId;
-    const transactionId = payload.params?.transactionId;
-    const state = payload.params?.state;
-
-    await this.prisma.paymentWebhookEvent.create({
-      data: {
-        provider: PaymentMethodType.WAAFI,
-        externalEventId: payload.requestId,
-        merchantOrderId,
-        providerTxnId: transactionId,
-        signatureValid,
-        status: state || 'UNKNOWN',
-        payload: payload as any,
-      },
-    });
-
-    if (!signatureValid) {
-      this.logger.warn(`Waafi webhook signature invalid for ref=${merchantOrderId}`);
-      return { received: true };
-    }
-
-    if (!merchantOrderId) {
-      this.logger.error('Waafi webhook missing referenceId');
-      return { received: true };
-    }
-
-    const intent = await this.prisma.paymentIntent.findFirst({
-      where: { merchantOrderId },
-    });
-
-    if (!intent) {
-      this.logger.warn(`No PaymentIntent found for merchantOrderId=${merchantOrderId}`);
-      return { received: true };
-    }
-
-    const mappedStatus = this.waafiProvider.mapState(state);
-
-    if (mappedStatus === PaymentIntentStatus.SUCCEEDED) {
-      await this.paymentsService.finalizePaymentSuccess({
-        intentId: intent.id,
-        providerTxnId: transactionId,
-      });
-      this.logger.log(`Waafi payment succeeded: intent=${intent.id} txn=${transactionId}`);
-    } else if (mappedStatus === PaymentIntentStatus.FAILED) {
-      await this.paymentsService.markPaymentFailed({
-        intentId: intent.id,
-        failureCode: state,
-        failureMessage: payload.params?.description,
-      });
-      this.logger.log(`Waafi payment failed: intent=${intent.id} state=${state}`);
-    } else {
-      await this.prisma.paymentIntent.update({
-        where: { id: intent.id },
-        data: {
-          status: mappedStatus,
-          providerTxnId: transactionId,
-        },
-      });
-      this.logger.log(`Waafi payment status updated: intent=${intent.id} status=${mappedStatus}`);
-    }
-
-    return { received: true };
-  }
-}

apps/edr-passenger-api/src/modules/payments/webhooks/webhooks.controller.ts

@@ -1,116 +0,0 @@
-import { Body, Controller, Headers, HttpCode, HttpStatus, Logger, Post } from '@nestjs/common';
-import { ApiOperation, ApiTags } from '@nestjs/swagger';
-import {
-  TelebirrWebhookPayload,
-  TelebirrWebhookService,
-} from './telebirr-webhook.service';
-import {
-  CbeBirrWebhookPayload,
-  CbeBirrWebhookService,
-} from './cbe-birr-webhook.service';
-import {
-  EBirrWebhookPayload,
-  EBirrWebhookService,
-} from './ebirr-webhook.service';
-import {
-  CardWebhookPayload,
-  CardWebhookService,
-} from './card-webhook.service';
-import { WaafiWebhookService } from './waafi-webhook.service';
-
-@ApiTags('Payment Webhooks')
-@Controller('payments/webhooks')
-export class WebhooksController {
-  private readonly logger = new Logger(WebhooksController.name);
-
-  constructor(
-    private readonly telebirr: TelebirrWebhookService,
-    private readonly cbeBirr: CbeBirrWebhookService,
-    private readonly eBirr: EBirrWebhookService,
-    private readonly card: CardWebhookService,
-    private readonly waafi: WaafiWebhookService,
-  ) {}
-
-  @Post('telebirr')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({ 
-    summary: 'Telebirr payment notification callback (Ethiopia)',
-    description: 'Webhook endpoint for Telebirr payment status updates. Used by Ethiopian passengers.'
-  })
-  async receiveTelebirr(@Body() payload: TelebirrWebhookPayload) {
-    try {
-      await this.telebirr.handle(payload);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.logger.error(`Telebirr webhook handler threw: ${message}`);
-    }
-    return { code: '0', message: 'OK' };
-  }
-
-  @Post('cbe-birr')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({ 
-    summary: 'CBE Birr payment notification callback (Ethiopia)',
-    description: 'Webhook endpoint for Commercial Bank of Ethiopia payment status updates.'
-  })
-  async receiveCbeBirr(@Body() payload: CbeBirrWebhookPayload) {
-    try {
-      await this.cbeBirr.handle(payload);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.logger.error(`CBE Birr webhook handler threw: ${message}`);
-    }
-    return { success: true };
-  }
-
-  @Post('ebirr')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({ 
-    summary: 'eBirr payment notification callback (Ethiopia)',
-    description: 'Webhook endpoint for eBirr electronic payment gateway status updates.'
-  })
-  async receiveEBirr(@Body() payload: EBirrWebhookPayload) {
-    try {
-      await this.eBirr.handle(payload);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.logger.error(`eBirr webhook handler threw: ${message}`);
-    }
-    return { code: '0000', message: 'success' };
-  }
-
-  @Post('card')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({ 
-    summary: 'Card payment notification callback (International)',
-    description: 'Webhook endpoint for international card payments (Visa, Mastercard) via Stripe.'
-  })
-  async receiveCard(
-    @Body() payload: CardWebhookPayload,
-    @Headers('stripe-signature') signature: string,
-  ) {
-    try {
-      await this.card.handle(payload, signature);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.logger.error(`Card webhook handler threw: ${message}`);
-    }
-    return { received: true };
-  }
-
-  @Post('waafi')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({ 
-    summary: 'Waafi payment notification callback (Djibouti)',
-    description: 'Webhook endpoint for Waafi mobile money payment status updates. Used by Djiboutian passengers.'
-  })
-  async receiveWaafi(@Body() payload: any) {
-    try {
-      await this.waafi.handleWebhook(payload);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.logger.error(`Waafi webhook handler threw: ${message}`);
-    }
-    return { responseCode: '2001', responseMsg: 'Success' };
-  }
-}

apps/edr-passenger-api/src/modules/promos/promos.controller.ts

@@ -1,4 +1,4 @@
-import { Body, Controller, Get, Param, Post, UseGuards } from '@nestjs/common';
+import { Body, Controller, Get, Param, Post, UseGuards, Query, Patch, Delete } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
 import { PromosService } from './promos.service';
 import { CreatePromotionDto } from './promos.dto';
@@ -8,7 +8,66 @@ import { JwtGuard } from '../../common/jwt.guard';
 @Controller('promos')
 export class PromosController {
   constructor(private service: PromosService) {}
-  @Get()                  @ApiOperation({ summary: 'Get active promotions' })       getActive() { return this.service.getActive(); }
-  @Get('validate/:code')  @ApiOperation({ summary: 'Validate a promo code' })       validate(@Param('code') code: string) { return this.service.validate(code); }
-  @Post() @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth') @ApiOperation({ summary: 'Create promotion (admin)' }) create(@Body() dto: CreatePromotionDto) { return this.service.create(dto); }
+
+  @Get()
+  @ApiOperation({ summary: 'Get active promotions' })
+  getActive() {
+    return this.service.getActive();
+  }
+
+  @Get('all')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Get all promos with filters (admin)' })
+  getAll(
+    @Query('search') search?: string,
+    @Query('active') active?: string,
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+  ) {
+    return this.service.getAll({
+      search,
+      active: active === 'true' ? true : active === 'false' ? false : undefined,
+      page: page ? parseInt(page) : 1,
+      pageSize: pageSize ? parseInt(pageSize) : 10,
+    });
+  }
+
+  @Get(':id')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Get promo by ID' })
+  getById(@Param('id') id: string) {
+    return this.service.getById(id);
+  }
+
+  @Get('validate/:code')
+  @ApiOperation({ summary: 'Validate a promo code' })
+  validate(@Param('code') code: string) {
+    return this.service.validate(code);
+  }
+
+  @Post()
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Create promotion (admin)' })
+  create(@Body() dto: CreatePromotionDto) {
+    return this.service.create(dto);
+  }
+
+  @Patch(':id')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Update promo (admin)' })
+  update(@Param('id') id: string, @Body() dto: Partial<CreatePromotionDto>) {
+    return this.service.update(id, dto);
+  }
+
+  @Delete(':id')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Delete promo (admin)' })
+  delete(@Param('id') id: string) {
+    return this.service.delete(id);
+  }
 }

apps/edr-passenger-api/src/modules/promos/promos.dto.ts

@@ -1,13 +1,46 @@
-import { IsString, IsOptional, IsInt } from 'class-validator';
+import { IsString, IsOptional, IsInt, IsBoolean } from 'class-validator';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 
 export class CreatePromotionDto {
-  @ApiProperty({ example: 'Weekend Special' }) @IsString() title: string;
-  @ApiPropertyOptional({ example: '15% off all routes' }) @IsOptional() @IsString() subtitle?: string;
-  @ApiProperty({ example: 'WEEKEND15' }) @IsString() code: string;
-  @ApiPropertyOptional({ example: 15 }) @IsOptional() @IsInt() percentOff?: number;
-  @ApiPropertyOptional({ example: 5000 }) @IsOptional() @IsInt() amountOffMinor?: number;
-  @ApiProperty({ example: '2026-12-31T23:59:59Z' }) @IsString() validUntil: string;
-  @ApiPropertyOptional({ example: 'Book Now' }) @IsOptional() @IsString() ctaLabel?: string;
-  @ApiPropertyOptional({ example: 'edr://search' }) @IsOptional() @IsString() deepLink?: string;
+  @ApiProperty({ example: 'SUMMER2024' })
+  @IsString()
+  code: string;
+
+  @ApiProperty({ example: 'Summer Discount' })
+  @IsString()
+  title: string;
+
+  @ApiPropertyOptional({ example: 'Get 15% off' })
+  @IsOptional()
+  @IsString()
+  subtitle?: string;
+
+  @ApiPropertyOptional({ example: 15 })
+  @IsOptional()
+  @IsInt()
+  percentOff?: number;
+
+  @ApiPropertyOptional({ example: 5000 })
+  @IsOptional()
+  @IsInt()
+  amountOffMinor?: number;
+
+  @ApiProperty({ example: '2026-12-31T23:59:59Z' })
+  @IsString()
+  validUntil: string;
+
+  @ApiPropertyOptional({ example: 'Book Now' })
+  @IsOptional()
+  @IsString()
+  ctaLabel?: string;
+
+  @ApiPropertyOptional({ example: 'edr://search' })
+  @IsOptional()
+  @IsString()
+  deepLink?: string;
+
+  @ApiPropertyOptional({ example: true })
+  @IsOptional()
+  @IsBoolean()
+  active?: boolean;
 }

apps/edr-passenger-api/src/modules/promos/promos.service.ts

@@ -1,20 +1,190 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, BadRequestException, NotFoundException } from '@nestjs/common';
 import { PrismaService } from '../../common/prisma.service';
 import { CreatePromotionDto } from './promos.dto';
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
 
 @Injectable()
 export class PromosService {
   constructor(private prisma: PrismaService) {}
 
-  getActive() { return this.prisma.promotion.findMany({ where: { active: true, validUntil: { gte: new Date() } }, orderBy: { createdAt: 'desc' } }); }
+  getActive() {
+    return this.prisma.promotion.findMany({
+      where: { active: true, validUntil: { gte: new Date() } },
+      orderBy: { createdAt: 'desc' },
+    });
+  }
+
+  async getAll(filters: { search?: string; active?: boolean; page?: number; pageSize?: number }) {
+    const { search, active, page = 1, pageSize = 10 } = filters;
+    const skip = (page - 1) * pageSize;
+
+    const where: any = {};
+    if (search) {
+      where.OR = [
+        { code: { contains: search, mode: 'insensitive' } },
+        { title: { contains: search, mode: 'insensitive' } },
+      ];
+    }
+    if (active !== undefined) {
+      where.active = active;
+    }
+
+    const [items, total] = await Promise.all([
+      this.prisma.promotion.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy: { createdAt: 'desc' },
+      }),
+      this.prisma.promotion.count({ where }),
+    ]);
+
+    return { items: this.formatItems(items), total, page, pageSize };
+  }
+
+  async getById(id: string) {
+    const promo = await this.prisma.promotion.findUnique({ where: { id } });
+    if (!promo) throw new NotFoundException('Promo not found');
+    return this.formatItem(promo);
+  }
 
   async validate(code: string) {
     const promo = await this.prisma.promotion.findUnique({ where: { code } });
-    if (!promo || !promo.active || promo.validUntil < new Date()) return { applicable: false, message: 'Promo code invalid or expired' };
-    return { code: promo.code, percentOff: promo.percentOff, amountOffMinor: promo.amountOffMinor, validUntil: promo.validUntil, applicable: true, message: promo.percentOff ? `${promo.percentOff}% off` : `ETB ${((promo.amountOffMinor ?? 0) / 100).toFixed(2)} off` };
+    if (!promo || !promo.active || promo.validUntil < new Date())
+      return { applicable: false, message: 'Promo code invalid or expired' };
+    return {
+      code: promo.code,
+      percentOff: promo.percentOff,
+      amountOffMinor: promo.amountOffMinor,
+      validUntil: promo.validUntil,
+      applicable: true,
+      message: promo.percentOff
+        ? `${promo.percentOff}% off`
+        : `ETB ${((promo.amountOffMinor ?? 0) / 100).toFixed(2)} off`,
+    };
   }
 
-  create(dto: CreatePromotionDto) {
-    return this.prisma.promotion.create({ data: { ...dto, validUntil: new Date(dto.validUntil) } });
+  async create(dto: CreatePromotionDto & { discountType?: string; discountValue?: number }) {
+    try {
+      // Map frontend fields to database fields
+      let percentOff: number | undefined;
+      let amountOffMinor: number | undefined;
+
+      if (dto.discountType && dto.discountValue !== undefined) {
+        if (dto.discountType === 'PERCENTAGE') {
+          percentOff = dto.discountValue;
+        } else if (dto.discountType === 'FIXED') {
+          amountOffMinor = dto.discountValue;
+        }
+      } else {
+        // Fallback to direct fields
+        percentOff = dto.percentOff;
+        amountOffMinor = dto.amountOffMinor;
+      }
+
+      const promo = await this.prisma.promotion.create({
+        data: {
+          code: dto.code,
+          title: dto.title,
+          subtitle: dto.subtitle,
+          percentOff,
+          amountOffMinor,
+          validUntil: new Date(dto.validUntil),
+          ctaLabel: dto.ctaLabel,
+          deepLink: dto.deepLink,
+          active: dto.active ?? true,
+        },
+      });
+      return this.formatItem(promo);
+    } catch (error) {
+      if (error instanceof PrismaClientKnownRequestError) {
+        if (error.code === 'P2002') {
+          const field = (error.meta?.target as string[])?.[0];
+          throw new BadRequestException(
+            `A promo code with this ${field} already exists. Please use a different ${field}.`,
+          );
+        }
+      }
+      throw error;
+    }
+  }
+
+  async update(id: string, dto: Partial<CreatePromotionDto> & { discountType?: string; discountValue?: number }) {
+    const promo = await this.prisma.promotion.findUnique({ where: { id } });
+    if (!promo) throw new NotFoundException('Promo not found');
+
+    const updateData: any = {};
+    
+    // Map frontend fields to database fields
+    if (dto.discountType && dto.discountValue !== undefined) {
+      // Clear existing discount fields
+      updateData.percentOff = null;
+      updateData.amountOffMinor = null;
+      
+      if (dto.discountType === 'PERCENTAGE') {
+        updateData.percentOff = dto.discountValue;
+      } else if (dto.discountType === 'FIXED') {
+        updateData.amountOffMinor = dto.discountValue;
+      }
+    } else {
+      // Only include fields that are explicitly provided
+      if (dto.percentOff !== undefined) updateData.percentOff = dto.percentOff;
+      if (dto.amountOffMinor !== undefined) updateData.amountOffMinor = dto.amountOffMinor;
+    }
+    
+    if (dto.title !== undefined) updateData.title = dto.title;
+    if (dto.subtitle !== undefined) updateData.subtitle = dto.subtitle;
+    if (dto.ctaLabel !== undefined) updateData.ctaLabel = dto.ctaLabel;
+    if (dto.deepLink !== undefined) updateData.deepLink = dto.deepLink;
+    if (dto.active !== undefined) updateData.active = dto.active;
+    if (dto.validUntil !== undefined) updateData.validUntil = new Date(dto.validUntil);
+
+    // Don't allow updating code - it's immutable after creation
+    
+    try {
+      const updated = await this.prisma.promotion.update({
+        where: { id },
+        data: updateData,
+      });
+      return this.formatItem(updated);
+    } catch (error) {
+      if (error instanceof PrismaClientKnownRequestError && error.code === 'P2002') {
+        const field = (error.meta?.target as string[])?.[0];
+        throw new BadRequestException(
+          `A promo code with this ${field} already exists. Please use a different ${field}.`,
+        );
+      }
+      throw error;
+    }
+  }
+
+  async delete(id: string) {
+    const promo = await this.prisma.promotion.findUnique({ where: { id } });
+    if (!promo) throw new NotFoundException('Promo not found');
+    return this.prisma.promotion.delete({ where: { id } });
+  }
+
+  private formatItem(promo: any) {
+    return {
+      id: promo.id,
+      code: promo.code,
+      title: promo.title,
+      discountType: promo.percentOff ? 'PERCENTAGE' : 'FIXED',
+      discountValue: promo.percentOff || promo.amountOffMinor || 0,
+      maxDiscount: undefined,
+      minBookingAmount: undefined,
+      maxUsagePerUser: undefined,
+      totalUsageLimit: undefined,
+      usageCount: 0,
+      validFrom: promo.createdAt,
+      validUntil: promo.validUntil,
+      isActive: promo.active,
+      createdAt: promo.createdAt,
+      updatedAt: promo.createdAt,
+    };
+  }
+
+  private formatItems(promos: any[]) {
+    return promos.map((promo) => this.formatItem(promo));
   }
 }

apps/edr-passenger-api/src/modules/reports/reports.service.ts

@@ -8,7 +8,10 @@ export class ReportsService {
 
   async generateReport(dto: GenerateReportDto) {
     const dateFrom = new Date(dto.dateFrom);
+    dateFrom.setHours(0, 0, 0, 0);
+    
     const dateTo = new Date(dto.dateTo);
+    dateTo.setHours(23, 59, 59, 999);
 
     let data: any;
     switch (dto.reportType) {
@@ -44,14 +47,16 @@ export class ReportsService {
   }
 
   private async generateRevenueReport(dateFrom: Date, dateTo: Date) {
+    // Fetch all bookings in date range, regardless of status
     const bookings = await this.prisma.booking.findMany({
       where: {
-        createdAt: { gte: dateFrom, lte: dateTo },
-        status: { in: ['CONFIRMED', 'COMPLETED'] }
+        createdAt: { gte: dateFrom, lte: dateTo }
       },
       include: { paymentIntent: true }
     });
 
+    console.log(`[Reports] Revenue Report: Found ${bookings.length} bookings between ${dateFrom} and ${dateTo}`);
+
     const totalRevenue = bookings.reduce((sum, b) => sum + b.totalMinor, 0);
     const byPaymentMethod = bookings.reduce((acc, b) => {
       const method = b.paymentIntent?.method ?? 'UNKNOWN';
@@ -59,12 +64,25 @@ export class ReportsService {
       return acc;
     }, {} as Record<string, number>);
 
+    // Group by date for charts
+    const byDate = bookings.reduce((acc, b) => {
+      const date = b.createdAt.toISOString().split('T')[0];
+      if (!acc[date]) {
+        acc[date] = { totalMinor: 0, count: 0 };
+      }
+      acc[date].totalMinor += b.totalMinor;
+      acc[date].count += 1;
+      return acc;
+    }, {} as Record<string, any>);
+
     return {
       totalBookings: bookings.length,
       totalRevenueMinor: totalRevenue,
       totalRevenue: totalRevenue / 100,
       currency: 'ETB',
-      byPaymentMethod
+      byPaymentMethod,
+      byDate,
+      cancellationRate: 0
     };
   }
 
@@ -73,7 +91,7 @@ export class ReportsService {
       where: { departureAt: { gte: dateFrom, lte: dateTo } },
       include: {
         coachAssignments: { include: { coach: { include: { seats: true } } } },
-        bookings: { where: { status: { in: ['CONFIRMED', 'COMPLETED'] } }, include: { seats: true } },
+        bookings: { include: { seats: true } },
       },
     });
 

apps/edr-passenger-api/src/modules/schedules/schedules.controller.ts

@@ -1,7 +1,7 @@
 import { Body, Controller, Delete, Get, Param, Patch, Post, Query, ParseIntPipe, UseGuards } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth, ApiParam, ApiQuery, ApiResponse } from '@nestjs/swagger';
 import { SchedulesService } from './schedules.service';
-import { CreateScheduleDto, CreateFareRuleDto, UpdateScheduleStatusDto, UpdateStopTimeDto, ListSchedulesDto } from './schedules.dto';
+import { CreateScheduleDto, UpdateScheduleDto, CreateFareRuleDto, UpdateScheduleStatusDto, UpdateStopTimeDto, ListSchedulesDto, BulkCreateSchedulesDto, BulkSchedulesResponseDto } from './schedules.dto';
 import { JwtGuard } from '../../common/jwt.guard';
 import { TripStatus } from '@prisma/client';
 
@@ -10,27 +10,24 @@ import { TripStatus } from '@prisma/client';
 export class SchedulesController {
   constructor(private service: SchedulesService) {}
 
+  @Post('bulk-generate')
+  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Bulk generate repetitive schedules' })
+  bulkGenerateSchedules(@Body() dto: BulkCreateSchedulesDto) {
+    return this.service.bulkGenerateSchedules(dto);
+  }
+
   @Post()
   @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
-  @ApiOperation({
-    summary: 'Create a train schedule from a route template',
-    description: `Creates a schedule by referencing a Route (routeId).
-Stops are automatically copied from the route's RouteStop definitions.
-You supply the actual planned arrival/departure times per stop sequence.
-Origin and destination are derived from the first and last route stop — no need to specify them manually.`,
-  })
-  @ApiResponse({ status: 201, description: 'Schedule created with stops copied from route template' })
-  @ApiResponse({ status: 400, description: 'Invalid times, inactive route, or missing planned times for some stops' })
-  @ApiResponse({ status: 404, description: 'Train or route not found' })
+  @ApiOperation({ summary: 'Create a train schedule from a route template' })
   createSchedule(@Body() dto: CreateScheduleDto) { return this.service.createSchedule(dto); }
 
   @Get()
   @ApiOperation({ summary: 'List schedules with optional filters' })
-  @ApiQuery({ name: 'date', required: false, example: '2026-06-15', description: 'Departure date (YYYY-MM-DD). Returns all schedules departing on this calendar day.' })
-  @ApiQuery({ name: 'routeId', required: false, description: 'Filter by route UUID' })
-  @ApiQuery({ name: 'trainId', required: false, description: 'Filter by train UUID' })
-  @ApiQuery({ name: 'status', required: false, enum: TripStatus, description: 'Filter by schedule status' })
-  @ApiResponse({ status: 200, description: 'Array of schedules ordered by departureAt, each with train, origin/destination, stops, and booking/assignment counts' })
+  @ApiQuery({ name: 'date', required: false })
+  @ApiQuery({ name: 'routeId', required: false })
+  @ApiQuery({ name: 'trainId', required: false })
+  @ApiQuery({ name: 'status', required: false, enum: TripStatus })
   listSchedules(
     @Query('date') date?: string,
     @Query('routeId') routeId?: string,
@@ -40,36 +37,71 @@ Origin and destination are derived from the first and last route stop — no nee
     return this.service.listSchedules({ date, routeId, trainId, status });
   }
 
-  // Static routes before parameterised ones
+  // ===== SPECIFIC ROUTES (must come BEFORE generic :id routes) =====
+
   @Post('fares')
   @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
   @ApiOperation({ summary: 'Create a fare rule scoped to a schedule or route code' })
   @ApiResponse({ status: 201, description: 'Fare rule created' })
   createFareRule(@Body() dto: CreateFareRuleDto) { return this.service.createFareRule(dto); }
 
+  @Patch('fares/:id')
+  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Update a fare rule' })
+  @ApiParam({ name: 'id', description: 'FareRule UUID' })
+  @ApiResponse({ status: 200, description: 'Fare rule updated' })
+  updateFareRule(@Param('id') id: string, @Body() dto: Partial<CreateFareRuleDto>) {
+    return this.service.updateFareRule(id, dto);
+  }
+
+  @Delete('fares/:id')
+  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Delete a fare rule' })
+  @ApiParam({ name: 'id', description: 'FareRule UUID' })
+  @ApiResponse({ status: 200, description: 'Fare rule deleted' })
+  deleteFareRule(@Param('id') id: string) { return this.service.deleteFareRule(id); }
+
+  @Post('segment-fares')
+  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Create a segment fare rule' })
+  createSegmentFareRule(@Body() dto: any) { return this.service.createSegmentFareRule(dto); }
+
+  @Get('routes/:routeId/segment-fares')
+  @ApiOperation({ summary: 'List all segment fare rules for a route' })
+  @ApiParam({ name: 'routeId', description: 'Route UUID' })
+  getSegmentFares(@Param('routeId') routeId: string) { return this.service.getSegmentFares(routeId); }
+
+  @Patch('segment-fares/:id')
+  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Update a segment fare rule' })
+  @ApiParam({ name: 'id', description: 'SegmentFareRule UUID' })
+  updateSegmentFareRule(@Param('id') id: string, @Body() dto: any) { return this.service.updateSegmentFareRule(id, dto); }
+
+  @Delete('segment-fares/:id')
+  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Delete a segment fare rule' })
+  @ApiParam({ name: 'id', description: 'SegmentFareRule UUID' })
+  deleteSegmentFareRule(@Param('id') id: string) { return this.service.deleteSegmentFareRule(id); }
+
+  // ===== PARAMETRIZED ROUTES (generic :id routes come AFTER specific routes) =====
+
   @Get(':id')
-  @ApiOperation({ summary: 'Get schedule with train, coaches, seats, and stop timeline' })
+  @ApiOperation({ summary: 'Get schedule detail' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
-  @ApiResponse({ status: 200, description: 'Full schedule detail including route stops with station info' })
-  @ApiResponse({ status: 404, description: 'Schedule not found' })
   getSchedule(@Param('id') id: string) { return this.service.getSchedule(id); }
 
   @Patch(':id')
   @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Update a schedule' })
+  @ApiOperation({ summary: 'Update a schedule (partial)' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
-  @ApiResponse({ status: 200, description: 'Schedule updated' })
-  @ApiResponse({ status: 404, description: 'Schedule not found' })
-  updateSchedule(@Param('id') id: string, @Body() dto: CreateScheduleDto) {
-    return this.service.updateSchedule(id, dto);
+  updateSchedule(@Param('id') id: string, @Body() dto: UpdateScheduleDto) {
+    return this.service.updateSchedulePartial(id, dto);
   }
 
   @Patch(':id/status')
   @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Update schedule status (SCHEDULED → BOARDING → EN_ROUTE → ARRIVED)' })
+  @ApiOperation({ summary: 'Update schedule status' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
-  @ApiResponse({ status: 200, description: 'Status updated' })
-  @ApiResponse({ status: 404, description: 'Schedule not found' })
   updateStatus(@Param('id') id: string, @Body() dto: UpdateScheduleStatusDto) {
     return this.service.updateScheduleStatus(id, dto);
   }
@@ -78,44 +110,47 @@ Origin and destination are derived from the first and last route stop — no nee
   @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
   @ApiOperation({ summary: 'Delete a schedule' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
-  @ApiResponse({ status: 200, description: 'Schedule deleted' })
-  @ApiResponse({ status: 404, description: 'Schedule not found' })
-  deleteSchedule(@Param('id') id: string) {
-    return this.service.deleteSchedule(id);
-  }
-
-  // ── Stop Times ─────────────────────────────────────────────────────────────
+  deleteSchedule(@Param('id') id: string) { return this.service.deleteSchedule(id); }
 
   @Get(':id/stops')
-  @ApiOperation({ summary: 'List all stops for a schedule ordered by sequence' })
+  @ApiOperation({ summary: 'List all stops for a schedule' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
-  @ApiResponse({ status: 200, description: 'Ordered stop list with station details and planned/actual times' })
-  @ApiResponse({ status: 404, description: 'Schedule not found' })
   getStops(@Param('id') id: string) { return this.service.getStops(id); }
 
   @Patch(':id/stops/:sequence')
   @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Update planned times or live status of a specific stop' })
+  @ApiOperation({ summary: 'Update a stop time' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
   @ApiParam({ name: 'sequence', description: 'Stop sequence number' })
-  @ApiResponse({ status: 200, description: 'Stop updated' })
-  @ApiResponse({ status: 404, description: 'Stop not found on schedule' })
   updateStop(
     @Param('id') id: string,
     @Param('sequence', ParseIntPipe) sequence: number,
     @Body() dto: UpdateStopTimeDto,
   ) { return this.service.updateStop(id, sequence, dto); }
 
-  // ── Fares ──────────────────────────────────────────────────────────────────
+  @Get(':scheduleId/fares/stored')
+  @ApiOperation({ summary: 'Get stored fare rules for a schedule' })
+  @ApiParam({ name: 'scheduleId', description: 'TrainSchedule UUID' })
+  getStoredFares(@Param('scheduleId') scheduleId: string) {
+    return this.service.getFareRules(scheduleId);
+  }
+
+  @Get(':scheduleId/fares/all')
+  @ApiOperation({ summary: 'Get fares for all active seat classes from the fare engine' })
+  @ApiParam({ name: 'scheduleId', description: 'TrainSchedule UUID' })
+  @ApiQuery({ name: 'nationality', required: false })
+  getAllFares(
+    @Param('scheduleId') scheduleId: string,
+    @Query('nationality') nationality?: string,
+  ) {
+    return this.service.getAllFaresFromEngine(scheduleId, nationality);
+  }
 
   @Get(':scheduleId/fares')
-  @ApiOperation({ summary: 'Get fare for a schedule and seat class from the fare engine' })
+  @ApiOperation({ summary: 'Get fare for a specific seat class from the fare engine' })
   @ApiParam({ name: 'scheduleId', description: 'TrainSchedule UUID' })
-  @ApiQuery({ name: 'seatClassId', required: true, description: 'SeatClass UUID' })
-  @ApiQuery({ name: 'nationality', required: false, description: 'Passenger nationality — determines billing currency (Ethiopian→ETB, Djiboutian→DJF, other→USD)' })
-  @ApiResponse({ status: 200, description: 'Live fare breakdown from fare engine' })
-  @ApiResponse({ status: 400, description: 'Schedule has no route or missing distanceKm on stops' })
-  @ApiResponse({ status: 404, description: 'Schedule or seat class not found' })
+  @ApiQuery({ name: 'seatClassId', required: true })
+  @ApiQuery({ name: 'nationality', required: false })
   getFare(
     @Param('scheduleId') scheduleId: string,
     @Query('seatClassId') seatClassId: string,
@@ -124,44 +159,15 @@ Origin and destination are derived from the first and last route stop — no nee
     return this.service.getFareFromEngine(scheduleId, seatClassId, nationality);
   }
 
-  @Get(':scheduleId/fares/all')
-  @ApiOperation({ summary: 'Get fares for all active seat classes on a schedule' })
-  @ApiParam({ name: 'scheduleId', description: 'TrainSchedule UUID' })
-  @ApiQuery({ name: 'nationality', required: false, description: 'Passenger nationality — determines billing currency' })
-  @ApiResponse({ status: 200, description: 'Array of fare breakdowns for every active seat class, ordered by price ascending' })
-  @ApiResponse({ status: 400, description: 'Schedule has no route or missing distanceKm on stops' })
-  @ApiResponse({ status: 404, description: 'Schedule not found' })
-  getAllFares(
-    @Param('scheduleId') scheduleId: string,
-    @Query('nationality') nationality?: string,
-  ) {
-    return this.service.getAllFaresFromEngine(scheduleId, nationality);
-  }
-
   @Post(':id/fares/sync')
-  @ApiOperation({
-    summary: 'Sync fares from fare engine',
-    description: 'Recalculates fares for all active seat classes using the fare engine (km × ratePerKm + tax) and upserts them as FareRule records scoped to this schedule. Previous active rules are expired.',
-  })
+  @ApiOperation({ summary: 'Sync fares from fare engine' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
-  @ApiResponse({ status: 201, description: 'Fares synced — returns count of synced rules and any errors' })
-  @ApiResponse({ status: 400, description: 'Schedule has no associated route or missing distanceKm on stops' })
-  @ApiResponse({ status: 404, description: 'Schedule not found' })
-  syncFares(@Param('id') id: string) {
-    return this.service.syncFaresFromEngine(id);
-  }
-
-  // ── Coach Assignments ──────────────────────────────────────────────────────
+  syncFares(@Param('id') id: string) { return this.service.syncFaresFromEngine(id); }
 
   @Post(':id/coaches')
   @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ 
-    summary: 'Assign coaches to a schedule',
-    description: 'Assigns selected coaches to a schedule with their position numbers. Replaces any existing coach assignments.'
-  })
+  @ApiOperation({ summary: 'Assign coaches to a schedule' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
-  @ApiResponse({ status: 201, description: 'Coaches assigned successfully' })
-  @ApiResponse({ status: 404, description: 'Schedule or coach not found' })
   assignCoaches(
     @Param('id') id: string,
     @Body() dto: { coaches: Array<{ coachId: string; positionNumber: number }> },
@@ -172,21 +178,14 @@ Origin and destination are derived from the first and last route stop — no nee
   @Get(':id/coaches')
   @ApiOperation({ summary: 'Get assigned coaches for a schedule' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
-  @ApiResponse({ status: 200, description: 'List of assigned coaches with seat details' })
-  getAssignedCoaches(@Param('id') id: string) {
-    return this.service.getAssignedCoaches(id);
-  }
+  getAssignedCoaches(@Param('id') id: string) { return this.service.getAssignedCoaches(id); }
 
   @Delete(':id/coaches/:coachId')
   @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Remove a coach assignment from a schedule' })
+  @ApiOperation({ summary: 'Remove a coach assignment' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
   @ApiParam({ name: 'coachId', description: 'Coach UUID' })
-  @ApiResponse({ status: 200, description: 'Coach assignment removed' })
-  removeCoachAssignment(
-    @Param('id') id: string,
-    @Param('coachId') coachId: string,
-  ) {
+  removeCoachAssignment(@Param('id') id: string, @Param('coachId') coachId: string) {
     return this.service.removeCoachAssignment(id, coachId);
   }
 }

apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts

@@ -1,7 +1,7 @@
 import { IsString, IsDateString, IsInt, IsOptional, IsEnum, IsArray, ValidateNested, IsObject, Min } from 'class-validator';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Type } from 'class-transformer';
-import { TripStatus, StopStatus } from '@prisma/client';
+import { TripStatus, StopStatus, PassengerCategory } from '@prisma/client';
 
 export class PlannedStopTimeDto {
   @ApiProperty({ example: 1, description: 'Route stop sequence number this timing applies to' }) @IsInt() @Min(1) sequence: number;
@@ -34,6 +34,13 @@ export class CreateScheduleDto {
   plannedTimes: PlannedStopTimeDto[];
 }
 
+export class UpdateScheduleDto {
+  @ApiPropertyOptional({ example: '2026-06-15T08:00:00Z', description: 'Scheduled departure from the first stop (origin)' }) @IsOptional() @IsDateString() departureAt?: string;
+  @ApiPropertyOptional({ example: '2026-06-15T20:00:00Z', description: 'Scheduled arrival at the last stop (destination)' }) @IsOptional() @IsDateString() arrivalAt?: string;
+  @ApiPropertyOptional({ enum: TripStatus, example: TripStatus.SCHEDULED }) @IsOptional() @IsEnum(TripStatus) status?: TripStatus;
+  @ApiPropertyOptional({ type: Array, description: 'List of coaches to assign' }) @IsOptional() @IsArray() coaches?: Array<{ coachId: string; positionNumber: number }>;
+}
+
 export class UpdateStopTimeDto {
   @ApiPropertyOptional({ example: '2026-06-15T09:30:00Z' }) @IsOptional() @IsDateString() plannedArrivalAt?: string;
   @ApiPropertyOptional({ example: '2026-06-15T09:45:00Z' }) @IsOptional() @IsDateString() plannedDepartureAt?: string;
@@ -44,12 +51,25 @@ export class CreateFareRuleDto {
   @ApiPropertyOptional({ example: 'schedule-uuid', description: 'Scope fare rule to a specific schedule' }) @IsOptional() @IsString() scheduleId?: string;
   @ApiPropertyOptional({ example: 'ADD-DJI', description: 'Scope fare rule to a route code (e.g. ADD-DJI for full route or ADD-ADM for segment)' }) @IsOptional() @IsString() route?: string;
   @ApiPropertyOptional({ example: 'Ethiopian', description: 'Scope fare rule to nationality: Ethiopian, Djiboutian, Other' }) @IsOptional() @IsString() nationality?: string;
+  @ApiPropertyOptional({ enum: PassengerCategory, example: 'ADULT', description: 'Passenger category: ADULT (5+ yrs) or CHILD (<5 yrs)' }) @IsOptional() @IsEnum(PassengerCategory) passengerCategory?: PassengerCategory;
   @ApiProperty({ example: 'seat-class-uuid', description: 'Seat class UUID' }) @IsString() seatClassId: string;
   @ApiProperty({ example: 45000, description: 'Base fare in minor currency units (ETB cents)' }) @IsInt() baseFareMinor: number;
   @ApiProperty({ example: '2026-01-01T00:00:00Z' }) @IsDateString() validFrom: string;
   @ApiPropertyOptional({ example: '2026-12-31T23:59:59Z' }) @IsOptional() @IsDateString() validUntil?: string;
 }
 
+export class CreateSegmentFareRuleDto {
+  @ApiProperty({ example: 'route-uuid', description: 'Route UUID' }) @IsString() routeId: string;
+  @ApiProperty({ example: 1, description: 'Origin stop sequence number' }) @IsInt() @Min(1) originStopSequence: number;
+  @ApiProperty({ example: 2, description: 'Destination stop sequence number' }) @IsInt() @Min(1) destinationStopSequence: number;
+  @ApiProperty({ example: 'seat-class-uuid', description: 'Seat class UUID' }) @IsString() seatClassId: string;
+  @ApiProperty({ example: 45000, description: 'Base fare in minor currency units (ETB cents)' }) @IsInt() baseFareMinor: number;
+  @ApiPropertyOptional({ example: 'Ethiopian', description: 'Nationality scope (Ethiopian, Djiboutian, Other)' }) @IsOptional() @IsString() nationality?: string;
+  @ApiPropertyOptional({ enum: PassengerCategory, example: 'ADULT', description: 'Passenger category: ADULT (5+ yrs) or CHILD (<5 yrs)' }) @IsOptional() @IsEnum(PassengerCategory) passengerCategory?: PassengerCategory;
+  @ApiProperty({ example: '2026-01-01T00:00:00Z' }) @IsDateString() validFrom: string;
+  @ApiPropertyOptional({ example: '2026-12-31T23:59:59Z' }) @IsOptional() @IsDateString() validUntil?: string;
+}
+
 export class ListSchedulesDto {
   @ApiPropertyOptional({ example: '2026-06-15', description: 'Filter by departure date (YYYY-MM-DD). Returns all schedules departing on this calendar day.' })
   @IsOptional() @IsDateString() date?: string;
@@ -67,3 +87,25 @@ export class ListSchedulesDto {
 export class UpdateScheduleStatusDto {
   @ApiProperty({ enum: TripStatus, example: TripStatus.EN_ROUTE }) @IsEnum(TripStatus) status: TripStatus;
 }
+
+export class BulkCreateSchedulesDto {
+  @ApiProperty({ example: 'train-uuid', description: 'Train UUID' }) @IsString() trainId: string;
+  @ApiProperty({ example: 'route-uuid', description: 'Route UUID' }) @IsString() routeId: string;
+  @ApiProperty({ example: '2026-06-15T08:00:00Z', description: 'Start date and time for first schedule' }) @IsDateString() startDateTime: string;
+  @ApiProperty({ example: 12, description: 'Hours duration per schedule' }) @IsInt() @Min(1) durationHours: number;
+  @ApiProperty({ example: 2, description: 'Repeat every X days' }) @IsInt() @Min(1) repeatEveryDays: number;
+  @ApiProperty({ example: 30, description: 'Generate schedules for the next Y days' }) @IsInt() @Min(1) forNextDays: number;
+  @ApiPropertyOptional({ type: [PlannedStopTimeDto], description: 'Optional custom planned times per stop. If not provided, will auto-generate.' })
+  @IsOptional() @IsArray() @ValidateNested({ each: true }) @Type(() => PlannedStopTimeDto)
+  plannedTimes?: PlannedStopTimeDto[];
+
+  @ApiPropertyOptional({ type: [String], description: 'Optional coach UUIDs to assign to every generated schedule' })
+  @IsOptional() @IsArray() @IsString({ each: true })
+  coachIds?: string[];
+}
+
+export class BulkSchedulesResponseDto {
+  @ApiProperty() schedulesCreated: number;
+  @ApiProperty() errors: string[];
+  @ApiProperty() scheduleIds: string[];
+}

apps/edr-passenger-api/src/modules/schedules/schedules.service.ts

@@ -2,7 +2,7 @@ import { Injectable, NotFoundException, BadRequestException } from '@nestjs/comm
 import { PrismaService } from '../../common/prisma.service';
 import { RoutesService } from './routes.service';
 import { FareEngineService } from '../fare-engine/fare-engine.service';
-import { CreateScheduleDto, CreateFareRuleDto, UpdateScheduleStatusDto, UpdateStopTimeDto, ListSchedulesDto } from './schedules.dto';
+import { CreateScheduleDto, UpdateScheduleDto, CreateFareRuleDto, UpdateScheduleStatusDto, UpdateStopTimeDto, ListSchedulesDto, BulkCreateSchedulesDto } from './schedules.dto';
 
 @Injectable()
 export class SchedulesService {
@@ -10,9 +10,57 @@ export class SchedulesService {
     private prisma: PrismaService,
     private routesService: RoutesService,
     private fareEngine: FareEngineService,
-  ) {}
+  ) { }
 
-  // ── Schedule CRUD ──────────────────────────────────────────────────────────
+  async bulkGenerateSchedules(dto: BulkCreateSchedulesDto) {
+    const startDate = new Date(dto.startDateTime);
+    const endDate = new Date(startDate.getTime() + dto.forNextDays * 24 * 60 * 60 * 1000);
+    const errors: string[] = [];
+    const scheduleIds: string[] = [];
+
+    const route = await this.prisma.route.findUnique({
+      where: { id: dto.routeId },
+      include: { stops: { orderBy: { sequence: 'asc' } } },
+    });
+    if (!route) throw new NotFoundException('Route not found');
+    if (!route.active) throw new BadRequestException('Route is not active');
+
+    let currentDate = new Date(startDate);
+    let scheduleCount = 0;
+
+    while (currentDate < endDate) {
+      try {
+        const departureAt = new Date(currentDate);
+        const arrivalAt = new Date(departureAt.getTime() + dto.durationHours * 60 * 60 * 1000);
+
+        const createDto: CreateScheduleDto = {
+          trainId: dto.trainId,
+          routeId: dto.routeId,
+          departureAt: departureAt.toISOString(),
+          arrivalAt: arrivalAt.toISOString(),
+          plannedTimes: dto.plannedTimes || [],
+        };
+
+        const schedule = await this.createSchedule(createDto);
+        scheduleIds.push(schedule.id);
+
+        if (dto.coachIds && dto.coachIds.length > 0) {
+          await this.assignCoaches(
+            schedule.id,
+            dto.coachIds.map((coachId, idx) => ({ coachId, positionNumber: idx + 1 })),
+          );
+        }
+
+        scheduleCount++;
+      } catch (error) {
+        errors.push(`Failed to create schedule for ${currentDate.toISOString()}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+
+      currentDate = new Date(currentDate.getTime() + dto.repeatEveryDays * 24 * 60 * 60 * 1000);
+    }
+
+    return { schedulesCreated: scheduleCount, errors, scheduleIds };
+  }
 
   async listSchedules(dto: ListSchedulesDto) {
     const where: any = {};
@@ -49,7 +97,6 @@ export class SchedulesService {
     const arr = new Date(dto.arrivalAt);
     if (arr <= dep) throw new BadRequestException('arrivalAt must be after departureAt');
 
-    // Validate route exists and has stops
     const route = await this.prisma.route.findUnique({
       where: { id: dto.routeId },
       include: { stops: { orderBy: { sequence: 'asc' } } },
@@ -58,28 +105,37 @@ export class SchedulesService {
     if (!route.active) throw new BadRequestException('Route is not active');
     if (route.stops.length < 2) throw new BadRequestException('Route must have at least 2 stops');
 
-    // Auto-generate plannedTimes if not provided or empty
+    const depDate = new Date(dep);
+    depDate.setHours(0, 0, 0, 0);
+    const nextDay = new Date(depDate);
+    nextDay.setDate(nextDay.getDate() + 1);
+
+    const existingSchedule = await this.prisma.trainSchedule.findFirst({
+      where: { trainId: dto.trainId, routeId: dto.routeId, departureAt: { gte: depDate, lt: nextDay } },
+    });
+
+    if (existingSchedule) {
+      throw new BadRequestException(
+        `A schedule for this train, route, and date already exists. Departure: ${new Date(existingSchedule.departureAt).toLocaleString()}`,
+      );
+    }
+
     let plannedTimes = dto.plannedTimes;
     if (!plannedTimes || plannedTimes.length === 0) {
       const totalDuration = arr.getTime() - dep.getTime();
       const totalDistance = route.stops[route.stops.length - 1].distanceKm || 0;
-      
+
       plannedTimes = route.stops.map((stop, index) => {
         let stopTime: Date;
-        
         if (index === 0) {
-          // First stop - use departure time
           stopTime = dep;
         } else if (index === route.stops.length - 1) {
-          // Last stop - use arrival time
           stopTime = arr;
         } else {
-          // Intermediate stops - calculate based on distance proportion
           const stopDistance = stop.distanceKm || 0;
           const progress = totalDistance > 0 ? stopDistance / totalDistance : index / (route.stops.length - 1);
           stopTime = new Date(dep.getTime() + totalDuration * progress);
         }
-        
         return {
           sequence: stop.sequence,
           plannedArrivalAt: index === 0 ? undefined : stopTime.toISOString(),
@@ -88,14 +144,12 @@ export class SchedulesService {
       });
     }
 
-    // Validate all route stop sequences are covered by plannedTimes
     const providedSeqs = new Set(plannedTimes.map(t => t.sequence));
     const missingSeqs = route.stops.map(s => s.sequence).filter(seq => !providedSeqs.has(seq));
     if (missingSeqs.length > 0) {
       throw new BadRequestException(`Missing planned times for stop sequences: ${missingSeqs.join(', ')}`);
     }
 
-    // Derive origin and destination from first and last route stop
     const firstStop = route.stops[0];
     const lastStop = route.stops[route.stops.length - 1];
 
@@ -113,10 +167,7 @@ export class SchedulesService {
       include: { train: true, originStation: true, destinationStation: true },
     });
 
-    // Copy route stops into TripStopTime with the provided planned times
-    const plannedTimesMap = Object.fromEntries(
-      plannedTimes.map(t => [t.sequence, t]),
-    );
+    const plannedTimesMap = Object.fromEntries(plannedTimes.map(t => [t.sequence, t]));
     await this.routesService.applyRouteToSchedule(dto.routeId, schedule.id, plannedTimesMap);
 
     return this.getSchedule(schedule.id);
@@ -130,7 +181,7 @@ export class SchedulesService {
         originStation: true,
         destinationStation: true,
         coachAssignments: {
-          include: { coach: { include: { seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] }, seatClass: true } } },
+          include: { coach: { include: { seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] } } } },
           orderBy: { positionNumber: 'asc' },
         },
         stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
@@ -138,18 +189,16 @@ export class SchedulesService {
     });
     if (!schedule) throw new NotFoundException('Schedule not found');
 
-    // Compute effective seat statuses from SeatHold + JourneySegment
-    // (seat.status DB column is no longer written during booking)
-    const allSeatIds = schedule.coachAssignments.flatMap(a => a.coach.seats.map(s => s.id));
+    const allSeatIds = schedule.coachAssignments.flatMap((a: any) => a.coach.seats.map((s: any) => s.id));
     const effectiveStatuses = await this.resolveEffectiveStatuses(id, allSeatIds);
 
     return {
       ...schedule,
-      coachAssignments: schedule.coachAssignments.map(a => ({
+      coachAssignments: schedule.coachAssignments.map((a: any) => ({
         ...a,
         coach: {
           ...a.coach,
-          seats: a.coach.seats.map(s => ({
+          seats: a.coach.seats.map((s: any) => ({
             ...s,
             status: effectiveStatuses.get(s.id) ?? s.status,
           })),
@@ -158,16 +207,7 @@ export class SchedulesService {
     };
   }
 
-  /**
-   * Computes effective seat status for a schedule by checking active SeatHolds
-   * and confirmed JourneySegments. The DB seat.status column is not written
-   * during segment-based booking, so this overlay is required.
-   * Priority: BLOCKED (physical) > BOOKED (confirmed) > HELD (active hold) > AVAILABLE
-   */
-  private async resolveEffectiveStatuses(
-    scheduleId: string,
-    seatIds: string[],
-  ): Promise<Map<string, string>> {
+  private async resolveEffectiveStatuses(scheduleId: string, seatIds: string[]): Promise<Map<string, string>> {
     const statusMap = new Map<string, string>();
     if (seatIds.length === 0) return statusMap;
 
@@ -204,7 +244,6 @@ export class SchedulesService {
     const arr = new Date(dto.arrivalAt);
     if (arr <= dep) throw new BadRequestException('arrivalAt must be after departureAt');
 
-    // Validate route exists and has stops
     const route = await this.prisma.route.findUnique({
       where: { id: dto.routeId },
       include: { stops: { orderBy: { sequence: 'asc' } } },
@@ -213,7 +252,6 @@ export class SchedulesService {
     if (!route.active) throw new BadRequestException('Route is not active');
     if (route.stops.length < 2) throw new BadRequestException('Route must have at least 2 stops');
 
-    // Derive origin and destination from first and last route stop
     const firstStop = route.stops[0];
     const lastStop = route.stops[route.stops.length - 1];
 
@@ -231,18 +269,15 @@ export class SchedulesService {
       },
     });
 
-    // Delete existing stop times and recreate
     await this.prisma.tripStopTime.deleteMany({ where: { scheduleId: id } });
 
-    // Auto-generate plannedTimes if not provided
     let plannedTimes = dto.plannedTimes;
     if (!plannedTimes || plannedTimes.length === 0) {
       const totalDuration = arr.getTime() - dep.getTime();
       const totalDistance = route.stops[route.stops.length - 1].distanceKm || 0;
-      
+
       plannedTimes = route.stops.map((stop, index) => {
         let stopTime: Date;
-        
         if (index === 0) {
           stopTime = dep;
         } else if (index === route.stops.length - 1) {
@@ -252,7 +287,6 @@ export class SchedulesService {
           const progress = totalDistance > 0 ? stopDistance / totalDistance : index / (route.stops.length - 1);
           stopTime = new Date(dep.getTime() + totalDuration * progress);
         }
-        
         return {
           sequence: stop.sequence,
           plannedArrivalAt: index === 0 ? undefined : stopTime.toISOString(),
@@ -261,9 +295,7 @@ export class SchedulesService {
       });
     }
 
-    const plannedTimesMap = Object.fromEntries(
-      plannedTimes.map(t => [t.sequence, t]),
-    );
+    const plannedTimesMap = Object.fromEntries(plannedTimes.map(t => [t.sequence, t]));
     await this.routesService.applyRouteToSchedule(dto.routeId, id, plannedTimesMap);
 
     return this.getSchedule(id);
@@ -276,19 +308,9 @@ export class SchedulesService {
   async deleteSchedule(id: string) {
     const schedule = await this.prisma.trainSchedule.findUnique({ where: { id } });
     if (!schedule) throw new NotFoundException('Schedule not found');
-    
-    // Delete related records first (in dependency order)
-    await this.prisma.journeySegment.deleteMany({ where: { scheduleId: id } });
-    await this.prisma.seatHold.deleteMany({ where: { scheduleId: id } });
-    await this.prisma.booking.deleteMany({ where: { scheduleId: id } });
-    await this.prisma.tripStopTime.deleteMany({ where: { scheduleId: id } });
-    await this.prisma.coachAssignment.deleteMany({ where: { scheduleId: id } });
-    
     return this.prisma.trainSchedule.delete({ where: { id } });
   }
 
-  // ── Stop Times (per-schedule overrides) ───────────────────────────────────
-
   getStops(scheduleId: string) {
     return this.prisma.tripStopTime.findMany({
       where: { scheduleId },
@@ -314,10 +336,8 @@ export class SchedulesService {
     });
   }
 
-  // ── Fare Rules ─────────────────────────────────────────────────────────────
-
   createFareRule(dto: CreateFareRuleDto) {
-    const { validFrom, validUntil, scheduleId, nationality, ...rest } = dto;
+    const { validFrom, validUntil, scheduleId, nationality, passengerCategory, ...rest } = dto;
     return this.prisma.fareRule.create({
       data: {
         ...rest,
@@ -326,6 +346,79 @@ export class SchedulesService {
         validFrom: new Date(validFrom),
         validUntil: validUntil ? new Date(validUntil) : null,
       },
+      include: { seatClass: true },
+    });
+  }
+
+  async updateFareRule(id: string, dto: Partial<CreateFareRuleDto>) {
+    const existing = await this.prisma.fareRule.findUnique({ where: { id } });
+    if (!existing) throw new NotFoundException('Fare rule not found');
+
+    const { validFrom, validUntil, scheduleId, nationality, passengerCategory, ...rest } = dto;
+    return this.prisma.fareRule.update({
+      where: { id },
+      data: {
+        ...rest,
+        ...(scheduleId !== undefined && { tripId: scheduleId }),
+        ...(nationality !== undefined && { nationality }),
+        ...(validFrom && { validFrom: new Date(validFrom) }),
+        ...(validUntil !== undefined && { validUntil: validUntil ? new Date(validUntil) : null }),
+      },
+      include: { seatClass: true },
+    });
+  }
+
+  async deleteFareRule(id: string) {
+    const existing = await this.prisma.fareRule.findUnique({ where: { id } });
+    if (!existing) throw new NotFoundException('Fare rule not found');
+    await this.prisma.fareRule.delete({ where: { id } });
+    return { deleted: true, id };
+  }
+
+  createSegmentFareRule(dto: any) {
+    const { validFrom, validUntil, passengerCategory, ...rest } = dto;
+    return this.prisma.segmentFareRule.create({
+      data: {
+        ...rest,
+        validFrom: new Date(validFrom),
+        validUntil: validUntil ? new Date(validUntil) : null,
+      },
+      include: { seatClass: true, route: true },
+    });
+  }
+
+  getSegmentFares(routeId: string) {
+    return this.prisma.segmentFareRule.findMany({
+      where: { routeId },
+      include: { seatClass: true, route: true },
+      orderBy: [{ originStopSequence: 'asc' }, { destinationStopSequence: 'asc' }],
+    });
+  }
+
+  deleteSegmentFareRule(id: string) {
+    return this.prisma.segmentFareRule.delete({ where: { id } });
+  }
+
+  updateSegmentFareRule(id: string, dto: any) {
+    const { validFrom, validUntil, passengerCategory, ...rest } = dto;
+    return this.prisma.segmentFareRule.update({
+      where: { id },
+      data: {
+        ...rest,
+        validFrom: validFrom ? new Date(validFrom) : undefined,
+        validUntil: validUntil ? new Date(validUntil) : null,
+      },
+      include: { seatClass: true, route: true },
+    });
+  }
+
+  async getFareRules(scheduleId?: string) {
+    const where: any = {};
+    if (scheduleId) where.tripId = scheduleId;
+    return this.prisma.fareRule.findMany({
+      where,
+      include: { seatClass: true },
+      orderBy: { createdAt: 'desc' },
     });
   }
 
@@ -333,14 +426,22 @@ export class SchedulesService {
     return this.fareEngine.calculateForSchedule(scheduleId, seatClassId, nationality);
   }
 
-  getAllFaresFromEngine(scheduleId: string, nationality?: string) {
-    return this.fareEngine.calculateAllForSchedule(scheduleId, nationality);
+  async getAllFaresFromEngine(scheduleId: string, nationality?: string) {
+    try {
+      const schedule = await this.prisma.trainSchedule.findUnique({
+        where: { id: scheduleId },
+        select: { routeId: true, originStationId: true, destinationStationId: true },
+      });
+      if (!schedule) throw new NotFoundException('Schedule not found');
+      if (!schedule.routeId) throw new BadRequestException('Schedule has no associated route');
+      return await this.fareEngine.calculateAllForSchedule(scheduleId, nationality);
+    } catch (error) {
+      throw new BadRequestException(
+        error instanceof Error ? error.message : 'Failed to calculate fares for schedule',
+      );
+    }
   }
 
-  /**
-   * Recalculate fares for all active seat classes on a schedule using the fare engine
-   * and upsert them as FareRule records scoped to this schedule.
-   */
   async syncFaresFromEngine(scheduleId: string): Promise<{ synced: number; errors: string[] }> {
     const results = await this.fareEngine.calculateAllForSchedule(scheduleId);
     const errors: string[] = [];
@@ -352,7 +453,6 @@ export class SchedulesService {
         const seatClass = await this.prisma.seatClass.findFirst({ where: { name: fare.seatClassName } });
         if (!seatClass) { errors.push(`Seat class not found: ${fare.seatClassName}`); continue; }
 
-        // Expire any existing active rule for this schedule + seat class
         await this.prisma.fareRule.updateMany({
           where: { tripId: scheduleId, seatClassId: seatClass.id, validUntil: null },
           data: { validUntil: now },
@@ -377,61 +477,70 @@ export class SchedulesService {
     return { synced, errors };
   }
 
-  // ── Coach Assignments ──────────────────────────────────────────────────────
-
-  async assignCoaches(
-    scheduleId: string,
-    coaches: Array<{ coachId: string; positionNumber: number }>,
-  ) {
+  async assignCoaches(scheduleId: string, coaches: Array<{ coachId: string; positionNumber: number }>) {
     const schedule = await this.prisma.trainSchedule.findUnique({ where: { id: scheduleId } });
     if (!schedule) throw new NotFoundException('Schedule not found');
 
-    // Validate all coaches exist
     const coachIds = coaches.map(c => c.coachId);
-    const existingCoaches = await this.prisma.coach.findMany({
-      where: { id: { in: coachIds } },
-    });
-    if (existingCoaches.length !== coachIds.length) {
-      throw new NotFoundException('One or more coaches not found');
-    }
+    const existingCoaches = await this.prisma.coach.findMany({ where: { id: { in: coachIds } } });
+    if (existingCoaches.length !== coachIds.length) throw new NotFoundException('One or more coaches not found');
 
-    // Remove existing assignments
     await this.prisma.coachAssignment.deleteMany({ where: { scheduleId } });
 
-    // Create new assignments
-    await this.prisma.coachAssignment.createMany({
-      data: coaches.map(c => ({
-        scheduleId,
-        coachId: c.coachId,
-        positionNumber: c.positionNumber,
-        isOperational: true,
-      })),
-    });
+    const data = coaches.map((c, idx) => ({
+      scheduleId,
+      coachId: c.coachId,
+      positionNumber: idx + 1,
+      isOperational: true,
+    }));
 
+    await this.prisma.coachAssignment.createMany({ data });
     return { message: 'Coaches assigned successfully', count: coaches.length };
   }
 
   async getAssignedCoaches(scheduleId: string) {
     return this.prisma.coachAssignment.findMany({
       where: { scheduleId },
-      include: {
-        coach: {
-          include: {
-            seatClass: true,
-            seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] },
-          },
-        },
-      },
+      include: { coach: { include: { seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] } } } },
       orderBy: { positionNumber: 'asc' },
     });
   }
 
-  async removeCoachAssignment(scheduleId: string, coachId: string) {
-    const assignment = await this.prisma.coachAssignment.findFirst({
-      where: { scheduleId, coachId },
-    });
-    if (!assignment) throw new NotFoundException('Coach assignment not found');
+  async updateSchedulePartial(id: string, dto: UpdateScheduleDto) {
+    const schedule = await this.prisma.trainSchedule.findUnique({ where: { id } });
+    if (!schedule) throw new NotFoundException('Schedule not found');
 
+    const updateData: any = {};
+
+    if (dto.departureAt || dto.arrivalAt) {
+      const dep = dto.departureAt ? new Date(dto.departureAt) : new Date(schedule.departureAt);
+      const arr = dto.arrivalAt ? new Date(dto.arrivalAt) : new Date(schedule.arrivalAt);
+      if (arr <= dep) throw new BadRequestException('Arrival time must be after departure time');
+      updateData.departureAt = dep;
+      updateData.arrivalAt = arr;
+      updateData.durationMinutes = Math.round((arr.getTime() - dep.getTime()) / 60_000);
+    }
+
+    if (dto.status) updateData.status = dto.status;
+
+    if (Object.keys(updateData).length > 0) {
+      await this.prisma.trainSchedule.update({ where: { id }, data: updateData });
+    }
+
+    if (dto.coaches !== undefined) {
+      if (dto.coaches.length > 0) {
+        await this.assignCoaches(id, dto.coaches);
+      } else {
+        await this.prisma.coachAssignment.deleteMany({ where: { scheduleId: id } });
+      }
+    }
+
+    return this.getSchedule(id);
+  }
+
+  async removeCoachAssignment(scheduleId: string, coachId: string) {
+    const assignment = await this.prisma.coachAssignment.findFirst({ where: { scheduleId, coachId } });
+    if (!assignment) throw new NotFoundException('Coach assignment not found');
     await this.prisma.coachAssignment.delete({ where: { id: assignment.id } });
     return { message: 'Coach assignment removed' };
   }

apps/edr-passenger-api/src/modules/search/search.controller.ts

@@ -11,17 +11,24 @@ export class SearchController {
   @Post()
   @ApiOperation({
     summary: 'Search trips by origin, destination, date, passengers, and nationality',
-    description: `Finds all train schedules matching search criteria with real-time seat availability.
+    description: `Finds all train schedules matching search criteria with real-time seat availability and coach type options.
 
+**Coach Type Selection Flow:**
+- Users browse available coach types (Economy, VIP, etc.)
+- Each coach type displays available seat classes and base fares
+- Users select a coach type to proceed to seat selection
+- At seat selection, users choose specific seat and class (actual price confirmed here)
+- Final fare may adjust based on seat position/amenities selected
+
+**Features:**
 - Any origin→destination stop pair (not just terminals)
 - Age-based passenger counts (adults ≥5 years, children <5 years)
 - Nationality filtering (Ethiopian, Djiboutian, Other)
 - Real-time seat availability per class
 - Multi-currency fare display
-- Example: Train A→B→C→D appears in results for A→B, A→C, A→D, B→C, B→D, C→D
-- Availability: Segment-based (seat booked A→B is still available B→D)`
+- Segment-based availability (seat booked A→B still available B→D)`
   })
-  @ApiResponse({ status: 200, description: 'Matching schedules with segment-accurate seat availability per class' })
+  @ApiResponse({ status: 200, description: 'Matching schedules with coachTypes array showing available coach types with seat classes and base fares' })
   searchTrips(@Body() dto: SearchTripsDto) {
     return this.service.searchTrips(dto);
   }

apps/edr-passenger-api/src/modules/search/search.dto.ts

@@ -21,6 +21,12 @@ export class SearchTripsDto {
 
   @ApiPropertyOptional({ example: 'Ethiopian', description: 'Passenger nationality: Ethiopian (Verifayda verification), Djiboutian (Waafi payment), Other (international payments)' })
   @IsOptional() @IsString() nationality?: string;
+
+  @ApiPropertyOptional({ example: 'ONE_WAY', enum: ['ONE_WAY', 'ROUND_TRIP'], description: 'Journey type: ONE_WAY or ROUND_TRIP' })
+  @IsOptional() @IsEnum(['ONE_WAY', 'ROUND_TRIP']) journeyType?: string;
+
+  @ApiPropertyOptional({ example: '2026-06-20', description: 'Return date (YYYY-MM-DD) — required for ROUND_TRIP, must be after outbound date' })
+  @IsOptional() @IsDateString() returnDate?: string;
 }
 
 export class FareQuoteDto {
@@ -53,4 +59,50 @@ export class FareQuoteDto {
 
   @ApiPropertyOptional({ example: 'Ethiopian', description: 'Passenger nationality for payment method filtering' })
   @IsOptional() @IsString() nationality?: string;
+
+  @ApiPropertyOptional({ example: 'schedule-uuid', description: 'Return schedule UUID (required for ROUND_TRIP journeys)' })
+  @IsOptional() @IsString() returnScheduleId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'Return origin station ID (required for ROUND_TRIP)' })
+  @IsOptional() @IsString() returnOriginStationId?: string;
+
+  @ApiPropertyOptional({ example: 'station-uuid', description: 'Return destination station ID (required for ROUND_TRIP)' })
+  @IsOptional() @IsString() returnDestinationStationId?: string;
+}
+
+export class CoachTypeOptionClass {
+  @ApiProperty({ example: 'Economy Regular' }) name: string;
+  @ApiProperty({ example: 35000 }) baseFareMinor: number;
+}
+
+export class CoachTypeOption {
+  @ApiProperty({ example: 'coach-type-uuid' }) coachTypeId: string;
+  @ApiProperty({ example: 'Economy' }) coachTypeName: string;
+  @ApiProperty({ example: 'ECO' }) coachTypeCode: string;
+  @ApiProperty({ type: 'array', items: { type: 'object', $ref: '#/components/schemas/CoachTypeOptionClass' } }) classes: CoachTypeOptionClass[];
+}
+
+export class TransitLegDto {
+  @ApiProperty({ example: 'schedule-uuid' }) scheduleId: string;
+  @ApiProperty() trainNumber: string;
+  @ApiProperty() trainName: string;
+  @ApiProperty() origin: object;
+  @ApiProperty() destination: object;
+  @ApiProperty() departureAt: Date;
+  @ApiProperty() arrivalAt: Date;
+  @ApiProperty() durationMinutes: number;
+  @ApiProperty() availabilityByClass: object;
+  @ApiProperty() faresByClass: object[];
+  @ApiProperty() coachTypes: CoachTypeOption[];
+}
+
+export class TransitResultDto {
+  @ApiProperty({ example: 'TRANSIT' }) type: string;
+  @ApiProperty({ example: 'station-uuid' }) transitStationId: string;
+  @ApiProperty({ example: 'Dire Dawa' }) transitStationName: string;
+  @ApiProperty({ description: 'Connection wait time in minutes' }) connectionMinutes: number;
+  @ApiProperty({ type: TransitLegDto }) leg1: TransitLegDto;
+  @ApiProperty({ type: TransitLegDto }) leg2: TransitLegDto;
+  @ApiProperty({ description: 'Combined minimum fare across all shared classes', example: 70000 }) combinedMinFareMinor: number;
+  @ApiProperty({ description: 'Total travel time including connection in minutes' }) totalDurationMinutes: number;
 }

apps/edr-passenger-api/src/modules/search/search.service.ts

@@ -18,17 +18,80 @@ export class SearchService {
   ) {}
 
   async searchTrips(dto: SearchTripsDto) {
-    const date = new Date(dto.date);
-    const nextDay = new Date(date.getTime() + 86_400_000);
-    const totalPassengers = dto.adultCount + (dto.childCount ?? 0);
+    const [direct, transit] = await Promise.all([
+      this.searchSchedules(
+        dto.originStationId,
+        dto.destinationStationId,
+        dto.date,
+        dto.adultCount,
+        dto.childCount,
+        dto.nationality,
+      ),
+      this.searchTransitOptions(
+        dto.originStationId,
+        dto.destinationStationId,
+        dto.date,
+        dto.adultCount,
+        dto.childCount,
+        dto.nationality,
+      ),
+    ]);
+
+    const outbound = [...direct, ...transit];
+
+    if (dto.journeyType === 'ROUND_TRIP') {
+      const [returnDirect, returnTransit] = await Promise.all([
+        this.searchSchedules(
+          dto.destinationStationId,
+          dto.originStationId,
+          dto.returnDate ?? dto.date,
+          dto.adultCount,
+          dto.childCount,
+          dto.nationality,
+        ),
+        this.searchTransitOptions(
+          dto.destinationStationId,
+          dto.originStationId,
+          dto.returnDate ?? dto.date,
+          dto.adultCount,
+          dto.childCount,
+          dto.nationality,
+        ),
+      ]);
+
+      const allReturn = [...returnDirect, ...returnTransit];
+      const latestOutboundArrival = outbound.length > 0
+        ? Math.max(...outbound.map((s: any) => new Date(s.arrivalAt ?? s.leg2?.arrivalAt).getTime()))
+        : Date.now();
+
+      const inbound = allReturn.filter((s: any) =>
+        new Date(s.departureAt ?? s.leg1?.departureAt).getTime() > latestOutboundArrival
+      );
+
+      return { journeyType: 'ROUND_TRIP', outbound, inbound };
+    }
+
+    return { journeyType: 'ONE_WAY', outbound };
+  }
+
+  private async searchSchedules(
+    originStationId: string,
+    destinationStationId: string,
+    dateStr: string,
+    adultCount: number,
+    childCount?: number,
+    nationality?: string,
+  ) {
+    const [y, m, d] = dateStr.split('-').map(Number);
+    const date    = new Date(y, m - 1, d, 0, 0, 0, 0);
+    const nextDay = new Date(y, m - 1, d + 1, 0, 0, 0, 0);
+    const totalPassengers = adultCount + (childCount ?? 0);
 
-    // Find all schedules that have BOTH origin and destination as stops
-    // (not just terminal-to-terminal) and depart on the requested date
     const schedules = await this.prisma.trainSchedule.findMany({
       where: {
         status: { in: ['SCHEDULED', 'BOARDING'] },
         departureAt: { gte: date, lt: nextDay },
-        stopTimes: { some: { stationId: dto.originStationId } },
+        stopTimes: { some: { stationId: originStationId } },
       },
       include: {
         train: true,
@@ -36,93 +99,216 @@ export class SearchService {
         destinationStation: true,
         stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
         coachAssignments: {
-          include: { coach: { include: { seats: true, seatClass: true } } },
+          include: { coach: { include: { seats: true, coachType: { include: { seatClasses: true } } } } },
         },
       },
     });
 
-    const results = [];
-
+    const results: any[] = [];
     for (const schedule of schedules) {
-      const originStop = schedule.stopTimes.find(s => s.stationId === dto.originStationId);
-      const destStop = schedule.stopTimes.find(s => s.stationId === dto.destinationStationId);
+      const result = await this.buildScheduleResult(schedule, originStationId, destinationStationId, totalPassengers, nationality);
+      if (result) results.push(result);
+    }
+    return results;
+  }
 
-      // Both stops must exist and origin must come before destination
-      if (!originStop || !destStop || originStop.sequence >= destStop.sequence) continue;
+  // ── Transit search ─────────────────────────────────────────────────────────
+  // Finds pairs of schedules (leg1: origin→transit, leg2: transit→destination)
+  // where the passenger has between MIN_CONNECTION and MAX_CONNECTION minutes
+  // to change trains at the transit station.
+  private readonly MIN_CONNECTION_MINUTES = 30;
+  private readonly MAX_CONNECTION_MINUTES = 360;
 
-      // Compute per-seat availability for the requested segment range
-      // A seat is available if no active booking/hold overlaps [originSeq, destSeq)
-      const availabilityByClass: Record<string, number> = {};
+  private async searchTransitOptions(
+    originStationId: string,
+    destinationStationId: string,
+    dateStr: string,
+    adultCount: number,
+    childCount?: number,
+    nationality?: string,
+  ) {
+    // Find all stations that can serve as transit points:
+    // they must be a stop after origin on some schedule AND
+    // a stop before destination on another schedule on the same day.
+    const [y, m, d] = dateStr.split('-').map(Number);
+    const dayStart = new Date(y, m - 1, d, 0, 0, 0, 0);
+    const dayEnd   = new Date(y, m - 1, d + 1, 0, 0, 0, 0);
+    const totalPassengers = adultCount + (childCount ?? 0);
 
-      for (const assignment of schedule.coachAssignments) {
-        const className = assignment.coach.seatClass.name;
-        if (!availabilityByClass[className]) availabilityByClass[className] = 0;
+    // Load all schedules on this date that pass through origin
+    const leg1Schedules = await this.prisma.trainSchedule.findMany({
+      where: {
+        status: { in: ['SCHEDULED', 'BOARDING'] },
+        departureAt: { gte: dayStart, lt: dayEnd },
+        stopTimes: { some: { stationId: originStationId } },
+      },
+      include: {
+        train: true,
+        originStation: true,
+        destinationStation: true,
+        stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
+        coachAssignments: {
+          include: { coach: { include: { seats: true, coachType: { include: { seatClasses: true } } } } },
+        },
+      },
+    });
 
-        for (const seat of assignment.coach.seats) {
-          if (seat.status === 'BLOCKED') continue;
-          // Use segment-aware check — a seat booked A→B is still free for B→D
-          const free = await this.segmentsService.isSeatFreeForLeg(
-            schedule.id, seat.id,
-            originStop.sequence, destStop.sequence,
-          );
-          if (free) availabilityByClass[className]++;
-        }
-      }
+    const results: any[] = [];
 
-      // Departure/arrival times for the requested leg (not the full schedule)
-      const legDepartureAt = originStop.plannedDepartureAt ?? schedule.departureAt;
-      const legArrivalAt = destStop.plannedArrivalAt ?? schedule.arrivalAt;
+    for (const leg1 of leg1Schedules) {
+      const originStop = leg1.stopTimes.find((s: any) => s.stationId === originStationId);
+      if (!originStop) continue;
 
-      // Fetch fares for all seat classes - need to pass the SEARCH origin/destination, not schedule terminals
-      const faresByClass = await this.calculateFaresForSegment(
-        schedule,
-        dto.originStationId,
-        dto.destinationStationId,
-        dto.nationality,
+      // Every stop after origin on leg1 is a candidate transit station
+      const candidateTransitStops = leg1.stopTimes.filter(
+        (s: any) => s.sequence > originStop.sequence,
       );
 
-      results.push({
-        scheduleId: schedule.id,
-        trainNumber: schedule.train.number,
-        trainName: schedule.train.name,
-        origin: {
-          id: originStop.stationId,
-          code: originStop.station.code,
-          name: originStop.station.name,
-          city: originStop.station.city,
-          sequence: originStop.sequence,
-        },
-        destination: {
-          id: destStop.stationId,
-          code: destStop.station.code,
-          name: destStop.station.name,
-          city: destStop.station.city,
-          sequence: destStop.sequence,
-        },
-        departureAt: legDepartureAt,
-        arrivalAt: legArrivalAt,
-        durationMinutes: Math.round(
-          (new Date(legArrivalAt).getTime() - new Date(legDepartureAt).getTime()) / 60_000,
-        ),
-        status: schedule.status,
-        stops: schedule.stopTimes
-          .filter(st => st.sequence >= originStop.sequence && st.sequence <= destStop.sequence)
-          .map(st => ({
-          stationId: st.stationId,
-          stationName: st.station.name,
-          sequence: st.sequence,
-          plannedArrivalAt: st.plannedArrivalAt,
-          plannedDepartureAt: st.plannedDepartureAt,
-        })),
-        availabilityByClass,
-        hasAvailability: Object.values(availabilityByClass).some(n => n >= totalPassengers),
-        faresByClass,
-      });
+      for (const transitStop of candidateTransitStops) {
+        // leg1 must NOT already contain the final destination
+        const leg1HasDest = leg1.stopTimes.some((s: any) => s.stationId === destinationStationId);
+        if (leg1HasDest) continue; // direct route exists — already returned by searchSchedules
+
+        const transitStationId = transitStop.stationId;
+        const leg1ArrivalAt = transitStop.plannedArrivalAt ?? transitStop.plannedDepartureAt ?? leg1.arrivalAt;
+
+        // Find leg2 schedules departing from the transit station within the connection window,
+        // and reaching the final destination. Search up to the next calendar day to handle
+        // overnight connections.
+        const connWindowStart = new Date(new Date(leg1ArrivalAt).getTime() + this.MIN_CONNECTION_MINUTES * 60_000);
+        const connWindowEnd   = new Date(new Date(leg1ArrivalAt).getTime() + this.MAX_CONNECTION_MINUTES * 60_000);
+
+        const leg2Schedules = await this.prisma.trainSchedule.findMany({
+          where: {
+            status: { in: ['SCHEDULED', 'BOARDING'] },
+            departureAt: { gte: connWindowStart, lte: connWindowEnd },
+            stopTimes: { some: { stationId: transitStationId } },
+          },
+          include: {
+            train: true,
+            originStation: true,
+            destinationStation: true,
+            stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
+            coachAssignments: {
+              include: { coach: { include: { seats: true, coachType: { include: { seatClasses: true } } } } },
+            },
+          },
+        });
+
+        for (const leg2 of leg2Schedules) {
+          const leg2TransitStop = leg2.stopTimes.find((s: any) => s.stationId === transitStationId);
+          const leg2DestStop    = leg2.stopTimes.find((s: any) => s.stationId === destinationStationId);
+
+          if (!leg2TransitStop || !leg2DestStop) continue;
+          if (leg2TransitStop.sequence >= leg2DestStop.sequence) continue;
+
+          // Build individual leg result objects (reuse existing per-schedule logic)
+          const [leg1Result, leg2Result] = await Promise.all([
+            this.buildScheduleResult(leg1, originStationId, transitStationId, totalPassengers, nationality),
+            this.buildScheduleResult(leg2, transitStationId, destinationStationId, totalPassengers, nationality),
+          ]);
+
+          if (!leg1Result || !leg2Result) continue;
+          if (!leg1Result.hasAvailability || !leg2Result.hasAvailability) continue;
+
+          const leg2DepartureAt = leg2TransitStop.plannedDepartureAt ?? leg2.departureAt;
+          const connectionMinutes = Math.round(
+            (new Date(leg2DepartureAt).getTime() - new Date(leg1ArrivalAt).getTime()) / 60_000,
+          );
+
+          const leg1MinFare = Math.min(...(leg1Result.faresByClass as any[]).map((f: any) => f.baseFareMinor).filter((n: number) => n > 0), Infinity);
+          const leg2MinFare = Math.min(...(leg2Result.faresByClass as any[]).map((f: any) => f.baseFareMinor).filter((n: number) => n > 0), Infinity);
+          const combinedMinFareMinor = (isFinite(leg1MinFare) ? leg1MinFare : 0) + (isFinite(leg2MinFare) ? leg2MinFare : 0);
+
+          results.push({
+            type: 'TRANSIT',
+            transitStationId,
+            transitStationName: transitStop.station.name,
+            connectionMinutes,
+            leg1: leg1Result,
+            leg2: leg2Result,
+            combinedMinFareMinor,
+            // Convenience top-level fields so round-trip filter can read them uniformly
+            departureAt: leg1Result.departureAt,
+            arrivalAt:   leg2Result.arrivalAt,
+            totalDurationMinutes:
+              leg1Result.durationMinutes + connectionMinutes + leg2Result.durationMinutes,
+          });
+        }
+      }
     }
 
     return results;
   }
 
+  // Builds the same result shape as searchSchedules for a single schedule+leg,
+  // extracted so both direct and transit paths share identical output.
+  private async buildScheduleResult(
+    schedule: any,
+    originStationId: string,
+    destinationStationId: string,
+    totalPassengers: number,
+    nationality?: string,
+  ) {
+    const originStop = schedule.stopTimes.find((s: any) => s.stationId === originStationId);
+    const destStop   = schedule.stopTimes.find((s: any) => s.stationId === destinationStationId);
+    if (!originStop || !destStop || originStop.sequence >= destStop.sequence) return null;
+
+    const availabilityByClass: Record<string, number> = {};
+    for (const assignment of schedule.coachAssignments) {
+      const seatClassNames = assignment.coach.coachType?.seatClasses?.map((sc: any) => sc.name) || ['Standard'];
+      const isBedCoach = assignment.coach.seats.some((s: any) => s.bedPosition);
+
+      if (isBedCoach) {
+        for (const bedPosition of ['upper', 'middle', 'lower']) {
+          let count = 0;
+          for (const seat of assignment.coach.seats) {
+            if (seat.bedPosition !== bedPosition || seat.status === 'BLOCKED' || !seat.seatNumber?.trim()) continue;
+            const free = await this.segmentsService.isSeatFreeForLeg(schedule.id, seat.id, originStop.sequence, destStop.sequence);
+            if (free) count++;
+          }
+          if (count > 0) {
+            const matchingClass = seatClassNames.find((n: string) => n.toLowerCase().includes(bedPosition));
+            if (matchingClass) availabilityByClass[matchingClass] = (availabilityByClass[matchingClass] ?? 0) + count;
+          }
+        }
+      } else {
+        let available = 0;
+        for (const seat of assignment.coach.seats) {
+          if (seat.status === 'BLOCKED' || !seat.seatNumber?.trim()) continue;
+          const free = await this.segmentsService.isSeatFreeForLeg(schedule.id, seat.id, originStop.sequence, destStop.sequence);
+          if (free) available++;
+        }
+        for (const name of seatClassNames) availabilityByClass[name] = (availabilityByClass[name] ?? 0) + available;
+      }
+    }
+
+    const faresByClass = await this.calculateFaresForSegment(schedule, originStationId, destinationStationId, nationality);
+    const coachTypes   = await this.buildCoachTypeDetails(schedule, faresByClass);
+    const legDepartureAt = originStop.plannedDepartureAt ?? schedule.departureAt;
+    const legArrivalAt   = destStop.plannedArrivalAt   ?? schedule.arrivalAt;
+
+    return {
+      type: 'DIRECT',
+      scheduleId: schedule.id,
+      trainNumber: schedule.train.number,
+      trainName:   schedule.train.name,
+      origin: { id: originStop.stationId, code: originStop.station.code, name: originStop.station.name, city: originStop.station.city, sequence: originStop.sequence },
+      destination: { id: destStop.stationId, code: destStop.station.code, name: destStop.station.name, city: destStop.station.city, sequence: destStop.sequence },
+      departureAt: legDepartureAt,
+      arrivalAt:   legArrivalAt,
+      durationMinutes: Math.round((new Date(legArrivalAt).getTime() - new Date(legDepartureAt).getTime()) / 60_000),
+      status: schedule.status,
+      stops: schedule.stopTimes
+        .filter((st: any) => st.sequence >= originStop.sequence && st.sequence <= destStop.sequence)
+        .map((st: any) => ({ stationId: st.stationId, stationName: st.station.name, sequence: st.sequence, plannedArrivalAt: st.plannedArrivalAt, plannedDepartureAt: st.plannedDepartureAt })),
+      availabilityByClass,
+      hasAvailability: Object.values(availabilityByClass).some(n => n >= totalPassengers),
+      faresByClass,
+      coachTypes,
+    };
+  }
+
   async getFareQuote(dto: FareQuoteDto) {
     const schedule = await this.prisma.trainSchedule.findUnique({
       where: { id: dto.scheduleId },
@@ -134,51 +320,19 @@ export class SearchService {
     });
     if (!schedule) throw new NotFoundException('Schedule not found');
 
-    const originStop = schedule.stopTimes.find(s => s.stationId === dto.originStationId);
-    const destStop = schedule.stopTimes.find(s => s.stationId === dto.destinationStationId);
+    const originStop = schedule.stopTimes.find((s: any) => s.stationId === dto.originStationId);
+    const destStop = schedule.stopTimes.find((s: any) => s.stationId === dto.destinationStationId);
     if (!originStop || !destStop || originStop.sequence >= destStop.sequence) {
       throw new NotFoundException('Origin or destination not found on this schedule');
     }
 
     const seatClass = await this.prisma.seatClass.findFirst({ where: { name: dto.seatClassName } });
 
-    // Compute route codes for fare lookup
     const segmentRoute = `${originStop.station.code}-${destStop.station.code}`;
     const fullRoute = `${schedule.originStation.code}-${schedule.destinationStation.code}`;
     const now = new Date();
     const nationality = dto.nationality;
 
-    // Query fare rules with specificity ordering:
-    // 1. schedule+segment+nationality
-    // 2. schedule+segment
-    // 3. schedule+full-route+nationality
-    // 4. schedule+full-route
-    // 5. schedule+global
-    // 6. segment+nationality
-    // 7. segment
-    // 8. full-route+nationality
-    // 9. full-route
-    // 10. global
-    const fareRule = await this.prisma.fareRule.findFirst({
-      where: {
-        seatClassId: seatClass?.id,
-        validFrom: { lte: now },
-        OR: [
-          { validUntil: null },
-          { validUntil: { gte: now } },
-        ],
-      },
-      orderBy: [
-        // Prioritize schedule-specific rules
-        { tripId: { sort: 'desc', nulls: 'last' } },
-        // Then prioritize nationality match
-        { nationality: { sort: 'desc', nulls: 'last' } },
-        // Most recent validFrom
-        { validFrom: 'desc' },
-      ],
-    });
-
-    // Manual specificity filtering to find best match
     const candidates = await this.prisma.fareRule.findMany({
       where: {
         seatClassId: seatClass?.id,
@@ -198,7 +352,8 @@ export class SearchService {
       nationality,
     );
 
-    const baseFareMinor = bestMatch?.baseFareMinor ?? this.defaultFare(dto.seatClassName);
+    const baseFareMinor = bestMatch?.baseFareMinor
+      ?? await this.resolveScheduleFare(dto.scheduleId, seatClass?.id, dto.seatClassName);
 
     const adultCount = dto.adultCount;
     const childCount = dto.childCount ?? 0;
@@ -243,38 +398,39 @@ export class SearchService {
     };
   }
 
-  /**
-   * Calculate fares for a specific segment of a schedule
-   */
   private async calculateFaresForSegment(
     schedule: any,
     originStationId: string,
     destinationStationId: string,
     nationality?: string,
   ): Promise<Array<{ seatClassName: string; baseFareMinor: number }>> {
-    // Get seat classes that are actually assigned to this schedule via coaches
-    const assignedSeatClassIds: string[] = Array.from(
+    const seatClassIds: string[] = Array.from(
       new Set(
-        schedule.coachAssignments.map((a: any) => a.coach.seatClass.id as string)
+        schedule.coachAssignments
+          .flatMap((a: any) => a.coach.coachType?.seatClasses || [])
+          .map((sc: any) => sc.id)
+          .filter((id: any) => id)
       )
     );
-    
-    // Get only the seat classes that are assigned to this schedule
-    const seatClasses = await this.prisma.seatClass.findMany({
-      where: { 
-        isActive: true,
-        id: { in: assignedSeatClassIds }
-      },
-      orderBy: { basePrice: 'asc' },
-    });
 
-    // If no coaches assigned, return empty array
-    if (seatClasses.length === 0) {
+    if (seatClassIds.length === 0) {
       console.log(`No seat classes assigned to schedule ${schedule.id}`);
       return [];
     }
 
-    // If schedule has a route, use route-based calculation
+    const seatClasses = await this.prisma.seatClass.findMany({
+      where: {
+        isActive: true,
+        id: { in: seatClassIds }
+      },
+      orderBy: { baseFareMinor: 'asc' },
+    });
+
+    if (seatClasses.length === 0) {
+      console.log(`No active seat classes for schedule ${schedule.id}`);
+      return [];
+    }
+
     if (schedule.routeId) {
       const results = await Promise.all(
         seatClasses.map(async (sc) => {
@@ -285,6 +441,7 @@ export class SearchService {
               destinationStationId,
               seatClassId: sc.id,
               nationality,
+              scheduleId: schedule.id,
             });
             return {
               seatClassName: fare.seatClassName,
@@ -303,10 +460,9 @@ export class SearchService {
       }
     }
 
-    // Fallback: Try to get fares from FareRule table
     const originStation = await this.prisma.station.findUnique({ where: { id: originStationId } });
     const destStation = await this.prisma.station.findUnique({ where: { id: destinationStationId } });
-    
+
     if (originStation && destStation) {
       const segmentRoute = `${originStation.code}-${destStation.code}`;
       const now = new Date();
@@ -314,105 +470,111 @@ export class SearchService {
       const fareRules = await this.prisma.fareRule.findMany({
         where: {
           route: segmentRoute,
-          seatClassId: { in: assignedSeatClassIds },
+          seatClassId: { in: seatClassIds },
           validFrom: { lte: now },
           OR: [
             { validUntil: null },
             { validUntil: { gte: now } },
           ],
         },
-        include: { seatClass: true },
       });
 
       if (fareRules.length > 0) {
         console.log(`Found ${fareRules.length} fare rules for segment ${segmentRoute}`);
+        const seatClassMap = Object.fromEntries(seatClasses.map(sc => [sc.id, sc.name]));
         return fareRules.map(rule => ({
-          seatClassName: rule.seatClass.name,
+          seatClassName: seatClassMap[rule.seatClassId] || 'Unknown',
           baseFareMinor: rule.baseFareMinor,
         }));
       }
     }
 
-    // Last resort: Return default fares only for assigned seat classes
-    console.log(`No fares found, using defaults for ${originStationId} to ${destinationStationId}`);
-    return seatClasses.map(sc => ({
-      seatClassName: sc.name,
-      baseFareMinor: this.getDefaultFareForClass(sc.name),
-    }));
+    console.log(`No fares found via engine or rules for ${originStationId} to ${destinationStationId}`);
+    return [];
   }
 
-  private getDefaultFareForClass(className: string): number {
-    const defaults: Record<string, number> = {
-      'Economy Regular': 35000,
-      'Economy Bed': 49000,
-      'VIP Bed': 63000,
-    };
-    return defaults[className] ?? 35000;
-  }
+  private async buildCoachTypeDetails(
+    schedule: any,
+    faresByClass: Array<{ seatClassName: string; baseFareMinor: number }>,
+  ): Promise<Array<{
+    coachTypeId: string;
+    coachTypeName: string;
+    coachTypeCode: string;
+    coachId: string;
+    classes: Array<{ name: string; baseFareMinor: number }>;
+  }>> {
+    const coachTypeMap = new Map<
+      string,
+      { coachType: any; classNames: Set<string>; coachId: string }
+    >();
 
-  private defaultFare(seatClassName: string): number {
-    const fares: Record<string, number> = {
-      'Economy Regular': 45000,
-      'Economy Bed': 65000,
-      'VIP Bed': 95000,
-    };
-    return fares[seatClassName] ?? 45000;
-  }
+    for (const assignment of schedule.coachAssignments) {
+      const coachType = assignment.coach.coachType;
+      if (!coachType) continue;
 
-  /**
-   * Fallback method to get fares from FareRule table when fare engine fails
-   */
-  private async getFallbackFares(
-    scheduleId: string,
-    originCode: string,
-    destCode: string,
-  ): Promise<Array<{ seatClassName: string; baseFareMinor: number }>> {
-    const segmentRoute = `${originCode}-${destCode}`;
-    const now = new Date();
+      if (!coachTypeMap.has(coachType.id)) {
+        coachTypeMap.set(coachType.id, {
+          coachType,
+          classNames: new Set(),
+          coachId: assignment.coach.id,
+        });
+      }
 
-    // Try to find fare rules for this segment
-    const fareRules = await this.prisma.fareRule.findMany({
-      where: {
-        route: segmentRoute,
-        validFrom: { lte: now },
-        OR: [
-          { validUntil: null },
-          { validUntil: { gte: now } },
-        ],
-      },
-      include: { seatClass: true },
-    });
-
-    if (fareRules.length > 0) {
-      console.log(`Found ${fareRules.length} fare rules for segment ${segmentRoute}`);
-      return fareRules.map(rule => ({
-        seatClassName: rule.seatClass.name,
-        baseFareMinor: rule.baseFareMinor,
-      }));
+      const entry = coachTypeMap.get(coachType.id)!;
+      coachType.seatClasses?.forEach((sc: any) => entry.classNames.add(sc.name));
     }
 
-    // If no segment-specific rules, return default fares
-    console.log(`No fare rules found for ${segmentRoute}, using defaults`);
-    return [
-      { seatClassName: 'Economy Regular', baseFareMinor: 35000 },
-      { seatClassName: 'Economy Bed', baseFareMinor: 49000 },
-      { seatClassName: 'VIP Bed', baseFareMinor: 63000 },
-    ];
+    const result = [];
+    for (const [, { coachType, classNames, coachId }] of coachTypeMap) {
+      const classes = Array.from(classNames)
+        .map((className) => {
+          const fareInfo = faresByClass.find((f) => f.seatClassName === className);
+          if (!fareInfo) return null;
+          return { name: className, baseFareMinor: fareInfo.baseFareMinor };
+        })
+        .filter((c): c is { name: string; baseFareMinor: number } => c !== null)
+        .sort((a, b) => a.baseFareMinor - b.baseFareMinor);
+
+      result.push({
+        coachTypeId: coachType.id,
+        coachTypeName: coachType.name,
+        coachTypeCode: coachType.code,
+        coachId,
+        classes,
+      });
+    }
+
+    return result.sort((a, b) => {
+      const minPriceA = Math.min(...a.classes.map((c) => c.baseFareMinor));
+      const minPriceB = Math.min(...b.classes.map((c) => c.baseFareMinor));
+      return minPriceA - minPriceB;
+    });
+  }
+
+  private async resolveScheduleFare(scheduleId: string, seatClassId?: string, seatClassName?: string): Promise<number> {
+    if (!seatClassId) throw new NotFoundException(`Seat class '${seatClassName}' not found`);
+    const schedule = await this.prisma.trainSchedule.findUnique({
+      where: { id: scheduleId },
+      select: { routeId: true, originStationId: true, destinationStationId: true },
+    });
+    if (!schedule?.routeId) throw new NotFoundException('Schedule has no route configured for fare calculation');
+    const fare = await this.fareEngine.calculate({
+      routeId: schedule.routeId,
+      originStationId: schedule.originStationId,
+      destinationStationId: schedule.destinationStationId,
+      seatClassId,
+    });
+    return fare.baseFarePerPassengerMinor;
+  }
+
+  private getDefaultFareForClass(_className: string): never {
+    throw new Error('getDefaultFareForClass should not be called — use resolveScheduleFare instead');
+  }
+
+  private defaultFare(_seatClassName: string): never {
+    throw new Error('defaultFare should not be called — use resolveScheduleFare instead');
   }
 
-  /**
-   * Select the best matching fare rule based on specificity:
-   * 1. schedule+segment+nationality
-   * 2. schedule+segment
-   * 3. schedule+full-route+nationality
-   * 4. schedule+full-route
-   * 5. schedule+global
-   * 6. segment+nationality
-   * 7. segment
-   * 8. full-route+nationality
-   * 9. full-route
-   * 10. global
-   */
   private selectBestFareRule(
     candidates: any[],
     scheduleId: string,
@@ -421,19 +583,16 @@ export class SearchService {
     nationality?: string,
   ): any | null {
     const priorities = [
-      // Schedule-specific rules
       { tripId: scheduleId, route: segmentRoute, nationality },
       { tripId: scheduleId, route: segmentRoute, nationality: null },
       { tripId: scheduleId, route: fullRoute, nationality },
       { tripId: scheduleId, route: fullRoute, nationality: null },
       { tripId: scheduleId, route: null, nationality },
       { tripId: scheduleId, route: null, nationality: null },
-      // Route-specific rules (no schedule)
       { tripId: null, route: segmentRoute, nationality },
       { tripId: null, route: segmentRoute, nationality: null },
       { tripId: null, route: fullRoute, nationality },
       { tripId: null, route: fullRoute, nationality: null },
-      // Global rules
       { tripId: null, route: null, nationality },
       { tripId: null, route: null, nationality: null },
     ];

apps/edr-passenger-api/src/modules/seat-classes/seat-classes.service.ts

@@ -1,41 +1,33 @@
 import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
 import { PrismaService } from '../../common/prisma.service';
-import { CreateSeatClassDto, UpdateSeatClassDto } from './seat-classes.dto';
 
 @Injectable()
 export class SeatClassesService {
   constructor(private prisma: PrismaService) {}
 
-  private readonly coachInclude = {
-    coaches: {
-      select: { id: true, coachNumber: true, label: true, mode: true, totalUnits: true, _count: { select: { seats: true } } },
-      orderBy: { label: 'asc' as const },
-    },
-  };
-
   listSeatClasses() {
-    return this.prisma.seatClass.findMany({ orderBy: { createdAt: 'asc' }, include: this.coachInclude });
+    return this.prisma.seatClass.findMany({ orderBy: { createdAt: 'asc' } });
   }
 
   async getSeatClass(id: string) {
-    const sc = await this.prisma.seatClass.findUnique({ where: { id }, include: this.coachInclude });
+    const sc = await this.prisma.seatClass.findUnique({ where: { id } });
     if (!sc) throw new NotFoundException('SeatClass not found');
     return sc;
   }
 
-  async createSeatClass(dto: CreateSeatClassDto) {
+  async createSeatClass(dto: any) {
     try {
-      return await this.prisma.seatClass.create({ data: dto, include: this.coachInclude });
+      return await this.prisma.seatClass.create({ data: dto });
     } catch (e: any) {
       if (e.code === 'P2002') throw new ConflictException(`Seat class "${dto.name}" already exists`);
       throw e;
     }
   }
 
-  async updateSeatClass(id: string, dto: UpdateSeatClassDto) {
+  async updateSeatClass(id: string, dto: any) {
     const sc = await this.prisma.seatClass.findUnique({ where: { id } });
     if (!sc) throw new NotFoundException('SeatClass not found');
-    return this.prisma.seatClass.update({ where: { id }, data: dto, include: this.coachInclude });
+    return this.prisma.seatClass.update({ where: { id }, data: dto });
   }
 
   async deleteSeatClass(id: string) {

apps/edr-passenger-api/src/modules/seats/seats.controller.ts

@@ -1,8 +1,9 @@
-import { Body, Controller, Delete, Get, Param, Post, Query, UseGuards } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, Post, Patch, Query, UseGuards } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth, ApiParam, ApiQuery, ApiResponse } from '@nestjs/swagger';
 import { SeatsService } from './seats.service';
 import { HoldSeatsDto } from './seats.dto';
 import { JwtGuard } from '../../common/jwt.guard';
+import { IamGuard } from '../../common/iam-adapter';
 
 @ApiTags('Seats')
 @Controller('seats')
@@ -78,6 +79,47 @@ This makes it clear which segment of the route each seat is held for, enabling s
   @ApiResponse({ status: 404, description: 'Hold not found' })
   releaseHold(@Param('holdId') holdId: string) { return this.service.releaseHold(holdId); }
 
+  // ── Seat Block / Unblock ───────────────────────────────────────────────────
+  @Post(':seatId/block')
+  @UseGuards(IamGuard) @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'Block a seat (e.g., maintenance, damage)' })
+  @ApiParam({ name: 'seatId', description: 'Seat UUID' })
+  @ApiResponse({ status: 200, description: 'Seat blocked' })
+  blockSeat(@Param('seatId') seatId: string, @Body() body: { reason: string }) {
+    return this.service.blockSeat(seatId, body.reason);
+  }
+
+  @Delete(':seatId/block')
+  @UseGuards(IamGuard) @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'Unblock a seat' })
+  @ApiParam({ name: 'seatId', description: 'Seat UUID' })
+  @ApiResponse({ status: 200, description: 'Seat unblocked' })
+  unblockSeat(@Param('seatId') seatId: string) {
+    return this.service.unblockSeat(seatId);
+  }
+
+  // ── Remove Seat ────────────────────────────────────────────────────────────
+  @Patch(':seatId/remove')
+  @UseGuards(IamGuard) @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'Remove a seat by marking with negative seatNumber' })
+  @ApiParam({ name: 'seatId', description: 'Seat UUID' })
+  @ApiResponse({ status: 200, description: 'Seat removed (seatNumber negated), shows as empty space' })
+  @ApiResponse({ status: 404, description: 'Seat not found' })
+  removeSeat(@Param('seatId') seatId: string) {
+    return this.service.removeSeat(seatId);
+  }
+
+  @Patch(':seatId/undo-remove')
+  @UseGuards(IamGuard) @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'Undo seat removal by restoring original seatNumber' })
+  @ApiParam({ name: 'seatId', description: 'Seat UUID' })
+  @ApiResponse({ status: 200, description: 'Seat restored (negative seatNumber removed)' })
+  @ApiResponse({ status: 404, description: 'Seat not found' })
+  @ApiResponse({ status: 400, description: 'Seat is not removed' })
+  undoRemoveSeat(@Param('seatId') seatId: string) {
+    return this.service.undoRemoveSeat(seatId);
+  }
+
   @Get('export/csv/:scheduleId') @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth') @ApiOperation({ summary: 'Export seats as CSV' })
   async exportCSV(@Param('scheduleId') scheduleId: string) {
     const csv = await this.service.exportSeatsCSV(scheduleId);

apps/edr-passenger-api/src/modules/seats/seats.module.ts

@@ -1,10 +1,12 @@
 import { Module } from '@nestjs/common';
+import { HttpModule } from '@nestjs/axios';
 import { SeatsController } from './seats.controller';
 import { SeatsService } from './seats.service';
 import { SegmentsModule } from '../segments/segments.module';
+import { IamModule } from '../../common/iam.module';
 
 @Module({
-  imports: [SegmentsModule],
+  imports: [SegmentsModule, HttpModule, IamModule],
   controllers: [SeatsController],
   providers: [SeatsService],
   exports: [SeatsService],

apps/edr-passenger-api/src/modules/seats/seats.service.spec.ts

@@ -62,7 +62,7 @@ describe('SeatsService - Auto Assign', () => {
 
       mockPrisma.seat.findMany.mockResolvedValue(mockSeats);
 
-      const result = await service.autoAssignSeats('trip-1', 2, 'ECONOMY_REGULAR', 'ACCESSIBLE');
+      const result = await service.autoAssignSeats('trip-1', 2, 'ECONOMY_REGULAR');
 
       expect(result).toHaveLength(2);
     });

apps/edr-passenger-api/src/modules/seats/seats.service.ts

@@ -11,48 +11,68 @@ export class SeatsService {
     private segmentsService: SegmentsService,
   ) {}
 
-  // ── Seat Map ──────────────────────────────────────────────────────────────
   async getSeatMap(scheduleId: string, coachId?: string) {
     const assignments = await this.prisma.coachAssignment.findMany({
       where: { scheduleId, ...(coachId ? { coachId } : {}) },
-      include: { coach: { include: { seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] }, seatClass: true } } },
+      include: {
+        coach: {
+          include: {
+            seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] },
+            coachType: { include: { seatClasses: true } },
+          },
+        },
+      },
       orderBy: { positionNumber: 'asc' },
     });
 
-    const allSeatIds = assignments.flatMap(a => a.coach.seats.map(s => s.id));
+    console.log(`[getSeatMap] scheduleId=${scheduleId}, coachId=${coachId}, found ${assignments.length} coach assignments`);
+
+    const allSeatIds = assignments.flatMap((a: any) => a.coach.seats.map((s: any) => s.id));
     const effectiveStatuses = await this.resolveEffectiveStatuses(scheduleId, allSeatIds);
 
-    return {
-      coaches: assignments.map((a) => ({
-        id: a.coach.id,
-        assignmentId: a.id,
-        name: `Coach ${a.coach.label}`,
-        seatClass: a.coach.seatClass.name,
-        positionNumber: a.positionNumber,
-        seats: a.coach.seats.map((s) => ({
-          id: s.id,
-          number: s.label,
-          status: effectiveStatuses.get(s.id) ?? s.status,
-          kind: s.kind,
-          row: s.row,
-          col: s.col,
-          isWindow: s.isWindow,
-          isAisle: s.isAisle,
-          bedPosition: s.bedPosition,
-        })),
-      })),
+    const response = {
+      coaches: assignments.map((a) => {
+        const allSeats = a.coach.seats;
+        const seatClassNames = a.coach.coachType.seatClasses.map((sc: any) => sc.name);
+        
+        return {
+          id: a.coach.id,
+          assignmentId: a.id,
+          coachNumber: a.coach.number,
+          label: a.coach.number,
+          mode: a.coach.status,
+          name: `Coach ${a.coach.number}`,
+          seatClasses: seatClassNames,
+          seatClass: seatClassNames.length > 0 ? seatClassNames[0] : 'Standard',
+          positionNumber: a.positionNumber,
+          seatArrangement: a.coach.arrangement,
+          totalSeats: a.coach.capacity,
+          seats: allSeats.map((s) => ({
+            id: s.id,
+            seatNumber: s.seatNumber,
+            number: s.seatNumber,
+            label: s.seatNumber,
+            status: effectiveStatuses.get(s.id) ?? s.status,
+            kind: s.kind,
+            row: s.row,
+            col: s.col,
+            isWindow: s.isWindow,
+            isAisle: s.isAisle,
+            bedPosition: s.bedPosition,
+            coach: {
+              id: a.coach.id,
+              coachNumber: a.coach.number,
+              label: a.coach.number,
+            },
+          })),
+        };
+      }),
     };
+
+    console.log(`[getSeatMap] returning ${response.coaches.length} coaches with seats`);
+    return response;
   }
 
-  /**
-   * Computes the effective seat status for a set of seats on a specific schedule
-   * by checking active SeatHolds and confirmed JourneySegments.
-   *
-   * Priority: BLOCKED (physical) > BOOKED (confirmed journey) > HELD (active hold) > AVAILABLE
-   *
-   * This is needed because seat.status is no longer written during booking —
-   * availability is segment-scoped, so the DB column stays AVAILABLE even when held.
-   */
   async resolveEffectiveStatuses(
     scheduleId: string,
     seatIds: string[],
@@ -61,7 +81,6 @@ export class SeatsService {
 
     if (seatIds.length === 0) return statusMap;
 
-    // 1. Active holds — any seat in an unexpired SeatHold for this schedule is HELD
     const activeHolds = await this.prisma.seatHold.findMany({
       where: {
         scheduleId,
@@ -76,8 +95,6 @@ export class SeatsService {
       }
     }
 
-    // 2. Active bookings via JourneySegment — CONFIRMED or PENDING_PAYMENT → BOOKED
-    //    (overwrites HELD if the same seat has a confirmed booking)
     const bookedSegments = await this.prisma.journeySegment.findMany({
       where: {
         scheduleId,
@@ -93,24 +110,21 @@ export class SeatsService {
     return statusMap;
   }
 
-  // ── Hold / Release ────────────────────────────────────────────────────────
   async holdSeats(dto: HoldSeatsDto) {
-    // ── Validate request integrity ───────────────────────────────────────────
     const passengerIds = dto.passengers.map(p => p.passengerId);
     const seatIds      = dto.passengers.map(p => p.seatId);
 
     if (new Set(passengerIds).size !== passengerIds.length)
-      throw new BadRequestException('Duplicate passengerId in passengers list — each passenger must appear once');
+      throw new BadRequestException('Duplicate passengerId in passengers list');
     if (new Set(seatIds).size !== seatIds.length)
-      throw new BadRequestException('Duplicate seatId in passengers list — each seat can only be assigned to one passenger');
+      throw new BadRequestException('Duplicate seatId in passengers list');
 
     const expiresAt = new Date(Date.now() + 5 * 60 * 1000);
 
     const hold = await this.prisma.$transaction(async (tx) => {
-      // ── 1. Validate seats exist and none are BLOCKED ─────────────────────
       const seats = await tx.seat.findMany({
         where: { id: { in: seatIds } },
-        select: { id: true, status: true, label: true },
+        select: { id: true, status: true, seatNumber: true },
       });
 
       if (seats.length !== seatIds.length) {
@@ -121,11 +135,10 @@ export class SeatsService {
 
       const blocked = seats.filter(s => s.status === 'BLOCKED');
       if (blocked.length > 0)
-        throw new ConflictException(`Seat(s) ${blocked.map(s => s.label).join(', ')} are blocked`);
+        throw new ConflictException(`Seat(s) ${blocked.map(s => s.seatNumber).join(', ')} are blocked`);
 
-      const seatLabelById = Object.fromEntries(seats.map(s => [s.id, s.label]));
+      const seatLabelById = Object.fromEntries(seats.map(s => [s.id, s.seatNumber]));
 
-      // ── 2. Resolve requested leg sequences ──────────────────────────────
       const stopTimes = await tx.tripStopTime.findMany({
         where: { scheduleId: dto.scheduleId },
         select: { stationId: true, sequence: true },
@@ -137,17 +150,15 @@ export class SeatsService {
       const reqTo   = seqOf(dto.destinationStationId);
 
       if (reqFrom === undefined || reqTo === undefined)
-        throw new BadRequestException('Origin or destination station not found on this schedule');
+        throw new BadRequestException('Origin or destination station not found');
       if (reqFrom >= reqTo)
         throw new BadRequestException('Origin must come before destination');
 
-      // ── 3. Load active holds for this schedule ───────────────────────────
       const activeHolds = await tx.seatHold.findMany({
         where: { scheduleId: dto.scheduleId, expiresAt: { gt: new Date() } },
         select: { seatIds: true, createdBy: true },
       });
 
-      // Parse each hold's leg range and passenger list
       const parsedHolds: { seatIds: string[]; from: number; to: number; passengerIds: string[] }[] = [];
       for (const h of activeHolds) {
         try {
@@ -164,32 +175,28 @@ export class SeatsService {
               });
             }
           }
-        } catch { /* ignore malformed */ }
+        } catch { /* ignore */ }
       }
 
-      // ── 4. Per-passenger validation with overlap check ───────────────────
       for (const { passengerId, seatId } of dto.passengers) {
         for (const hold of parsedHolds) {
           const legsOverlap = hold.from < reqTo && reqFrom < hold.to;
-          if (!legsOverlap) continue; // non-overlapping leg — no conflict
+          if (!legsOverlap) continue;
 
-          // Rule A: seat is held on an overlapping leg
           if (hold.seatIds.includes(seatId)) {
             throw new ConflictException(
-              `Seat ${seatLabelById[seatId]} is already held for this leg. Please choose a different seat.`,
+              `Seat ${seatLabelById[seatId]} is already held for this leg`,
             );
           }
 
-          // Rule B: passenger already holds a seat on an overlapping leg
           if (hold.passengerIds.includes(passengerId)) {
             throw new ConflictException(
-              `Passenger already holds a seat on this journey leg. You can only hold one seat per journey.`,
+              `Passenger already holds a seat on this journey leg`,
             );
           }
         }
       }
 
-      // Store passenger→seat mapping AND leg in createdBy as JSON
       const holdMeta = {
         originStationId:      dto.originStationId,
         destinationStationId: dto.destinationStationId,
@@ -228,12 +235,7 @@ export class SeatsService {
     return this.enrichHold(hold);
   }
 
-  /**
-   * Resolves the opaque fareQuoteId leg encoding into human-readable station
-   * names and enriches the hold with schedule, seat, and leg details.
-   */
   private async enrichHold(hold: any) {
-    // Decode leg and passenger→seat mapping from createdBy JSON
     let originStationId: string | null = null;
     let destinationStationId: string | null = null;
     let passengerSeatMap: { passengerId: string; seatId: string }[] = [];
@@ -241,7 +243,6 @@ export class SeatsService {
     try {
       if (hold.createdBy) {
         const raw = hold.createdBy;
-        // Guard: only parse if it looks like a JSON object, not a plain number/string
         if (typeof raw === 'string' && raw.trimStart().startsWith('{')) {
           const meta = JSON.parse(raw);
           originStationId      = meta.originStationId      ?? null;
@@ -249,7 +250,7 @@ export class SeatsService {
           passengerSeatMap     = Array.isArray(meta.passengers) ? meta.passengers : [];
         }
       }
-    } catch { /* ignore malformed createdBy */ }
+    } catch { /* ignore */ }
 
     const seatIds = hold.seatIds as string[];
 
@@ -262,7 +263,7 @@ export class SeatsService {
       destinationStationId ? this.prisma.station.findUnique({ where: { id: destinationStationId } }) : null,
       this.prisma.seat.findMany({
         where: { id: { in: seatIds } },
-        include: { coach: { include: { seatClass: true } } },
+        include: { coach: true },
       }),
     ]);
 
@@ -277,10 +278,8 @@ export class SeatsService {
       destinationSequence = stopTimes.find(s => s.stationId === destinationStationId)?.sequence ?? null;
     }
 
-    // Build seat map keyed by seatId for quick lookup
     const seatById = Object.fromEntries(seats.map(s => [s.id, s]));
 
-    // Merge passenger→seat mapping with seat details
     const passengers = passengerSeatMap.length > 0
       ? passengerSeatMap.map(({ passengerId, seatId }) => {
           const s = seatById[seatId];
@@ -288,26 +287,25 @@ export class SeatsService {
             passengerId,
             seat: s ? {
               id:         s.id,
-              label:      s.label,
+              label:      s.seatNumber,
               seatNumber: s.seatNumber,
-              coach:      s.coach.label,
-              seatClass:  s.coach.seatClass.name,
+              coach:      s.coach.number,
+              seatClass:  'Standard',
               row:        s.row,
               col:        s.col,
             } : { id: seatId },
           };
         })
-      // Fallback for holds created before this change
       : seatIds.map(seatId => {
           const s = seatById[seatId];
           return {
             passengerId: hold.passengerId,
             seat: s ? {
               id:         s.id,
-              label:      s.label,
+              label:      s.seatNumber,
               seatNumber: s.seatNumber,
-              coach:      s.coach.label,
-              seatClass:  s.coach.seatClass.name,
+              coach:      s.coach.number,
+              seatClass:  'Standard',
               row:        s.row,
               col:        s.col,
             } : { id: seatId },
@@ -350,8 +348,7 @@ export class SeatsService {
   }
 
   async confirmSeats(seatIds: string[]) {
-    // No-op for status — availability is segment-scoped via JourneySegment
-    // seat.status = BLOCKED is the only hard gate; BOOKED is not used as a booking flag
+    // No-op
   }
 
   async releaseSeats(seatIds: string[]) {
@@ -362,14 +359,15 @@ export class SeatsService {
     }
   }
 
-  async autoAssignSeats(scheduleId: string, count: number, seatClassName: string, eligibility?: string): Promise<string[]> {
+  async autoAssignSeats(scheduleId: string, count: number, seatClassName: string): Promise<string[]> {
     const seats = await this.prisma.seat.findMany({
       where: {
-        coach: { seatClass: { name: seatClassName }, assignments: { some: { scheduleId } } },
+        coach: { assignments: { some: { scheduleId } } },
         status: 'AVAILABLE',
-        ...(eligibility ? { eligibility } : {}),
+        seatNumber: { not: '' },
+        NOT: { seatNumber: { startsWith: '-' } },
       },
-      orderBy: [{ coach: { label: 'asc' } }, { row: 'asc' }, { col: 'asc' }],
+      orderBy: [{ coach: { number: 'asc' } }, { row: 'asc' }, { col: 'asc' }],
     });
 
     if (seats.length < count) {
@@ -404,10 +402,10 @@ export class SeatsService {
       where: { scheduleId },
       include: { coach: { include: { seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] } } } },
     });
-    const rows = ['coachId,coachLabel,row,col,label,kind,status,premiumFeeMinor,eligibility'];
+    const rows = ['coachId,coachLabel,row,col,seatNumber,kind,status,premiumFeeMinor'];
     for (const a of assignments) {
       for (const seat of a.coach.seats) {
-        rows.push(`${a.coach.id},${a.coach.label},${seat.row},${seat.col},${seat.label},${seat.kind},${seat.status},${seat.premiumFeeMinor},${seat.eligibility || ''}`);
+        rows.push(`${a.coach.id},${a.coach.number},${seat.row},${seat.col},${seat.seatNumber},${seat.kind},${seat.status},${seat.premiumFeeMinor}`);
       }
     }
     return rows.join('\n');
@@ -426,8 +424,8 @@ export class SeatsService {
         invalid++;
         continue;
       }
-      const [coachId, coachLabel, row, col, label, kind, status, premiumFeeMinor] = parts;
-      if (!coachId || !row || !col || !label) {
+      const [coachId, coachLabel, row, col, seatNumber, kind, status, premiumFeeMinor] = parts;
+      if (!coachId || !row || !col || !seatNumber) {
         errors.push(`Line ${i + 2}: Missing required fields`);
         invalid++;
         continue;
@@ -444,32 +442,30 @@ export class SeatsService {
     let imported = 0;
 
     if (!commit) {
-      return { imported: 0, errors: ['Preview mode - use commit=true to apply changes'] };
+      return { imported: 0, errors: ['Preview mode'] };
     }
 
     for (let i = 0; i < lines.length; i++) {
       try {
         const parts = lines[i].split(',');
-        const [coachId, coachLabel, row, col, label, kind, status, premiumFeeMinor, eligibility] = parts;
+        const [coachId, coachLabel, row, col, seatNumber, kind, status, premiumFeeMinor] = parts;
 
         await this.prisma.seat.upsert({
           where: { coachId_row_col: { coachId, row: parseInt(row), col } },
           update: {
-            label,
+            seatNumber,
             kind: kind as any,
             status: status as any,
             premiumFeeMinor: parseInt(premiumFeeMinor) || 0,
-            eligibility: eligibility || null,
           },
           create: {
             coachId,
             row: parseInt(row),
             col,
-            label,
+            seatNumber,
             kind: kind as any,
             status: status as any,
             premiumFeeMinor: parseInt(premiumFeeMinor) || 0,
-            eligibility: eligibility || null,
           },
         });
         imported++;
@@ -481,19 +477,84 @@ export class SeatsService {
     return { imported, errors: errors.slice(0, 10) };
   }
 
+  async blockSeat(seatId: string, reason: string) {
+    const seat = await this.prisma.seat.findUnique({ where: { id: seatId } });
+    if (!seat) throw new NotFoundException('Seat not found');
+
+    await this.prisma.seat.update({
+      where: { id: seatId },
+      data: { status: 'BLOCKED' },
+    });
+
+    await this.prisma.seatBlock.create({
+      data: {
+        seatId,
+        reason,
+        blockedBy: 'system',
+      },
+    });
+
+    return { blocked: true, seatId, reason };
+  }
+
+  async unblockSeat(seatId: string) {
+    const seat = await this.prisma.seat.findUnique({ where: { id: seatId } });
+    if (!seat) throw new NotFoundException('Seat not found');
+
+    await this.prisma.seat.update({
+      where: { id: seatId },
+      data: { status: 'AVAILABLE' },
+    });
+
+    await this.prisma.seatBlock.deleteMany({
+      where: { seatId },
+    });
+
+    return { unblocked: true, seatId };
+  }
+
+  async removeSeat(seatId: string) {
+    const seat = await this.prisma.seat.findUnique({ where: { id: seatId } });
+    if (!seat) throw new NotFoundException('Seat not found');
+    if (!seat.seatNumber) throw new BadRequestException('Seat already removed');
+
+    // Mark removed seat with negative seatNumber (e.g., '1' → '-1') to show empty space
+    const negatedNumber = `-${seat.seatNumber}`;
+    await this.prisma.seat.update({
+      where: { id: seatId },
+      data: { seatNumber: negatedNumber },
+    });
+
+    return { removed: true, seatId, originalSeatNumber: seat.seatNumber };
+  }
+
+  async undoRemoveSeat(seatId: string) {
+    const seat = await this.prisma.seat.findUnique({ where: { id: seatId } });
+    if (!seat) throw new NotFoundException('Seat not found');
+    if (!seat.seatNumber || !seat.seatNumber.startsWith('-')) {
+      throw new BadRequestException('Seat is not removed');
+    }
+
+    // Restore original seatNumber by removing the negative sign
+    const originalNumber = seat.seatNumber.slice(1);
+    await this.prisma.seat.update({
+      where: { id: seatId },
+      data: { seatNumber: originalNumber },
+    });
+
+    return { restored: true, seatId, seatNumber: originalNumber };
+  }
+
   @Cron(CronExpression.EVERY_MINUTE)
   async expireHolds() {
-    const expired = await this.prisma.seatHold.findMany({ where: { expiresAt: { lt: new Date() } } });
-    for (const hold of expired) { 
+    const now = new Date();
+    const expired = await this.prisma.seatHold.findMany({ where: { expiresAt: { lt: now } } });
+    if (expired.length === 0) return;
+
+    const expiredIds = expired.map(h => h.id);
+    for (const hold of expired) {
       await this.releaseSeats(hold.seatIds);
-      try {
-        await this.prisma.seatHold.delete({ where: { id: hold.id } });
-      } catch (err) {
-        // Ignore if already deleted (e.g., by another process)
-        if (err instanceof Error && !err.message.includes('P2025')) {
-          throw err;
-        }
-      }
     }
+    await this.prisma.seatHold.deleteMany({ where: { id: { in: expiredIds } } });
   }
 }

apps/edr-passenger-api/src/modules/segments/booking-flow-example.ts

@@ -87,7 +87,7 @@ async function holdSeatsTransaction(scheduleId: string, seatIds: string[], passe
 
     for (const seat of seats) {
       if (seat.status !== 'AVAILABLE') {
-        throw new Error(`Seat ${seat.label} is not available (status: ${seat.status})`);
+        throw new Error(`Seat ${seat.seatNumber} is not available (status: ${seat.status})`);
       }
     }
 

apps/edr-passenger-api/src/modules/segments/enhanced-seats.service.ts

@@ -35,14 +35,12 @@ export class EnhancedSeatsService {
       for (const seatId of request.seatIds) {
         const seat = await tx.seat.findUnique({ where: { id: seatId } });
         if (!seat) throw new BadRequestException(`Seat ${seatId} not found`);
-        // Only BLOCKED seats are hard-rejected — BOOKED/HELD are fine if the
-        // segment does not overlap (another passenger may occupy a different leg)
-        if (seat.status === 'BLOCKED') throw new BadRequestException(`Seat ${seat.label} is blocked`);
+        if (seat.status === 'BLOCKED') throw new BadRequestException(`Seat ${seat.seatNumber} is blocked`);
 
         const free = await this.segmentsService.isSeatFreeForLeg(
           request.scheduleId, seatId, reqFrom, reqTo,
         );
-        if (!free) throw new ConflictException(`Seat ${seat.label} is not available for the requested leg`);
+        if (!free) throw new ConflictException(`Seat ${seat.seatNumber} is not available for the requested leg`);
       }
 
       const expiresAt = new Date(Date.now() + 10 * 60 * 1000);
@@ -51,7 +49,6 @@ export class EnhancedSeatsService {
           scheduleId:  request.scheduleId,
           seatIds:     request.seatIds,
           passengerId: request.passengerId,
-          // Store leg in createdBy JSON — no fareQuoteId needed
           createdBy: JSON.stringify({
             originStationId:      request.originStationId,
             destinationStationId: request.destinationStationId,
@@ -60,7 +57,6 @@ export class EnhancedSeatsService {
         },
       });
 
-      // Do NOT set seat.status = HELD globally — status is segment-scoped
       this.eventEmitter.emit('seats.held', { holdId: seatHold.id, scheduleId: request.scheduleId, seatIds: request.seatIds, segments });
       return { holdId: seatHold.id, expiresAt, segments, seats: request.seatIds };
     });
@@ -81,7 +77,6 @@ export class EnhancedSeatsService {
       });
       if (!schedule) throw new BadRequestException('Schedule not found');
 
-      // Resolve the passenger's leg from createdBy JSON
       let originStationId: string | undefined;
       let destinationStationId: string | undefined;
       try {
@@ -92,15 +87,15 @@ export class EnhancedSeatsService {
         }
       } catch { /* ignore */ }
 
-      const originStop = originStationId ? schedule.stopTimes.find(s => s.stationId === originStationId) : undefined;
-      const destStop = destinationStationId ? schedule.stopTimes.find(s => s.stationId === destinationStationId) : undefined;
+      const originStop = originStationId ? schedule.stopTimes.find((s: any) => s.stationId === originStationId) : undefined;
+      const destStop = destinationStationId ? schedule.stopTimes.find((s: any) => s.stationId === destinationStationId) : undefined;
       const fromSeq = originStop?.sequence ?? schedule.stopTimes[0].sequence;
       const toSeq = destStop?.sequence ?? schedule.stopTimes[schedule.stopTimes.length - 1].sequence;
 
       const segments: Segment[] = [];
       for (let i = fromSeq; i < toSeq; i++) {
-        const fromStop = schedule.stopTimes.find(s => s.sequence === i);
-        const toStop = schedule.stopTimes.find(s => s.sequence === i + 1);
+        const fromStop = schedule.stopTimes.find((s: any) => s.sequence === i);
+        const toStop = schedule.stopTimes.find((s: any) => s.sequence === i + 1);
         if (fromStop && toStop) {
           segments.push({
             fromStationId: fromStop.stationId,
@@ -132,7 +127,6 @@ export class EnhancedSeatsService {
         }
       }
 
-      // Do NOT set seat.status = BOOKED globally — availability is segment-scoped
       await tx.seatHold.delete({ where: { id: request.holdId } });
 
       this.eventEmitter.emit('booking.confirmed', { bookingId: request.bookingId, scheduleId: hold.scheduleId, seatIds: hold.seatIds, segments });
@@ -185,22 +179,20 @@ export class EnhancedSeatsService {
 
     const schedule = await this.prisma.trainSchedule.findUnique({
       where: { id: scheduleId },
-      include: { coachAssignments: { include: { coach: { include: { seats: true, seatClass: true } } } } },
+      include: { coachAssignments: { include: { coach: { include: { seats: true } } } } },
     });
     if (!schedule) throw new BadRequestException('Schedule not found');
 
     const availableSeats = [];
     for (const assignment of schedule.coachAssignments) {
       for (const seat of assignment.coach.seats) {
-        // Hard-blocked seats are never available
         if (seat.status === 'BLOCKED') continue;
-        // Availability is determined purely by segment overlap — not global seat.status
         const free = await this.segmentsService.isSeatFreeForLeg(scheduleId, seat.id, reqFrom, reqTo);
         if (free) {
           availableSeats.push({
-            id: seat.id, label: seat.label,
-            coach: assignment.coach.label,
-            seatClass: assignment.coach.seatClass.name,
+            id: seat.id, label: seat.seatNumber,
+            coach: assignment.coach.number,
+            seatClass: 'Standard',
             row: seat.row, col: seat.col,
             kind: seat.kind,
             isWindow: seat.isWindow,

apps/edr-passenger-api/src/modules/stations/stations.controller.ts

@@ -1,5 +1,5 @@
 import { Body, Controller, Get, Param, Post, Patch, Delete, UseGuards, Query } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery } from '@nestjs/swagger';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery, ApiResponse } from '@nestjs/swagger';
 import { StationsService } from './stations.service';
 import { CreateStationDto } from './stations.dto';
 import { JwtGuard } from '../../common/jwt.guard';
@@ -17,6 +17,28 @@ export class StationsController {
   @ApiQuery({ name: 'search', required: false, description: 'Search by station name or code' })
   @ApiQuery({ name: 'country', required: false, description: 'Filter by country code (ET, DJ)' })
   @ApiQuery({ name: 'operational', required: false, description: 'Filter by operational status (true, false)' })
+  @ApiResponse({ 
+    status: 200, 
+    description: 'Array of stations',
+    schema: {
+      example: [
+        {
+          id: '550e8400-e29b-41d4-a716-446655440000',
+          code: 'AAA',
+          sequence: 1,
+          name: 'Addis Ababa',
+          city: 'Addis Ababa',
+          countryCode: 'ET',
+          lat: 9.0054,
+          lng: 38.7636,
+          timezone: 'Africa/Addis_Ababa',
+          isOperational: true,
+          createdAt: '2024-01-15T10:30:00.000Z',
+          updatedAt: '2024-01-15T10:30:00.000Z'
+        }
+      ]
+    }
+  })
   findAll(
     @Query('search') search?: string,
     @Query('country') country?: string,
@@ -30,18 +52,79 @@ export class StationsController {
     summary: 'Get station details by ID',
     description: 'Returns station information including name, code, country, coordinates, and facilities'
   })
+  @ApiResponse({
+    status: 200,
+    description: 'Station details',
+    schema: {
+      example: {
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        code: 'AAA',
+        sequence: 1,
+        name: 'Addis Ababa',
+        city: 'Addis Ababa',
+        countryCode: 'ET',
+        lat: 9.0054,
+        lng: 38.7636,
+        timezone: 'Africa/Addis_Ababa',
+        isOperational: true,
+        createdAt: '2024-01-15T10:30:00.000Z',
+        updatedAt: '2024-01-15T10:30:00.000Z'
+      }
+    }
+  })
   findOne(@Param('id') id: string) { return this.service.findOne(id); }
   
   @Post()
   @UseGuards(JwtGuard)
   @ApiBearerAuth('JWT-auth')
   @ApiOperation({ summary: 'Create new station' })
+  @ApiResponse({
+    status: 201,
+    description: 'Station created',
+    schema: {
+      example: {
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        code: 'AAA',
+        sequence: 1,
+        name: 'Addis Ababa',
+        city: 'Addis Ababa',
+        countryCode: 'ET',
+        lat: 9.0054,
+        lng: 38.7636,
+        timezone: 'Africa/Addis_Ababa',
+        isOperational: true,
+        createdAt: '2024-01-15T10:30:00.000Z',
+        updatedAt: '2024-01-15T10:30:00.000Z'
+      }
+    }
+  })
   create(@Body() dto: CreateStationDto) { return this.service.create(dto); }
 
   @Patch(':id')
   @UseGuards(JwtGuard)
   @ApiBearerAuth('JWT-auth')
   @ApiOperation({ summary: 'Update station' })
+  @ApiResponse({
+    status: 200,
+    description: 'Station updated',
+    schema: {
+      example: {
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        code: 'AAA',
+        sequence: 1,
+        name: 'Addis Ababa',
+        city: 'Addis Ababa',
+        countryCode: 'ET',
+        lat: 9.0054,
+        lng: 38.7636,
+        timezone: 'Africa/Addis_Ababa',
+        isOperational: true,
+        createdAt: '2024-01-15T10:30:00.000Z',
+        updatedAt: '2024-01-15T10:30:00.000Z'
+      }
+    }
+  })
+  @ApiResponse({ status: 404, description: 'Station not found' })
   update(@Param('id') id: string, @Body() dto: Partial<CreateStationDto>) {
     return this.service.update(id, dto);
   }
@@ -50,6 +133,8 @@ export class StationsController {
   @UseGuards(JwtGuard)
   @ApiBearerAuth('JWT-auth')
   @ApiOperation({ summary: 'Delete station' })
+  @ApiResponse({ status: 200, description: 'Station deleted successfully' })
+  @ApiResponse({ status: 404, description: 'Station not found' })
   remove(@Param('id') id: string) {
     return this.service.remove(id);
   }

apps/edr-passenger-api/src/modules/stations/stations.dto.ts

@@ -1,4 +1,4 @@
-import { IsString, IsNumber, IsOptional } from 'class-validator';
+import { IsString, IsNumber, IsOptional, IsInt, IsBoolean } from 'class-validator';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 
 export class CreateStationDto {
@@ -6,6 +6,9 @@ export class CreateStationDto {
   @ApiProperty({ example: 'Addis Ababa' }) @IsString() name: string;
   @ApiProperty({ example: 'Addis Ababa' }) @IsString() city: string;
   @ApiPropertyOptional() @IsOptional() @IsString() timezone?: string;
+  @ApiPropertyOptional() @IsOptional() @IsString() countryCode?: string;
   @ApiProperty({ example: 9.0054 }) @IsNumber() lat: number;
   @ApiProperty({ example: 38.7636 }) @IsNumber() lng: number;
+  @ApiPropertyOptional({ example: 1 }) @IsOptional() @IsInt() sequence?: number;
+  @ApiPropertyOptional({ example: true }) @IsOptional() @IsBoolean() isOperational?: boolean;
 }

apps/edr-passenger-api/src/modules/stations/stations.module.ts

@@ -1,6 +1,12 @@
 import { Module } from '@nestjs/common';
+import { AuditModule } from '../../common/audit.module';
 import { StationsController } from './stations.controller';
 import { StationsService } from './stations.service';
 
-@Module({ controllers: [StationsController], providers: [StationsService], exports: [StationsService] })
+@Module({
+  imports: [AuditModule],
+  controllers: [StationsController],
+  providers: [StationsService],
+  exports: [StationsService],
+})
 export class StationsModule {}

apps/edr-passenger-api/src/modules/stations/stations.service.ts

@@ -1,5 +1,7 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import { Injectable, NotFoundException, Inject, Optional, BadRequestException } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
 import { PrismaService } from '../../common/prisma.service';
+import { AuditService } from '../../common/audit.service';
 import { CreateStationDto } from './stations.dto';
 
 interface StationFilters {
@@ -10,7 +12,11 @@ interface StationFilters {
 
 @Injectable()
 export class StationsService {
-  constructor(private prisma: PrismaService) {}
+  constructor(
+    private prisma: PrismaService,
+    private auditService: AuditService,
+    @Optional() @Inject(REQUEST) private request?: any,
+  ) {}
   
   findAll(filters: StationFilters = {}) {
     const where: any = {};
@@ -33,7 +39,7 @@ export class StationsService {
     
     return this.prisma.station.findMany({ 
       where,
-      orderBy: { name: 'asc' } 
+      orderBy: { sequence: 'asc' } 
     }); 
   }
   
@@ -43,20 +49,57 @@ export class StationsService {
     return s;
   }
   
-  create(dto: CreateStationDto) { 
-    return this.prisma.station.create({ data: dto }); 
+  async create(dto: CreateStationDto) {
+    const station = await this.prisma.station.create({ data: dto });
+    
+    await this.auditService.log({
+      userId: this.request?.user?.id,
+      action: 'CREATE',
+      entityType: 'Station',
+      entityId: station.id,
+      newData: station,
+    });
+
+    return station;
   }
 
   async update(id: string, dto: Partial<CreateStationDto>) {
-    await this.findOne(id); // Check if exists
-    return this.prisma.station.update({ 
-      where: { id }, 
-      data: dto 
+    const oldStation = await this.findOne(id);
+    const { code, name, city, timezone, lat, lng } = dto;
+    const data: any = { code, name, city, timezone, lat, lng };
+    if ('countryCode' in dto) data.countryCode = (dto as any).countryCode;
+    if ('sequence' in dto) data.sequence = (dto as any).sequence;
+    if ('isOperational' in dto) data.isOperational = (dto as any).isOperational;
+    
+    const updatedStation = await this.prisma.station.update({
+      where: { id },
+      data,
     });
+
+    await this.auditService.log({
+      userId: this.request?.user?.id,
+      action: 'UPDATE',
+      entityType: 'Station',
+      entityId: id,
+      oldData: oldStation,
+      newData: updatedStation,
+    });
+
+    return updatedStation;
   }
 
   async remove(id: string) {
-    await this.findOne(id); // Check if exists
-    return this.prisma.station.delete({ where: { id } });
+    const station = await this.findOne(id);
+    const deleted = await this.prisma.station.delete({ where: { id } });
+
+    await this.auditService.log({
+      userId: this.request?.user?.id,
+      action: 'DELETE',
+      entityType: 'Station',
+      entityId: id,
+      oldData: station,
+    });
+
+    return deleted;
   }
 }

apps/edr-passenger-api/src/modules/tickets/tickets.controller.ts

@@ -1,5 +1,5 @@
 import { Body, Controller, Get, Param, Post, Query, UseGuards, Delete, Patch } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiBody, ApiQuery } from '@nestjs/swagger';
 import { TicketsService } from './tickets.service';
 import { JwtGuard } from '../../common/jwt.guard';
 
@@ -30,32 +30,47 @@ export class TicketsController {
   @UseGuards(JwtGuard)
   @ApiBearerAuth('JWT-auth')
   @ApiOperation({ summary: 'List all tickets with optional filters' })
+  @ApiQuery({ name: 'search', required: false })
+  @ApiQuery({ name: 'status', required: false })
+  @ApiQuery({ name: 'originStationId', required: false })
+  @ApiQuery({ name: 'destinationStationId', required: false })
+  @ApiQuery({ name: 'arrivalDate', required: false })
+  @ApiQuery({ name: 'skip', required: false })
+  @ApiQuery({ name: 'take', required: false })
   listTickets(
     @Query('search') search?: string,
     @Query('status') status?: string,
+    @Query('originStationId') originStationId?: string,
+    @Query('destinationStationId') destinationStationId?: string,
+    @Query('arrivalDate') arrivalDate?: string,
     @Query('skip') skip?: string,
     @Query('take') take?: string,
   ) {
     return this.service.listTickets({
       search,
       status,
+      originStationId,
+      destinationStationId,
+      arrivalDate,
       skip: skip ? parseInt(skip) : 0,
       take: take ? parseInt(take) : 50,
     });
   }
   
-  @Get(':bookingRef')
+  @Get('by-order/:merchantOrderId')
   @UseGuards(JwtGuard)
   @ApiBearerAuth('JWT-auth')
+  @ApiOperation({
+    summary: 'Get ticket by merchant order ID',
+    description: 'Looks up the booking ID from the PaymentIntent using merchantOrderId, then returns the full ticket information.'
+  })
+  getByMerchantOrderId(@Param('merchantOrderId') merchantOrderId: string) {
+    return this.service.getByMerchantOrderId(merchantOrderId);
+  }
+
+  @Get(':bookingRef')
   @ApiOperation({ 
-    summary: 'Get ticket with QR code and passenger details',
-    description: `Returns ticket information including:
-- QR code for gate scanning
-- Barcode for offline validation
-- Passenger details (name, age category, nationality)
-- Journey details (origin, destination, seat, coach)
-- Fare breakdown with currency
-- PDF download link`
+    summary: 'Get ticket with QR code and passenger details (public)',
   })
   getByRef(@Param('bookingRef') ref: string) { 
     return this.service.getByRef(ref); 
@@ -66,14 +81,30 @@ export class TicketsController {
   @ApiBearerAuth('JWT-auth')
   @ApiOperation({ 
     summary: 'Validate ticket at gate with audit logging',
-    description: 'Validates ticket QR/barcode at station gate. Records validation in audit log with timestamp, gate, and validator.'
+    description: 'Validates ticket QR/barcode at station gate. For round-trip bookings, supply `leg` (OUTBOUND or RETURN) to record which leg is being used. Defaults to OUTBOUND if omitted. Records validation in audit log with timestamp, gate, and validator.'
+  })
+  @ApiBody({
+    schema: {
+      type: 'object',
+      required: ['validatorId'],
+      properties: {
+        validatorId: { type: 'string', example: 'agent-uuid' },
+        gateId:      { type: 'string', example: 'gate-01' },
+        leg: {
+          type: 'string',
+          enum: ['OUTBOUND', 'RETURN', 'LEG1', 'LEG2', 'OUTBOUND_LEG1', 'OUTBOUND_LEG2', 'RETURN_LEG1', 'RETURN_LEG2'],
+          description: 'ONE_WAY: omit | TRANSIT: LEG1/LEG2 | ROUND_TRIP: OUTBOUND/RETURN | ROUND_TRIP_TRANSIT: OUTBOUND_LEG1/OUTBOUND_LEG2/RETURN_LEG1/RETURN_LEG2',
+        },
+      },
+    },
   })
   validate(
-    @Param('bookingRef') ref: string, 
+    @Param('bookingRef') ref: string,
     @Body('validatorId') validatorId: string,
-    @Body('gateId') gateId?: string
-  ) { 
-    return this.service.validate(ref, validatorId, gateId); 
+    @Body('gateId') gateId?: string,
+    @Body('leg') leg?: string,
+  ) {
+    return this.service.validate(ref, validatorId, gateId, leg);
   }
   
   @Get(':ticketId/validation-logs')
@@ -95,7 +126,31 @@ export class TicketsController {
   @Post('validate/offline')
   @UseGuards(JwtGuard)
   @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Batch import offline validations' })
+  @ApiOperation({
+    summary: 'Batch import offline validations',
+    description: 'Processes validations collected offline. Each entry may include an optional `leg` field (OUTBOUND | RETURN) for round-trip tickets. Deduplication is per bookingRef+leg combination so both legs of the same booking can be submitted in one batch.'
+  })
+  @ApiBody({
+    schema: {
+      type: 'object',
+      properties: {
+        validations: {
+          type: 'array',
+          items: {
+            type: 'object',
+            required: ['bookingRef', 'validatorId', 'validatedAt'],
+            properties: {
+              bookingRef:  { type: 'string' },
+              validatorId: { type: 'string' },
+              gateId:      { type: 'string' },
+              validatedAt: { type: 'string', format: 'date-time' },
+              leg: { type: 'string', enum: ['OUTBOUND', 'RETURN', 'LEG1', 'LEG2', 'OUTBOUND_LEG1', 'OUTBOUND_LEG2', 'RETURN_LEG1', 'RETURN_LEG2'] },
+            },
+          },
+        },
+      },
+    },
+  })
   validateOfflineBatch(@Body() body: { validations: any[] }) {
     return this.service.validateOfflineBatch(body.validations);
   }

apps/edr-passenger-api/src/modules/tickets/tickets.service.ts

@@ -9,6 +9,7 @@ interface OfflineValidation {
   validatorId: string;
   gateId?: string;
   validatedAt: string;
+  leg?: string;
 }
 
 @Injectable()
@@ -18,7 +19,7 @@ export class TicketsService {
     @InjectDataSource() private readonly dataSource: DataSource,
   ) {}
 
-  async listTickets(filters: { search?: string; status?: string; skip: number; take: number }) {
+  async listTickets(filters: { search?: string; status?: string; originStationId?: string; destinationStationId?: string; arrivalDate?: string; skip: number; take: number }) {
     const where: any = {};
     if (filters.search) {
       where.OR = [
@@ -28,7 +29,19 @@ export class TicketsService {
       ];
     }
     if (filters.status) {
-      where.booking = { status: filters.status };
+      where.booking = { ...where.booking, status: filters.status };
+    }
+    if (filters.originStationId) {
+      where.booking = { ...where.booking, schedule: { ...where.booking?.schedule, originStationId: filters.originStationId } };
+    }
+    if (filters.destinationStationId) {
+      where.booking = { ...where.booking, schedule: { ...where.booking?.schedule, destinationStationId: filters.destinationStationId } };
+    }
+    if (filters.arrivalDate) {
+      const start = new Date(filters.arrivalDate);
+      const end = new Date(filters.arrivalDate);
+      end.setDate(end.getDate() + 1);
+      where.booking = { ...where.booking, schedule: { ...where.booking?.schedule, arrivalAt: { gte: start, lt: end } } };
     }
     const [tickets, total] = await Promise.all([
       this.prisma.ticket.findMany({
@@ -88,42 +101,65 @@ export class TicketsService {
   }
 
   async generate(bookingId: string) {
-    if (!bookingId) {
-      throw new BadRequestException('Booking ID is required');
-    }
-    
+    if (!bookingId) throw new BadRequestException('Booking ID is required');
+
     const booking = await this.prisma.booking.findUnique({
       where: { id: bookingId },
-      include: { 
-        schedule: { include: { originStation: true, destinationStation: true, train: true } }, 
-        seats: { include: { seat: { include: { coach: true } } } } 
+      include: {
+        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+        seats: { include: { seat: { include: { coach: true } } } },
       },
     });
     if (!booking) throw new NotFoundException(`Booking ${bookingId} not found`);
-    
-    const qrPayload = await QRCode.toDataURL(`edr:tkt:${booking.id}:${booking.bookingRef}`);
+
+    // Build a compact multi-leg payload for the QR so gate scanners see all legs
+    const legSummary = this.buildLegSummary(booking);
+    const qrData = JSON.stringify({
+      ref:  booking.bookingRef,
+      type: booking.bookingType,
+      legs: legSummary,
+    });
+    const qrPayload      = await QRCode.toDataURL(qrData);
     const barcodePayload = `EDR${booking.bookingRef}${booking.id.substring(0, 8).toUpperCase()}`;
-    
+
     const ticket = await this.prisma.ticket.upsert({
-      where: { bookingId },
+      where:  { bookingId },
       update: { qrPayload, barcodePayload },
       create: { bookingId, bookingRef: booking.bookingRef, qrPayload, barcodePayload },
     });
 
-    // Create permanent seat blocks for all booked seats
+    // Block all seats across all legs
     const seatIds = booking.seats.map(bs => bs.seatId);
     for (const seatId of seatIds) {
+      await this.prisma.seat.update({ where: { id: seatId }, data: { status: 'BOOKED' } });
       await this.prisma.seatBlock.create({
-        data: {
-          seatId,
-          reason: `Permanently booked in ticket ${ticket.id}`,
-          blockedBy: 'SYSTEM',
-          approvedBy: 'SYSTEM',
-        }
-      }).catch(() => null); // Ignore if already exists
+        data: { seatId, reason: `Booked in ticket ${ticket.id}`, blockedBy: 'SYSTEM', approvedBy: 'SYSTEM' },
+      }).catch(() => null);
     }
-    
-    return ticket;
+
+    return { ...ticket, legs: legSummary };
+  }
+
+  private buildLegSummary(booking: any) {
+    const seatsByLeg = new Map<number, any[]>();
+    for (const bs of booking.seats) {
+      const leg = bs.leg ?? 1;
+      if (!seatsByLeg.has(leg)) seatsByLeg.set(leg, []);
+      seatsByLeg.get(leg)!.push(bs);
+    }
+    return Array.from(seatsByLeg.entries())
+      .sort(([a], [b]) => a - b)
+      .map(([leg, seats]) => ({
+        leg,
+        scheduleId: (seats[0] as any).scheduleId ?? booking.scheduleId,
+        passengers: seats.map(bs => ({
+          name:      bs.passengerName,
+          category:  bs.passengerCategory,
+          coach:     bs.seat?.coach?.number,
+          seat:      bs.seat?.seatNumber,
+          fareMinor: bs.fareMinor,
+        })),
+      }));
   }
 
   async updateSeats(bookingId: string, newSeatIds: string[]) {
@@ -174,9 +210,14 @@ export class TicketsService {
     return { success: true, updatedSeats: newSeatIds.length };
   }
 
-  async getByRef(bookingRef: string) {
+  async getByMerchantOrderId(merchantOrderId: string) {
+    const intent = await this.prisma.paymentIntent.findUnique({
+      where: { merchantOrderId },
+      select: { bookingId: true },
+    });
+    if (!intent) throw new NotFoundException(`No payment intent found for order ${merchantOrderId}`);
     const booking = await this.prisma.booking.findUnique({
-      where: { bookingRef },
+      where: { id: intent.bookingId },
       include: { schedule: { include: { originStation: true, destinationStation: true, train: true } }, seats: { include: { seat: { include: { coach: true } } } }, ticket: true },
     });
     if (!booking?.ticket) throw new NotFoundException('Ticket not found');
@@ -185,28 +226,158 @@ export class TicketsService {
       id: booking.ticket.id, bookingId: booking.id, bookingRef: booking.bookingRef, status: booking.status,
       fromStationName: booking.schedule.originStation.name, toStationName: booking.schedule.destinationStation.name,
       departureAt: booking.schedule.departureAt, trainName: booking.schedule.train.name,
-      coachLabel: seat?.seat.coach.label, seatLabel: seat?.seat.label, passengerName: seat?.passengerName,
+      coachLabel: seat?.seat.coach.number, seatLabel: seat?.seat.seatNumber, passengerName: seat?.passengerName,
       priceMinor: booking.totalMinor, currency: booking.currency, qrPayload: booking.ticket.qrPayload,
+      barcodePayload: booking.ticket.barcodePayload,
+    };
+  }
+
+  async getByRef(bookingRef: string) {
+    const booking = await this.prisma.booking.findUnique({
+      where: { bookingRef },
+      include: { 
+        schedule: { include: { originStation: true, destinationStation: true, train: true } }, 
+        seats: { include: { seat: { include: { coach: true } } } }, 
+        ticket: true 
+      },
+    });
+    if (!booking?.ticket) throw new NotFoundException('Ticket not found');
+    const seat = booking.seats[0];
+    return {
+      id: booking.ticket.id, 
+      bookingId: booking.id, 
+      bookingRef: booking.bookingRef, 
+      status: booking.status,
+      fromStationName: booking.schedule.originStation.name, 
+      toStationName: booking.schedule.destinationStation.name,
+      departureAt: booking.schedule.departureAt, 
+      trainName: booking.schedule.train.name,
+      coachLabel: seat?.seat.coach.number, 
+      seatLabel: seat?.seat.seatNumber, 
+      passengerName: seat?.passengerName,
+      priceMinor: booking.totalMinor, 
+      currency: booking.currency, 
+      qrPayload: booking.ticket.qrPayload,
       barcodePayload: booking.ticket.barcodePayload
     };
   }
 
-  async validate(bookingRef: string, validatorId: string, gateId?: string) {
+  async validate(ticketIdOrRef: string, validatorId: string, gateId?: string, leg?: string) {
+    // Accept either a ticket UUID or a bookingRef
+    let bookingRef = ticketIdOrRef;
+    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(ticketIdOrRef);
+    if (isUuid) {
+      const ticket = await this.prisma.ticket.findUnique({ where: { id: ticketIdOrRef }, select: { bookingRef: true } });
+      if (!ticket) throw new NotFoundException('Ticket not found');
+      bookingRef = ticket.bookingRef;
+    }
+    const resolvedValidatorId = validatorId || 'BACKOFFICE';
     const booking = await this.prisma.booking.findUnique({ where: { bookingRef } });
     if (!booking) throw new NotFoundException('Booking not found');
     const ticket = await this.prisma.ticket.findUnique({ where: { bookingId: booking.id } });
     if (!ticket) throw new NotFoundException('Ticket not found');
-    if (ticket.validatedAt) {
-      await this.prisma.gateValidationLog.create({
-        data: { ticketId: ticket.id, validatorId, gateId, status: 'REJECTED', reason: 'ALREADY_VALIDATED' }
-      });
-      throw new BadRequestException('Ticket already validated');
+
+    const type = booking.bookingType;
+    const now  = new Date();
+
+    // ── ONE_WAY / TRANSIT (single scan) ───────────────────────────────────
+    if (type === 'ONE_WAY') {
+      if (ticket.validatedAt) {
+        return { validated: true, ticketId: ticket.id, validatedAt: ticket.validatedAt, alreadyValidated: true };
+      }
+      await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId: resolvedValidatorId } });
+      await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, status: 'APPROVED' } });
+      return { validated: true, ticketId: ticket.id, validatedAt: now };
     }
-    await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: new Date(), validatorId } });
-    await this.prisma.gateValidationLog.create({
-      data: { ticketId: ticket.id, validatorId, gateId, status: 'APPROVED' }
-    });
-    return { validated: true, ticketId: ticket.id, validatedAt: new Date() };
+
+    // ── TRANSIT — leg=LEG1 or leg=LEG2 ──────────────────────────────────
+    if (type === 'TRANSIT') {
+      const resolvedLeg = (leg ?? 'LEG1').toUpperCase();
+      if (resolvedLeg !== 'LEG1' && resolvedLeg !== 'LEG2') {
+        throw new BadRequestException('For TRANSIT bookings supply leg=LEG1 or leg=LEG2');
+      }
+      const logs = await this.prisma.gateValidationLog.findMany({ where: { ticketId: ticket.id, status: 'APPROVED' } }) as any[];
+      const alreadyValidated = logs.some(l => l.leg === resolvedLeg);
+      if (alreadyValidated) {
+        await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: `${resolvedLeg}_ALREADY_USED` } as any });
+        throw new BadRequestException(`${resolvedLeg} already validated`);
+      }
+      if (!ticket.validatedAt) await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId: resolvedValidatorId } });
+      await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'APPROVED' } as any });
+      return { validated: true, ticketId: ticket.id, leg: resolvedLeg, validatedAt: now };
+    }
+
+    // ── ROUND_TRIP — leg=OUTBOUND or leg=RETURN ────────────────────────
+    if (type === 'ROUND_TRIP') {
+      let resolvedLeg = (leg ?? '').toUpperCase();
+      // Auto-detect next unused leg when called from backoffice without a leg param
+      if (!resolvedLeg) {
+        resolvedLeg = !(booking as any).outboundBoardedAt ? 'OUTBOUND' : 'RETURN';
+      }
+      const bookingData: Record<string, any> = {};
+      if (resolvedLeg === 'OUTBOUND') {
+        if ((booking as any).outboundBoardedAt) {
+          await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: 'OUTBOUND_ALREADY_USED' } as any });
+          throw new BadRequestException('Outbound leg already used');
+        }
+        bookingData.outboundBoardedAt = now;
+        if (!ticket.validatedAt) await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId: resolvedValidatorId } });
+      } else if (resolvedLeg === 'RETURN') {
+        if ((booking as any).returnBoardedAt) {
+          await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: 'RETURN_ALREADY_USED' } as any });
+          throw new BadRequestException('Return leg already used');
+        }
+        bookingData.returnBoardedAt = now;
+      } else {
+        throw new BadRequestException('For ROUND_TRIP bookings supply leg=OUTBOUND or leg=RETURN');
+      }
+      const outboundUsed = resolvedLeg === 'OUTBOUND' ? true : !!(booking as any).outboundBoardedAt;
+      const returnUsed   = resolvedLeg === 'RETURN'   ? true : !!(booking as any).returnBoardedAt;
+      if (outboundUsed && returnUsed)        bookingData.returnLegStatus = 'BOTH_USED';
+      else if (outboundUsed && !returnUsed)  bookingData.returnLegStatus = 'OUTBOUND_ONLY';
+      else if (!outboundUsed && returnUsed)  bookingData.returnLegStatus = 'INBOUND_ONLY';
+      await this.prisma.booking.update({ where: { id: booking.id }, data: bookingData });
+      await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'APPROVED' } as any });
+      return { validated: true, ticketId: ticket.id, leg: resolvedLeg, validatedAt: now };
+    }
+
+    // ── ROUND_TRIP_TRANSIT — leg=OUTBOUND_LEG1|OUTBOUND_LEG2|RETURN_LEG1|RETURN_LEG2
+    if (type === 'ROUND_TRIP_TRANSIT') {
+      const validLegs = ['OUTBOUND_LEG1', 'OUTBOUND_LEG2', 'RETURN_LEG1', 'RETURN_LEG2'];
+      const resolvedLeg = (leg ?? '').toUpperCase();
+      if (!validLegs.includes(resolvedLeg)) {
+        throw new BadRequestException(`For ROUND_TRIP_TRANSIT supply leg=${validLegs.join('|')}`);
+      }
+      const logs = await this.prisma.gateValidationLog.findMany({ where: { ticketId: ticket.id, status: 'APPROVED' } }) as any[];
+      if (logs.some(l => l.leg === resolvedLeg)) {
+        await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: `${resolvedLeg}_ALREADY_USED` } as any });
+        throw new BadRequestException(`${resolvedLeg} already validated`);
+      }
+      const bookingData: Record<string, any> = {};
+      if (resolvedLeg.startsWith('OUTBOUND') && !logs.some(l => l.leg?.startsWith('OUTBOUND') && l.status === 'APPROVED')) {
+        bookingData.outboundBoardedAt = now;
+      }
+      if (resolvedLeg.startsWith('RETURN') && !logs.some(l => l.leg?.startsWith('RETURN') && l.status === 'APPROVED')) {
+        bookingData.returnBoardedAt = now;
+      }
+      const allOutboundDone = ['OUTBOUND_LEG1','OUTBOUND_LEG2'].every(l => l === resolvedLeg || logs.some(x => x.leg === l && x.status === 'APPROVED'));
+      const allReturnDone   = ['RETURN_LEG1','RETURN_LEG2'].every(l => l === resolvedLeg || logs.some(x => x.leg === l && x.status === 'APPROVED'));
+      if (allOutboundDone && allReturnDone)       bookingData.returnLegStatus = 'BOTH_USED';
+      else if (allOutboundDone && !allReturnDone) bookingData.returnLegStatus = 'OUTBOUND_ONLY';
+      else if (!allOutboundDone && allReturnDone) bookingData.returnLegStatus = 'INBOUND_ONLY';
+      if (Object.keys(bookingData).length) await this.prisma.booking.update({ where: { id: booking.id }, data: bookingData });
+      if (!ticket.validatedAt) await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId: resolvedValidatorId } });
+      await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'APPROVED' } as any });
+      return { validated: true, ticketId: ticket.id, leg: resolvedLeg, validatedAt: now };
+    }
+
+    // Fallback for unknown booking types — single scan
+    if (ticket.validatedAt) {
+      return { validated: true, ticketId: ticket.id, validatedAt: ticket.validatedAt, alreadyValidated: true };
+    }
+    await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId: resolvedValidatorId } });
+    await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, status: 'APPROVED' } });
+    return { validated: true, ticketId: ticket.id, validatedAt: now };
   }
 
   async getValidationLogs(ticketId: string) {
@@ -230,10 +401,12 @@ export class TicketsService {
       bookingRef: b.bookingRef,
       ticketId: b.ticket?.id,
       passengerName: b.seats[0]?.passengerName,
-      seatLabel: b.seats[0]?.seat.label,
-      coachLabel: b.seats[0]?.seat.coach.label,
+      seatLabel: b.seats[0]?.seat.seatNumber,
+      coachLabel: b.seats[0]?.seat.coach.number,
       qrPayload: b.ticket?.qrPayload,
       status: b.status,
+      bookingType: b.bookingType,
+      returnLegStatus: (b as any).returnLegStatus ?? null,
       validatedAt: b.ticket?.validatedAt,
     }));
   }
@@ -243,11 +416,13 @@ export class TicketsService {
     const processedRefs = new Set<string>();
 
     for (const v of validations) {
-      if (processedRefs.has(v.bookingRef)) {
+      const offlineLeg = v.leg;
+      const dedupKey = offlineLeg ? `${v.bookingRef}:${offlineLeg}` : v.bookingRef;
+      if (processedRefs.has(dedupKey)) {
         results.duplicate++;
         continue;
       }
-      processedRefs.add(v.bookingRef);
+      processedRefs.add(dedupKey);
 
       try {
         const booking = await this.prisma.booking.findUnique({ where: { bookingRef: v.bookingRef } });
@@ -264,11 +439,24 @@ export class TicketsService {
           continue;
         }
 
-        if (ticket.validatedAt) {
+        if (ticket.validatedAt && booking.bookingType !== 'ROUND_TRIP' &&
+            booking.bookingType !== 'TRANSIT' && booking.bookingType !== 'ROUND_TRIP_TRANSIT') {
           results.duplicate++;
           continue;
         }
 
+        // For multi-leg bookings, check per-leg duplication
+        const isMultiLeg = booking.bookingType === 'ROUND_TRIP' ||
+                           booking.bookingType === 'TRANSIT' ||
+                           booking.bookingType === 'ROUND_TRIP_TRANSIT';
+        if (isMultiLeg && offlineLeg) {
+          const existingLogs = await this.prisma.gateValidationLog.findMany({ where: { ticketId: ticket.id, status: 'APPROVED' } }) as any[];
+          if (existingLogs.some(l => l.leg === offlineLeg)) {
+            results.duplicate++;
+            continue;
+          }
+        }
+
         await this.prisma.ticket.update({
           where: { id: ticket.id },
           data: { validatedAt: new Date(v.validatedAt), validatorId: v.validatorId },
@@ -279,11 +467,27 @@ export class TicketsService {
             ticketId: ticket.id,
             validatorId: v.validatorId,
             gateId: v.gateId,
+            leg: v.leg ?? null,
             status: 'APPROVED',
             validatedAt: new Date(v.validatedAt),
-          },
+          } as any,
         });
 
+        // update boarding timestamps for multi-leg bookings
+        const isMultiLegBooking = booking.bookingType === 'ROUND_TRIP' ||
+                                  booking.bookingType === 'TRANSIT' ||
+                                  booking.bookingType === 'ROUND_TRIP_TRANSIT';
+        if (isMultiLegBooking && offlineLeg) {
+          const bookingData: Record<string, any> = {};
+          const isOutbound = (offlineLeg as string) === 'OUTBOUND' || (offlineLeg as string) === 'OUTBOUND_LEG1' || (offlineLeg as string) === 'LEG1';
+          const isReturn   = (offlineLeg as string) === 'RETURN'   || (offlineLeg as string) === 'RETURN_LEG1'   || (offlineLeg as string) === 'RETURN_LEG2';
+          if (isOutbound && !(booking as any).outboundBoardedAt) bookingData.outboundBoardedAt = new Date(v.validatedAt);
+          if (isReturn   && !(booking as any).returnBoardedAt)   bookingData.returnBoardedAt   = new Date(v.validatedAt);
+          if (Object.keys(bookingData).length) {
+            await this.prisma.booking.update({ where: { id: booking.id }, data: bookingData });
+          }
+        }
+
         results.success++;
       } catch (err) {
         results.failed++;