Update payment methods and cron job for payment cancellation

apps/edr-passenger-api/src/modules/payments/payments.controller.ts

@@ -31,6 +31,7 @@ import {
   SupportedPaymentMethodDto,
   PaymentMethodTypeEnum,
   PaymentPlatformDto,
+  BookingAmountResponseDto,
 } from "./payments.dto";
 import { PassengerStaff } from "../../common/passenger-guards";
 import { PASSENGER_PERMS } from "../../seed/passenger-permissions.registry";
@@ -139,16 +140,33 @@ export class PaymentsController {
   @ApiOperation({
     summary: "List payment systems supported by the platform",
     description:
-      "Returns the global catalog of accepted payment systems. Filter by `currency` (e.g. ETB, DJF, USD) to get methods that settle in that currency, and/or by `region` to match a passenger's nationality. Both filters can be combined.",
+      "Returns all enabled payment methods. Optionally filter by `region` to narrow to methods available for a passenger's nationality.",
   })
-  @ApiQuery({ name: "currency", required: false, example: "DJF", description: "Settlement currency — ETB, DJF, USD, etc." })
   @ApiQuery({ name: "region", enum: PaymentRegionEnum, required: false })
   @ApiOkResponse({ type: [SupportedPaymentMethodDto] })
   getMethods(
-    @Query("currency") currency?: string,
     @Query("region") region?: PaymentRegionEnum,
   ) {
-    return this.service.getSupportedPaymentMethods(region, currency);
+    return this.service.getSupportedPaymentMethods(region);
+  }
+
+  @Get("booking-amount")
+  @SetMetadata('isPublic', true)
+  @ApiOperation({
+    summary: "Get booking amount in a specific currency",
+    description:
+      "Returns the booking total converted from ETB to the requested currency using the latest exchange rate. " +
+      "If currency is ETB the stored amount is returned as-is (no conversion). " +
+      "Amounts are returned in major currency units (e.g. 162.50 DJF, not centimes).",
+  })
+  @ApiQuery({ name: "bookingId", required: true, description: "Booking UUID" })
+  @ApiQuery({ name: "currency", required: true, example: "DJF", description: "Target currency: ETB, DJF, or USD" })
+  @ApiOkResponse({ type: BookingAmountResponseDto })
+  getBookingAmount(
+    @Query("bookingId") bookingId: string,
+    @Query("currency") currency: string,
+  ) {
+    return this.service.getBookingAmountByCurrency(bookingId, currency);
   }
 
   @Get("checkout")

apps/edr-passenger-api/src/modules/payments/payments.dto.ts

@@ -136,3 +136,9 @@ export class IntentStatusDto {
   @ApiPropertyOptional() failureCode?: string;
   @ApiPropertyOptional() failureMessage?: string;
 }
+
+export class BookingAmountResponseDto {
+  @ApiProperty({ example: 'booking-uuid' }) booking_id: string;
+  @ApiProperty({ example: 'DJF', description: 'Currency of the returned amount' }) currency: string;
+  @ApiProperty({ example: 162.5, description: 'Booking total converted to the requested currency (major units)' }) amount: number;
+}

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

@@ -491,7 +491,7 @@ export class PaymentsService {
     });
   }
 
-  getSupportedPaymentMethods(region?: PaymentRegionEnum, currency?: string) {
+  getSupportedPaymentMethods(region?: PaymentRegionEnum) {
     return this.prisma.paymentMethod.findMany({
       where: {
         enabled: true,
@@ -505,12 +505,41 @@ export class PaymentsService {
               },
             }
           : {}),
-        ...(currency ? { currency: currency.toUpperCase() } : {}),
       },
       orderBy: [{ sortOrder: "asc" }, { displayName: "asc" }],
     });
   }
 
+  async getBookingAmountByCurrency(
+    bookingId: string,
+    currency: string,
+  ): Promise<{ booking_id: string; currency: string; amount: number }> {
+    const booking = await this.prisma.booking.findUnique({
+      where: { id: bookingId },
+      select: { id: true, totalMinor: true },
+    });
+    if (!booking) throw new NotFoundException('Booking not found');
+
+    const requestedCurrency = currency.toUpperCase();
+    const amountInETB = booking.totalMinor / 100;
+
+    if (requestedCurrency === 'ETB') {
+      return { booking_id: bookingId, currency: 'ETB', amount: amountInETB };
+    }
+
+    const exchangeRate = await this.prisma.currencyExchangeRate.findFirst({
+      where: { fromCurrency: 'ETB' as any, toCurrency: requestedCurrency as any },
+      orderBy: { effectiveDate: 'desc' },
+    });
+    if (!exchangeRate) {
+      throw new NotFoundException(`Exchange rate not found for ETB → ${requestedCurrency}`);
+    }
+
+    const rate = Number(exchangeRate.rate);
+    const converted = parseFloat((amountInETB * rate).toFixed(2));
+    return { booking_id: bookingId, currency: requestedCurrency, amount: converted };
+  }
+
   /**
    * Guard against an implausible paidAt from a provider event (e.g. a Telebirr epoch parsed as
    * ms×1000 → year 58429), which Prisma/Postgres rejects and would otherwise dead-letter the