feat(billing): USD offline bank-transfer payments

apps/edr-freight-api/src/modules/billing/billing.service.ts

@@ -12,6 +12,7 @@ import { DataSource, EntityManager, In } from "typeorm";
 
 import { Booking } from "../bookings/entities/booking.entity";
 import { CompaniesService } from "../companies/companies.service";
+import { FilesService } from "../files/files.service";
 import { applyBookingRefDirectionScope } from "../user-trade-access/trade-scope.util";
 import { PaymentService } from "../payment/payment.service";
 import { InitiateResponseDto, IntentStatusDto } from "../payment/payments.dto";
@@ -35,6 +36,14 @@ export interface PayInvoiceOptions {
   failureUrl?: string;
 }
 
+/** Booking context attached to a finance offline-USD invoice row. */
+export interface OfflineUsdBookingInfo {
+  id: string;
+  reference: string;
+  paymentDeadline: Date | null;
+  paymentStatus: string;
+}
+
 /** A single manual/offline settlement to record against an invoice. */
 export interface RecordPaymentInput {
   /** Amount settled by this payment; must be > 0. */
@@ -150,6 +159,7 @@ export class BillingService {
     private readonly payment: PaymentService,
     private readonly companies: CompaniesService,
     private readonly invoiceDocuments: InvoiceDocumentService,
+    private readonly files: FilesService,
   ) { }
 
   // ── Reads ──────────────────────────────────────────────────────────────────
@@ -214,6 +224,146 @@ export class BillingService {
     return { items, total };
   }
 
+  /**
+   * Finance's offline-settlement worklist: USD invoices (paid by bank transfer,
+   * never through the gateway), open ones by default or a single status when
+   * filtered. Booking-sourced rows carry the booking's reference and pay-window
+   * deadline so the UI can show the countdown and link to the booking.
+   */
+  async findOfflineUsdPaginated(
+    filter: {
+      status?: Freight.InvoiceStatus;
+      search?: string;
+      page?: number;
+      pageSize?: number;
+    } = {},
+  ): Promise<{
+    items: (Invoice & { booking: OfflineUsdBookingInfo | null })[];
+    total: number;
+  }> {
+    const page = filter.page && filter.page > 0 ? filter.page : 1;
+    const pageSize =
+      filter.pageSize && filter.pageSize > 0 ? filter.pageSize : 20;
+
+    const qb = this.dataSource
+      .getRepository(Invoice)
+      .createQueryBuilder("invoice")
+      .leftJoinAndSelect("invoice.company", "company")
+      .where("UPPER(invoice.currency) = 'USD'")
+      .orderBy("invoice.issuedAt", "DESC")
+      .skip((page - 1) * pageSize)
+      .take(pageSize);
+
+    if (filter.status) {
+      qb.andWhere("invoice.status = :status", { status: filter.status });
+    } else {
+      qb.andWhere("invoice.status IN (:...open)", { open: OPEN_STATUSES });
+    }
+    if (filter.search) {
+      qb.andWhere(
+        "(invoice.invoiceNumber ILIKE :search OR invoice.sourceId ILIKE :search)",
+        { search: `%${filter.search}%` },
+      );
+    }
+
+    const [items, total] = await qb.getManyAndCount();
+
+    const bookingIds = items
+      .filter((i) => i.source === "booking")
+      .map((i) => i.sourceId);
+    const bookings = bookingIds.length
+      ? await this.dataSource.getRepository(Booking).find({
+          where: { id: In(bookingIds) },
+          select: ["id", "reference", "paymentDeadline", "paymentStatus"],
+        })
+      : [];
+    const byId = new Map(bookings.map((b) => [b.id, b]));
+
+    return {
+      items: items.map((inv) => {
+        const b = byId.get(inv.sourceId);
+        return {
+          ...inv,
+          booking: b
+            ? {
+                id: b.id,
+                reference: b.reference,
+                paymentDeadline: b.paymentDeadline ?? null,
+                paymentStatus: b.paymentStatus,
+              }
+            : null,
+        } as Invoice & { booking: OfflineUsdBookingInfo | null };
+      }),
+      total,
+    };
+  }
+
+  /**
+   * Finance confirms a USD invoice as paid by bank transfer: stores the slip
+   * against the invoice and settles the FULL outstanding balance through
+   * {@link recordPayment}, which flips the invoice to PAID and (for bookings)
+   * emits `booking.invoice.paid` — the same event an online payment fires, so
+   * the booking advances exactly as if it had been paid through the gateway.
+   *
+   * Guarded by the booking's pay window: past the deadline the booking expires
+   * like any unpaid one, so confirmation is refused.
+   */
+  async confirmOfflinePayment(
+    invoiceId: string,
+    file: Express.Multer.File | undefined,
+    input: {
+      reference?: string | null;
+      userId?: string | null;
+      userName?: string | null;
+    },
+  ): Promise<Invoice> {
+    const invoice = await this.invoices.findById(invoiceId);
+    if (!invoice) throw new NotFoundException(`Invoice ${invoiceId} not found`);
+    if (invoice.currency?.toUpperCase() !== "USD") {
+      throw new BadRequestException(
+        "Offline confirmation is only for USD invoices — this invoice is paid online.",
+      );
+    }
+    if (!file) {
+      throw new BadRequestException("The bank payment slip file is required.");
+    }
+
+    if (invoice.source === "booking") {
+      const booking = await this.dataSource.getRepository(Booking).findOne({
+        where: { id: invoice.sourceId },
+        select: ["id", "paymentDeadline"],
+      });
+      const deadline = booking?.paymentDeadline;
+      if (deadline && new Date(deadline).getTime() < Date.now()) {
+        throw new BadRequestException(
+          "The payment window has closed — this booking can no longer be confirmed as paid.",
+        );
+      }
+    }
+
+    const slip = await this.files.upload({
+      resource: "invoice",
+      resourceId: invoice.id,
+      code: "OFFLINE_PAYMENT_SLIP",
+      file,
+      title: "Bank payment slip",
+      uploadedByUserId: input.userId ?? null,
+      uploadedByName: input.userName ?? null,
+    });
+
+    return this.recordPayment(invoiceId, {
+      amount: Number(invoice.balanceAmount),
+      method: "BANK_TRANSFER",
+      reference: input.reference || slip.name,
+      metadata: {
+        offline: true,
+        slipFileId: slip.id,
+        confirmedByUserId: input.userId ?? null,
+        confirmedByName: input.userName ?? null,
+      },
+    });
+  }
+
   /** Invoice header plus its line items. */
   async findById(id: string): Promise<Invoice & { lines: InvoiceLine[] }> {
     const invoice = await this.invoices.findById(id, {