@cloudcommerce/app-pagarme-v5 0.32.0

package/lib-mjs/pagarme5-webhooks.mjs

@@ -0,0 +1,343 @@
+import { getFirestore } from 'firebase-admin/firestore';
+import config from '@cloudcommerce/firebase/lib/config';
+import api from '@cloudcommerce/api';
+import logger from 'firebase-functions/logger';
+import axios from './functions-lib/pagarme/create-axios.mjs';
+import {
+  getOrderById,
+  addPaymentHistory,
+  updateTransaction,
+  getOrderIntermediatorTransactionId,
+  createNewOrderBasedOld,
+  // updateOrder,
+  checkItemCategory,
+} from './functions-lib/api-utils.mjs';
+import { parserChangeStatusToEcom } from './functions-lib/pagarme/parses-utils.mjs';
+
+const getAppData = async () => {
+  return new Promise((resolve, reject) => {
+    api.get(
+      `applications?app_id=${config.get().apps.pagarMeV5.appId}&fields=hidden_data`,
+    )
+      .then(({ data: result }) => {
+        resolve(result[0]);
+      })
+      .catch((err) => {
+        reject(err);
+      });
+  });
+};
+
+const handleWehook = async (req, res) => {
+  const colletionFirebase = getFirestore().collection('pagarmeV5Subscriptions');
+  const { body } = req;
+
+  try {
+    const type = body.type;
+    const appData = await getAppData();
+
+    if (!process.env.PAGARMEV5_API_TOKEN) {
+      const pagarmeApiToken = appData.pagarme_api_token;
+      if (pagarmeApiToken && typeof pagarmeApiToken === 'string') {
+        process.env.PAGARMEV5_API_TOKEN = pagarmeApiToken;
+      } else {
+        logger.warn('Missing PAGARMEV5 API TOKEN');
+
+        return res.status(401)
+          .send({
+            error: 'NO_PAGARME_KEYS',
+            message: 'The token is not defined in the application\'s environment variables and hidden data',
+          });
+      }
+    }
+    const pagarmeAxios = axios(process.env.PAGARMEV5_API_TOKEN);
+    logger.log(`>> webhook ${JSON.stringify(body)}, type:${type}`);
+    if (type === 'subscription.created' && body.data) {
+      const orderOriginalId = body.data?.code;
+      const subscriptionPagarmeId = body.data?.id;
+      logger.log(`>> Check SubcriptionId: ${orderOriginalId}`);
+      const documentSnapshot = await colletionFirebase.doc(orderOriginalId).get();
+      const docSubscription = documentSnapshot.exists && documentSnapshot.data();
+      if (!docSubscription) {
+        logger.log('> Subscription not found');
+        return res.status(404)
+          .send({ message: `Subscription code: #${orderOriginalId} not found` });
+      }
+      const requestPagarme = [];
+      // Check if the product belongs to categories that can be subscribed
+      const categoryIds = appData.recurrency_category_ids;
+      const { items: itemsApi } = await getOrderById(orderOriginalId);
+
+      if (categoryIds && Array.isArray(categoryIds) && categoryIds.length) {
+        const { data: { items: itemsPagarme } } = await pagarmeAxios.get(`/subscriptions/${subscriptionPagarmeId}`);
+        const itemsIdPagarmeDelete = await checkItemCategory(categoryIds, itemsPagarme, itemsApi);
+
+        const urlRemoveItem = `/subscriptions/${subscriptionPagarmeId}/items/`;
+        if (itemsIdPagarmeDelete?.length) {
+          itemsIdPagarmeDelete.forEach((itemId) => {
+            requestPagarme.push(pagarmeAxios.delete(`${urlRemoveItem}${itemId}`));
+          });
+        }
+      }
+
+      const { plan } = docSubscription;
+      const { discount } = plan;
+      const urlDiscount = `/subscriptions/${subscriptionPagarmeId}/discounts`;
+      const bodyDiscountPagarme = { value: discount.value };
+
+      // Add plan discount on each product
+      if (discount.type === 'percentage') {
+        itemsApi?.forEach((item) => {
+          requestPagarme.push(pagarmeAxios.post(
+            urlDiscount,
+            {
+              ...bodyDiscountPagarme,
+              discount_type: 'percentage',
+              item_id: `pi_${item.sku}`,
+            },
+          ));
+        });
+
+        // Apply shipping discount if app configuration allows
+        if (discount.apply_at !== 'subtotal') {
+          requestPagarme.push(pagarmeAxios.post(
+            urlDiscount,
+            {
+              ...bodyDiscountPagarme,
+              discount_type: 'percentage',
+              item_id: `pi_freight_${orderOriginalId}`,
+            },
+          ));
+        }
+      } else {
+        requestPagarme.push(pagarmeAxios.post(
+          urlDiscount,
+          {
+            ...bodyDiscountPagarme,
+            discount_type: 'flat',
+          },
+        ));
+      }
+
+      try {
+        await Promise.all(requestPagarme);
+        logger.log('>> Updated signature');
+        res.status(201)
+          .send({ message: 'Updated signature' });
+      } catch (error) {
+        logger.error(error);
+        const errCode = 'WEBHOOK_PAGARME_INVOICE_CREATED';
+        let status = 409;
+        let message = error.message;
+        if (error.response) {
+          status = error.response.status || status;
+          const { data } = error.response;
+          if (status !== 401 && status !== 403) {
+            message = error.response.message || message;
+          } else if (
+            data && Array.isArray(data.errors)
+            && data.errors[0] && data.errors[0].message
+          ) {
+            message = data.errors[0].message;
+          }
+        }
+        return res.status(status || 400)
+          .send({
+            error: errCode,
+            message,
+          });
+      }
+    } else if (type === 'subscription.canceled' && body.data) {
+      const { data: subscription } = await pagarmeAxios.get(`/subscriptions/${body.data.id}`);
+      if (subscription && subscription.status === 'canceled') {
+        const orderOriginalId = subscription.code;
+        const orderOriginal = await getOrderById(orderOriginalId);
+        if (!orderOriginal) {
+          logger.log('>> Order status canceled');
+          return res.sendStatus(404);
+        } if (orderOriginal.status !== 'cancelled') {
+          await api.patch(`orders/${orderOriginalId}`, { status: 'cancelled' });
+          logger.log('>> Status update Cancelled');
+          return res.sendStatus(200);
+        }
+        logger.log('>> Order status canceled');
+        return res.sendStatus(200);
+      }
+      return res.status(!subscription ? 404 : 400)
+        .send({ message: !subscription ? 'Not found subscription' : 'Subscription not canceled' });
+    } else if (type.startsWith('charge.')) {
+      // const statusChange = type.replace('charge.', '')
+      const { data: charge } = await pagarmeAxios.get(`/charges/${body.data.id}`);
+      logger.log('>> Charge ', JSON.stringify(charge));
+      if (charge.invoice) {
+        const { invoice, status } = charge;
+        logger.log('>>Parse status: ', parserChangeStatusToEcom(status));
+        const order = await getOrderIntermediatorTransactionId(invoice.id);
+        if (order) {
+          if (order.financial_status.current !== parserChangeStatusToEcom(status)) {
+            // updadte status
+            const transaction = order.transactions
+              .find(
+                (transactionFind) => transactionFind.intermediator.transaction_id === invoice.id,
+              );
+            logger.log('>> Try add payment history');
+            const transactionPagarme = charge.last_transaction;
+            let notificationCode = `${type};${body.id};`;
+            if (transactionPagarme.transaction_type === 'credit_card') {
+              notificationCode += `${transactionPagarme.gateway_id || ''};`;
+              notificationCode += `${transactionPagarme.acquirer_tid || ''};`;
+              notificationCode += `${transactionPagarme.acquirer_nsu || ''};`;
+              notificationCode += `${transactionPagarme.acquirer_auth_code || ''};`;
+            } else if (transactionPagarme.transaction_type === 'boleto') {
+              notificationCode += `${transactionPagarme.gateway_id || ''};`;
+            }
+            const bodyPaymentHistory = {
+              date_time: transactionPagarme.updated_at || new Date().toISOString(),
+              status: parserChangeStatusToEcom(status),
+              notification_code: notificationCode,
+              flags: ['PagarMe'],
+            };
+            if (transaction && transaction._id) {
+              bodyPaymentHistory.transaction_id = transaction._id;
+            }
+            await addPaymentHistory(order._id, bodyPaymentHistory);
+            logger.log('>> Status update to paid');
+            return res.sendStatus(200);
+          }
+          logger.log(`Status is ${parserChangeStatusToEcom(status)}`);
+          return res.sendStatus(200);
+        }
+
+        if (status === 'paid') {
+          logger.log('>> Try create new order for recurrence');
+          const { data: subscription } = await pagarmeAxios.get(`/subscriptions/${invoice.subscriptionId}`);
+          const orderOriginal = await getOrderById(subscription.code);
+          const documentSnapshot = await colletionFirebase.doc(subscription.code).get();
+          const docSubscription = documentSnapshot.exists && documentSnapshot.data();
+          if (orderOriginal && docSubscription) {
+            const { plan } = docSubscription;
+
+            await createNewOrderBasedOld(orderOriginal, plan, 'paid', charge, subscription);
+
+            // Check if the product belongs to categories that can be subscribed,
+            // for next recurrence
+            const categoryIds = appData.recurrency_category_ids;
+            if (categoryIds && Array.isArray(categoryIds) && categoryIds.length) {
+              const requestPagarme = [];
+              const itemsPagarme = subscription.items;
+              const itemsApi = orderOriginal.items;
+              const itemsIdPagarmeDelete = await checkItemCategory(
+                categoryIds,
+                itemsPagarme,
+                itemsApi,
+              );
+
+              const urlRemoveItem = `/subscriptions/${invoice.subscriptionId}/items/`;
+              if (itemsIdPagarmeDelete?.length) {
+                itemsIdPagarmeDelete.forEach((itemId) => {
+                  requestPagarme.push(pagarmeAxios.delete(`${urlRemoveItem}${itemId}`));
+                });
+              }
+
+              try {
+                logger.log('>> Updated signature, for next recurrence');
+                await Promise.all(requestPagarme);
+              } catch (err) {
+                logger.warn(err);
+              }
+            }
+
+            logger.log('>> Create new Order');
+            return res.sendStatus(201);
+          }
+          logger.log('>> Subscription not found');
+          return res.status(404)
+            .send({ message: `Subscription code: #${subscription.code} not found` });
+        }
+
+        logger.log('>> Order not found and transaction status is not paid');
+        return res.status(400)
+          .send({ message: 'Order not found and status is not paid' });
+      }
+
+      if (charge.order) {
+        // TODO:
+        // payment update (order in pagarme)
+        logger.log('>> Try update status order');
+        const { order: orderPagarme, status } = charge;
+        const order = await getOrderIntermediatorTransactionId(orderPagarme.id);
+        if (order) {
+          if (order.financial_status.current !== parserChangeStatusToEcom(status)) {
+            // updadte status
+            let isUpdateTransaction = false;
+            let transactionBody;
+            const transaction = order.transactions.find(
+              (transactionFind) => transactionFind.intermediator.transaction_id === orderPagarme.id,
+            );
+            // console.log('>> Try add payment history')
+            const transactionPagarme = charge.last_transaction;
+            // console.log('>>> TransactionPagarme ', JSON.stringify(transactionPagarme))
+            let notificationCode = `${type};${body.id};`;
+            if (transactionPagarme.transaction_type === 'credit_card') {
+              notificationCode += `${transactionPagarme.gateway_id || ''};`;
+              notificationCode += `${transactionPagarme.acquirer_tid || ''};`;
+              notificationCode += `${transactionPagarme.acquirer_nsu || ''};`;
+              notificationCode += `${transactionPagarme.acquirer_auth_code || ''};`;
+            } else if (transactionPagarme.transaction_type === 'boleto') {
+              notificationCode += `${transactionPagarme.gateway_id || ''};`;
+            } else if (transactionPagarme.transaction_type === 'pix') {
+              let notes = transaction.notes;
+              // pix_provider_tid"
+              notes = notes.replaceAll('display:block', 'display:none'); // disable QR Code
+              notes = `${notes} # PIX Aprovado`;
+              transactionBody = { notes };
+              isUpdateTransaction = true;
+            }
+            const bodyPaymentHistory = {
+              date_time: transactionPagarme.updated_at || new Date().toISOString(),
+              status: parserChangeStatusToEcom(status),
+              notification_code: notificationCode,
+              flags: ['PagarMe'],
+            };
+            if (transaction && transaction._id) {
+              bodyPaymentHistory.transaction_id = transaction._id;
+            }
+            await addPaymentHistory(order._id, bodyPaymentHistory);
+            if (isUpdateTransaction && transaction._id) {
+              // console.log('>> Try Update transaction ')
+              await updateTransaction(order._id, transactionBody, transaction._id)
+                .catch(logger.error);
+            }
+            logger.log(`>> Status update to ${parserChangeStatusToEcom(status)}`);
+            return res.sendStatus(200);
+          }
+        }
+        return res.sendStatus(404);
+      }
+
+      return res.sendStatus(405);
+    }
+    return res.sendStatus(405);
+  } catch (error) {
+    logger.error(error);
+    const errCode = 'WEBHOOK_PAGARME_INTERNAL_ERR';
+    let status = 409;
+    let message = error.message;
+    if (error.response) {
+      status = error.response.status || status;
+      const { data } = error.response;
+      if (status !== 401 && status !== 403) {
+        message = error.response.message || message;
+      } else if (data && Array.isArray(data.errors) && data.errors[0] && data.errors[0].message) {
+        message = data.errors[0].message;
+      }
+    }
+    return res.status(status || 500)
+      .send({
+        error: errCode,
+        message,
+      });
+  }
+};
+
+export default handleWehook;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@cloudcommerce/app-pagarme-v5",
+  "type": "module",
+  "version": "0.32.0",
+  "description": "E-Com Plus Cloud Commerce app to integrate Pagar.me API v5 with recurring payments",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./events": "./lib/pagarme-v5-events.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ecomplus/cloud-commerce.git",
+    "directory": "packages/apps/pagarme-v5"
+  },
+  "author": "E-Com Club Softwares para E-commerce <ti@e-com.club>",
+  "license": "Apache 2.0 with Commons Clause",
+  "bugs": {
+    "url": "https://github.com/ecomplus/cloud-commerce/issues"
+  },
+  "homepage": "https://github.com/ecomplus/cloud-commerce/tree/main/packages/apps/pagarme-v5#readme",
+  "dependencies": {
+    "@ecomplus/utils": "1.5.0-rc.5",
+    "axios": "^1.5.1",
+    "firebase-admin": "^11.11.0",
+    "firebase-functions": "^4.4.1",
+    "@cloudcommerce/api": "0.32.0",
+    "@cloudcommerce/firebase": "0.32.0"
+  },
+  "devDependencies": {
+    "@cloudcommerce/test-base": "0.32.0",
+    "@cloudcommerce/types": "0.32.0"
+  },
+  "scripts": {
+    "build": "bash scripts/build.sh",
+    "test": "bash scripts/tests.sh"
+  }
+}

package/scripts/build.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+node ../../../scripts/assets-minification.mjs
+bash ../../../scripts/build-lib.sh

package/scripts/tests.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+if [ -z "$PAGARMEV5_API_TOKEN" ]; then
+  echo -e "PAGARMEV5_API_TOKEN not set\n"
+elif [ -z "$PAGARMEV5_PUBLIC_KEY" ]; then
+  echo -e "PAGARMEV5_PUBLIC_KEY not set\n"
+else
+  node --test tests/
+fi

package/src/index.ts

@@ -0,0 +1 @@
+export * from './pagarme-v5';

package/src/pagarme-v5-events.ts

@@ -0,0 +1,27 @@
+/* eslint-disable import/prefer-default-export */
+
+import '@cloudcommerce/firebase/lib/init';
+import * as functions from 'firebase-functions/v1';
+import config from '@cloudcommerce/firebase/lib/config';
+import {
+  createAppEventsFunction,
+  ApiEventHandler,
+} from '@cloudcommerce/firebase/lib/helpers/pubsub';
+import handleApiEvent from '../lib-mjs/events-to-pagarme5.mjs';
+import handlePagarmeV5Webhook from '../lib-mjs/pagarme5-webhooks.mjs';
+
+export const pagarmev5 = {
+  onStoreEvent: createAppEventsFunction(
+    'pagarMeV5',
+    handleApiEvent as ApiEventHandler,
+  ),
+  webhooks: functions
+    .region(config.get().httpsFunctionOptions.region)
+    .https.onRequest((req, res) => {
+      if (req.method !== 'POST') {
+        res.sendStatus(405);
+      } else {
+        handlePagarmeV5Webhook(req, res);
+      }
+    }),
+};

package/src/pagarme-v5.ts

@@ -0,0 +1,12 @@
+import '@cloudcommerce/firebase/lib/init';
+import type { AppModuleBody } from '@cloudcommerce/types';
+import handleListPayments from '../lib-mjs/list-pagarme5-payments.mjs';
+import handleCreateTransaction from '../lib-mjs/create-pagarme5-transaction.mjs';
+
+export const listPayments = async (modBody: AppModuleBody) => {
+  return handleListPayments(modBody);
+};
+
+export const createTransaction = async (modBody: AppModuleBody) => {
+  return handleCreateTransaction(modBody);
+};

package/tests/1-list-payments.test.mjs

@@ -0,0 +1,37 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import assert from 'node:assert';
+import test, { before, describe } from 'node:test';
+import {
+  modulesUrl,
+  bodyListPayments,
+} from '@cloudcommerce/test-base';
+
+describe('Test payment list of Pagar.me V5 App', async () => {
+  let req;
+  let data;
+  const appId = 112381;
+
+  before(async () => {
+    req = await fetch(`${modulesUrl}/list_payments?app_id=${appId}`, {
+      method: 'POST',
+      body: JSON.stringify(bodyListPayments),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    data = (await req.json()).result;
+  });
+
+  test('Check Status 200', async () => {
+    assert.strictEqual(req?.status, 200);
+  });
+
+  test('Check validated is true', async () => {
+    assert.equal(data[0].validated, true);
+  });
+
+  test('Have payment gateways', async () => {
+    assert.equal(data[0].response.payment_gateways.length > 0, true);
+  });
+});

package/tests/2-create-transaction.test.mjs

@@ -0,0 +1,56 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import assert from 'node:assert';
+import test, { before, describe } from 'node:test';
+import {
+  modulesUrl,
+  bodyCreateTransaction,
+} from '@cloudcommerce/test-base';
+
+describe('Test to create a transaction in the Pagar.me V5 with banking billet', async () => {
+  let req;
+  let data;
+  const appId = 112381;
+  before(async () => {
+    const paymentMethod = {
+      code: 'account_deposit',
+      name: 'Pix - Pagar.me',
+    };
+    const to = {
+      zip: '35701134',
+      province_code: 'MG',
+      name: 'Wisley Alves',
+      city: 'Sete Lagoas',
+      borough: 'Progresso',
+      street: 'Rua Santo André',
+      number: 81,
+    };
+
+    Object.assign(bodyCreateTransaction, {
+      payment_method: paymentMethod,
+      to,
+      domain: 'www.lojatest.com.br',
+    });
+
+    req = await fetch(`${modulesUrl}/create_transaction?app_id=${appId}`, {
+      method: 'POST',
+      body: JSON.stringify(bodyCreateTransaction),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    data = (await req.json()).result;
+  });
+
+  test('Check Status 200', async () => {
+    assert.strictEqual(req?.status, 200);
+  });
+
+  test('Check validated is true', async () => {
+    assert.equal(data[0].validated, true);
+  });
+
+  test('Have transaction', async () => {
+    assert.notEqual(data[0].response.transaction, undefined);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "declaration": true
+  }
+}