mirror of
https://github.com/Tria-plc/edr-platform.git
synced 2026-08-28 09:00:57 +00:00
1378 lines
55 KiB
TypeScript
1378 lines
55 KiB
TypeScript
import { Injectable, ConflictException, NotFoundException, BadRequestException, Logger } from '@nestjs/common';
|
|
import { PrismaService } from '../../common/prisma.service';
|
|
import { HoldSeatsDto, JourneyDirection } from './seats.dto';
|
|
import { Cron, CronExpression } from '@nestjs/schedule';
|
|
import { SegmentsService } from '../segments/segments.service';
|
|
import { SystemConfigService, CONFIG_KEYS } from '../system-config/system-config.service';
|
|
import { AuditService } from '../../common/audit.service';
|
|
import { SmsClientService } from '../notifications/sms-client.service';
|
|
import { computePaymentDeadline } from '../../common/utils/payment-deadline.utils';
|
|
import { checkDirectionConflict } from '../../common/utils/journey-direction.utils';
|
|
|
|
@Injectable()
|
|
export class SeatsService {
|
|
private readonly logger = new Logger(SeatsService.name);
|
|
|
|
constructor(
|
|
private prisma: PrismaService,
|
|
private segmentsService: SegmentsService,
|
|
private systemConfig: SystemConfigService,
|
|
private auditService: AuditService,
|
|
private sms: SmsClientService,
|
|
) {}
|
|
|
|
async getSeatMap(scheduleId: string, coachTypeId?: string, journeyDirection?: JourneyDirection, originStationId?: string, destinationStationId?: string) {
|
|
const schedule = await this.prisma.trainSchedule.findUnique({
|
|
where: { id: scheduleId },
|
|
select: { originStationId: true, destinationStationId: true },
|
|
});
|
|
if (!schedule) throw new NotFoundException('Schedule not found');
|
|
|
|
const assignments = await this.prisma.coachAssignment.findMany({
|
|
where: {
|
|
scheduleId,
|
|
...(coachTypeId ? { coach: { coachTypeId } } : {}),
|
|
},
|
|
include: {
|
|
coach: {
|
|
include: {
|
|
seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] },
|
|
coachType: { include: { seatClasses: true } },
|
|
},
|
|
},
|
|
},
|
|
orderBy: { positionNumber: 'asc' },
|
|
});
|
|
|
|
const allSeatIds = assignments.flatMap((a: any) => a.coach.seats.map((s: any) => s.id));
|
|
const effectiveStatuses = await this.resolveEffectiveStatuses(
|
|
scheduleId,
|
|
allSeatIds,
|
|
originStationId ?? schedule.originStationId,
|
|
destinationStationId ?? schedule.destinationStationId,
|
|
journeyDirection
|
|
);
|
|
|
|
return {
|
|
coaches: assignments.map((a) => {
|
|
const allSeats = a.coach.seats;
|
|
const coachTypeName = a.coach.coachType?.name ?? '';
|
|
const seatClassNames = a.coach.coachType.seatClasses.map((sc: any) => sc.name);
|
|
const isBedCoach = this.isBedCoach(coachTypeName);
|
|
// Compute actual beds-per-room from first room to correctly identify VIP (4) vs Economy (6)
|
|
const bedsPerRoom = isBedCoach
|
|
? allSeats.filter((s: any) => s.row === (allSeats[0] as any)?.row).length
|
|
: 0;
|
|
const bedCategory = isBedCoach ? this.getBedCategory(coachTypeName, bedsPerRoom) : null;
|
|
|
|
const mappedSeats = allSeats.map((s: any) => {
|
|
const resolvedBedPosition = isBedCoach
|
|
? this.resolveBedPosition(s.col, s.bedPosition)
|
|
: s.bedPosition;
|
|
const effectiveStatus = effectiveStatuses.get(s.id) ?? (s.status === 'BLOCKED' || s.status === 'BOOKED' ? s.status : 'AVAILABLE');
|
|
return {
|
|
id: s.id,
|
|
seatNumber: s.seatNumber,
|
|
label: s.seatNumber,
|
|
status: effectiveStatus,
|
|
kind: s.kind,
|
|
row: s.row,
|
|
col: s.col,
|
|
isWindow: s.isWindow,
|
|
isAisle: s.isAisle,
|
|
bedPosition: resolvedBedPosition,
|
|
// Bed-specific fields (only when coach is a bed coach)
|
|
...(isBedCoach ? {
|
|
room_id: `${a.coach.id}-R${s.row}`,
|
|
category: bedCategory,
|
|
position: this.colToPosition(s.col, a.coach.arrangement),
|
|
bed_type: this.bedPositionToType(resolvedBedPosition),
|
|
} : {}),
|
|
};
|
|
});
|
|
|
|
const base = {
|
|
id: a.coach.id,
|
|
assignmentId: a.id,
|
|
coachNumber: a.coach.number,
|
|
label: a.coach.number,
|
|
mode: a.coach.status,
|
|
name: `Coach ${a.coach.number}`,
|
|
coachTypeId: a.coach.coachType?.id ?? null,
|
|
coachTypeName,
|
|
isBedCoach,
|
|
bedCategory,
|
|
seatClasses: seatClassNames,
|
|
seatClass: seatClassNames.length > 0 ? seatClassNames[0] : 'Standard',
|
|
positionNumber: a.positionNumber,
|
|
seatArrangement: a.coach.arrangement,
|
|
totalSeats: a.coach.capacity,
|
|
};
|
|
|
|
if (isBedCoach) {
|
|
// Group seats into rooms; row = room number
|
|
const roomMap = new Map<number, any[]>();
|
|
for (const seat of mappedSeats) {
|
|
if (!roomMap.has(seat.row)) roomMap.set(seat.row, []);
|
|
roomMap.get(seat.row)!.push(seat);
|
|
}
|
|
const rooms = Array.from(roomMap.entries())
|
|
.sort(([a], [b]) => a - b)
|
|
.map(([roomNumber, beds]) => ({
|
|
room_id: `${a.coach.id}-R${roomNumber}`,
|
|
roomNumber,
|
|
category: bedCategory,
|
|
totalBeds: beds.length,
|
|
beds,
|
|
}));
|
|
return { ...base, rooms, seats: mappedSeats };
|
|
}
|
|
|
|
return { ...base, seats: mappedSeats };
|
|
}),
|
|
};
|
|
}
|
|
|
|
private isBedCoach(coachTypeName: string): boolean {
|
|
const n = coachTypeName.toLowerCase();
|
|
return n.includes('bed') || n.includes('berth') || n.includes('sleeper') || n.includes('couchette');
|
|
}
|
|
|
|
private getBedCategory(coachTypeName: string, bedsPerRoom?: number): 'ECONOMY_BED' | 'VIP_BED' {
|
|
const n = coachTypeName.toLowerCase();
|
|
// Name-based: VIP / Soft Berth Coach → VIP_BED
|
|
if (n.includes('vip') || n.includes('soft')) return 'VIP_BED';
|
|
// Beds-per-room fallback: 2 or 4 beds per room = VIP, more = Economy
|
|
if (bedsPerRoom != null && bedsPerRoom <= 4) return 'VIP_BED';
|
|
return 'ECONOMY_BED';
|
|
}
|
|
|
|
// col format: L1, L2, L3, R1, R2, R3 (new) or A, B, C, D (legacy)
|
|
// arrangement e.g. "2+2", "3+3", "2+0" → "leftCount+rightCount"
|
|
private colToPosition(col: string, arrangement?: string): 'LEFT' | 'RIGHT' | null {
|
|
if (!col) return null;
|
|
// New named-col format: L1, L2, R1, R2 …
|
|
if (/^L\d+$/.test(col)) return 'LEFT';
|
|
if (/^R\d+$/.test(col)) return 'RIGHT';
|
|
// Legacy single-letter cols (A, B, C, D …): derive from arrangement
|
|
const colIndex = col.toUpperCase().charCodeAt(0) - 65; // A=0, B=1, C=2 …
|
|
if (arrangement) {
|
|
const [leftStr, rightStr] = arrangement.split('+');
|
|
const rightCount = parseInt(rightStr ?? '0', 10);
|
|
if (rightCount === 0) return 'LEFT'; // single-side berth coach — all LEFT
|
|
const leftCount = parseInt(leftStr, 10) || 0;
|
|
return colIndex < leftCount ? 'LEFT' : 'RIGHT';
|
|
}
|
|
return 'LEFT'; // safe default when no arrangement info
|
|
}
|
|
|
|
private bedPositionToType(bedPosition: string | null): 'LOWER' | 'MIDDLE' | 'UPPER' | null {
|
|
if (!bedPosition) return null;
|
|
const map: Record<string, 'LOWER' | 'MIDDLE' | 'UPPER'> = {
|
|
lower: 'LOWER', middle: 'MIDDLE', upper: 'UPPER',
|
|
};
|
|
return map[bedPosition.toLowerCase()] ?? null;
|
|
}
|
|
|
|
// Derives bedPosition from col when the seat was created with legacy A/B/C columns
|
|
// (new coaches use L1/L2/L3/R1/R2/R3 and store bedPosition explicitly).
|
|
// Col-to-tier mapping: A → lower, B → middle, C → upper, D → upper (4-tier).
|
|
private resolveBedPosition(col: string, storedBedPosition: string | null): string | null {
|
|
if (storedBedPosition) return storedBedPosition;
|
|
const legacyMap: Record<string, string> = { A: 'lower', B: 'middle', C: 'upper', D: 'upper' };
|
|
// Also handle numeric suffix in L/R cols: L1→lower, L2→middle, L3→upper
|
|
if (/^[LR]\d+$/.test(col)) {
|
|
const tier = parseInt(col.slice(1), 10);
|
|
if (tier === 1) return 'lower';
|
|
if (tier === 2) return 'middle';
|
|
return 'upper';
|
|
}
|
|
return legacyMap[col?.toUpperCase()] ?? null;
|
|
}
|
|
|
|
// Delegates the actual "is this seat held/booked for this leg" determination to
|
|
// SegmentsService.getSeatAvailabilityMap — the same canonical check search results
|
|
// (availabilityByClass) use — so the seatmap and search results can never disagree
|
|
// about seat availability again. Previously this method carried its own
|
|
// separately-written copy of the same hold/JourneySegment-overlap logic.
|
|
async resolveEffectiveStatuses(
|
|
scheduleId: string,
|
|
seatIds: string[],
|
|
originStationId?: string,
|
|
destinationStationId?: string,
|
|
journeyDirection?: JourneyDirection,
|
|
): Promise<Map<string, string>> {
|
|
const statusMap = new Map<string, string>();
|
|
if (seatIds.length === 0) return statusMap;
|
|
|
|
const stopTimes = await this.prisma.tripStopTime.findMany({
|
|
where: { scheduleId },
|
|
select: { stationId: true, sequence: true },
|
|
});
|
|
|
|
// No specific leg requested (or it doesn't resolve to real stops on this
|
|
// schedule) — conservatively treat the whole schedule as one big leg, so any
|
|
// resolvable hold/booking anywhere on it blocks these seats. Matches this
|
|
// method's previous behavior when called without origin/destination.
|
|
let reqFrom = -Infinity;
|
|
let reqTo = Infinity;
|
|
if (originStationId && destinationStationId) {
|
|
const seqOf = (id: string) => stopTimes.find(s => s.stationId === id)?.sequence;
|
|
const resolvedFrom = seqOf(originStationId);
|
|
const resolvedTo = seqOf(destinationStationId);
|
|
if (resolvedFrom !== undefined && resolvedTo !== undefined) {
|
|
reqFrom = resolvedFrom;
|
|
reqTo = resolvedTo;
|
|
}
|
|
}
|
|
|
|
const [availability, persistedSeats, scheduleBlocks] = await Promise.all([
|
|
this.segmentsService.getSeatAvailabilityMap(
|
|
scheduleId, seatIds, stopTimes, reqFrom, reqTo, journeyDirection || JourneyDirection.ONE_WAY,
|
|
),
|
|
this.prisma.seat.findMany({
|
|
where: { id: { in: seatIds } },
|
|
select: { id: true, status: true },
|
|
}),
|
|
this.prisma.seatBlock.findMany({
|
|
where: { seatId: { in: seatIds }, scheduleId },
|
|
select: { seatId: true },
|
|
}),
|
|
]);
|
|
|
|
const persistedStatus = new Map(persistedSeats.map(s => [s.id, s.status]));
|
|
const scheduleBlockedIds = new Set(scheduleBlocks.map(b => b.seatId));
|
|
|
|
for (const seatId of seatIds) {
|
|
const persisted = persistedStatus.get(seatId);
|
|
// Global BLOCKED/UNDER_MAINTENANCE (no scheduleId) — always honour
|
|
if ((persisted as string) === 'BLOCKED' || (persisted as string) === 'UNDER_MAINTENANCE') {
|
|
statusMap.set(seatId, persisted!);
|
|
} else if (scheduleBlockedIds.has(seatId)) {
|
|
// Schedule-scoped block — only blocked for this schedule
|
|
statusMap.set(seatId, 'BLOCKED');
|
|
} else {
|
|
statusMap.set(seatId, availability.get(seatId) ?? 'AVAILABLE');
|
|
}
|
|
}
|
|
|
|
return statusMap;
|
|
}
|
|
|
|
async holdSeats(dto: HoldSeatsDto) {
|
|
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');
|
|
if (new Set(seatIds).size !== seatIds.length)
|
|
throw new BadRequestException('Duplicate seatId in passengers list');
|
|
|
|
const [holdMinutes, cutoffHours] = await Promise.all([
|
|
this.systemConfig.getNumber(CONFIG_KEYS.SEAT_HOLD_DURATION_MINUTES),
|
|
this.systemConfig.getNumber(CONFIG_KEYS.HOLD_CUTOFF_HOURS_BEFORE_DEPARTURE),
|
|
]);
|
|
const expiresAt = new Date(Date.now() + holdMinutes * 60 * 1000);
|
|
|
|
const schedule = await this.prisma.trainSchedule.findUnique({
|
|
where: { id: dto.scheduleId },
|
|
select: { departureAt: true },
|
|
});
|
|
if (!schedule) throw new NotFoundException('Schedule not found');
|
|
|
|
const msUntilDeparture = schedule.departureAt.getTime() - Date.now();
|
|
const cutoffMs = cutoffHours * 60 * 60 * 1000;
|
|
if (msUntilDeparture <= cutoffMs) {
|
|
throw new BadRequestException(
|
|
`Seats cannot be held within ${cutoffHours} hour${cutoffHours !== 1 ? 's' : ''} of departure`,
|
|
);
|
|
}
|
|
|
|
const hold = await this.prisma.$transaction(async (tx) => {
|
|
const seats = await tx.seat.findMany({
|
|
where: { id: { in: seatIds } },
|
|
select: { id: true, status: true, seatNumber: true },
|
|
});
|
|
|
|
if (seats.length !== seatIds.length) {
|
|
const found = new Set(seats.map(s => s.id));
|
|
const missing = seatIds.filter(id => !found.has(id));
|
|
throw new NotFoundException(`Seat(s) not found: ${missing.join(', ')}`);
|
|
}
|
|
|
|
// Only the raw BLOCKED/UNDER_MAINTENANCE status (seat pulled out of service —
|
|
// a genuine cross-schedule flag) is checked here. Seat.status is never written
|
|
// for holds/bookings because coaches are reused across schedules; the
|
|
// schedule-scoped SeatHold/JourneySegment checks below are the authoritative
|
|
// source for whether a seat is taken on this specific schedule/leg.
|
|
const blocked = seats.filter(s => s.status === 'BLOCKED' || (s.status as string) === 'UNDER_MAINTENANCE');
|
|
if (blocked.length > 0)
|
|
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]));
|
|
const stopTimes = await tx.tripStopTime.findMany({
|
|
where: { scheduleId: dto.scheduleId },
|
|
select: { stationId: true, sequence: true },
|
|
});
|
|
|
|
// When no stop times exist, fall back to the schedule's own origin/destination
|
|
// with synthetic sequences so the hold can still be created.
|
|
let effectiveStopTimes = stopTimes;
|
|
if (stopTimes.length === 0) {
|
|
const sched = await tx.trainSchedule.findUnique({
|
|
where: { id: dto.scheduleId },
|
|
select: { originStationId: true, destinationStationId: true },
|
|
});
|
|
if (sched) {
|
|
effectiveStopTimes = [
|
|
{ stationId: sched.originStationId, sequence: 0 },
|
|
{ stationId: sched.destinationStationId, sequence: 1 },
|
|
];
|
|
}
|
|
}
|
|
|
|
const seqOf = (stationId: string) => effectiveStopTimes.find(s => s.stationId === stationId)?.sequence;
|
|
const reqFrom = seqOf(dto.originStationId);
|
|
const reqTo = seqOf(dto.destinationStationId);
|
|
|
|
if (reqFrom === undefined || reqTo === undefined)
|
|
throw new BadRequestException('Origin or destination station not found');
|
|
if (reqFrom >= reqTo)
|
|
throw new BadRequestException('Origin must come before destination');
|
|
|
|
const currentDirection = dto.journeyDirection || JourneyDirection.ONE_WAY;
|
|
const activeHolds = await tx.seatHold.findMany({
|
|
where: { scheduleId: dto.scheduleId, expiresAt: { gt: new Date() } },
|
|
select: { seatIds: true, createdBy: true },
|
|
});
|
|
|
|
for (const h of activeHolds) {
|
|
const rawSeatIds = h.seatIds as string[];
|
|
let holdDirection = JourneyDirection.ONE_WAY;
|
|
let holdFrom = 0, holdTo = Number.MAX_SAFE_INTEGER;
|
|
let passengerIds: string[] = [];
|
|
let legUnknown = true;
|
|
|
|
try {
|
|
if (h.createdBy?.trimStart().startsWith('{')) {
|
|
const meta = JSON.parse(h.createdBy);
|
|
holdFrom = seqOf(meta.originStationId) ?? 0;
|
|
holdTo = seqOf(meta.destinationStationId) ?? Number.MAX_SAFE_INTEGER;
|
|
holdDirection = meta.journeyDirection || JourneyDirection.ONE_WAY;
|
|
passengerIds = (meta.passengers ?? []).map((p: any) => p.passengerId);
|
|
legUnknown = !meta.originStationId || !meta.destinationStationId;
|
|
}
|
|
} catch { /* ignore */ }
|
|
|
|
const legsOverlap = legUnknown || (holdFrom < reqTo && reqFrom < holdTo);
|
|
if (!legsOverlap) continue;
|
|
|
|
const directionsConflict = checkDirectionConflict(currentDirection, holdDirection);
|
|
if (!directionsConflict) continue;
|
|
|
|
for (const { passengerId, seatId } of dto.passengers) {
|
|
if (rawSeatIds.includes(seatId)) {
|
|
throw new ConflictException(`Seat ${seatLabelById[seatId]} is already held for this leg`);
|
|
}
|
|
if (!legUnknown && passengerIds.includes(passengerId)) {
|
|
throw new ConflictException(`Passenger already holds a seat on this journey leg`);
|
|
}
|
|
}
|
|
}
|
|
|
|
const bookedSegments = await tx.journeySegment.findMany({
|
|
where: {
|
|
scheduleId: dto.scheduleId,
|
|
seatId: { in: seatIds },
|
|
journey: { status: { in: ['CONFIRMED', 'PENDING_PAYMENT'] } },
|
|
},
|
|
select: { seatId: true, departureStationId: true, arrivalStationId: true },
|
|
});
|
|
|
|
for (const seg of bookedSegments) {
|
|
if (!seg.seatId) continue;
|
|
const segFrom = seqOf(seg.departureStationId);
|
|
const segTo = seqOf(seg.arrivalStationId);
|
|
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`);
|
|
}
|
|
}
|
|
|
|
const holdMeta = {
|
|
originStationId: dto.originStationId,
|
|
destinationStationId: dto.destinationStationId,
|
|
journeyDirection: currentDirection,
|
|
passengers: dto.passengers.map(p => ({ passengerId: p.passengerId, seatId: p.seatId })),
|
|
};
|
|
|
|
return tx.seatHold.create({
|
|
data: {
|
|
scheduleId: dto.scheduleId,
|
|
passengerId: dto.passengers[0].passengerId,
|
|
seatIds,
|
|
createdBy: JSON.stringify(holdMeta),
|
|
expiresAt,
|
|
},
|
|
});
|
|
});
|
|
|
|
return this.enrichHold(hold);
|
|
}
|
|
|
|
async getHolds(scheduleId?: string, passengerId?: string) {
|
|
const holds = await this.prisma.seatHold.findMany({
|
|
where: {
|
|
expiresAt: { gt: new Date() },
|
|
...(scheduleId ? { scheduleId } : {}),
|
|
...(passengerId ? { passengerId } : {}),
|
|
},
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
return Promise.all(holds.map(h => this.enrichHold(h)));
|
|
}
|
|
|
|
async getHold(holdId: string) {
|
|
const hold = await this.prisma.seatHold.findUnique({ where: { id: holdId } });
|
|
if (!hold) throw new NotFoundException('Hold not found');
|
|
return this.enrichHold(hold);
|
|
}
|
|
|
|
private async enrichHold(hold: any) {
|
|
let originStationId: string | null = null;
|
|
let destinationStationId: string | null = null;
|
|
let passengerSeatMap: { passengerId: string; seatId: string }[] = [];
|
|
|
|
try {
|
|
if (hold.createdBy) {
|
|
const raw = hold.createdBy;
|
|
if (typeof raw === 'string' && raw.trimStart().startsWith('{')) {
|
|
const meta = JSON.parse(raw);
|
|
originStationId = meta.originStationId ?? null;
|
|
destinationStationId = meta.destinationStationId ?? null;
|
|
passengerSeatMap = Array.isArray(meta.passengers) ? meta.passengers : [];
|
|
}
|
|
}
|
|
} catch { /* ignore */ }
|
|
|
|
const seatIds = hold.seatIds as string[];
|
|
|
|
const [schedule, originStation, destinationStation, seats] = await Promise.all([
|
|
this.prisma.trainSchedule.findUnique({
|
|
where: { id: hold.scheduleId },
|
|
include: { train: true, originStation: true, destinationStation: true },
|
|
}),
|
|
originStationId ? this.prisma.station.findUnique({ where: { id: originStationId } }) : null,
|
|
destinationStationId ? this.prisma.station.findUnique({ where: { id: destinationStationId } }) : null,
|
|
this.prisma.seat.findMany({
|
|
where: { id: { in: seatIds } },
|
|
include: { coach: true },
|
|
}),
|
|
]);
|
|
|
|
let originSequence: number | null = null;
|
|
let destinationSequence: number | null = null;
|
|
if (originStationId && destinationStationId) {
|
|
const stopTimes = await this.prisma.tripStopTime.findMany({
|
|
where: { scheduleId: hold.scheduleId, stationId: { in: [originStationId, destinationStationId] } },
|
|
select: { stationId: true, sequence: true },
|
|
});
|
|
originSequence = stopTimes.find(s => s.stationId === originStationId)?.sequence ?? null;
|
|
destinationSequence = stopTimes.find(s => s.stationId === destinationStationId)?.sequence ?? null;
|
|
}
|
|
|
|
const seatById = Object.fromEntries(seats.map(s => [s.id, s]));
|
|
|
|
const passengers = passengerSeatMap.length > 0
|
|
? passengerSeatMap.map(({ passengerId, seatId }) => {
|
|
const s = seatById[seatId];
|
|
return {
|
|
passengerId,
|
|
seat: s ? {
|
|
id: s.id,
|
|
label: s.seatNumber,
|
|
seatNumber: s.seatNumber,
|
|
coach: s.coach.number,
|
|
seatClass: 'Standard',
|
|
row: s.row,
|
|
col: s.col,
|
|
} : { id: seatId },
|
|
};
|
|
})
|
|
: seatIds.map(seatId => {
|
|
const s = seatById[seatId];
|
|
return {
|
|
passengerId: hold.passengerId,
|
|
seat: s ? {
|
|
id: s.id,
|
|
label: s.seatNumber,
|
|
seatNumber: s.seatNumber,
|
|
coach: s.coach.number,
|
|
seatClass: 'Standard',
|
|
row: s.row,
|
|
col: s.col,
|
|
} : { id: seatId },
|
|
};
|
|
});
|
|
|
|
return {
|
|
holdId: hold.id,
|
|
expiresAt: hold.expiresAt,
|
|
createdAt: hold.createdAt,
|
|
ttlSeconds: Math.max(0, Math.floor((hold.expiresAt.getTime() - Date.now()) / 1000)),
|
|
schedule: schedule ? {
|
|
id: schedule.id,
|
|
trainNumber: schedule.train.number,
|
|
trainName: schedule.train.name,
|
|
departureAt: schedule.departureAt,
|
|
arrivalAt: schedule.arrivalAt,
|
|
fullRouteOrigin: schedule.originStation.name,
|
|
fullRouteDestination: schedule.destinationStation.name,
|
|
} : null,
|
|
leg: {
|
|
originStationId,
|
|
originStationName: originStation?.name ?? null,
|
|
originStationCode: originStation?.code ?? null,
|
|
originSequence,
|
|
destinationStationId,
|
|
destinationStationName: destinationStation?.name ?? null,
|
|
destinationStationCode: destinationStation?.code ?? null,
|
|
destinationSequence,
|
|
},
|
|
passengers,
|
|
};
|
|
}
|
|
|
|
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 } });
|
|
return { released: true, holdId };
|
|
}
|
|
|
|
// Called right after a booking (PNR) is created, and again on successful payment.
|
|
// Extends the SeatHold(s) covering these seats to the booking's actual payment
|
|
// deadline — the same MIN(createdAt + 2h, departureAt - 30min) window TasksService
|
|
// uses to auto-cancel unpaid bookings — instead of leaving them on the original
|
|
// short seat-selection hold (5 min by default). Without this, the hold could expire
|
|
// while the customer was still on the payment page, and a second customer could
|
|
// hold/book the exact same seat out from under them.
|
|
async confirmSeats(seatIds: string[], now: Date = new Date()): Promise<void> {
|
|
if (seatIds.length === 0) return;
|
|
|
|
const holds = await this.prisma.seatHold.findMany({
|
|
where: { seatIds: { hasSome: seatIds } },
|
|
select: { id: true, scheduleId: true, expiresAt: true },
|
|
});
|
|
if (holds.length === 0) return;
|
|
|
|
const scheduleIds = Array.from(new Set(holds.map(h => h.scheduleId)));
|
|
const schedules = await this.prisma.trainSchedule.findMany({
|
|
where: { id: { in: scheduleIds } },
|
|
select: { id: true, departureAt: true },
|
|
});
|
|
const departureById = new Map(schedules.map(s => [s.id, s.departureAt]));
|
|
|
|
let extended = 0;
|
|
await Promise.all(
|
|
holds.map(async (hold) => {
|
|
const departureAt = departureById.get(hold.scheduleId);
|
|
if (!departureAt) return;
|
|
const deadline = computePaymentDeadline(now, departureAt);
|
|
// Only ever extend forward — never shorten a hold that's already valid longer
|
|
// than the payment deadline would give it (e.g. a second confirmSeats call on
|
|
// the same booking, or a hold that was already extended).
|
|
if (deadline <= hold.expiresAt) return;
|
|
await this.prisma.seatHold.update({ where: { id: hold.id }, data: { expiresAt: deadline } });
|
|
extended++;
|
|
}),
|
|
);
|
|
|
|
if (extended > 0) {
|
|
this.logger.log(
|
|
`Extended ${extended} seat hold(s) covering ${seatIds.length} seat(s) to their booking's payment deadline`,
|
|
);
|
|
}
|
|
}
|
|
|
|
// Delete the Journey (and its JourneySegments) scoped to this booking.
|
|
async releaseSeats(bookingId: string) {
|
|
await this.prisma.journey.deleteMany({ where: { bookingId } as any });
|
|
}
|
|
|
|
async getCoachesWithAvailability(scheduleId: string, originStationId?: string, destinationStationId?: string) {
|
|
const schedule = await this.prisma.trainSchedule.findUnique({
|
|
where: { id: scheduleId },
|
|
select: { originStationId: true, destinationStationId: true },
|
|
});
|
|
if (!schedule) throw new NotFoundException('Schedule not found');
|
|
|
|
const assignments = await this.prisma.coachAssignment.findMany({
|
|
where: { scheduleId },
|
|
include: {
|
|
coach: {
|
|
include: {
|
|
seats: { select: { id: true, status: true, seatNumber: true } },
|
|
coachType: { include: { seatClasses: { select: { name: true } } } },
|
|
},
|
|
},
|
|
},
|
|
orderBy: { positionNumber: 'asc' },
|
|
});
|
|
|
|
const allSeatIds = assignments.flatMap(a => a.coach.seats.map(s => s.id));
|
|
const effectiveStatuses = await this.resolveEffectiveStatuses(
|
|
scheduleId,
|
|
allSeatIds,
|
|
originStationId ?? schedule.originStationId,
|
|
destinationStationId ?? schedule.destinationStationId,
|
|
);
|
|
|
|
return assignments.map(a => {
|
|
const seats = a.coach.seats.filter(s => s.seatNumber && !s.seatNumber.startsWith('-'));
|
|
const totalSeats = seats.length;
|
|
const unavailable = seats.filter(s => {
|
|
const status = effectiveStatuses.get(s.id) ?? (s.status === 'BLOCKED' || s.status === 'BOOKED' ? s.status : 'AVAILABLE');
|
|
return status === 'HELD' || status === 'BOOKED' || status === 'BLOCKED';
|
|
}).length;
|
|
|
|
return {
|
|
coachId: a.coach.id,
|
|
coachTypeId: a.coach.coachType?.id ?? null,
|
|
coachNumber: a.coach.number,
|
|
positionNumber: a.positionNumber,
|
|
coachTypeName: a.coach.coachType?.name ?? '',
|
|
seatClasses: a.coach.coachType?.seatClasses.map(sc => sc.name) ?? [],
|
|
totalSeats,
|
|
availableSeats: totalSeats - unavailable,
|
|
heldSeats: seats.filter(s => (effectiveStatuses.get(s.id) ?? (s.status === 'BLOCKED' || s.status === 'BOOKED' ? s.status : 'AVAILABLE')) === 'HELD').length,
|
|
bookedSeats: seats.filter(s => (effectiveStatuses.get(s.id) ?? (s.status === 'BLOCKED' || s.status === 'BOOKED' ? s.status : 'AVAILABLE')) === 'BOOKED').length,
|
|
};
|
|
});
|
|
}
|
|
|
|
async autoAssignSeats(scheduleId: string, count: number, seatClassName: string): Promise<string[]> {
|
|
const schedule = await this.prisma.trainSchedule.findUnique({
|
|
where: { id: scheduleId },
|
|
select: { originStationId: true, destinationStationId: true },
|
|
});
|
|
if (!schedule) throw new NotFoundException('Schedule not found');
|
|
|
|
const seats = await this.prisma.seat.findMany({
|
|
where: {
|
|
coach: { assignments: { some: { scheduleId } } },
|
|
seatNumber: { not: '' },
|
|
NOT: [{ seatNumber: { startsWith: '-' } }, { status: 'BLOCKED' }, { status: 'UNDER_MAINTENANCE' as any }],
|
|
},
|
|
orderBy: [{ coach: { number: 'asc' } }, { row: 'asc' }, { col: 'asc' }],
|
|
});
|
|
|
|
const allSeatIds = seats.map(s => s.id);
|
|
const stopTimes = await this.prisma.tripStopTime.findMany({
|
|
where: { scheduleId },
|
|
select: { stationId: true, sequence: true },
|
|
});
|
|
const seqOf = (id: string) => stopTimes.find(s => s.stationId === id)?.sequence;
|
|
const reqFrom = seqOf(schedule.originStationId) ?? 0;
|
|
const reqTo = seqOf(schedule.destinationStationId) ?? stopTimes.length;
|
|
|
|
const unavailable = await this.segmentsService.getSeatAvailabilityMap(
|
|
scheduleId, allSeatIds, stopTimes, reqFrom, reqTo,
|
|
);
|
|
|
|
const availableSeats = seats.filter(s => !unavailable.has(s.id));
|
|
|
|
if (availableSeats.length < count) {
|
|
throw new ConflictException(`Only ${availableSeats.length} seats available, requested ${count}`);
|
|
}
|
|
|
|
const assigned = this.findContiguousSeats(availableSeats, count);
|
|
return assigned.map((s) => s.id);
|
|
}
|
|
|
|
private findContiguousSeats(seats: any[], count: number): any[] {
|
|
if (count === 1) return [seats[0]];
|
|
|
|
const grouped = new Map<string, any[]>();
|
|
for (const seat of seats) {
|
|
const key = `${seat.coachId}-${seat.row}`;
|
|
if (!grouped.has(key)) grouped.set(key, []);
|
|
grouped.get(key)!.push(seat);
|
|
}
|
|
|
|
for (const rowSeats of grouped.values()) {
|
|
if (rowSeats.length >= count) {
|
|
return rowSeats.slice(0, count);
|
|
}
|
|
}
|
|
|
|
return seats.slice(0, count);
|
|
}
|
|
|
|
async exportSeatsCSV(scheduleId: string): Promise<string> {
|
|
const assignments = await this.prisma.coachAssignment.findMany({
|
|
where: { scheduleId },
|
|
include: { coach: { include: { seats: { orderBy: [{ row: 'asc' }, { col: 'asc' }] } } } },
|
|
});
|
|
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.number},${seat.row},${seat.col},${seat.seatNumber},${seat.kind},${seat.status},${seat.premiumFeeMinor}`);
|
|
}
|
|
}
|
|
return rows.join('\n');
|
|
}
|
|
|
|
async previewSeatsCSV(csvContent: string): Promise<{ valid: number; invalid: number; errors: string[] }> {
|
|
const lines = csvContent.trim().split('\n').slice(1);
|
|
const errors: string[] = [];
|
|
let valid = 0;
|
|
let invalid = 0;
|
|
|
|
for (let i = 0; i < lines.length; i++) {
|
|
const parts = lines[i].split(',');
|
|
if (parts.length < 8) {
|
|
errors.push(`Line ${i + 2}: Invalid format`);
|
|
invalid++;
|
|
continue;
|
|
}
|
|
const [coachId, , row, col, seatNumber] = parts;
|
|
if (!coachId || !row || !col || !seatNumber) {
|
|
errors.push(`Line ${i + 2}: Missing required fields`);
|
|
invalid++;
|
|
continue;
|
|
}
|
|
valid++;
|
|
}
|
|
|
|
return { valid, invalid, errors: errors.slice(0, 10) };
|
|
}
|
|
|
|
async importSeatsCSV(scheduleId: string, csvContent: string, commit: boolean): Promise<{ imported: number; errors: string[] }> {
|
|
const lines = csvContent.trim().split('\n').slice(1);
|
|
const errors: string[] = [];
|
|
let imported = 0;
|
|
|
|
if (!commit) {
|
|
return { imported: 0, errors: ['Preview mode'] };
|
|
}
|
|
|
|
for (let i = 0; i < lines.length; i++) {
|
|
try {
|
|
const parts = lines[i].split(',');
|
|
const [coachId, , row, col, seatNumber, kind, status, premiumFeeMinor] = parts;
|
|
|
|
await this.prisma.seat.upsert({
|
|
where: { coachId_row_col: { coachId, row: parseInt(row), col } },
|
|
update: {
|
|
seatNumber,
|
|
kind: kind as any,
|
|
status: status as any,
|
|
premiumFeeMinor: parseInt(premiumFeeMinor) || 0,
|
|
},
|
|
create: {
|
|
coachId,
|
|
row: parseInt(row),
|
|
col,
|
|
seatNumber,
|
|
kind: kind as any,
|
|
status: status as any,
|
|
premiumFeeMinor: parseInt(premiumFeeMinor) || 0,
|
|
},
|
|
});
|
|
imported++;
|
|
} catch (err) {
|
|
errors.push(`Line ${i + 2}: ${err instanceof Error ? err.message : String(err)}`);
|
|
}
|
|
}
|
|
|
|
return { imported, errors: errors.slice(0, 10) };
|
|
}
|
|
|
|
async blockSeat(seatId: string, reason: string, scheduleId?: string) {
|
|
const seat = await this.prisma.seat.findUnique({ where: { id: seatId } });
|
|
if (!seat) throw new NotFoundException('Seat not found');
|
|
|
|
// Schedule-scoped block: only affects this schedule, not all schedules
|
|
// Global block (no scheduleId): sets Seat.status = BLOCKED for all schedules
|
|
if (scheduleId) {
|
|
await this.prisma.seatBlock.create({ data: { seatId, scheduleId, reason, blockedBy: 'system' } });
|
|
} else {
|
|
await this.prisma.seat.update({ where: { id: seatId }, data: { status: 'BLOCKED' } });
|
|
await this.prisma.seatBlock.create({ data: { seatId, reason, blockedBy: 'system' } });
|
|
}
|
|
await this.auditService.log({ action: 'UPDATE', entityType: 'Seat', entityId: seatId, newData: { status: 'BLOCKED', reason, scheduleId } });
|
|
return { blocked: true, seatId, reason, scheduleId };
|
|
}
|
|
|
|
async unblockSeat(seatId: string, scheduleId?: string) {
|
|
const seat = await this.prisma.seat.findUnique({ where: { id: seatId } });
|
|
if (!seat) throw new NotFoundException('Seat not found');
|
|
|
|
if (scheduleId) {
|
|
await this.prisma.seatBlock.deleteMany({ where: { seatId, scheduleId } });
|
|
} else {
|
|
await this.prisma.seat.update({ where: { id: seatId }, data: { status: 'AVAILABLE' } });
|
|
await this.prisma.seatBlock.deleteMany({ where: { seatId, scheduleId: null } });
|
|
}
|
|
await this.auditService.log({ action: 'UPDATE', entityType: 'Seat', entityId: seatId, newData: { status: 'AVAILABLE', scheduleId } });
|
|
return { unblocked: true, seatId, scheduleId };
|
|
}
|
|
|
|
async setMaintenance(seatId: string, reason: string) {
|
|
const seat = await this.prisma.seat.findUnique({ where: { id: seatId } });
|
|
if (!seat) throw new NotFoundException('Seat not found');
|
|
if (seat.status === 'BOOKED') throw new BadRequestException('Cannot set a booked seat to maintenance');
|
|
await this.prisma.seat.update({ where: { id: seatId }, data: { status: 'UNDER_MAINTENANCE' as any } });
|
|
await this.prisma.seatBlock.create({ data: { seatId, reason: `MAINTENANCE: ${reason}`, blockedBy: 'system' } });
|
|
return { maintenance: true, seatId, reason };
|
|
}
|
|
|
|
async clearMaintenance(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' as any } });
|
|
await this.prisma.seatBlock.deleteMany({ where: { seatId } });
|
|
return { maintenance: false, 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 || seat.seatNumber.startsWith('-')) throw new BadRequestException('Seat already removed');
|
|
|
|
// Mark as removed, then renumber all active seats in the coach
|
|
await this.prisma.seat.update({
|
|
where: { id: seatId },
|
|
data: { seatNumber: `-${seat.seatNumber}` },
|
|
});
|
|
|
|
await this.renumberCoachSeats(seat.coachId);
|
|
await this.auditService.log({ action: 'DELETE', entityType: 'Seat', entityId: seatId, oldData: { seatNumber: seat.seatNumber, coachId: seat.coachId } });
|
|
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 with a temporary placeholder number, then renumber
|
|
await this.prisma.seat.update({ where: { id: seatId }, data: { seatNumber: `__restore__${seatId}` } });
|
|
await this.renumberCoachSeats(seat.coachId);
|
|
|
|
const restored = await this.prisma.seat.findUnique({ where: { id: seatId } });
|
|
return { restored: true, seatId, seatNumber: restored?.seatNumber };
|
|
}
|
|
|
|
/**
|
|
* Renumbers all active (non-removed) seats in a coach sequentially starting from 1,
|
|
* ordered by row then col. Removed seats (prefixed with "-") keep their slot but
|
|
* are excluded from the numbering sequence so numbers remain continuous.
|
|
*/
|
|
private async renumberCoachSeats(coachId: string): Promise<void> {
|
|
const allSeats = await this.prisma.seat.findMany({
|
|
where: { coachId },
|
|
orderBy: [{ row: 'asc' }, { col: 'asc' }],
|
|
select: { id: true, seatNumber: true },
|
|
});
|
|
|
|
const activeSeats = allSeats.filter(
|
|
(s) => s.seatNumber && !s.seatNumber.startsWith('-') && !s.seatNumber.startsWith('__restore__'),
|
|
);
|
|
|
|
await Promise.all(
|
|
activeSeats.map((s, idx) =>
|
|
this.prisma.seat.update({
|
|
where: { id: s.id },
|
|
data: { seatNumber: String(idx + 1) },
|
|
}),
|
|
),
|
|
);
|
|
}
|
|
|
|
// Runs every minute, but is also safe to call on-demand (e.g. right after a hold's
|
|
// TTL is read back to the client) — expiresAt/now are both absolute UTC instants
|
|
// (Date objects, not wall-clock strings), so this is correct regardless of the
|
|
// server's or a client's local timezone; there's no wall-clock parsing involved.
|
|
@Cron(CronExpression.EVERY_MINUTE)
|
|
async expireHolds() {
|
|
try {
|
|
const result = await this.expireHoldsCore();
|
|
if (result.expiredHolds > 0) {
|
|
this.logger.log(
|
|
`Expired ${result.expiredHolds} hold(s): released ${result.releasedSeatIds.length} seat(s), ` +
|
|
`skipped ${result.skippedSeatIds.length} still held by another active hold on the same schedule`,
|
|
);
|
|
}
|
|
} catch (error) {
|
|
// A failed run must not crash the process or silently go unnoticed — the next
|
|
// scheduled run one minute later will retry the same (still-expired) holds,
|
|
// since nothing here is deleted/updated until the queries above succeed.
|
|
this.logger.error('Failed to expire seat holds', error instanceof Error ? error.stack : error);
|
|
}
|
|
}
|
|
|
|
async expireHoldsCore(now: Date = new Date()): Promise<{
|
|
expiredHolds: number;
|
|
releasedSeatIds: string[];
|
|
skippedSeatIds: string[];
|
|
}> {
|
|
const expired = await this.prisma.seatHold.findMany({
|
|
where: { expiresAt: { lt: now } },
|
|
select: { id: true, scheduleId: true, seatIds: true },
|
|
});
|
|
if (expired.length === 0) {
|
|
return { expiredHolds: 0, releasedSeatIds: [], skippedSeatIds: [] };
|
|
}
|
|
|
|
// Still-active holds — scoped per (scheduleId, seatId), not just seatId. The same
|
|
// physical Seat row is reused across every recurring date a coach runs, so the
|
|
// same seatId legitimately appears in unrelated holds for other schedules; without
|
|
// this scoping, an unrelated active hold on a DIFFERENT schedule would wrongly
|
|
// block release of a seat whose hold expired on THIS schedule, leaving it stuck at
|
|
// status 'HELD' indefinitely.
|
|
const activeHolds = await this.prisma.seatHold.findMany({
|
|
where: { expiresAt: { gte: now } },
|
|
select: { scheduleId: true, seatIds: true },
|
|
});
|
|
const stillHeldKeys = new Set(
|
|
activeHolds.flatMap(h => (h.seatIds as string[]).map(seatId => `${h.scheduleId}:${seatId}`)),
|
|
);
|
|
|
|
const releasedSeatIds = new Set<string>();
|
|
const skippedSeatIds = new Set<string>();
|
|
for (const hold of expired) {
|
|
for (const seatId of hold.seatIds as string[]) {
|
|
if (stillHeldKeys.has(`${hold.scheduleId}:${seatId}`)) {
|
|
skippedSeatIds.add(seatId);
|
|
} else {
|
|
releasedSeatIds.add(seatId);
|
|
}
|
|
}
|
|
}
|
|
|
|
await this.prisma.seatHold.deleteMany({ where: { expiresAt: { lt: now } } });
|
|
|
|
return {
|
|
expiredHolds: expired.length,
|
|
releasedSeatIds: Array.from(releasedSeatIds),
|
|
skippedSeatIds: Array.from(skippedSeatIds), // kept for logging/API compat; no DB writes needed
|
|
};
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// Duplicate-seat management (backoffice)
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
async getDuplicateSeats(date: string, scheduleId?: string) {
|
|
const dayStart = new Date(`${date}T00:00:00.000Z`);
|
|
const dayEnd = new Date(`${date}T23:59:59.999Z`);
|
|
|
|
const schedules = await this.prisma.trainSchedule.findMany({
|
|
where: {
|
|
departureAt: { gte: dayStart, lte: dayEnd },
|
|
...(scheduleId ? { id: scheduleId } : {}),
|
|
},
|
|
orderBy: { departureAt: 'asc' },
|
|
include: {
|
|
originStation: { select: { name: true } },
|
|
destinationStation: { select: { name: true } },
|
|
coachAssignments: {
|
|
orderBy: { positionNumber: 'asc' },
|
|
include: {
|
|
coach: {
|
|
include: {
|
|
coachType: { select: { name: true } },
|
|
seats: {
|
|
orderBy: [{ row: 'asc' }, { col: 'asc' }],
|
|
select: { id: true, seatNumber: true, status: true, coachId: true },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const result = [];
|
|
|
|
for (const schedule of schedules) {
|
|
// All confirmed BookingSeat rows for this schedule
|
|
const bookingSeats = await this.prisma.bookingSeat.findMany({
|
|
where: {
|
|
OR: [
|
|
{ scheduleId: schedule.id },
|
|
{ scheduleId: null, booking: { scheduleId: schedule.id } },
|
|
],
|
|
booking: { status: { in: ['CONFIRMED', 'BOARDED'] } },
|
|
},
|
|
select: {
|
|
id: true, seatId: true, scheduleId: true, leg: true, passengerName: true,
|
|
seat: { select: { coachId: true } },
|
|
booking: {
|
|
select: {
|
|
id: true, bookingRef: true, scheduleId: true,
|
|
createdAt: true, contactPhone: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
// Seats occupied by any confirmed journey on this schedule (source of truth)
|
|
const journeySegments = await this.prisma.journeySegment.findMany({
|
|
where: {
|
|
scheduleId: schedule.id,
|
|
seatId: { not: null },
|
|
journey: { status: { in: ['CONFIRMED', 'PENDING_PAYMENT'] } },
|
|
},
|
|
select: { seatId: true },
|
|
});
|
|
const occupiedIds = new Set(journeySegments.map(js => js.seatId!));
|
|
|
|
// Group BookingSeat rows by (seatId::leg) to detect duplicates
|
|
type BS = (typeof bookingSeats)[number];
|
|
const groups = new Map<string, BS[]>();
|
|
for (const bs of bookingSeats) {
|
|
const key = `${bs.seatId}::${bs.leg}`;
|
|
if (!groups.has(key)) groups.set(key, []);
|
|
groups.get(key)!.push(bs);
|
|
}
|
|
|
|
// All seats held by any confirmed BookingSeat — union of JourneySegment-based
|
|
// occupancy AND BookingSeat-based occupancy so that seats whose JourneySegments
|
|
// are missing (e.g. created via enhanced-seats path without bookingId) are still
|
|
// excluded from the available list.
|
|
const bookedSeatIds = new Set<string>([
|
|
...occupiedIds,
|
|
...bookingSeats.map(bs => bs.seatId).filter((id): id is string => id !== null && id !== undefined),
|
|
]);
|
|
|
|
const coachReports = [];
|
|
|
|
for (const assignment of schedule.coachAssignments) {
|
|
const coach = assignment.coach;
|
|
|
|
// Duplicate groups whose seat belongs to this coach
|
|
const duplicates = [];
|
|
for (const [key, group] of groups) {
|
|
if (group.length <= 1) continue;
|
|
if (group[0].seat.coachId !== coach.id) continue;
|
|
const [seatId] = key.split('::');
|
|
const seat = coach.seats.find(s => s.id === seatId);
|
|
duplicates.push({
|
|
seatId,
|
|
seatNumber: seat?.seatNumber ?? seatId,
|
|
leg: group[0].leg,
|
|
bookings: group.map(bs => ({
|
|
bookingSeatId: bs.id,
|
|
bookingId: bs.booking.id,
|
|
bookingRef: bs.booking.bookingRef,
|
|
passengerName: bs.passengerName,
|
|
contactPhone: bs.booking.contactPhone,
|
|
createdAt: bs.booking.createdAt,
|
|
})),
|
|
});
|
|
}
|
|
|
|
// Free seats in this coach — excludes BLOCKED, all confirmed BookingSeat
|
|
// assignments, and all confirmed JourneySegment occupancies.
|
|
const availableSeats = coach.seats
|
|
.filter(s =>
|
|
(s.status as string) !== 'BLOCKED' &&
|
|
!s.seatNumber.startsWith('-') &&
|
|
!bookedSeatIds.has(s.id),
|
|
)
|
|
.map(s => ({ seatId: s.id, seatNumber: s.seatNumber }));
|
|
|
|
coachReports.push({
|
|
coachId: coach.id,
|
|
coachNumber: coach.number,
|
|
coachTypeName: coach.coachType.name,
|
|
duplicates,
|
|
availableSeats,
|
|
});
|
|
}
|
|
|
|
if (coachReports.some(c => c.duplicates.length > 0)) {
|
|
result.push({
|
|
scheduleId: schedule.id,
|
|
departureAt: schedule.departureAt,
|
|
origin: schedule.originStation.name,
|
|
destination: schedule.destinationStation.name,
|
|
coaches: coachReports,
|
|
});
|
|
}
|
|
}
|
|
|
|
const totalDuplicates = result.reduce(
|
|
(sum, s) => sum + s.coaches.reduce((cs, c) => cs + c.duplicates.length, 0),
|
|
0,
|
|
);
|
|
|
|
return { date, schedules: result, totalDuplicates };
|
|
}
|
|
|
|
async resolveDuplicateSeats(bookingSeatIds: string[], coachIds: string[]) {
|
|
if (bookingSeatIds.length === 0) return { resolved: 0, unresolved: 0, results: [] };
|
|
|
|
// Load BookingSeat rows with full booking + schedule context
|
|
const bookingSeats = await this.prisma.bookingSeat.findMany({
|
|
where: { id: { in: bookingSeatIds } },
|
|
select: {
|
|
id: true, seatId: true, leg: true, scheduleId: true,
|
|
seat: { select: { seatNumber: true } },
|
|
booking: {
|
|
select: {
|
|
id: true, bookingRef: true, scheduleId: true,
|
|
status: true, contactPhone: true, passengerId: true,
|
|
totalMinor: true, currency: true,
|
|
originStationId: true, destinationStationId: true,
|
|
schedule: {
|
|
select: {
|
|
originStationId: true,
|
|
destinationStationId: true,
|
|
originStation: { select: { name: true } },
|
|
destinationStation: { select: { name: true } },
|
|
departureAt: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
if (bookingSeats.length !== bookingSeatIds.length) {
|
|
const found = new Set(bookingSeats.map(bs => bs.id));
|
|
const missing = bookingSeatIds.filter(id => !found.has(id));
|
|
throw new NotFoundException(`BookingSeat(s) not found: ${missing.join(', ')}`);
|
|
}
|
|
|
|
const invalid = bookingSeats.filter(bs => !['CONFIRMED', 'BOARDED'].includes(bs.booking.status));
|
|
if (invalid.length > 0) {
|
|
throw new BadRequestException(
|
|
`Bookings must be CONFIRMED or BOARDED: ${invalid.map(bs => bs.booking.bookingRef).join(', ')}`,
|
|
);
|
|
}
|
|
|
|
// Load all non-blocked, non-removed seats from the selected coaches (ordered for deterministic pick)
|
|
const coachSeats = await this.prisma.seat.findMany({
|
|
where: {
|
|
coachId: { in: coachIds },
|
|
status: { not: 'BLOCKED' },
|
|
NOT: { seatNumber: { startsWith: '-' } },
|
|
},
|
|
select: { id: true, seatNumber: true, coachId: true, row: true, col: true },
|
|
orderBy: [{ coachId: 'asc' }, { row: 'asc' }, { col: 'asc' }],
|
|
});
|
|
|
|
// Build occupied-seat sets per schedule from confirmed JourneySegments
|
|
const scheduleIds = [
|
|
...new Set(
|
|
bookingSeats
|
|
.map(bs => bs.scheduleId ?? bs.booking.scheduleId)
|
|
.filter((id): id is string => id !== null && id !== undefined),
|
|
),
|
|
];
|
|
|
|
const occupiedBySchedule = new Map<string, Set<string>>();
|
|
await Promise.all(
|
|
scheduleIds.map(async scheduleId => {
|
|
const segments = await this.prisma.journeySegment.findMany({
|
|
where: {
|
|
scheduleId,
|
|
seatId: { not: null },
|
|
journey: { status: { in: ['CONFIRMED', 'PENDING_PAYMENT', 'BOARDED'] } },
|
|
},
|
|
select: { seatId: true },
|
|
});
|
|
occupiedBySchedule.set(scheduleId, new Set(segments.map(s => s.seatId!)));
|
|
}),
|
|
);
|
|
|
|
// Track seats assigned within this batch to prevent double-assignment
|
|
const assignedInBatch = new Set<string>();
|
|
|
|
const results: { bookingRef: string; oldSeatNumber: string; newSeatNumber: string; contactPhone: string | null }[] = [];
|
|
const unresolved: { bookingRef: string; reason: string }[] = [];
|
|
|
|
for (const bs of bookingSeats) {
|
|
const scheduleId = (bs.scheduleId ?? bs.booking.scheduleId)!;
|
|
const occupied = occupiedBySchedule.get(scheduleId) ?? new Set<string>();
|
|
|
|
// Pick the first available seat across the selected coaches
|
|
const newSeat = coachSeats.find(
|
|
seat =>
|
|
!occupied.has(seat.id) &&
|
|
!assignedInBatch.has(seat.id) &&
|
|
seat.id !== bs.seatId,
|
|
);
|
|
|
|
if (!newSeat) {
|
|
unresolved.push({
|
|
bookingRef: bs.booking.bookingRef,
|
|
reason: 'No available seat found in selected coaches',
|
|
});
|
|
this.logger.warn(
|
|
`Duplicate resolve: no seat available for ${bs.booking.bookingRef} (schedule ${scheduleId})`,
|
|
);
|
|
continue;
|
|
}
|
|
|
|
await this.prisma.$transaction(async tx => {
|
|
// 1. Change the seat on the booking and ticket.
|
|
await tx.bookingSeat.update({
|
|
where: { id: bs.id },
|
|
data: { seatId: newSeat.id, seatLabelSnapshot: newSeat.seatNumber },
|
|
});
|
|
await tx.ticket.updateMany({
|
|
where: { bookingId: bs.booking.id, seatId: bs.seatId, leg: bs.leg },
|
|
data: { seatId: newSeat.id },
|
|
});
|
|
|
|
// 2. Point the existing JourneySegments to the new seat.
|
|
// The Journey is already linked to this booking via bookingId;
|
|
// just update the seatId in its hop rows for this schedule.
|
|
const journey = await tx.journey.findFirst({
|
|
where: { bookingId: bs.booking.id },
|
|
select: { id: true },
|
|
});
|
|
|
|
if (!journey) {
|
|
// No Journey/JourneySegment for this booking (e.g. duplicate that was never
|
|
// processed by finalizePaymentSuccess). Create them now using the same logic,
|
|
// scoped to the booking's origin→destination leg so the seatmap shows BOOKED
|
|
// only for the correct range of stops.
|
|
const originId = bs.booking.originStationId ?? bs.booking.schedule?.originStationId;
|
|
const destId = bs.booking.destinationStationId ?? bs.booking.schedule?.destinationStationId;
|
|
|
|
const stopTimes = await tx.tripStopTime.findMany({
|
|
where: { scheduleId },
|
|
orderBy: { sequence: 'asc' },
|
|
select: { stationId: true },
|
|
});
|
|
|
|
const originIdx = originId ? stopTimes.findIndex(s => s.stationId === originId) : 0;
|
|
const destIdx = destId ? stopTimes.findIndex(s => s.stationId === destId) : stopTimes.length - 1;
|
|
const fromIdx = originIdx >= 0 ? originIdx : 0;
|
|
const toIdx = destIdx >= 0 ? destIdx : stopTimes.length - 1;
|
|
|
|
const newJourney = await tx.journey.create({
|
|
data: {
|
|
passengerId: bs.booking.passengerId,
|
|
bookingId: bs.booking.id,
|
|
status: 'CONFIRMED',
|
|
totalMinor: bs.booking.totalMinor,
|
|
currency: bs.booking.currency,
|
|
} as any,
|
|
});
|
|
|
|
const segments = [];
|
|
for (let i = fromIdx; i < toIdx; i++) {
|
|
segments.push({
|
|
journeyId: newJourney.id,
|
|
scheduleId,
|
|
segmentOrder: i - fromIdx,
|
|
seatId: newSeat.id,
|
|
coachId: newSeat.coachId,
|
|
departureStationId: stopTimes[i].stationId,
|
|
arrivalStationId: stopTimes[i + 1].stationId,
|
|
});
|
|
}
|
|
if (segments.length > 0) {
|
|
await tx.journeySegment.createMany({ data: segments, skipDuplicates: true });
|
|
}
|
|
this.logger.log(
|
|
`No Journey for ${bs.booking.bookingRef} — created Journey + ${segments.length} segment(s) for seat ${newSeat.seatNumber}`,
|
|
);
|
|
return;
|
|
}
|
|
|
|
const { count } = await tx.journeySegment.updateMany({
|
|
where: { journeyId: journey.id, scheduleId, seatId: bs.seatId },
|
|
data: { seatId: newSeat.id },
|
|
});
|
|
|
|
// Journey exists but had no segments (e.g. booking confirmed via a path
|
|
// that skipped JourneySegment creation). Create them now for the new seat
|
|
// so the seatmap reflects BOOKED.
|
|
if (count === 0) {
|
|
const originId = bs.booking.originStationId ?? bs.booking.schedule?.originStationId;
|
|
const destId = bs.booking.destinationStationId ?? bs.booking.schedule?.destinationStationId;
|
|
const stopTimes = await tx.tripStopTime.findMany({
|
|
where: { scheduleId },
|
|
orderBy: { sequence: 'asc' },
|
|
select: { stationId: true },
|
|
});
|
|
const originIdx = originId ? stopTimes.findIndex(s => s.stationId === originId) : 0;
|
|
const destIdx = destId ? stopTimes.findIndex(s => s.stationId === destId) : stopTimes.length - 1;
|
|
const fromIdx = originIdx >= 0 ? originIdx : 0;
|
|
const toIdx = destIdx >= 0 ? destIdx : stopTimes.length - 1;
|
|
const segments = [];
|
|
for (let i = fromIdx; i < toIdx; i++) {
|
|
segments.push({
|
|
journeyId: journey.id,
|
|
scheduleId,
|
|
segmentOrder: i - fromIdx,
|
|
seatId: newSeat.id,
|
|
coachId: newSeat.coachId,
|
|
departureStationId: stopTimes[i].stationId,
|
|
arrivalStationId: stopTimes[i + 1].stationId,
|
|
});
|
|
}
|
|
if (segments.length > 0) {
|
|
await tx.journeySegment.createMany({ data: segments, skipDuplicates: true });
|
|
}
|
|
this.logger.log(
|
|
`Seat reassigned: ${bs.booking.bookingRef} ` +
|
|
`${bs.seat?.seatNumber ?? bs.seatId} → ${newSeat.seatNumber} ` +
|
|
`(0 existing segments — created ${segments.length} new hop(s))`,
|
|
);
|
|
} else {
|
|
this.logger.log(
|
|
`Seat reassigned: ${bs.booking.bookingRef} ` +
|
|
`${bs.seat?.seatNumber ?? bs.seatId} → ${newSeat.seatNumber} ` +
|
|
`(${count} segment hop(s) updated)`,
|
|
);
|
|
}
|
|
});
|
|
|
|
// Mark as taken so the next booking in this batch doesn't get the same seat
|
|
assignedInBatch.add(newSeat.id);
|
|
occupied.add(newSeat.id);
|
|
|
|
const oldSeatNumber = bs.seat?.seatNumber ?? '?';
|
|
const origin = bs.booking.schedule?.originStation?.name ?? '';
|
|
const dest = bs.booking.schedule?.destinationStation?.name ?? '';
|
|
|
|
if (bs.booking.contactPhone) {
|
|
const message =
|
|
`EDR: Your booking ${bs.booking.bookingRef} (${origin} → ${dest}): ` +
|
|
`your seat has been changed from seat ${oldSeatNumber} to seat ${newSeat.seatNumber}. ` +
|
|
`We apologize for any inconvenience.`;
|
|
await this.sms.sendSms({ to: bs.booking.contactPhone, message }).catch(() => null);
|
|
}
|
|
|
|
this.logger.log(
|
|
`Duplicate resolved: ${bs.booking.bookingRef} seat ${oldSeatNumber} → ${newSeat.seatNumber}`,
|
|
);
|
|
|
|
results.push({
|
|
bookingRef: bs.booking.bookingRef,
|
|
oldSeatNumber,
|
|
newSeatNumber: newSeat.seatNumber,
|
|
contactPhone: bs.booking.contactPhone,
|
|
});
|
|
}
|
|
|
|
return {
|
|
resolved: results.length,
|
|
unresolved: unresolved.length,
|
|
results,
|
|
...(unresolved.length > 0 ? { unresolvedDetails: unresolved } : {}),
|
|
};
|
|
}
|
|
}
|