Update fare display based on currency and fix seat allocation

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

@@ -307,9 +307,9 @@ export class SeatsService {
         throw new NotFoundException(`Seat(s) not found: ${missing.join(', ')}`);
       }
 
-      const blocked = seats.filter(s => s.status === 'BLOCKED');
+      const blocked = seats.filter(s => s.status === 'BLOCKED' || s.status === 'BOOKED' || s.status === 'HELD');
       if (blocked.length > 0)
-        throw new ConflictException(`Seat(s) ${blocked.map(s => s.seatNumber).join(', ')} are blocked`);
+        throw new ConflictException(`Seat(s) ${blocked.map(s => s.seatNumber).join(', ')} are already taken`);
 
       const seatLabelById = Object.fromEntries(seats.map(s => [s.id, s.seatNumber]));
 
@@ -334,28 +334,34 @@ export class SeatsService {
         select: { seatIds: true, createdBy: true },
       });
 
-      const parsedHolds: { seatIds: string[]; from: number; to: number; passengerIds: string[] }[] = [];
+      const parsedHolds: { seatIds: string[]; from: number; to: number; passengerIds: string[]; legUnknown: boolean }[] = [];
       for (const h of activeHolds) {
+        const rawSeatIds = h.seatIds as string[];
         try {
           if (h.createdBy?.trimStart().startsWith('{')) {
             const meta = JSON.parse(h.createdBy);
             const holdFrom = seqOf(meta.originStationId);
             const holdTo   = seqOf(meta.destinationStationId);
-            if (holdFrom !== undefined && holdTo !== undefined) {
-              parsedHolds.push({
-                seatIds:      h.seatIds,
-                from:         holdFrom,
-                to:           holdTo,
-                passengerIds: (meta.passengers ?? []).map((p: any) => p.passengerId),
-              });
-            }
+            parsedHolds.push({
+              seatIds:      rawSeatIds,
+              from:         holdFrom ?? 0,
+              to:           holdTo   ?? Number.MAX_SAFE_INTEGER,
+              passengerIds: (meta.passengers ?? []).map((p: any) => p.passengerId),
+              legUnknown:   holdFrom === undefined || holdTo === undefined,
+            });
+          } else {
+            // Legacy plain-string createdBy — can't determine leg; block conservatively.
+            parsedHolds.push({ seatIds: rawSeatIds, from: 0, to: Number.MAX_SAFE_INTEGER, passengerIds: [], legUnknown: true });
           }
-        } catch { /* ignore */ }
+        } catch {
+          // Malformed JSON — block conservatively.
+          parsedHolds.push({ seatIds: rawSeatIds, from: 0, to: Number.MAX_SAFE_INTEGER, passengerIds: [], legUnknown: true });
+        }
       }
 
       for (const { passengerId, seatId } of dto.passengers) {
         for (const hold of parsedHolds) {
-          const legsOverlap = hold.from < reqTo && reqFrom < hold.to;
+          const legsOverlap = hold.legUnknown || (hold.from < reqTo && reqFrom < hold.to);
           if (!legsOverlap) continue;
 
           if (hold.seatIds.includes(seatId)) {
@@ -364,7 +370,7 @@ export class SeatsService {
             );
           }
 
-          if (hold.passengerIds.includes(passengerId)) {
+          if (!hold.legUnknown && hold.passengerIds.includes(passengerId)) {
             throw new ConflictException(
               `Passenger already holds a seat on this journey leg`,
             );
@@ -386,12 +392,14 @@ export class SeatsService {
         if (!seg.seatId) continue;
         const segFrom = seqOf(seg.departureStationId);
         const segTo   = seqOf(seg.arrivalStationId);
-        if (segFrom !== undefined && segTo !== undefined) {
-          if (segFrom < reqTo && reqFrom < segTo) {
-            throw new ConflictException(
-              `Seat ${seatLabelById[seg.seatId]} is already booked for this leg`,
-            );
-          }
+        // If stations can't be resolved, assume overlap (conservative) to prevent double-booking.
+        const overlaps = (segFrom === undefined || segTo === undefined)
+          ? true
+          : segFrom < reqTo && reqFrom < segTo;
+        if (overlaps) {
+          throw new ConflictException(
+            `Seat ${seatLabelById[seg.seatId]} is already booked for this leg`,
+          );
         }
       }
 
@@ -401,6 +409,13 @@ export class SeatsService {
         passengers: dto.passengers.map(p => ({ passengerId: p.passengerId, seatId: p.seatId })),
       };
 
+      // Mark seats as HELD so the status check catches them immediately on any
+      // subsequent hold attempt (avoids relying solely on the SeatHold table scan).
+      await tx.seat.updateMany({
+        where: { id: { in: seatIds } },
+        data: { status: 'HELD' },
+      });
+
       return tx.seatHold.create({
         data: {
           scheduleId:  dto.scheduleId,
@@ -541,11 +556,16 @@ export class SeatsService {
   async releaseHold(holdId: string) {
     const hold = await this.prisma.seatHold.findUnique({ where: { id: holdId } });
     if (!hold) throw new NotFoundException('Hold not found');
-    await this.prisma.seatHold.delete({ where: { id: holdId } });
+    await this.prisma.$transaction([
+      this.prisma.seat.updateMany({
+        where: { id: { in: hold.seatIds as string[] }, status: 'HELD' },
+        data: { status: 'AVAILABLE' },
+      }),
+      this.prisma.seatHold.delete({ where: { id: holdId } }),
+    ]);
     return { released: true, holdId };
   }
 
-  // Physical seat.status stays AVAILABLE — segment rows are the source of truth for occupancy.
   async confirmSeats(_seatIds: string[]) {}
 
   // Delete the Journey (and its JourneySegments) scoped to this booking.
@@ -719,7 +739,18 @@ export class SeatsService {
 
   @Cron(CronExpression.EVERY_MINUTE)
   async expireHolds() {
-    // Holds are temporary and don't create Journey rows — just delete expired ones.
+    const expired = await this.prisma.seatHold.findMany({
+      where: { expiresAt: { lt: new Date() } },
+      select: { id: true, seatIds: true },
+    });
+    if (expired.length === 0) return;
+
+    const expiredSeatIds = expired.flatMap(h => h.seatIds as string[]);
+    // Only reset seats that are still HELD — BOOKED seats have been confirmed and must not be touched.
+    await this.prisma.seat.updateMany({
+      where: { id: { in: expiredSeatIds }, status: 'HELD' },
+      data: { status: 'AVAILABLE' },
+    });
     await this.prisma.seatHold.deleteMany({ where: { expiresAt: { lt: new Date() } } });
   }
 }