Coaches, seats, schedules, and pricing related updates

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,55 @@ 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[] = [];
+
+    // Validate route and get stops for plannedTimes generation
+    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);
+        scheduleCount++;
+      } catch (error) {
+        errors.push(`Failed to create schedule for ${currentDate.toISOString()}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+
+      // Move to next repetition
+      currentDate = new Date(currentDate.getTime() + dto.repeatEveryDays * 24 * 60 * 60 * 1000);
+    }
+
+    return {
+      schedulesCreated: scheduleCount,
+      errors,
+      scheduleIds,
+    };
+  }
 
   async listSchedules(dto: ListSchedulesDto) {
     const where: any = {};
@@ -58,28 +104,48 @@ 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');
 
+    // Check for duplicate schedule with same train, route, and date
+    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()}`,
+      );
+    }
+
     // Auto-generate plannedTimes if not provided or empty
     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(),
@@ -113,7 +179,6 @@ 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]),
     );
@@ -130,7 +195,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 +203,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,12 +221,6 @@ 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[],
@@ -204,7 +261,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 +269,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 +286,16 @@ 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 +305,7 @@ 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(),
@@ -276,19 +329,53 @@ 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 } });
+
+    const bookings = await this.prisma.booking.findMany({
+      where: { scheduleId: id },
+      select: { id: true },
+    });
+    const bookingIds = bookings.map(b => b.id);
+
+    if (bookingIds.length > 0) {
+      const paymentIntents = await this.prisma.paymentIntent.findMany({
+        where: { bookingId: { in: bookingIds } },
+        select: { id: true },
+      });
+      const paymentIntentIds = paymentIntents.map(pi => pi.id);
+
+      if (paymentIntentIds.length > 0) {
+        await this.prisma.paymentRefund.deleteMany({
+          where: { paymentIntentId: { in: paymentIntentIds } },
+        });
+      }
+
+      await this.prisma.ticket.deleteMany({
+        where: { bookingId: { in: bookingIds } },
+      });
+      await this.prisma.bookingSeat.deleteMany({
+        where: { bookingId: { in: bookingIds } },
+      });
+      await this.prisma.bookingModification.deleteMany({
+        where: { bookingId: { in: bookingIds } },
+      });
+      await this.prisma.bookingCancellation.deleteMany({
+        where: { bookingId: { in: bookingIds } },
+      });
+      await this.prisma.paymentIntent.deleteMany({
+        where: { bookingId: { in: bookingIds } },
+      });
+    }
+
     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,8 +401,6 @@ export class SchedulesService {
     });
   }
 
-  // ── Fare Rules ─────────────────────────────────────────────────────────────
-
   createFareRule(dto: CreateFareRuleDto) {
     const { validFrom, validUntil, scheduleId, nationality, ...rest } = dto;
     return this.prisma.fareRule.create({
@@ -329,6 +414,43 @@ export class SchedulesService {
     });
   }
 
+  createSegmentFareRule(dto: any) {
+    const { validFrom, validUntil, ...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, ...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 },
+    });
+  }
+
   getFareFromEngine(scheduleId: string, seatClassId: string, nationality?: string) {
     return this.fareEngine.calculateForSchedule(scheduleId, seatClassId, nationality);
   }
@@ -337,10 +459,6 @@ export class SchedulesService {
     return this.fareEngine.calculateAllForSchedule(scheduleId, nationality);
   }
 
-  /**
-   * 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 +470,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,8 +494,6 @@ export class SchedulesService {
     return { synced, errors };
   }
 
-  // ── Coach Assignments ──────────────────────────────────────────────────────
-
   async assignCoaches(
     scheduleId: string,
     coaches: Array<{ coachId: string; positionNumber: number }>,
@@ -386,7 +501,6 @@ export class SchedulesService {
     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 } },
@@ -395,18 +509,16 @@ export class SchedulesService {
       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 };
   }
@@ -417,7 +529,6 @@ export class SchedulesService {
       include: {
         coach: {
           include: {
-            seatClass: true,
             seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] },
           },
         },
@@ -426,6 +537,41 @@ export class SchedulesService {
     });
   }
 
+  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 && dto.coaches.length > 0) {
+      await this.assignCoaches(id, dto.coaches);
+    }
+
+    return this.getSchedule(id);
+  }
+
   async removeCoachAssignment(scheduleId: string, coachId: string) {
     const assignment = await this.prisma.coachAssignment.findFirst({
       where: { scheduleId, coachId },
@@ -435,4 +581,4 @@ export class SchedulesService {
     await this.prisma.coachAssignment.delete({ where: { id: assignment.id } });
     return { message: 'Coach assignment removed' };
   }
-}
+}