Round trip booking and additional enhancements

2026-08-29 18:48:11 +00:00 · 2026-06-17 13:42:20 +03:00
parent 81a9c614b7
commit 24ee3b88f5
22 changed files with 502 additions and 205 deletions
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
@@ -75,21 +75,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 
    });
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
@@ -24,6 +24,7 @@ function calculateAge(dateOfBirth: Date): number {
 interface BookingFilters {
  search?: string;
  status?: string;
+  returnLegStatus?: string;
  page?: number;
  pageSize?: number;
 }
@@ -82,6 +83,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,
@@ -159,6 +162,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,
@@ -180,7 +185,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 = {};
@@ -194,9 +199,8 @@ export class BookingsService {
      ];
    }
    
-    if (status) {
-      where.status = status;
-    }
+    if (status) where.status = status;
+    if (returnLegStatus) where.returnLegStatus = returnLegStatus;
    
    const [items, total] = await Promise.all([
      this.prisma.booking.findMany({
@@ -225,6 +229,8 @@ export class BookingsService {
        displayTotalMinor: booking.displayTotalMinor,
        contactEmail: booking.contactEmail,
        contactPhone: booking.contactPhone,
+        bookingType: booking.bookingType,
+        returnLegStatus: (booking as any).returnLegStatus ?? null,
        createdAt: booking.createdAt,
        passenger: booking.passenger?.user,
        schedule: {
@@ -391,6 +397,7 @@ export class BookingsService {
        returnDestinationStationId: dto.returnDestinationStationId,
        returnHoldId: dto.returnHoldId,
        returnSeatClassId: dto.returnSeatClassId,
+        returnLegStatus: 'NEITHER_USED',
        seats: {
          create: passengersData.map(p => ({
            seat: { connect: { id: p.outboundSeatId } },
@@ -406,7 +413,7 @@ export class BookingsService {
            displayCurrency
          }))
        }
-      },
+      } as any,
      include: { seats: { include: { seat: true } }, schedule: { include: { originStation: true, destinationStation: true, train: true } } }
    });

@@ -646,7 +653,11 @@ 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 },
@@ -751,6 +762,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,
--- a/apps/edr-passenger-api/src/modules/notifications/email-client.service.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/email-client.service.ts
@@ -11,7 +11,10 @@ export class EmailClientService implements OnApplicationBootstrap {
    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'))
@@ -19,10 +22,8 @@ export class EmailClientService implements OnApplicationBootstrap {
  }

  async sendEmail(dto: SendEmail) {
-    this.emailServiceClient.emit('send-email', {
-      ...dto,
-      appKey: 'EDR-PASSENGER-API',
-    });
+    if (!this.enabled) return {};
+    this.emailServiceClient.emit('send-email', { ...dto, appKey: 'EDR-PASSENGER-API' });
    return {};
  }
 }
--- a/apps/edr-passenger-api/src/modules/notifications/notifications.module.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/notifications.module.ts
@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { DynamicModule, Module } from '@nestjs/common';
 import { HttpModule } from '@nestjs/axios';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { ClientsModule, Transport } from '@nestjs/microservices';
@@ -8,49 +8,64 @@ import { EmailAdapter, SmsAdapter, PushAdapter } from './notification.adapters';
 import { EmailClientService } from './email-client.service';
 import { SmsClientService } from './sms-client.service';

-@Module({
-  imports: [
-    HttpModule.register({ timeout: 10_000 }),
-    ClientsModule.registerAsync([
-      {
-        name: 'EMAIL_SERVICE',
-        imports: [ConfigModule],
-        inject: [ConfigService],
-        useFactory: (config: ConfigService) => ({
-          transport: Transport.RMQ,
-          options: {
-            urls: [config.get<string>('RABBITMQ_URL') ?? 'amqp://localhost:5672'],
-            queue: config.get<string>('EMAIL_QUEUE') ?? 'email_queue',
-            queueOptions: { durable: true },
-            noAck: true,
-          },
-        }),
+const rmqClientsModule = ClientsModule.registerAsync([
+  {
+    name: 'EMAIL_SERVICE',
+    imports: [ConfigModule],
+    inject: [ConfigService],
+    useFactory: (config: ConfigService) => ({
+      transport: Transport.RMQ,
+      options: {
+        urls: [config.get<string>('RABBITMQ_URL') ?? 'amqp://localhost:5672'],
+        queue: config.get<string>('EMAIL_QUEUE') ?? 'email_queue',
+        queueOptions: { durable: true },
+        noAck: true,
      },
-      {
-        name: 'SMS_SERVICE',
-        imports: [ConfigModule],
-        inject: [ConfigService],
-        useFactory: (config: ConfigService) => ({
-          transport: Transport.RMQ,
-          options: {
-            urls: [config.get<string>('RABBITMQ_URL') ?? 'amqp://localhost:5672'],
-            queue: config.get<string>('SMS_QUEUE') ?? 'sms_queue',
-            queueOptions: { durable: true },
-            noAck: true,
-          },
-        }),
+    }),
+  },
+  {
+    name: 'SMS_SERVICE',
+    imports: [ConfigModule],
+    inject: [ConfigService],
+    useFactory: (config: ConfigService) => ({
+      transport: Transport.RMQ,
+      options: {
+        urls: [config.get<string>('RABBITMQ_URL') ?? 'amqp://localhost:5672'],
+        queue: config.get<string>('SMS_QUEUE') ?? 'sms_queue',
+        queueOptions: { durable: true },
+        noAck: true,
      },
-    ]),
-  ],
-  controllers: [NotificationsController],
-  providers: [
-    NotificationsService,
-    EmailAdapter,
-    SmsAdapter,
-    PushAdapter,
-    EmailClientService,
-    SmsClientService,
-  ],
-  exports: [NotificationsService, EmailClientService, SmsClientService],
-})
-export class NotificationsModule {}
+    }),
+  },
+]);
+
+@Module({})
+export class NotificationsModule {
+  static register(): DynamicModule {
+    const rmqEnabled = process.env.RABBITMQ_ENABLED !== 'false';
+
+    return {
+      module: NotificationsModule,
+      imports: [
+        HttpModule.register({ timeout: 10_000 }),
+        ...(rmqEnabled ? [rmqClientsModule] : []),
+      ],
+      controllers: [NotificationsController],
+      providers: [
+        NotificationsService,
+        EmailAdapter,
+        SmsAdapter,
+        PushAdapter,
+        ...(rmqEnabled
+          ? [EmailClientService, SmsClientService]
+          : [
+              { provide: 'EMAIL_SERVICE', useValue: null },
+              { provide: 'SMS_SERVICE', useValue: null },
+              EmailClientService,
+              SmsClientService,
+            ]),
+      ],
+      exports: [NotificationsService, EmailClientService, SmsClientService],
+    };
+  }
+}
--- a/apps/edr-passenger-api/src/modules/notifications/sms-client.service.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/sms-client.service.ts
@@ -11,7 +11,10 @@ export class SmsClientService implements OnApplicationBootstrap {
    private readonly 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'))
@@ -19,18 +22,14 @@ export class SmsClientService implements OnApplicationBootstrap {
  }

  async sendSms(dto: SendMessage) {
-    this.smsClient.emit('send-sms', {
-      ...dto,
-      appKey: 'EDR-PASSENGER-API',
-    });
+    if (!this.enabled) return {};
+    this.smsClient.emit('send-sms', { ...dto, appKey: 'EDR-PASSENGER-API' });
    return {};
  }

  async sendBulkMessages(dto: BulkMessagesDto) {
-    this.smsClient.emit('ozeking-bulk-sms', {
-      ...dto,
-      appKey: 'EDR-PASSENGER-API',
-    });
+    if (!this.enabled) return {};
+    this.smsClient.emit('ozeking-bulk-sms', { ...dto, appKey: 'EDR-PASSENGER-API' });
    return {};
  }
 }
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts
@@ -98,6 +98,10 @@ export class BulkCreateSchedulesDto {
  @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 {
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
@@ -44,6 +44,15 @@ export class SchedulesService {

        const schedule = await this.createSchedule(createDto);
        scheduleIds.push(schedule.id);
+
+        // Assign coaches if provided
+        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)}`);
--- a/apps/edr-passenger-api/src/modules/seats/seats.service.spec.ts
+++ b/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);
    });
--- a/apps/edr-passenger-api/src/modules/tickets/tickets.controller.ts
+++ b/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,6 +30,10 @@ 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, description: 'ACTIVE | USED | CANCELLED' })
+  @ApiQuery({ name: 'skip', required: false })
+  @ApiQuery({ name: 'take', required: false })
  listTickets(
    @Query('search') search?: string,
    @Query('status') status?: string,
@@ -77,14 +81,26 @@ 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'], description: 'Required for round-trip bookings' },
+      },
+    },
  })
  validate(
    @Param('bookingRef') ref: string, 
    @Body('validatorId') validatorId: string,
-    @Body('gateId') gateId?: string
+    @Body('gateId') gateId?: string,
+    @Body('leg') leg?: 'OUTBOUND' | 'RETURN',
  ) { 
-    return this.service.validate(ref, validatorId, gateId); 
+    return this.service.validate(ref, validatorId, gateId, leg); 
  }
  
  @Get(':ticketId/validation-logs')
@@ -106,7 +122,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'] },
+            },
+          },
+        },
+      },
+    },
+  })
  validateOfflineBatch(@Body() body: { validations: any[] }) {
    return this.service.validateOfflineBatch(body.validations);
  }
--- a/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
+++ b/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
@@ -7,6 +7,7 @@ interface OfflineValidation {
  validatorId: string;
  gateId?: string;
  validatedAt: string;
+  leg?: 'OUTBOUND' | 'RETURN';
 }

@Injectable()
@@ -49,6 +50,10 @@ export class TicketsService {
        booking: {
          bookingRef: t.booking.bookingRef,
          status: t.booking.status,
+          bookingType: t.booking.bookingType,
+          returnLegStatus: (t.booking as any).returnLegStatus ?? null,
+          outboundBoardedAt: (t.booking as any).outboundBoardedAt ?? null,
+          returnBoardedAt: (t.booking as any).returnBoardedAt ?? null,
          totalMinor: t.booking.totalMinor,
          currency: t.booking.currency,
          displayCurrency: t.booking.displayCurrency,
@@ -213,22 +218,67 @@ export class TicketsService {
    };
  }

-  async validate(bookingRef: string, validatorId: string, gateId?: string) {
+  async validate(bookingRef: string, validatorId: string, gateId?: string, leg?: 'OUTBOUND' | 'RETURN') {
    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) {
+
+    const isRoundTrip = booking.bookingType === 'ROUND_TRIP';
+    // For one-way bookings use the original single-validation guard
+    if (!isRoundTrip) {
+      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');
+      }
+      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: 'REJECTED', reason: 'ALREADY_VALIDATED' }
+        data: { ticketId: ticket.id, validatorId, gateId, status: 'APPROVED' },
      });
-      throw new BadRequestException('Ticket already validated');
+      return { validated: true, ticketId: ticket.id, validatedAt: new Date() };
    }
-    await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: new Date(), validatorId } });
+
+    // Round-trip: track which leg is being boarded
+    const resolvedLeg = leg ?? 'OUTBOUND';
+    const now = new Date();
+    const bookingData: Record<string, any> = {};
+
+    if (resolvedLeg === 'OUTBOUND') {
+      if ((booking as any).outboundBoardedAt) {
+        await this.prisma.gateValidationLog.create({
+          data: { ticketId: ticket.id, validatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: 'OUTBOUND_ALREADY_USED' } as any,
+        });
+        throw new BadRequestException('Outbound leg already used');
+      }
+      bookingData.outboundBoardedAt = now;
+      // Stamp the ticket's first validation
+      if (!ticket.validatedAt) {
+        await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId } });
+      }
+    } else {
+      if ((booking as any).returnBoardedAt) {
+        await this.prisma.gateValidationLog.create({
+          data: { ticketId: ticket.id, validatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: 'RETURN_ALREADY_USED' } as any,
+        });
+        throw new BadRequestException('Return leg already used');
+      }
+      bookingData.returnBoardedAt = now;
+    }
+
+    // Derive the new composite status
+    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'; // return pending/no-show
+    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, gateId, status: 'APPROVED' }
+      data: { ticketId: ticket.id, validatorId, gateId, leg: resolvedLeg, status: 'APPROVED' } as any,
    });
-    return { validated: true, ticketId: ticket.id, validatedAt: new Date() };
+    return { validated: true, ticketId: ticket.id, leg: resolvedLeg, validatedAt: now };
  }

  async getValidationLogs(ticketId: string) {
@@ -256,6 +306,8 @@ export class TicketsService {
      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,
    }));
  }
@@ -265,11 +317,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 } });
@@ -286,11 +340,21 @@ export class TicketsService {
          continue;
        }

-        if (ticket.validatedAt) {
+        if (ticket.validatedAt && booking.bookingType !== 'ROUND_TRIP') {
          results.duplicate++;
          continue;
        }

+        // For round-trip, check per-leg duplication
+        if (booking.bookingType === 'ROUND_TRIP' && offlineLeg) {
+          const alreadyUsed =
+            offlineLeg === 'OUTBOUND' ? !!(booking as any).outboundBoardedAt : !!(booking as any).returnBoardedAt;
+          if (alreadyUsed) {
+            results.duplicate++;
+            continue;
+          }
+        }
+
        await this.prisma.ticket.update({
          where: { id: ticket.id },
          data: { validatedAt: new Date(v.validatedAt), validatorId: v.validatorId },
@@ -301,11 +365,24 @@ 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 returnLegStatus for round-trip offline validations
+        if (booking.bookingType === 'ROUND_TRIP' && offlineLeg) {
+          const bookingData: Record<string, any> =
+            offlineLeg === 'OUTBOUND' ? { outboundBoardedAt: new Date(v.validatedAt) } : { returnBoardedAt: new Date(v.validatedAt) };
+          const outboundUsed = offlineLeg === 'OUTBOUND' ? true : !!(booking as any).outboundBoardedAt;
+          const returnUsed   = offlineLeg === '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 });
+        }
+
        results.success++;
      } catch (err) {
        results.failed++;