mirror of
https://github.com/Tria-plc/edr-platform.git
synced 2026-08-29 19:58:11 +00:00
466 lines
16 KiB
TypeScript
466 lines
16 KiB
TypeScript
import { Injectable, Logger, NotFoundException, BadRequestException } from '@nestjs/common';
|
|
import { PrismaService } from '../../common/prisma.service';
|
|
import { SeatsService } from '../seats/seats.service';
|
|
import { TicketsService } from '../tickets/tickets.service';
|
|
import { EventEmitter2 } from '@nestjs/event-emitter';
|
|
import { Prisma, PaymentIntentStatus, PaymentMethodType, PaymentRegion } from '@prisma/client';
|
|
import { InitiatePaymentDto, RefundDto, AddPaymentMethodDto, InitiateResponseDto, IntentStatusDto, PaymentRegionEnum } from './payments.dto';
|
|
import {
|
|
ClientAction,
|
|
PaymentProvider,
|
|
ProviderStatus,
|
|
ProviderPaymentStatus,
|
|
TelebirrProvider,
|
|
CbeBirrProvider,
|
|
EBirrProvider,
|
|
CardProvider,
|
|
WaafiProvider,
|
|
createMerchantOrderId,
|
|
} from '@edr/payment-providers';
|
|
|
|
const NON_TERMINAL_STATUSES: PaymentIntentStatus[] = [
|
|
PaymentIntentStatus.REQUIRES_ACTION,
|
|
PaymentIntentStatus.PROCESSING,
|
|
PaymentIntentStatus.SUCCEEDED,
|
|
];
|
|
|
|
@Injectable()
|
|
export class PaymentsService {
|
|
private readonly logger = new Logger(PaymentsService.name);
|
|
private readonly providers: Map<PaymentMethodType, PaymentProvider>;
|
|
|
|
constructor(
|
|
private prisma: PrismaService,
|
|
private seatsService: SeatsService,
|
|
private ticketsService: TicketsService,
|
|
private eventEmitter: EventEmitter2,
|
|
private telebirrProvider: TelebirrProvider,
|
|
private cbeBirrProvider: CbeBirrProvider,
|
|
private eBirrProvider: EBirrProvider,
|
|
private cardProvider: CardProvider,
|
|
private waafiProvider: WaafiProvider,
|
|
) {
|
|
this.providers = new Map<PaymentMethodType, PaymentProvider>([
|
|
[PaymentMethodType.TELEBIRR, this.telebirrProvider],
|
|
[PaymentMethodType.CBE_BIRR, this.cbeBirrProvider],
|
|
[PaymentMethodType.EBIRR, this.eBirrProvider],
|
|
[PaymentMethodType.CARD, this.cardProvider],
|
|
[PaymentMethodType.WAAFI, this.waafiProvider],
|
|
]);
|
|
}
|
|
|
|
async initiatePayment(dto: InitiatePaymentDto): Promise<InitiateResponseDto> {
|
|
const booking = await this.prisma.booking.findUnique({
|
|
where: { id: dto.bookingId },
|
|
include: { seats: true },
|
|
});
|
|
if (!booking) throw new NotFoundException('Booking not found');
|
|
if (booking.status !== 'PENDING_PAYMENT') {
|
|
throw new BadRequestException('Booking not payable');
|
|
}
|
|
|
|
const existing = await this.prisma.paymentIntent.findUnique({
|
|
where: { bookingId: dto.bookingId },
|
|
});
|
|
if (existing && NON_TERMINAL_STATUSES.includes(existing.status)) {
|
|
return this.formatIntentResponse(existing);
|
|
}
|
|
|
|
const method = dto.method as PaymentMethodType;
|
|
|
|
if (method === PaymentMethodType.WALLET) {
|
|
return this.initiateWalletPayment(booking);
|
|
}
|
|
|
|
const provider = this.providers.get(method);
|
|
if (provider) {
|
|
return this.initiateProviderPayment(booking, provider, dto.platform);
|
|
}
|
|
|
|
throw new BadRequestException(`Unsupported payment method: ${method}`);
|
|
}
|
|
|
|
private async initiateWalletPayment(
|
|
booking: Prisma.BookingGetPayload<{ include: { seats: true } }>,
|
|
): Promise<InitiateResponseDto> {
|
|
const debitResult = await this.prisma.$transaction(async (tx) => {
|
|
const wallet = await tx.walletAccount.findUnique({
|
|
where: { passengerId: booking.passengerId },
|
|
});
|
|
if (!wallet || wallet.balanceMinor < booking.totalMinor) {
|
|
return { success: false };
|
|
}
|
|
const newBalance = wallet.balanceMinor - booking.totalMinor;
|
|
await tx.walletAccount.update({
|
|
where: { passengerId: booking.passengerId },
|
|
data: { balanceMinor: newBalance },
|
|
});
|
|
await tx.walletLedgerEntry.create({
|
|
data: {
|
|
walletId: wallet.id,
|
|
type: 'DEBIT',
|
|
amountMinor: booking.totalMinor,
|
|
balanceAfterMinor: newBalance,
|
|
description: `Train Ticket - ${booking.bookingRef}`,
|
|
relatedBookingId: booking.id,
|
|
},
|
|
});
|
|
return { success: true };
|
|
});
|
|
|
|
if (!debitResult.success) {
|
|
const failed = await this.prisma.paymentIntent.upsert({
|
|
where: { bookingId: booking.id },
|
|
update: {
|
|
status: PaymentIntentStatus.FAILED,
|
|
failureCode: 'INSUFFICIENT_BALANCE',
|
|
},
|
|
create: {
|
|
bookingId: booking.id,
|
|
amountMinor: booking.totalMinor,
|
|
method: PaymentMethodType.WALLET,
|
|
status: PaymentIntentStatus.FAILED,
|
|
failureCode: 'INSUFFICIENT_BALANCE',
|
|
},
|
|
});
|
|
return this.formatIntentResponse(failed);
|
|
}
|
|
|
|
const intent = await this.prisma.paymentIntent.upsert({
|
|
where: { bookingId: booking.id },
|
|
update: { status: PaymentIntentStatus.PROCESSING },
|
|
create: {
|
|
bookingId: booking.id,
|
|
amountMinor: booking.totalMinor,
|
|
method: PaymentMethodType.WALLET,
|
|
status: PaymentIntentStatus.PROCESSING,
|
|
providerRef: `WALLET-${Date.now()}`,
|
|
},
|
|
});
|
|
await this.finalizePaymentSuccess({ intentId: intent.id });
|
|
const refreshed = await this.prisma.paymentIntent.findUniqueOrThrow({
|
|
where: { id: intent.id },
|
|
});
|
|
return this.formatIntentResponse(refreshed);
|
|
}
|
|
|
|
private async initiateProviderPayment(
|
|
booking: Prisma.BookingGetPayload<{ include: { seats: true } }>,
|
|
provider: PaymentProvider,
|
|
platform: 'web' | 'mobile' | undefined,
|
|
): Promise<InitiateResponseDto> {
|
|
const merchantOrderId = createMerchantOrderId();
|
|
const result = await provider.initiate({
|
|
merchantOrderId,
|
|
orderRef: booking.bookingRef,
|
|
amountMinor: booking.totalMinor,
|
|
currency: booking.currency,
|
|
platform,
|
|
});
|
|
|
|
const providerMethod = provider.method as unknown as PaymentMethodType;
|
|
const intent = await this.prisma.paymentIntent.upsert({
|
|
where: { bookingId: booking.id },
|
|
update: {
|
|
status: PaymentIntentStatus.REQUIRES_ACTION,
|
|
method: providerMethod,
|
|
merchantOrderId,
|
|
providerOrderId: result.providerOrderId,
|
|
clientAction: result.clientAction as unknown as Prisma.InputJsonValue,
|
|
rawInitiation: result.rawInitiation as Prisma.InputJsonValue,
|
|
expiresAt: result.expiresAt,
|
|
failureCode: null,
|
|
failureMessage: null,
|
|
},
|
|
create: {
|
|
bookingId: booking.id,
|
|
amountMinor: booking.totalMinor,
|
|
currency: booking.currency,
|
|
method: providerMethod,
|
|
status: PaymentIntentStatus.REQUIRES_ACTION,
|
|
merchantOrderId,
|
|
providerOrderId: result.providerOrderId,
|
|
clientAction: result.clientAction as unknown as Prisma.InputJsonValue,
|
|
rawInitiation: result.rawInitiation as Prisma.InputJsonValue,
|
|
expiresAt: result.expiresAt,
|
|
},
|
|
});
|
|
return this.formatIntentResponse(intent);
|
|
}
|
|
|
|
private formatIntentResponse(
|
|
intent: Prisma.PaymentIntentGetPayload<Record<string, never>>,
|
|
): InitiateResponseDto {
|
|
const clientAction =
|
|
intent.clientAction && typeof intent.clientAction === 'object'
|
|
? (intent.clientAction as unknown as ClientAction)
|
|
: undefined;
|
|
return {
|
|
intentId: intent.id,
|
|
status: intent.status,
|
|
clientAction,
|
|
merchantOrderId: intent.merchantOrderId ?? undefined,
|
|
};
|
|
}
|
|
|
|
async getIntentByBookingId(bookingId: string): Promise<IntentStatusDto> {
|
|
const intent = await this.prisma.paymentIntent.findUnique({
|
|
where: { bookingId },
|
|
});
|
|
if (!intent) throw new NotFoundException('PaymentIntent not found');
|
|
|
|
const refreshable =
|
|
intent.status === PaymentIntentStatus.REQUIRES_ACTION ||
|
|
intent.status === PaymentIntentStatus.PROCESSING;
|
|
const stale = intent.updatedAt.getTime() < Date.now() - 5_000;
|
|
const provider = this.providers.get(intent.method);
|
|
|
|
if (refreshable && stale && intent.merchantOrderId && provider) {
|
|
try {
|
|
const status = await provider.queryStatus(intent.merchantOrderId);
|
|
this.logger.log(status);
|
|
await this.applyProviderStatus(intent.id, status);
|
|
const refreshed = await this.prisma.paymentIntent.findUniqueOrThrow({
|
|
where: { id: intent.id },
|
|
});
|
|
return this.formatIntentStatus(refreshed);
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : String(err);
|
|
this.logger.warn(
|
|
`queryStatus failed for intent ${intent.id}: ${message}; returning cached`,
|
|
);
|
|
}
|
|
}
|
|
|
|
return this.formatIntentStatus(intent);
|
|
}
|
|
|
|
private async applyProviderStatus(
|
|
intentId: string,
|
|
status: ProviderStatus,
|
|
): Promise<void> {
|
|
const bizContent = (status.rawResponse as { biz_content?: { order_status?: string } })
|
|
?.biz_content;
|
|
if (bizContent?.order_status === 'PAY_SUCCESS') {
|
|
await this.finalizePaymentSuccess({
|
|
intentId,
|
|
providerTxnId: status.providerTxnId,
|
|
});
|
|
return;
|
|
}
|
|
if (status.status === ProviderPaymentStatus.FAILED) {
|
|
await this.markPaymentFailed({
|
|
intentId,
|
|
failureCode: status.failureCode,
|
|
failureMessage: status.failureMessage,
|
|
});
|
|
return;
|
|
}
|
|
await this.prisma.paymentIntent.update({
|
|
where: { id: intentId },
|
|
data: {
|
|
status: status.status as unknown as PaymentIntentStatus,
|
|
providerTxnId: status.providerTxnId ?? undefined,
|
|
},
|
|
});
|
|
}
|
|
|
|
private formatIntentStatus(
|
|
intent: Prisma.PaymentIntentGetPayload<Record<string, never>>,
|
|
): IntentStatusDto {
|
|
const base = this.formatIntentResponse(intent);
|
|
return {
|
|
...base,
|
|
paidAt: intent.paidAt?.toISOString(),
|
|
failureCode: intent.failureCode ?? undefined,
|
|
failureMessage: intent.failureMessage ?? undefined,
|
|
};
|
|
}
|
|
|
|
async refund(dto: RefundDto) {
|
|
const intent = await this.prisma.paymentIntent.findUnique({ where: { bookingId: dto.bookingId } });
|
|
if (!intent || intent.status !== 'SUCCEEDED') throw new BadRequestException('No successful payment to refund');
|
|
await this.prisma.paymentIntent.update({ where: { bookingId: dto.bookingId }, data: { status: 'CANCELLED' } });
|
|
const booking = await this.prisma.booking.findUnique({ where: { id: dto.bookingId }, include: { seats: true } });
|
|
if (booking) {
|
|
await this.seatsService.releaseSeats(booking.seats.map((s) => s.seatId));
|
|
await this.prisma.booking.update({ where: { id: dto.bookingId }, data: { status: 'CANCELLED' } });
|
|
}
|
|
return { refunded: true, bookingRef: booking?.bookingRef };
|
|
}
|
|
|
|
addPaymentMethod(dto: AddPaymentMethodDto) {
|
|
const data = {
|
|
type: dto.type as unknown as PaymentMethodType,
|
|
displayName: dto.displayName,
|
|
region: dto.region as unknown as PaymentRegion,
|
|
currency: dto.currency ?? 'ETB',
|
|
providerId: dto.providerId,
|
|
enabled: dto.enabled ?? true,
|
|
sortOrder: dto.sortOrder ?? 0,
|
|
};
|
|
return this.prisma.paymentMethod.upsert({
|
|
where: { type: data.type },
|
|
update: data,
|
|
create: data,
|
|
});
|
|
}
|
|
|
|
getSupportedPaymentMethods(region?: PaymentRegionEnum) {
|
|
return this.prisma.paymentMethod.findMany({
|
|
where: {
|
|
enabled: true,
|
|
...(region
|
|
? { region: { in: [region, PaymentRegionEnum.GLOBAL] as unknown as PaymentRegion[] } }
|
|
: {}),
|
|
},
|
|
orderBy: [{ sortOrder: 'asc' }, { displayName: 'asc' }],
|
|
});
|
|
}
|
|
|
|
async finalizePaymentSuccess(input: {
|
|
intentId: string;
|
|
providerTxnId?: string;
|
|
paidAt?: Date;
|
|
}): Promise<{ alreadyFinalized: boolean }> {
|
|
const intent = await this.prisma.paymentIntent.findUnique({
|
|
where: { id: input.intentId },
|
|
});
|
|
if (!intent) throw new NotFoundException('PaymentIntent not found');
|
|
if (intent.status === PaymentIntentStatus.SUCCEEDED) {
|
|
return { alreadyFinalized: true };
|
|
}
|
|
if (intent.status === PaymentIntentStatus.CANCELLED) {
|
|
throw new BadRequestException('PaymentIntent is cancelled; cannot finalize');
|
|
}
|
|
|
|
const booking = await this.prisma.booking.findUnique({
|
|
where: { id: intent.bookingId },
|
|
include: { seats: true },
|
|
});
|
|
if (!booking) throw new NotFoundException('Booking not found');
|
|
|
|
const paidAt = input.paidAt ?? new Date();
|
|
await this.prisma.$transaction(async (tx) => {
|
|
await tx.paymentIntent.update({
|
|
where: { id: intent.id },
|
|
data: {
|
|
status: PaymentIntentStatus.SUCCEEDED,
|
|
providerTxnId: input.providerTxnId ?? intent.providerTxnId ?? undefined,
|
|
paidAt,
|
|
},
|
|
});
|
|
await tx.booking.update({
|
|
where: { id: booking.id },
|
|
data: { status: 'CONFIRMED' },
|
|
});
|
|
});
|
|
|
|
try {
|
|
await this.seatsService.confirmSeats(booking.seats.map((s) => s.seatId));
|
|
} catch (err) {
|
|
this.logger.error(`Error confirming seats: ${err instanceof Error ? err.message : String(err)}`);
|
|
}
|
|
|
|
try {
|
|
await this.createJourneySegments(booking);
|
|
} catch (err) {
|
|
this.logger.error(`Error creating journey segments: ${err instanceof Error ? err.message : String(err)}`);
|
|
}
|
|
|
|
try {
|
|
await this.ticketsService.generate(booking.id);
|
|
} catch (err) {
|
|
this.logger.error(`Error generating ticket: ${err instanceof Error ? err.message : String(err)}`);
|
|
throw err;
|
|
}
|
|
|
|
try {
|
|
await this.awardLoyaltyPoints(booking.passengerId, booking.totalMinor, booking.id);
|
|
} catch (err) {
|
|
this.logger.warn(`Error awarding loyalty points: ${err instanceof Error ? err.message : String(err)}`);
|
|
}
|
|
|
|
this.eventEmitter.emit('payment.succeeded', { booking });
|
|
return { alreadyFinalized: false };
|
|
}
|
|
|
|
async markPaymentFailed(input: {
|
|
intentId: string;
|
|
failureCode?: string;
|
|
failureMessage?: string;
|
|
}): Promise<void> {
|
|
const intent = await this.prisma.paymentIntent.findUnique({
|
|
where: { id: input.intentId },
|
|
});
|
|
if (!intent) throw new NotFoundException('PaymentIntent not found');
|
|
if (
|
|
intent.status === PaymentIntentStatus.SUCCEEDED ||
|
|
intent.status === PaymentIntentStatus.CANCELLED
|
|
) {
|
|
return;
|
|
}
|
|
await this.prisma.paymentIntent.update({
|
|
where: { id: intent.id },
|
|
data: {
|
|
status: PaymentIntentStatus.FAILED,
|
|
failureCode: input.failureCode,
|
|
failureMessage: input.failureMessage,
|
|
},
|
|
});
|
|
}
|
|
|
|
private async awardLoyaltyPoints(passengerId: string, amountMinor: number, bookingId: string) {
|
|
const points = Math.floor(amountMinor / 100);
|
|
const account = await this.prisma.loyaltyAccount.findUnique({ where: { passengerId } });
|
|
if (!account) return;
|
|
const newBalance = account.pointsBalance + points;
|
|
const tier = newBalance >= 10000 ? 'PLATINUM' : newBalance >= 5000 ? 'GOLD' : newBalance >= 2000 ? 'SILVER' : 'BRONZE';
|
|
await this.prisma.loyaltyAccount.update({ where: { passengerId }, data: { pointsBalance: { increment: points }, tier: tier as any } });
|
|
await this.prisma.loyaltyLedgerEntry.create({ data: { accountId: account.id, delta: points, reason: 'TRIP_COMPLETED', bookingId, balanceAfter: newBalance } });
|
|
}
|
|
|
|
private async createJourneySegments(booking: Prisma.BookingGetPayload<{ include: { seats: true } }>) {
|
|
const schedule = await this.prisma.trainSchedule.findUnique({
|
|
where: { id: booking.scheduleId },
|
|
include: { stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
|
|
});
|
|
if (!schedule) return;
|
|
|
|
const stopTimes = schedule.stopTimes;
|
|
if (stopTimes.length < 2) return;
|
|
|
|
const originSequence = stopTimes.findIndex(st => st.stationId === schedule.originStationId);
|
|
const destSequence = stopTimes.findIndex(st => st.stationId === schedule.destinationStationId);
|
|
|
|
if (originSequence < 0 || destSequence < 0 || originSequence >= destSequence) return;
|
|
|
|
const journey = await this.prisma.journey.create({
|
|
data: {
|
|
passengerId: booking.passengerId,
|
|
status: 'CONFIRMED',
|
|
totalMinor: booking.totalMinor,
|
|
currency: booking.currency,
|
|
},
|
|
});
|
|
|
|
const journeySegments = [];
|
|
for (const bookingSeat of booking.seats) {
|
|
for (let i = originSequence; i < destSequence; i++) {
|
|
journeySegments.push({
|
|
journeyId: journey.id,
|
|
scheduleId: booking.scheduleId,
|
|
segmentOrder: i,
|
|
seatId: bookingSeat.seatId,
|
|
departureStationId: stopTimes[i].stationId,
|
|
arrivalStationId: stopTimes[i + 1].stationId,
|
|
});
|
|
}
|
|
}
|
|
|
|
if (journeySegments.length > 0) {
|
|
await this.prisma.journeySegment.createMany({ data: journeySegments });
|
|
}
|
|
}
|
|
}
|