wip: save point

processor/src/dtos/operations/payment-intents.dto.ts

@@ -44,6 +44,7 @@ const PaymentModificationSchema = Type.Enum(PaymentModificationStatus);
 
 export const PaymentIntentResponseSchema = Type.Object({
   outcome: PaymentModificationSchema,
+  paymentReference: Type.String(),
 });
 
 export type PaymentIntentRequestSchemaDTO = Static<typeof PaymentIntentRequestSchema>;

processor/src/dtos/paypal-payment.dto.ts

@@ -10,6 +10,13 @@ export const PaymentRequestSchema = Type.Object({
   paymentMethod: Type.Composite([PaypalPaymentMethodSchema]),
 });
 
+export const PaymentConfirmationRequestSchema = Type.Object({
+  details: Type.Object({
+    pspReference: Type.String(),
+    paymentReference: Type.String(),
+  }),
+});
+
 export enum PaymentOutcome {
   AUTHORIZED = 'Authorized',
   REJECTED = 'Rejected',
@@ -23,4 +30,5 @@ export const PaymentResponseSchema = Type.Object({
 });
 
 export type PaymentRequestSchemaDTO = Static<typeof PaymentRequestSchema>;
+export type PaymentConfirmRequestSchemaDTO = Static<typeof PaymentConfirmationRequestSchema>;
 export type PaymentResponseSchemaDTO = Static<typeof PaymentResponseSchema>;

processor/src/routes/paypal-payment.route.ts

@@ -1,19 +1,21 @@
 import { SessionAuthenticationHook } from '@commercetools/connect-payments-sdk';
 import { FastifyInstance, FastifyPluginOptions } from 'fastify';
 import {
+  PaymentConfirmRequestSchemaDTO,
+  PaymentConfirmationRequestSchema,
   PaymentRequestSchema,
   PaymentRequestSchemaDTO,
   PaymentResponseSchema,
   PaymentResponseSchemaDTO,
 } from '../dtos/paypal-payment.dto';
 import { PaypalPaymentService } from '../services/paypal-payment.service';
+import { PaymentIntentResponseSchemaDTO, PaymentIntentResponseSchema } from '../dtos/operations/payment-intents.dto';
 
 type PaymentRoutesOptions = {
   paymentService: PaypalPaymentService;
   sessionAuthHook: SessionAuthenticationHook;
 };
 
-// TODO: this would contain the endpoints for creating and confirming a payment intent. IN our case, /payment-intent and /payment-intent/confirm
 export const paymentRoutes = async (fastify: FastifyInstance, opts: FastifyPluginOptions & PaymentRoutesOptions) => {
   fastify.post<{ Body: PaymentRequestSchemaDTO; Reply: PaymentResponseSchemaDTO }>(
     '/payments',
@@ -35,20 +37,19 @@ export const paymentRoutes = async (fastify: FastifyInstance, opts: FastifyPlugi
     },
   );
 
-  // TODO: implement this, but we can test it without implementing the enabler. To test lets log the paypal response after creating an order, and use the link to approve the payment
-  fastify.post<{ Body: PaymentRequestSchemaDTO; Reply: PaymentResponseSchemaDTO }>(
+  fastify.post<{ Body: PaymentConfirmRequestSchemaDTO; Reply: PaymentIntentResponseSchemaDTO }>(
     '/payments/confirm',
     {
       preHandler: [opts.sessionAuthHook.authenticate()],
       schema: {
-        body: PaymentRequestSchema,
+        body: PaymentConfirmationRequestSchema,
         response: {
-          200: PaymentResponseSchema,
+          200: PaymentIntentResponseSchema,
         },
       },
     },
     async (request, reply) => {
-      const resp = await opts.paymentService.createPayment({
+      const resp = await opts.paymentService.confirmPayment({
         data: request.body,
       });
 

processor/src/services/operation.service.ts

@@ -59,7 +59,7 @@ export class DefaultOperationService implements OperationService {
 
     const transactionType = this.getPaymentTransactionType(request.action);
 
-    const updatedPayment = await this.ctPaymentService.updatePayment({
+    let updatedPayment = await this.ctPaymentService.updatePayment({
       id: ctPayment.id,
       transaction: {
         type: transactionType,
@@ -68,22 +68,38 @@ export class DefaultOperationService implements OperationService {
       },
     });
 
-    const res = await this.processPaymentModification(updatedPayment, transactionType, requestAmount);
+    // TODO: use the methods within the ctPaymentService, to validate the payment modification requests.
+    // this.ctPaymentService.validatePaymentCharge() ==> example
 
-    // TODO: if we throw an error in any of the calls within processPaymentModification, we never get to update this transsaction state to Failure below
-    await this.ctPaymentService.updatePayment({
-      id: ctPayment.id,
-      transaction: {
-        type: transactionType,
-        amount: requestAmount,
-        interactionId: res?.pspReference,
-        state: res.outcome === PaymentModificationStatus.APPROVED ? 'Success' : 'Failure',
-      },
-    });
+    try {
+      const res = await this.processPaymentModification(updatedPayment, transactionType, requestAmount);
 
-    return {
-      outcome: res.outcome,
-    };
+      updatedPayment = await this.ctPaymentService.updatePayment({
+        id: ctPayment.id,
+        transaction: {
+          type: transactionType,
+          amount: requestAmount,
+          interactionId: res?.pspReference,
+          state: res.outcome === PaymentModificationStatus.APPROVED ? 'Success' : 'Failure',
+        },
+      });
+
+      return {
+        outcome: res.outcome,
+        paymentReference: updatedPayment.id,
+      };
+    } catch (e) {
+      await this.ctPaymentService.updatePayment({
+        id: ctPayment.id,
+        transaction: {
+          type: transactionType,
+          amount: requestAmount,
+          state: 'Failure',
+        },
+      });
+
+      throw e;
+    }
   }
 
   private getPaymentTransactionType(action: string): string {

processor/src/services/paypal-payment.service.ts

@@ -1,12 +1,16 @@
-import { CommercetoolsCartService, CommercetoolsPaymentService } from '@commercetools/connect-payments-sdk';
-import { PaymentOutcome, PaymentResponseSchemaDTO } from '../dtos/paypal-payment.dto';
+import {
+  CommercetoolsCartService,
+  CommercetoolsPaymentService,
+  ErrorGeneral,
+} from '@commercetools/connect-payments-sdk';
+import { PaymentConfirmRequestSchemaDTO, PaymentOutcome, PaymentResponseSchemaDTO } from '../dtos/paypal-payment.dto';
 
 import { getCartIdFromContext } from '../libs/fastify/context/context';
-import { CreatePayment } from './types/paypal-payment.type';
+import { ConfirmPayment, CreatePayment } from './types/paypal-payment.type';
 import { PaypalPaymentAPI } from './api/api';
-import { Address, Cart, Money } from '@commercetools/platform-sdk';
+import { Address, Cart, Money, Payment } from '@commercetools/platform-sdk';
 import { CreateOrderRequest, PaypalShipping, parseAmount } from './types/paypal-api.type';
-import { PaymentModificationStatus } from '../dtos/operations/payment-intents.dto';
+import { PaymentIntentResponseSchemaDTO, PaymentModificationStatus } from '../dtos/operations/payment-intents.dto';
 import { randomUUID } from 'crypto';
 
 export type PaypalPaymentServiceOptions = {
@@ -69,18 +73,14 @@ export class PaypalPaymentService {
 
     const resultCode = isAuthorized ? PaymentOutcome.AUTHORIZED : PaymentOutcome.REJECTED;
 
-    const pspReference = paypalResponse.pspReference;
-
-    const paymentMethodType = paymentMethod.type;
-
     const updatedPayment = await this.ctPaymentService.updatePayment({
       id: ctPayment.id,
-      pspReference: pspReference,
-      paymentMethod: paymentMethodType,
+      pspReference: paypalResponse.pspReference,
+      paymentMethod: paymentMethod.type,
       transaction: {
         type: 'Authorization',
         amount: ctPayment.amountPlanned,
-        interactionId: pspReference,
+        interactionId: paypalResponse.pspReference,
         state: this.convertPaymentResultCode(resultCode as PaymentOutcome),
       },
     });
@@ -91,6 +91,68 @@ export class PaypalPaymentService {
     };
   }
 
+  public async confirmPayment(opts: ConfirmPayment): Promise<PaymentIntentResponseSchemaDTO> {
+    const ctPayment = await this.ctPaymentService.getPayment({
+      id: opts.data.details.paymentReference,
+    });
+
+    this.validateInterfaceIdMismatch(ctPayment, opts.data);
+
+    let updatedPayment = await this.ctPaymentService.updatePayment({
+      id: ctPayment.id,
+      transaction: {
+        type: 'Charge',
+        amount: ctPayment.amountPlanned,
+        state: 'Initial',
+      },
+    });
+
+    try {
+      // Make call to paypal to create payment intent
+      const paypalResponse = await this.paypalClient.captureOrder(opts.data.details.pspReference);
+
+      updatedPayment = await this.ctPaymentService.updatePayment({
+        id: ctPayment.id,
+        transaction: {
+          type: 'Charge',
+          amount: ctPayment.amountPlanned,
+          interactionId: paypalResponse.pspReference,
+          state: paypalResponse.outcome === PaymentModificationStatus.APPROVED ? 'Success' : 'Failure',
+        },
+      });
+
+      return {
+        outcome: paypalResponse.outcome,
+        paymentReference: updatedPayment.id,
+      };
+    } catch (e) {
+      // TODO: create a new method in payment sdk for changing transaction stat. To be used in scenarios, where we expect the txn state to change,
+      // from initial, to success to failure https://docs.commercetools.com/api/projects/payments#change-transactionstate
+      await this.ctPaymentService.updatePayment({
+        id: ctPayment.id,
+        transaction: {
+          type: 'Charge',
+          amount: ctPayment.amountPlanned,
+          state: 'Failure',
+        },
+      });
+
+      throw e;
+    }
+  }
+
+  private validateInterfaceIdMismatch(payment: Payment, data: PaymentConfirmRequestSchemaDTO) {
+    if (payment.interfaceId !== data.details?.pspReference) {
+      throw new ErrorGeneral('not able to confirm the payment', {
+        fields: {
+          cocoError: 'interface id mismatch',
+          pspReference: data.details?.pspReference,
+          paymentReference: payment.id,
+        },
+      });
+    }
+  }
+
   private convertPaymentResultCode(resultCode: PaymentOutcome): string {
     switch (resultCode) {
       case PaymentOutcome.AUTHORIZED:

processor/src/services/types/paypal-payment.type.ts

@@ -1,9 +1,13 @@
-import { PaymentOutcome, PaymentRequestSchemaDTO } from '../../dtos/paypal-payment.dto';
+import { PaymentConfirmRequestSchemaDTO, PaymentOutcome, PaymentRequestSchemaDTO } from '../../dtos/paypal-payment.dto';
 
 export type CreatePayment = {
   data: PaymentRequestSchemaDTO;
 };
 
+export type ConfirmPayment = {
+  data: PaymentConfirmRequestSchemaDTO;
+};
+
 export type CreatePaymentRequest = {
   data: PaymentRequestSchemaDTO;
 };