Coaches, seats, schedules, and pricing related updates

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,180 @@ 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 seat number cycling
+      if (isBedCoach) {
+        if (totalCols === 3) {
+          // Economy bed (3 levels): 1L, 2M, 3U, 4L, 5M, 6U...
+          const posMod = ((seatNumber - 1) % 3);
+          if (posMod === 0) bedPosition = 'lower';
+          else if (posMod === 1) bedPosition = 'middle';
+          else if (posMod === 2) bedPosition = 'upper';
+        } else if (totalCols === 2) {
+          // VIP bed (2 levels): 1L, 2U, 3L, 4U...
+          const posMod = ((seatNumber - 1) % 2);
+          if (posMod === 0) bedPosition = 'lower';
+          else if (posMod === 1) bedPosition = 'upper';
+        }
+      }
+
       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 } });
+    if (!coachType) throw new NotFoundException('Coach type not found');
+    
+    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');
+    
+    return this.prisma.seatClass.update({
+      where: { id },
+      data: {
+        name: dto.name,
+        description: dto.description,
+        baseFareMinor: dto.baseFareMinor,
+      },
+    });
+  }
+
+  async deleteClass(id: string) {
+    const seatClass = await this.prisma.seatClass.findUnique({ where: { id } });
+    if (!seatClass) throw new NotFoundException('Seat class not found');
+    
+    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 +214,112 @@ export class FleetService {
     return this.prisma.train.update({ where: { id }, data: dto });
   }
 
-  async getCoach(id: string) {
-    const coach = await this.prisma.coach.findUnique({
-      where: { id },
-      include: {
-        seatClass: 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 };
-  }
-
-  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.scheduleId) where.assignments = { some: { scheduleId: dto.scheduleId } };
-
-    const coaches = await this.prisma.coach.findMany({
-      where,
-      include: {
-        seatClass: true,
-        seats: { select: { status: true } },
-        _count: { select: { seats: true, assignments: true } },
-      },
-      orderBy: [{ isActive: 'desc' }, { label: '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 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 } } },
-    });
-  }
-
-  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 } });
   }
 
+  async getCoach(id: string) {
+    const coach = await this.prisma.coach.findUnique({
+      where: { id },
+      include: {
+        coachType: true,
+        seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] },
+        assignments: {
+          include: { schedule: { include: { originStation: true, destinationStation: true } } },
+          orderBy: { schedule: { departureAt: 'desc' } },
+          take: 5,
+        },
+      },
+    });
+    if (!coach) throw new NotFoundException('Coach not found');
+    return coach;
+  }
+
+  async listCoaches(dto: ListCoachesDto) {
+    const where: any = {};
+    if (dto.status) where.status = dto.status;
+    if (dto.scheduleId) where.assignments = { some: { scheduleId: dto.scheduleId } };
+
+    return this.prisma.coach.findMany({
+      where,
+      include: { coachType: true },
+      orderBy: { number: 'asc' },
+    });
+  }
+
+  async createCoach(dto: CreateCoachDto) {
+    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: {
+        coachTypeId: dto.coachTypeId,
+        number: dto.number,
+        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: {
+        arrangement: dto.arrangement,
+        capacity: dto.capacity,
+        status: dto.status,
+      },
+      include: { coachType: true },
+    });
+  }
+
   async deleteCoach(id: string) {
     const coach = await this.prisma.coach.findUnique({ where: { id } });
     if (!coach) throw new NotFoundException('Coach not found');
+    
+    // Get all seat IDs for this coach
+    const seats = await this.prisma.seat.findMany({ where: { coachId: id }, select: { id: true } });
+    const seatIds = seats.map(s => s.id);
+    
+    // Delete in order of foreign key dependencies
+    if (seatIds.length > 0) {
+      // 1. Delete seat blocks (references seats)
+      await this.prisma.seatBlock.deleteMany({ where: { seatId: { in: seatIds } } });
+      
+      // 2. Delete ticket seats (references seats)
+      await this.prisma.ticketSeat.deleteMany({ where: { seatId: { in: seatIds } } });
+      
+      // 3. Delete booking seats (references seats)
+      await this.prisma.bookingSeat.deleteMany({ where: { seatId: { in: seatIds } } });
+      
+      // 4. Delete journey segments with these seats
+      await this.prisma.journeySegment.deleteMany({ where: { seatId: { in: seatIds } } });
+    }
+    
+    // 5. Delete all associated seats
+    await this.prisma.seat.deleteMany({ where: { coachId: id } });
+    
+    // 6. Delete coach assignments
+    await this.prisma.coachAssignment.deleteMany({ where: { coachId: id } });
+    
+    // 7. Finally delete the coach
     return this.prisma.coach.delete({ where: { id } });
   }
 
@@ -251,19 +339,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 +346,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,
+    };
   }
 }