cloudcommerce 0.0.126 → 0.0.127

package/packages/apps/pagarme/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@cloudcommerce/app-pagarme",
+  "type": "module",
+  "version": "0.0.127",
+  "description": "E-Com Plus Cloud Commerce app to integrate Pagar.me",
+  "main": "lib/pagarme.js",
+  "exports": {
+    ".": "./lib/pagarme.js",
+    "./webhook": "./lib/pagarme-webhook.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ecomplus/cloud-commerce.git",
+    "directory": "packages/apps/pagar-me"
+  },
+  "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#readme",
+  "scripts": {
+    "build": "sh scripts/build.sh"
+  },
+  "dependencies": {
+    "@cloudcommerce/api": "workspace:*",
+    "@cloudcommerce/firebase": "workspace:*",
+    "axios": "^1.2.0",
+    "firebase-admin": "^11.3.0",
+    "firebase-functions": "^4.1.0",
+    "pagarme": "^4.28.0",
+    "qs": "^6.11.0"
+  },
+  "devDependencies": {
+    "@cloudcommerce/types": "workspace:*",
+    "@firebase/app-types": "^0.8.1"
+  }
+}

package/packages/apps/pagarme/scripts/build.sh

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

package/packages/apps/pagarme/src/functions-lib/add-installments.ts

@@ -0,0 +1,59 @@
+import type { ListPaymentsResponse } from '@cloudcommerce/types/modules/list_payments:response';
+
+type Gateway = ListPaymentsResponse['payment_gateways'][number]
+
+const addInstallments = (
+  total: number | undefined,
+  installments: { [key: string]: any },
+  gateway: Gateway,
+  response?: ListPaymentsResponse,
+) => {
+  let maxInterestFree = total && !(installments.interest_free_min_amount > total)
+    ? installments.max_interest_free
+    : 0;
+  const maxInstallments = installments.max_number && maxInterestFree
+    ? Math.max(installments.max_number, maxInterestFree)
+    : installments.max_number || maxInterestFree;
+  if (maxInstallments > 1) {
+    // default installments option
+    if (!installments.monthly_interest) {
+      maxInterestFree = maxInstallments;
+    }
+    const minInstallment = installments.min_installment || 5;
+    if (response) {
+      response.installments_option = {
+        min_installment: minInstallment,
+        max_number: maxInterestFree || installments.max_number,
+        monthly_interest: maxInterestFree ? 0 : installments.monthly_interest,
+      };
+    }
+
+    // list installment options
+    gateway.installment_options = [];
+    if (total) {
+      for (let number = 2; number <= maxInstallments; number++) {
+        const tax = !(maxInterestFree >= number);
+        let interest;
+
+        if (tax) {
+          interest = installments.monthly_interest / 100;
+        }
+        const value = !tax
+          ? (total / number)
+          // https://pt.wikipedia.org/wiki/Tabela_Price
+          : total * (interest / (1 - (1 + interest) ** -number));
+
+        if (value >= minInstallment) {
+          gateway.installment_options.push({
+            number,
+            value,
+            tax,
+          });
+        }
+      }
+    }
+  }
+  return { response, gateway };
+};
+
+export default addInstallments;

package/packages/apps/pagarme/src/functions-lib/parse-status-to-ecom.ts

@@ -0,0 +1,23 @@
+export default (pagarmeStatus: string) => {
+  switch (pagarmeStatus) {
+    case 'processing':
+    case 'analyzing':
+      return 'under_analysis';
+    case 'authorized':
+    case 'paid':
+    case 'refunded':
+      return pagarmeStatus;
+    case 'waiting_payment':
+      return 'pending';
+    case 'pending_refund':
+      return 'in_dispute';
+    case 'refused':
+      return 'unauthorized';
+    case 'chargedback':
+      return 'refunded';
+    case 'pending_review':
+      return 'authorized';
+    default:
+      return 'unknown';
+  }
+};

package/packages/apps/pagarme/src/index.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/prefer-default-export
+export * from './pagarme';

package/packages/apps/pagarme/src/pagarme-create-transaction.ts

@@ -0,0 +1,307 @@
+import type { CreateTransactionParams } from '@cloudcommerce/types/modules/create_transaction:params';
+import type { CreateTransactionResponse } from '@cloudcommerce/types/modules/create_transaction:response';
+import type { AppModuleBody } from '@cloudcommerce/types';
+import logger from 'firebase-functions/logger';
+import config from '@cloudcommerce/firebase/lib/config';
+import axios from 'axios';
+import addInstallments from './functions-lib/add-installments';
+import parseStatus from './functions-lib/parse-status-to-ecom';
+
+type To = Exclude<CreateTransactionParams['to'], undefined>
+
+const parseAddress = (to: To) => ({
+  street: to.street,
+  neighborhood: to.borough,
+  city: to.city,
+  state: to.province || to.province_code,
+  country: to.country_code ? to.country_code.toLowerCase() : 'br',
+  zipcode: to.zip,
+  street_number: String(to.number) || 's/n',
+  complementary: to.complement || undefined,
+});
+
+export default async (appData: AppModuleBody) => {
+  const locationId = config.get().httpsFunctionOptions.region;
+  const baseUri = `https://${locationId}-${process.env.GCLOUD_PROJECT}.cloudfunctions.net`;
+
+  const { application, storeId } = appData;
+  const params = appData.params as CreateTransactionParams;
+  // app configured options
+  const configApp = { ...application.data, ...application.hidden_data };
+  const notificationUrl = `${baseUri}/pagarme-webhook`;
+
+  const orderId = params.order_id;
+  const {
+    amount,
+    buyer,
+    payer,
+    to,
+    items,
+  } = params;
+  logger.log('>(App:PagarMe) Transaction #', orderId);
+
+  // https://apx-mods.e-com.plus/api/v1/create_transaction/response_schema.json?store_id=100
+  const transaction: CreateTransactionResponse['transaction'] = {
+    amount: amount.total,
+  };
+
+  const paymentMethod = params.payment_method.code;
+  const methodConfig = configApp[paymentMethod] || {};
+  const isPix = paymentMethod === 'account_deposit';
+  const isCreditCard = paymentMethod === 'credit_card';
+
+  let { label } = methodConfig;
+  if (!label) {
+    if (isCreditCard) {
+      label = 'Cartão de crédito';
+    } else {
+      label = !isPix ? 'Boleto bancário' : 'Pix';
+    }
+  }
+
+  // https://docs.pagar.me/docs/realizando-uma-transacao-de-cartao-de-credito
+  // https://docs.pagar.me/docs/realizando-uma-transacao-de-boleto-bancario
+  let pagarmeTransaction: { [key: string]: any };
+
+  if (isCreditCard) {
+    let installmentsNumber = params.installments_number;
+    let finalAmount = amount.total;
+    if (installmentsNumber && installmentsNumber > 1) {
+      if (configApp.installments) {
+        // list all installment options
+        const { gateway } = addInstallments(
+          amount.total,
+          configApp.installments,
+          {
+            label,
+            payment_method: params.payment_method,
+          },
+        );
+        const installmentOption = gateway.installment_options
+          && gateway.installment_options.find(({ number }) => number === installmentsNumber);
+        if (installmentOption) {
+          transaction.installments = installmentOption;
+          finalAmount = installmentOption.number * installmentOption.value;
+          transaction.installments.total = finalAmount;
+        } else {
+          installmentsNumber = 1;
+        }
+      }
+    }
+
+    pagarmeTransaction = {
+      payment_method: 'credit_card',
+      amount: Math.floor(finalAmount * 100),
+      installments: installmentsNumber,
+      card_hash: params.credit_card && params.credit_card.hash,
+    };
+  } else if (params.payment_method.code === 'account_deposit') {
+    const finalAmount = amount.total;
+    const pixConfig = configApp.account_deposit;
+    const dueTime = pixConfig.due_time || 60;
+    const date = new Date();
+    date.setTime(date.getTime() + dueTime * 60000);
+    pagarmeTransaction = {
+      payment_method: 'pix',
+      amount: Math.floor(finalAmount * 100),
+      pix_expiration_date: date.toISOString(),
+    };
+  } else {
+    // banking billet
+    transaction.banking_billet = {};
+    pagarmeTransaction = {
+      payment_method: 'boleto',
+      async: false,
+      amount: Math.floor(amount.total * 100),
+    };
+
+    const boleto = configApp.banking_billet;
+    if (boleto) {
+      if (boleto.instructions) {
+        pagarmeTransaction.boleto_instructions = boleto.instructions
+          .replace(/\r\n/g, '\n')
+          .replace(/\r/g, '\n')
+          .substr(0, 255);
+        transaction.banking_billet.text_lines = [pagarmeTransaction.boleto_instructions];
+      }
+      if (boleto.days_due_date) {
+        const date = new Date();
+        date.setDate(date.getDate() + boleto.days_due_date);
+        pagarmeTransaction.boleto_expiration_date = date.toISOString().substring(0, 10);
+      }
+    }
+  }
+
+  pagarmeTransaction.api_key = configApp.pagarme_api_key;
+  pagarmeTransaction.postback_url = notificationUrl;
+  pagarmeTransaction.soft_descriptor = (configApp.soft_descriptor
+    || `${params.domain}_PagarMe`).substring(0, 13);
+  pagarmeTransaction.metadata = {
+    order_number: params.order_number,
+    store_id: storeId,
+    order_id: orderId,
+    platform_integration: 'ecomplus',
+  };
+
+  pagarmeTransaction.customer = {
+    email: buyer.email,
+    name: buyer.fullname,
+    external_id: buyer.customer_id,
+    type: buyer.registry_type === 'j' ? 'corporation' : 'individual',
+    country: (buyer.doc_country || 'BR').toLowerCase(),
+    phone_numbers: [`+${(buyer.phone.country_code || '55')}${buyer.phone.number}`],
+    documents: [{
+      type: buyer.registry_type === 'j' ? 'cnpj' : 'cpf',
+      number: buyer.doc_number,
+    }],
+  };
+  const birthDate = buyer.birth_date;
+  if (birthDate && birthDate.year && birthDate.day && birthDate.month) {
+    pagarmeTransaction.customer.birthday = `${birthDate.year}-`
+      + `${birthDate.month.toString().padStart(2, '0')}-${birthDate.day.toString().padStart(2, '0')}`;
+  }
+
+  if (to && to.street) {
+    pagarmeTransaction.shipping = {
+      name: to.name || buyer.fullname,
+      fee: Math.floor((amount.freight || 0) * 100),
+      address: parseAddress(to),
+    };
+    pagarmeTransaction.billing = {
+      name: (payer || buyer).fullname,
+      address: params.billing_address
+        ? parseAddress(params.billing_address)
+        : pagarmeTransaction.shipping.address,
+    };
+  } else if (params.billing_address) {
+    pagarmeTransaction.billing = {
+      name: (payer || buyer).fullname,
+      address: parseAddress(params.billing_address),
+    };
+  }
+
+  pagarmeTransaction.items = [];
+  items.forEach((item) => {
+    if (item.quantity > 0) {
+      pagarmeTransaction.items.push({
+        id: item.sku || item.variation_id || item.product_id,
+        title: item.name || item.sku,
+        unit_price: Math.floor((item.final_price || item.price) * 100),
+        quantity: item.quantity,
+        tangible: Boolean(to && to.street),
+      });
+    }
+  });
+
+  try {
+    // https://docs.pagar.me/reference#criar-transacao
+    const { data } = await axios({
+      url: 'https://api.pagar.me/1/transactions',
+      method: 'post',
+      data: pagarmeTransaction,
+    });
+
+    if (data) {
+      if (data.authorized_amount) {
+        transaction.amount = data.authorized_amount / 100;
+      } else if (data.amount) {
+        transaction.amount = data.amount / 100;
+      }
+      const paymentMethodPagarMe = data.payment_method === 'pix'
+        ? 'account_deposit'
+        : data.payment_method;
+      transaction.intermediator = {
+        payment_method: {
+          code: paymentMethodPagarMe || params.payment_method.code,
+        },
+      };
+      [
+        ['id', 'transaction_id'],
+        ['tid', 'transaction_code'],
+        ['reference_key', 'transaction_reference'],
+      ].forEach(([dataField, transactionField]) => {
+        if (data[dataField] && transaction.intermediator) {
+          transaction.intermediator[transactionField] = String(data[dataField]);
+        }
+      });
+      if (data.customer && data.customer.id) {
+        transaction.intermediator.buyer_id = String(data.customer.id);
+      }
+
+      if (transaction.banking_billet) {
+        if (data.boleto_barcode) {
+          transaction.banking_billet.code = data.boleto_barcode;
+        }
+        if (data.boleto_url && transaction.banking_billet.link) {
+          transaction.banking_billet.link = data.boleto_url;
+          transaction.payment_link = transaction.banking_billet.link;
+        }
+        if (data.boleto_expiration_date) {
+          transaction.banking_billet.valid_thru = new Date(data.boleto_expiration_date)
+            .toISOString();
+        }
+      } else if (data.card) {
+        transaction.credit_card = {
+          holder_name: data.card.holder_name,
+          last_digits: data.card.last_digits,
+          company: data.card.brand,
+          token: data.card.fingerprint,
+        };
+      } else if (paymentMethodPagarMe === 'account_deposit') {
+        const qrCode = data.pix_qr_code;
+        transaction.intermediator.transaction_code = qrCode;
+        const qrCodeSrc = `https://gerarqrcodepix.com.br/api/v1?brcode=${qrCode}&tamanho=256`;
+        transaction.notes = `<img src="${qrCodeSrc}" style="display:block;margin:0 auto">`;
+      }
+
+      transaction.status = {
+        updated_at: data.date_created || data.date_updated || new Date().toISOString(),
+        current: parseStatus(data.status),
+      };
+
+      return {
+        status: 200,
+        redirect_to_payment: false,
+        transaction,
+      };
+    }
+    return {
+      status: 409,
+      message: `PAGARME_TRANSACTION_ERR Order: #${orderId} => Pagar.Me not response`,
+    };
+  } catch (error: any) {
+    logger.error('(App:PagarMe) =>', error);
+    let { message } = error;
+    //
+    const err = {
+      message: `PAGARME_TRANSACTION_ERR Order: #${orderId} => ${message}`,
+      payment: '',
+      status: 0,
+      response: '',
+    };
+    let errCode = 'PAGARME_TRANSACTION_ERR_';
+
+    if (error.response) {
+      const { status, data } = error.response;
+      if (status !== 401 && status !== 403) {
+        err.payment = JSON.stringify(pagarmeTransaction);
+        errCode += status;
+        err.status = status;
+        if (typeof data === 'object' && data) {
+          err.response = JSON.stringify(data);
+        } else {
+          err.response = data;
+        }
+      } else if (data && Array.isArray(data.errors) && data.errors[0] && data.errors[0].message) {
+        message = data.errors[0].message;
+      }
+    }
+
+    // logger.error(err);
+    return {
+      status: 409,
+      error: errCode,
+      message,
+    };
+  }
+};

package/packages/apps/pagarme/src/pagarme-list-payments.ts

@@ -0,0 +1,158 @@
+import type { AppModuleBody } from '@cloudcommerce/types';
+import type { ListPaymentsParams } from '@cloudcommerce/types/modules/list_payments:params';
+import type { ListPaymentsResponse } from '@cloudcommerce/types/modules/list_payments:response';
+import * as path from 'path';
+import * as fs from 'fs';
+import url from 'url';
+import addInstallments from './functions-lib/add-installments';
+
+type Gateway = ListPaymentsResponse['payment_gateways'][number]
+type CodePaymentMethod = Gateway['payment_method']['code']
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
+export default (data: AppModuleBody) => {
+  const { application } = data;
+  const params = data.params as ListPaymentsParams;
+  // https://apx-mods.e-com.plus/api/v1/list_payments/schema.json?store_id=100
+  const amount = params.amount || { total: undefined };
+  const initialTotalAmount = amount.total;
+
+  const configApp = {
+    ...application.data,
+    ...application.hidden_data,
+  };
+
+  if (!configApp.pagarme_encryption_key || !configApp.pagarme_api_key) {
+    return {
+      error: 'NO_PAGARME_KEYS',
+      message: 'Chave de API e/ou criptografia não configurada (lojista deve configurar o aplicativo)',
+    };
+  }
+
+  // https://apx-mods.e-com.plus/api/v1/list_payments/response_schema.json?store_id=100
+  const response: ListPaymentsResponse = {
+    payment_gateways: [],
+  };
+
+  const { discount } = configApp;
+  if (discount && discount.value > 0) {
+    if (discount.apply_at !== 'freight') {
+      // default discount option
+      const { value } = discount;
+      response.discount_option = {
+        label: configApp.discount_option_label,
+        value,
+      };
+      // specify the discount type and min amount is optional
+      const discountTypeMinAmount = ['type', 'min_amount'];
+      discountTypeMinAmount.forEach((prop) => {
+        if (response.discount_option && discount[prop]) {
+          response.discount_option[prop] = discount[prop];
+        }
+      });
+    }
+
+    if (amount.total) {
+      // check amount value to apply discount
+      if (amount.total < discount.min_amount) {
+        discount.value = 0;
+      } else {
+        delete discount.min_amount;
+
+        // fix local amount object
+        const maxDiscount = amount[discount.apply_at || 'subtotal'];
+        let discountValue: number;
+        if (discount.type === 'percentage') {
+          discountValue = (maxDiscount * discount.value) / 100;
+        } else {
+          discountValue = discount.value;
+          if (discountValue > maxDiscount) {
+            discountValue = maxDiscount;
+          }
+        }
+        if (discountValue > 0) {
+          amount.discount = (amount.discount || 0) + discountValue;
+          amount.total -= discountValue;
+          if (amount.total < 0) {
+            amount.total = 0;
+          }
+        }
+      }
+    }
+  }
+
+  // setup payment gateway objects
+  const intermediator = {
+    name: 'Pagar.me',
+    link: 'https://pagar.me/',
+    code: 'pagarme',
+  };
+  const listPaymentMethods = ['credit_card', 'banking_billet', 'account_deposit'];
+
+  listPaymentMethods.forEach((paymentMethod) => {
+    const methodConfig = configApp[paymentMethod] || {};
+    const isPix = paymentMethod === 'account_deposit';
+    if (!methodConfig.disable && (!isPix || methodConfig.enable)) {
+      const isCreditCard = paymentMethod === 'credit_card';
+      let { label } = methodConfig;
+      if (!label) {
+        if (isCreditCard) {
+          label = 'Cartão de crédito';
+        } else {
+          label = !isPix ? 'Boleto bancário' : 'Pix';
+        }
+      }
+      const gateway: Gateway = {
+        label,
+        icon: methodConfig.icon,
+        text: methodConfig.text,
+        payment_method: {
+          code: paymentMethod as CodePaymentMethod,
+          name: `${label} - ${intermediator.name}`,
+        },
+        intermediator,
+      };
+
+      if (methodConfig.discount) {
+        gateway.discount = methodConfig.discount;
+      } else if (
+        discount
+        && (discount[paymentMethod] === true
+          || (!isCreditCard && discount[paymentMethod] !== false))
+      ) {
+        gateway.discount = discount;
+        if (response.discount_option && !response.discount_option.label) {
+          response.discount_option.label = label;
+        }
+      }
+
+      if (isCreditCard) {
+        if (!gateway.icon) {
+          // gateway.icon = `${baseUri}/credit-card.png`; // TODO: baseUri
+          gateway.icon = 'https://us-central1-ecom-pagarme.cloudfunctions.net/app/credit-card.png';
+        }
+        // https://github.com/pagarme/pagarme-js
+        gateway.js_client = {
+          script_uri: 'https://assets.pagar.me/pagarme-js/4.8/pagarme.min.js',
+          onload_expression: `window._pagarmeKey="${configApp.pagarme_encryption_key}";
+          ${fs.readFileSync(path.join(__dirname, '../../assets/onload-expression.min.js'), 'utf8')}`,
+          cc_hash: {
+            function: '_pagarmeHash',
+            is_promise: true,
+          },
+        };
+        const { installments } = configApp;
+        if (installments) {
+          const installmentsTotal = gateway.discount ? amount.total : initialTotalAmount;
+          // list all installment options and default one
+          addInstallments(installmentsTotal, installments, gateway, response);
+        }
+      }
+
+      response.payment_gateways.push(gateway);
+    }
+  });
+
+  return response;
+};

package/packages/apps/pagarme/src/pagarme-webhook.ts

@@ -0,0 +1,88 @@
+/* eslint-disable import/prefer-default-export */
+import logger from 'firebase-functions/logger';
+import api from '@cloudcommerce/api';
+import * as functions from 'firebase-functions/v1';
+import config from '@cloudcommerce/firebase/lib/config';
+import Pagarme from 'pagarme';
+import qs from 'qs';
+import parseStatus from './functions-lib/parse-status-to-ecom';
+
+const ECHO_SUCCESS = 'OK';
+
+export const pagarme = {
+  webhook: functions
+    .region(config.get().httpsFunctionOptions.region)
+    .https.onRequest(async (req, res) => {
+      const { method } = req;
+      if (method !== 'POST') {
+        res.sendStatus(405);
+      } else {
+        // read configured E-Com Plus app data
+        const app = (await api.get(
+          'applications?app_id=117391&fields=hidden_data',
+        )).data.result;
+        const apiKeyPagame = app[0].hidden_data?.pagarme_api_key;
+
+        // https://docs.pagar.me/docs/gerenciando-postbacks
+        const pagarmeTransaction = req.body && req.body.transaction;
+        if (pagarmeTransaction && pagarmeTransaction.metadata) {
+          // const storeId = parseInt(pagarmeTransaction.metadata.store_id, 10);
+          const orderId = pagarmeTransaction.metadata.order_id;
+
+          if (/^[a-f0-9]{24}$/.test(orderId)) {
+            logger.log('>(App:PagarMe) Webhook Order: ', orderId);
+
+            // validate Pagar.me postback
+            // https://github.com/pagarme/pagarme-js/issues/170#issuecomment-503729557
+            const verifyBody = qs.stringify(req.body);
+            const headerSignature = req.headers['x-hub-signature'];
+
+            if (headerSignature && !Array.isArray(headerSignature)) {
+              const signature = headerSignature.replace('sha1=', '');
+              if (!Pagarme.postback.verifySignature(apiKeyPagame, verifyBody, signature)) {
+                res.sendStatus(403);
+              } else {
+                try {
+                  // get E-Com Plus order
+                  const order = (await api.get(`orders/${orderId}`)).data;
+
+                  if (order && order.transactions) {
+                    // add new transaction status to payment history
+                    const transaction = order.transactions?.find(({ intermediator }) => {
+                      return intermediator
+                        && intermediator.transaction_id === String(pagarmeTransaction.id);
+                    });
+
+                    const bodyPaymentHistory = {
+                      date_time: new Date().toISOString(),
+                      status: parseStatus(req.body.current_status || pagarmeTransaction.status),
+                      notification_code: req.body.fingerprint,
+                      flags: ['pagarme'],
+                    } as any; // TODO: incompatible type=> amount and status
+
+                    if (transaction) {
+                      Object.assign(bodyPaymentHistory, { transaction_id: transaction._id });
+                    }
+                    if (req.body.old_status) {
+                      bodyPaymentHistory.flags.push(`old:${req.body.old_status}`.substring(0, 20));
+                    }
+                    // return appSdk.apiRequest(storeId, resource, method, body);
+                    await api.post(`orders/${orderId}/payments_history`, bodyPaymentHistory);
+                    res.status(200).send(ECHO_SUCCESS);
+                  } else {
+                    //
+                    res.status(404).send('>(App:PagarMe) Order not found');
+                  }
+                } catch (err: any) {
+                  err.metadata = pagarmeTransaction.metadata;
+                  logger.error('(App:PagarMe) =>', err);
+                  res.sendStatus(500);
+                }
+              }
+            }
+          }
+        }
+        res.sendStatus(404);
+      }
+    }),
+};