@cloudcommerce/app-pagarme-v5 0.32.0

package/lib-mjs/events-to-pagarme5.mjs

@@ -0,0 +1,209 @@
+import api from '@cloudcommerce/api';
+import logger from 'firebase-functions/logger';
+// import config from '@cloudcommerce/firebase/lib/config';
+import { getFirestore } from 'firebase-admin/firestore';
+import ecomUtils from '@ecomplus/utils';
+import axios from './functions-lib/pagarme/create-axios.mjs';
+import { getOrderWithQueryString } from './functions-lib/api-utils.mjs';
+import { getDocFirestore } from './functions-lib/firestore-utils.mjs';
+
+const colletionFirebase = getFirestore().collection('pagarmeV5Subscriptions');
+
+const eventOrderCancelled = async (
+  apiDoc,
+  pagarmeAxios,
+) => {
+  const order = apiDoc;
+  if (order?.transactions[0]?.type === 'recurrence') {
+    const { data: { data: subcriptions } } = await pagarmeAxios.get(`/subscriptions?code=${order._id}`);
+    if (subcriptions && subcriptions[0].status !== 'canceled') {
+      try {
+        logger.log(`> (App PagarMe V5): Try cancel subscription: #${order._id}`);
+        await pagarmeAxios.delete(`/subscriptions/${subcriptions[0].id}`);
+        logger.log('> (App PagarMe V5):  Successfully canceled');
+        await colletionFirebase.doc(order._id)
+          .set({
+            status: 'cancelled',
+            updatedAt: new Date().toISOString(),
+          }, { merge: true })
+          .catch(logger.error);
+
+        logger.log('>> SUCESSS');
+        return null;
+      } catch (err) {
+        logger.error('> (App PagarMe V5): Error when canceling in Pagar.Me, return the status');
+        await api.patch(order._id, { status: 'open' })
+          .catch(logger.error);
+
+        return null;
+      }
+    } else {
+      logger.log('> (App PagarMe V5): Subscription already canceled or does not exist');
+      return null;
+    }
+  }
+  // edit items order order Original
+  return null;
+};
+
+const eventProducts = async (
+  apiDoc,
+  pagarmeAxios,
+) => {
+  // console.log('> Edit product ', resourceId, 's: ', storeId);
+  const product = apiDoc;
+
+  let query = 'status!=cancelled&transactions.type=recurrence';
+  query += '&transactions.app.intermediator.code=pagarme';
+  query += `&items.product_id=${product._id}`;
+
+  const result = await getOrderWithQueryString(query);
+
+  if (result && result.length) {
+    let i = 0;
+    while (i < result.length) {
+      const updateItemPagarme = [];
+      // eslint-disable-next-line no-await-in-loop
+      const order = (await api.get(`orders/${result[i]._id}`)).data;
+      // eslint-disable-next-line no-await-in-loop
+      const docSubscription = await getDocFirestore(colletionFirebase, result[i]._id);
+      logger.log('> (App PagarMe v5): Order ', JSON.stringify(order), ' ', JSON.stringify(docSubscription));
+      if (order && docSubscription) {
+        const itemsUpdate = [];
+        order.items.forEach((orderItem) => {
+          if (orderItem.product_id === product._id) {
+            if (orderItem.variation_id) {
+              const variation = product.variations
+                .find((itemFind) => itemFind.sku === orderItem.sku);
+
+              let quantity = orderItem.quantity;
+              if (variation && variation.quantity < orderItem.quantity) {
+                quantity = variation.quantity;
+              } else if (!variation) {
+                quantity = 0;
+              }
+              const newItem = {
+                sku: variation.sku,
+                price: ecomUtils.price({ ...product, ...variation }),
+                quantity,
+              };
+              if ((orderItem.final_price && orderItem.final_price !== newItem.price)
+                || orderItem.price !== newItem.price || orderItem.quantity !== newItem.quantity) {
+                itemsUpdate.push(newItem);
+              }
+            } else {
+              const newItem = {
+                sku: product.sku,
+                price: ecomUtils.price(product),
+                quantity: product.quantity < orderItem.quantity
+                  ? product.quantity : orderItem.quantity,
+              };
+              if ((orderItem.final_price && orderItem.final_price !== newItem.price)
+                || orderItem.price !== newItem.price || orderItem.quantity !== newItem.quantity) {
+                itemsUpdate.push(newItem);
+              }
+            }
+          }
+        });
+
+        if (itemsUpdate.length) {
+          docSubscription?.items?.forEach((itemPagarme) => {
+            const itemToEdit = itemsUpdate.find((itemFind) => itemPagarme.id === `pi_${itemFind.sku}`);
+            if (itemToEdit && !itemPagarme.cycles) {
+              itemPagarme.quantity = itemToEdit.quantity;
+              itemPagarme.pricing_scheme.price = Math.floor((itemToEdit.price) * 100);
+              updateItemPagarme.push({
+                subscription_id: docSubscription.subscriptionPagarmeId,
+                item: itemPagarme,
+              });
+            }
+          });
+        }
+      }
+      // order not found or error
+      if (updateItemPagarme.length) {
+        logger.log('> (App PagarMe V5): Try update item in Pagar.Me');
+        try {
+          // eslint-disable-next-line no-await-in-loop
+          await Promise.all(updateItemPagarme.map((itemPagarme) => {
+            return pagarmeAxios.put(
+              `/subscriptions/${itemPagarme.subscription_id}/items/${itemPagarme.item.id}`,
+              {
+                ...itemPagarme.item,
+              },
+            );
+          }));
+        } catch (err) {
+          logger.error(err);
+          /* When creating a new order, check the items saved in Pagar.Me
+            with the original order items
+
+           No need to save to firestore
+          */
+        }
+      }
+      i += 1;
+    }
+    logger.log('>> SUCESSS');
+    return null;
+  }
+  logger.log('>> Orders not found ');
+  return null;
+};
+
+const handleApiEvent = async ({
+  evName,
+  apiEvent,
+  apiDoc,
+  app,
+}) => {
+  const resourceId = apiEvent.resource_id;
+  logger.info('>> ', resourceId, ' - Action: ', apiEvent.action);
+  const key = `${evName}_${resourceId}`;
+  const configApp = { ...app.data, ...app.hidden_data };
+  if (
+    Array.isArray(configApp.ignore_events)
+    && configApp.ignore_events.includes(evName)
+  ) {
+    logger.info('>> ', key, ' - Ignored event');
+    return null;
+  }
+  logger.info(`> Webhook ${resourceId} [${evName}] => ${apiDoc}`);
+
+  if (!process.env.PAGARMEV5_API_TOKEN) {
+    const pagarmeApiToken = configApp.pagarme_api_token;
+    if (pagarmeApiToken && typeof pagarmeApiToken === 'string') {
+      process.env.PAGARMEV5_API_TOKEN = pagarmeApiToken;
+    } else {
+      logger.warn('Missing PAGARMEV5 API TOKEN');
+      return null;
+    }
+  }
+
+  try {
+    const pagarmeAxios = axios(process.env.PAGARMEV5_API_TOKEN);
+
+    if (evName === 'orders-cancelled') {
+      return eventOrderCancelled(apiDoc, pagarmeAxios);
+    }
+
+    if (evName.startsWith('products-') && evName !== 'products-new') {
+      return eventProducts(apiDoc, pagarmeAxios);
+    }
+
+    return null;
+  } catch (error) {
+    const statusCode = error.response?.status;
+    if (statusCode === 404) {
+      logger.warn('> (App PagarMe V5): Subscription not found in PagarMe');
+      return null;
+    }
+    if (statusCode === 401 || statusCode === 403) {
+      logger.warn('> (App PagarMe V5): Unauthorized subscription deletion request');
+      return null;
+    }
+    throw error;
+  }
+};
+
+export default handleApiEvent;

package/lib-mjs/functions-lib/api-utils.mjs

@@ -0,0 +1,220 @@
+import ecomUtils from '@ecomplus/utils';
+import api from '@cloudcommerce/api';
+
+const getOrderById = async (orderId) => {
+  const { data } = await api.get(`orders/${orderId}`);
+  return data;
+};
+
+const addPaymentHistory = async (orderId, body) => {
+  return api.post(`orders/${orderId}/payments_history`, body);
+};
+
+const updateTransaction = (orderId, body, transactionId) => {
+  const urlTransaction = transactionId ? `/${transactionId}` : '';
+  const method = transactionId ? 'PATCH' : 'POST';
+
+  return api[method](`orders/${orderId}/transactions${urlTransaction}`, body);
+};
+
+const getOrderIntermediatorTransactionId = async (invoiceId) => {
+  let queryString = `?transactions.intermediator.transaction_id=${invoiceId}`;
+  queryString += '&fields=transactions,financial_status.current,status';
+  const data = await api.get(`orders${queryString}`);
+
+  return data?.result.length ? data?.result[0] : null;
+};
+
+const checkItemsAndRecalculeteOrder = (amount, items, plan, itemsPagarme) => {
+  let subtotal = 0;
+  let item;
+  let i = 0;
+  while (i < items.length) {
+    item = items[i];
+
+    if (item.flags && (item.flags.includes('freebie') || item.flags.includes('discount-set-free'))) {
+      items.splice(i, 1);
+    } else {
+      // eslint-disable-next-line no-loop-func
+      const itemFound = itemsPagarme.find((itemFind) => itemFind.id === `pi_${item.sku}`);
+
+      if (itemFound) {
+        item.quantity = itemFound.quantity;
+        if (item.final_price) {
+          item.final_price = (itemFound.pricing_scheme.price / 100);
+        }
+        item.price = (itemFound.pricing_scheme.price / 100);
+        subtotal += item.quantity * (item.final_price || item.price);
+        i += 1;
+      } else {
+        items.splice(i, 1);
+      }
+    }
+  }
+
+  if (subtotal > 0) {
+    amount.subtotal = subtotal;
+    amount.total = amount.subtotal + (amount.tax || 0)
+      + (amount.freight || 0) + (amount.extra || 0);
+
+    let planDiscount;
+    if (plan && plan.discount) {
+      if (plan.discount.type === 'percentage') {
+        planDiscount = amount[plan.discount.apply_at];
+        planDiscount *= ((plan.discount.value) / 100);
+      }
+    }
+    // if the plan doesn't exist, because it's subscription before the update
+    amount.discount = plan ? ((plan.discount && plan.discount.type !== 'percentage' ? plan.discount.value : planDiscount) || 0) : (amount.discount || 0);
+
+    amount.total -= amount.discount;
+    amount.total = amount.total > 0 ? amount.total : 0;
+
+    return amount.total > 0 ? Math.floor((amount.total).toFixed(2) * 1000) / 10 : 0;
+  }
+
+  return 0;
+};
+
+const createNewOrderBasedOld = (oldOrder, plan, status, charge, subscriptionPagarme) => {
+  const {
+    buyers, items, domain, amount,
+  } = oldOrder;
+  const channelType = oldOrder.channel_type;
+  const shippingLines = oldOrder.shipping_lines;
+  const shippingMethodLabel = oldOrder.shipping_method_label;
+  const paymentMethodLabel = oldOrder.payment_method_label;
+  const originalTransaction = oldOrder.transactions[0];
+
+  const portion = charge.code?.replace(`${oldOrder._id}-`, '');
+  const itemsPagarme = subscriptionPagarme.items;
+
+  checkItemsAndRecalculeteOrder(amount, items, plan, itemsPagarme);
+  if (amount.balance) {
+    delete amount.balance;
+  }
+
+  items.forEach((item) => {
+    if (item.stock_status && item.stock_status !== 'unmanaged') {
+      item.stock_status = 'pending';
+    }
+  });
+  const transactionPagarme = charge.last_transaction;
+
+  const transactions = [
+    {
+      amount: amount.total,
+      status: {
+        updated_at: transactionPagarme.updated_at || new Date().toISOString(),
+        current: status,
+      },
+      intermediator: {
+        transaction_id: `${charge.invoice.id}`,
+        transaction_code: `${transactionPagarme.acquirer_auth_code || ''}`,
+        transaction_reference: `${transactionPagarme.acquirer_tid || ''}`,
+      },
+      payment_method: originalTransaction.payment_method,
+      app: originalTransaction.app,
+      _id: ecomUtils.randomObjectId(),
+      notes: `Parcela #${portion} referente à ${plan?.label || 'Assinatura'}`,
+      custom_fields: originalTransaction.custom_fields,
+    },
+  ];
+
+  transactions[0].payment_link = transactionPagarme.url;
+
+  const financialStatus = {
+    updated_at: transactionPagarme.updated_at || new Date().toISOString(),
+    current: status,
+  };
+
+  let notes = `Parcela #${portion} desconto de ${plan.discount.type === 'percentage' ? '' : 'R$'}`;
+  notes += ` ${plan.discount.value} ${plan.discount.type === 'percentage' ? '%' : ''}`;
+  notes += ` sobre ${plan.discount.apply_at}`;
+
+  const body = {
+    opened_at: new Date().toISOString(),
+    items,
+    shipping_lines: shippingLines,
+    buyers,
+    channel_type: channelType,
+    domain,
+    amount,
+    shipping_method_label: shippingMethodLabel,
+    payment_method_label: paymentMethodLabel,
+    transactions,
+    financial_status: financialStatus,
+    subscription_order: {
+      _id: oldOrder._id,
+      number: oldOrder.number,
+    },
+    notes,
+    staff_notes: `Valor cobrado no Pagar.Me R$${(charge.amount) / 100}`,
+  };
+  return api.post('orders', body);
+};
+
+// const updateOrder = async (orderId, body) => {
+//   return api.patch(`orders/${orderId}`, body);
+// };
+
+const getOrderWithQueryString = async (query) => {
+  const { data } = await api.get(`orders?${query}`);
+
+  return data?.result.length ? data?.result : null;
+};
+
+const getProductById = async (productId) => {
+  const { data } = await api.get(`products/${productId}`);
+  return data;
+};
+
+const checkItemCategory = async (categoryIds, itemsPagarme, itemsApi) => {
+  let i = 0;
+
+  const itemsIdPagarmeDelete = [];
+  while (i < itemsPagarme.length) {
+    const itemPagarme = itemsPagarme[i];
+    // Obs.: freight is one item, initially do not remove freight
+    const isItemFreigth = itemPagarme?.id?.startsWith('pi_freight_');
+    const itemFound = itemsApi.find((itemFind) => itemPagarme.id === `pi_${itemFind.sku}`);
+    const itemFoundIndex = itemsApi.indexOf(itemFound);
+
+    if (itemFound && !isItemFreigth) {
+      // eslint-disable-next-line no-await-in-loop
+      const product = await getProductById(itemFound.product_id);
+      if (product.categories) {
+        let canSign = false;
+        product.categories.forEach((category) => {
+          if (categoryIds.includes(category._id)) {
+            canSign = true;
+          }
+        });
+
+        if (!canSign) {
+          itemsIdPagarmeDelete.push(itemPagarme.id);
+          itemsApi.splice(itemFoundIndex, 1);
+        }
+      } else {
+        itemsIdPagarmeDelete.push(itemPagarme.id);
+        itemsApi.splice(itemFoundIndex, 1);
+      }
+    } else if (!isItemFreigth) {
+      itemsIdPagarmeDelete.push(itemPagarme.id);
+    }
+    i += 1;
+  }
+
+  return itemsIdPagarmeDelete;
+};
+
+export {
+  getOrderById,
+  addPaymentHistory,
+  updateTransaction,
+  getOrderIntermediatorTransactionId,
+  createNewOrderBasedOld,
+  getOrderWithQueryString,
+  getProductById,
+  checkItemCategory,
+};

package/lib-mjs/functions-lib/firestore-utils.mjs

@@ -0,0 +1,24 @@
+import logger from 'firebase-functions/logger';
+
+const getDocFirestore = async (collection, documentId) => {
+  const documentSnapshot = await collection.doc(documentId).get();
+  let data;
+  if (documentSnapshot) {
+    data = documentSnapshot.data();
+  }
+  return data;
+};
+
+const updateDocFirestore = async (collection, documentId, body) => {
+  const updatedAt = new Date().toISOString();
+  body.updatedAt = updatedAt;
+
+  await collection.doc(documentId)
+    .set(body, { merge: true })
+    .catch(logger.error);
+};
+
+export {
+  getDocFirestore,
+  updateDocFirestore,
+};

package/lib-mjs/functions-lib/pagarme/create-axios.mjs

@@ -0,0 +1,12 @@
+import axios from 'axios';
+
+export default (apiSecretKey) => {
+  return axios.create({
+    baseURL: 'https://api.pagar.me/core/v5',
+    headers: {
+      accept: 'application/json',
+      'content-type': 'application/json',
+      Authorization: 'Basic ' + Buffer.from(`${apiSecretKey}:`).toString('base64'),
+    },
+  });
+};

package/lib-mjs/functions-lib/pagarme/handle-plans.mjs

@@ -0,0 +1,69 @@
+const discountPlanPayment = (planName, plan, amount) => {
+  let discount;
+  // console.log('>>Plan ', plan)
+  if (plan.discount_first_installment
+    && !plan.discount_first_installment.disable) {
+    discount = plan.discount_first_installment;
+  } else {
+    discount = plan.discount;
+  }
+
+  if (discount && discount.value > 0) {
+    // default discount option
+    const { value } = discount;
+    const discountOption = {
+      label: planName,
+      value,
+      type: discount.type,
+    };
+
+    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 applyDiscount = discount.apply_at;
+
+        const maxDiscount = amount[applyDiscount || 'subtotal'];
+        let discountValue;
+        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;
+          }
+        }
+      }
+    }
+    return { amount, discountOption };
+  }
+  return null;
+};
+
+const getPlanInTransction = (label, plans) => {
+  // find plan by name (label)
+  const plan = plans.find((planFind) => {
+    const planLabel = `Assinatura ${planFind.periodicity} ${planFind.label || 'Plano'}`;
+
+    label = label.trim();
+    return label === planLabel;
+  });
+
+  return plan;
+};
+
+export {
+  discountPlanPayment,
+  getPlanInTransction,
+};

package/lib-mjs/functions-lib/pagarme/parses-utils.mjs

@@ -0,0 +1,61 @@
+// pending, paid, canceled, scheduled ou failed.
+const parserInvoiceStatusToEcom = (status) => {
+  // pending, paid, canceled, scheduled ou failed
+  switch (status) {
+    case 'pending':
+    case 'paid':
+      return status;
+    case 'scheduled':
+      return 'under_analysis';
+    case 'canceled':
+      return 'voided';
+    case 'failed':
+      return 'unauthorized';
+    default:
+      return 'unknown';
+  }
+};
+
+const parserChangeStatusToEcom = (status) => {
+  // overpaid paid partial_canceled payment_failed pending processing refunded underpaid
+  switch (status) {
+    case 'pending':
+    case 'paid':
+    case 'refunded':
+      return status;
+
+    case 'overpaid':
+      return 'paid';
+
+    case 'processing':
+      return 'under_analysis';
+
+    case 'canceled':
+      return 'voided';
+
+    case 'payment_failed':
+    case 'failed':
+      return 'unauthorized';
+
+    case 'underpaid':
+      return 'partially_paid';
+
+    default:
+      return 'unknown';
+  }
+};
+
+const parseAddress = (to) => ({
+  city: to.city,
+  state: to.province || to.province_code,
+  country: to.country_code ? to.country_code.toLowerCase() : 'br',
+  zip_code: to.zip.replace(/\D/g, '').padStart(8, '0'),
+  line_1: `${String(to.number) || 's/n'},${to.street},${to.borough}`,
+  line_2: to.complement || '',
+});
+
+export {
+  parserInvoiceStatusToEcom,
+  parserChangeStatusToEcom,
+  parseAddress,
+};