@cloudcommerce/app-mercadopago 0.0.113

package/src/mercadopago.ts

@@ -0,0 +1,16 @@
+import '@cloudcommerce/firebase/lib/init';
+/* eslint-disable import/prefer-default-export */
+import type { AppModuleBody } from '@cloudcommerce/types';
+// eslint-disable-next-line import/no-unresolved
+import { getFirestore } from 'firebase-admin/firestore';
+// eslint-disable-next-line import/no-unresolved
+import handleListPayments from './mp-list-payments';
+import handleCreateTransaction from './mp-create-transaction';
+
+export const listPayments = async (modBody: AppModuleBody) => {
+  return handleListPayments(modBody);
+};
+
+export const createTransaction = async (modBody: AppModuleBody) => {
+  return handleCreateTransaction(modBody, getFirestore());
+};

package/src/mp-create-transaction.ts

@@ -0,0 +1,290 @@
+import type { AppModuleBody } from '@cloudcommerce/types';
+import type{ CreateTransactionParams } from '@cloudcommerce/types/modules/create_transaction:params';
+import type{ CreateTransactionResponse } from '@cloudcommerce/types/modules/create_transaction:response';
+import type { Firestore } from 'firebase-admin/firestore';
+import { logger } from 'firebase-functions';
+import config from '@cloudcommerce/firebase/lib/config';
+import axios from 'axios';
+
+const parsePaymentStatus = (status: string) => {
+  switch (status) {
+    case 'rejected':
+      return 'voided';
+    case 'in_process':
+      return 'under_analysis';
+    case 'approved':
+      return 'paid';
+    default:
+      return 'pending';
+  }
+};
+
+export default async (appData: AppModuleBody, firestore:Firestore) => {
+  const locationId = config.get().httpsFunctionOptions.region;
+  const baseUri = `https://${locationId}-${process.env.GCLOUD_PROJECT}.cloudfunctions.net`;
+  // body was already pre-validated on @/bin/web.js
+  // treat module request body
+  const { application, storeId } = appData;
+  const params = appData.params as CreateTransactionParams;
+  // app configured options
+  const configApp = { ...application.data, ...application.hidden_data };
+  const notificationUrl = `${baseUri}/mercadopago-webhook`;
+
+  let token: string| undefined;
+  let paymentMethodId: string;
+  const isPix = params.payment_method.code === 'account_deposit';
+  if (params.credit_card && params.credit_card.hash) {
+    const hashParts = params.credit_card.hash.split(' // ');
+    [token] = hashParts;
+    try {
+      paymentMethodId = JSON.parse(hashParts[1]).payment_method_id;
+    } catch (e) {
+      paymentMethodId = params.credit_card.company || 'visa';
+    }
+  } else if (params.payment_method.code === 'banking_billet') {
+    paymentMethodId = 'bolbradesco';
+  } else if (params.payment_method.code === 'account_deposit') {
+    paymentMethodId = 'pix';
+  } else {
+    return {
+      status: 400,
+      error: 'NO_CARD_ERR',
+      message: 'Credit card hash is required',
+    };
+  }
+
+  const { buyer } = params;
+  const orderId = params.order_id;
+  logger.log('> MP Transaction #', storeId, orderId);
+
+  // https://www.mercadopago.com.br/developers/pt/reference/payments/_payments/post/
+  const payerPhone = {
+    area_code: buyer.phone.number.substring(0, 2),
+    number: buyer.phone.number.substring(2, 11),
+  };
+  const additionalInfo: {[key:string]: any} = {
+    items: [],
+    payer: {
+      first_name: buyer.fullname.replace(/\s.*/, ''),
+      last_name: buyer.fullname.replace(/[^\s]+\s/, ''),
+      phone: payerPhone,
+    },
+  };
+
+  if (params.to && params.to.street) {
+    additionalInfo.shipments = {
+      receiver_address: {
+        zip_code: params.to.zip,
+        street_name: params.to.street,
+        street_number: params.to.number || 0,
+      },
+    };
+  }
+  if (params.billing_address && params.billing_address.street) {
+    additionalInfo.payer.address = {
+      zip_code: params.billing_address.zip,
+      street_name: params.billing_address.street,
+      street_number: params.billing_address.number || 0,
+    };
+  } else if (additionalInfo.shipments) {
+    additionalInfo.payer.address = additionalInfo.shipments.receiver_address;
+  }
+
+  if (Array.isArray(params.items)) {
+    params.items.forEach((item) => {
+      additionalInfo.items.push({
+        id: item.sku || item.variation_id || item.product_id,
+        title: item.name || item.sku,
+        description: item.name || item.sku,
+        quantity: item.quantity,
+        unit_price: item.final_price || item.price,
+      });
+    });
+  }
+
+  const payerOrBuyer = {
+    ...buyer,
+    ...params.payer,
+  };
+
+  Object.keys(payerOrBuyer).forEach(
+    (field) => {
+      if (!payerOrBuyer[field] && buyer[field]) {
+        payerOrBuyer[field] = buyer[field];
+      }
+    },
+  );
+
+  const payment = {
+    payer: {
+      type: 'customer',
+      email: buyer.email,
+      first_name: payerOrBuyer.fullname.replace(/\s.*/, ''),
+      last_name: payerOrBuyer.fullname.replace(/[^\s]+\s/, ''),
+      identification: {
+        type: payerOrBuyer.registry_type === 'j' ? 'CNPJ' : 'CPF',
+        number: String(payerOrBuyer.doc_number),
+      },
+    },
+    external_reference: String(params.order_number),
+    transaction_amount: params.amount.total,
+    description: `Pedido #${params.order_number} de ${buyer.fullname}`.substring(0, 60),
+    payment_method_id: paymentMethodId,
+    token,
+    statement_descriptor: configApp.statement_descriptor || `${params.domain}_MercadoPago`,
+    installments: params.installments_number || 1,
+    notification_url: notificationUrl,
+    additional_info: additionalInfo,
+    metadata: {
+      ecom_store_id: storeId,
+      ecom_order_id: orderId,
+    },
+  };
+  logger.log('>data: ', JSON.stringify(payment));
+
+  try {
+  // https://www.mercadopago.com.br/developers/pt/reference/payments/_payments/post
+    const { data } = await axios({
+      url: 'https://api.mercadopago.com/v1/payments',
+      method: 'post',
+      headers: {
+        Authorization: `Bearer ${configApp.mp_access_token}`,
+        'Content-Type': 'application/json',
+      },
+      data: payment,
+    });
+    if (data) {
+      logger.log('> MP Checkout #', storeId, orderId);
+
+      const statusPayment = parsePaymentStatus(data.status);
+      let isSaveRetry = false;
+      const saveToDb = () => {
+        return new Promise((resolve, reject) => {
+          firestore.collection('mp_payments')
+            .doc(String(data.id))
+            .set({
+              transaction_code: data.id,
+              store_id: storeId,
+              order_id: orderId,
+              status: statusPayment,
+              paymentMethod: paymentMethodId,
+              notificationUrl,
+            }, {
+              merge: true,
+            })
+            .then(() => {
+              logger.log('> Payment #', String(data.id));
+              resolve(true);
+            })
+            .catch((err) => {
+              if (err.code === 13 && !isSaveRetry) {
+                isSaveRetry = true;
+                setTimeout(saveToDb, 500);
+              } else {
+                logger.error('PAYMENT_SAVE_ERR', err);
+                reject(err);
+              }
+            });
+        });
+      };
+      await saveToDb();
+
+      const transaction: CreateTransactionResponse['transaction'] = {
+        amount: data.transaction_details.total_paid_amount,
+        currency_id: data.currency_id,
+        intermediator: {
+          payment_method: {
+            code: paymentMethodId || params.payment_method.code,
+          },
+          transaction_id: String(data.id),
+          transaction_code: String(data.id),
+          transaction_reference: data.external_reference,
+        },
+        status: {
+          current: statusPayment,
+        },
+      };
+
+      if (params.payment_method.code === 'credit_card') {
+        if (data.card) {
+          transaction.credit_card = {
+            holder_name: data.card.cardholder.name,
+            last_digits: data.card.last_four_digits,
+            token,
+          };
+        }
+        if (data.installments) {
+          transaction.installments = {
+            number: data.installments,
+            tax: (data.transaction_details.total_paid_amount > data.transaction_amount),
+            total: data.transaction_details.total_paid_amount,
+            value: data.transaction_details.installment_amount,
+          };
+        }
+      } else if (!isPix && data.transaction_details
+          && data.transaction_details.external_resource_url) {
+        transaction.payment_link = data.transaction_details.external_resource_url;
+        transaction.banking_billet = {
+          link: transaction.payment_link,
+        };
+        if (data.date_of_expiration) {
+          const dateValidThru = new Date(data.date_of_expiration);
+          if (dateValidThru.getTime() > 0) {
+            transaction.banking_billet.valid_thru = dateValidThru.toISOString();
+          }
+        }
+      } else if (isPix && data.point_of_interaction && data.point_of_interaction.transaction_data) {
+        // https://www.mercadopago.com.br/developers/pt/docs/checkout-api/integration-configuration/integrate-with-pix#bookmark_visualiza%C3%A7%C3%A3o_de_pagamento
+        const qrCode = data.point_of_interaction.transaction_data.qr_code;
+        const qrCodeBase64 = data.point_of_interaction.transaction_data.qr_code_base64;
+        transaction.notes = '<div style="display:block;margin:0 auto"> '
+          + `<img width="280" height="280" style="margin:5px auto" src='data:image/jpeg;base64,${qrCodeBase64}'/> `
+          + `<lable> ${qrCode} </label></div>`;
+      }
+
+      return {
+        status: 200,
+        redirect_to_payment: false,
+        transaction,
+      };
+    }
+    return {
+      status: 409,
+      message: `CREATE_TRANSACTION_ERR #${storeId} - ${orderId} => MP not response`,
+    };
+  } catch (error: any) {
+    let { message } = error;
+    //
+    const err = {
+      message: `CREATE_TRANSACTION_ERR #${storeId} - ${orderId} => ${message}`,
+      payment: '',
+      status: 0,
+      response: '',
+    };
+    if (error.response) {
+      const { status, data } = error.response;
+      if (status !== 401 && status !== 403) {
+        err.payment = JSON.stringify(payment);
+        err.status = status;
+        if (typeof data === 'object' && data) {
+          err.response = JSON.stringify(data);
+        } else {
+          err.response = data;
+        }
+        if (typeof data.message === 'string' && data.message) {
+          message = data.message;
+        }
+      }
+    }
+    logger.error(err);
+    return {
+      status: 409,
+      error: 'CREATE_TRANSACTION_ERR',
+      message,
+    };
+  }
+};
+
+export {
+  parsePaymentStatus,
+};

package/src/mp-list-payments.ts

@@ -0,0 +1,198 @@
+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';
+
+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 config = {
+    ...application.data,
+    ...application.hidden_data,
+  };
+
+  if (!config.mp_public_key || !config.mp_access_token) {
+    // must have configured PayPal app ID and secret
+    return {
+      error: 'LIST_PAYMENTS_ERR',
+      message: 'MP Public Key or Access Token is unset on app hidden data (merchant must configure the app)',
+    };
+  }
+
+  // start mounting response body
+  // https://apx-mods.e-com.plus/api/v1/list_payments/response_schema.json?store_id=100
+  const response: ListPaymentsResponse = {
+    payment_gateways: [],
+  };
+
+  // calculate discount value
+  const { discount } = config;
+  if (discount && discount.value) {
+    if (discount.apply_at !== 'freight') {
+      // default discount option
+      const { value } = discount;
+      response.discount_option = {
+        label: config.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) {
+          amount.discount = (amount.discount || 0) + discountValue;
+          amount.total -= discountValue;
+          if (amount.total < 0) {
+            amount.total = 0;
+          }
+        }
+      }
+    }
+  }
+
+  // setup payment gateway objects
+  const intermediator = {
+    code: 'mercadopago',
+    link: 'https://www.mercadopago.com.br',
+    name: 'Mercado Pago',
+  };
+  const listPaymentMethods = ['banking_billet', 'credit_card'];
+  if (config.account_deposit && config.account_deposit.key_pix) {
+    // pix Configured
+    listPaymentMethods.push('account_deposit');
+  }
+  listPaymentMethods.forEach((paymentMethod) => {
+    const isCreditCard = paymentMethod === 'credit_card';
+    const methodConfig = isCreditCard ? config : config[paymentMethod];
+    const minAmount = methodConfig.min_amount || 0;
+    const methodEnable = methodConfig.enable || (isCreditCard && !methodConfig.disable);
+    if (methodConfig && methodEnable && (amount.total === undefined || amount.total >= minAmount)) {
+      let label: string;
+      if (methodConfig.label) {
+        label = methodConfig.label;
+      } else if (isCreditCard) {
+        label = 'Cartão de crédito';
+      } else {
+        label = paymentMethod === 'account_deposit' ? 'Pix' : 'Boleto bancário';
+      }
+      const gateway:Gateway = {
+        label,
+        icon: methodConfig.icon,
+        text: methodConfig.text,
+        payment_method: {
+          code: paymentMethod as CodePaymentMethod,
+          name: `${label} - ${intermediator.name}`,
+        },
+        intermediator,
+        type: 'payment',
+      };
+
+      if (isCreditCard) {
+        if (!gateway.icon) {
+          // gateway.icon = `${baseUri}/checkout-stamp.png`; // TODO: baseUri
+          gateway.icon = 'https://us-central1-mercadopago-ecom.cloudfunctions.net/app/checkout-stamp.png';
+        }
+        gateway.js_client = {
+          script_uri: 'https://secure.mlstatic.com/sdk/javascript/v1/mercadopago.js',
+          onload_expression: `window.Mercadopago.setPublishableKey("${config.mp_public_key}");${
+            fs.readFileSync(path.join(__dirname, '../../assets/onload-expression.min.js'), 'utf8')}`,
+          cc_brand: {
+            function: '_mpBrand',
+            is_promise: true,
+          },
+          cc_hash: {
+            function: '_mpHash',
+            is_promise: true,
+          },
+          cc_installments: {
+            function: '_mpInstallments',
+            is_promise: true,
+          },
+        };
+
+        // default configured default installments option
+        const installmentsOption = config.installments_option;
+        if (installmentsOption && installmentsOption.max_number) {
+          response.installments_option = installmentsOption;
+          const minInstallment = installmentsOption.min_installment;
+
+          // optional configured installments list
+          if (amount.total && Array.isArray(config.installments) && config.installments.length) {
+            gateway.installment_options = [];
+            config.installments.forEach(({ number, interest }) => {
+              if (number >= 2) {
+                const value = amount.total / number;
+                if (gateway.installment_options && value >= minInstallment) {
+                  gateway.installment_options.push({
+                    number,
+                    value: interest > 0 ? (value + value * interest) / 100 : value,
+                    tax: Boolean(interest),
+                  });
+                }
+              }
+            });
+          }
+        }
+      }
+
+      // check available discount by payment method
+      if (discount && discount.value && discount[paymentMethod] !== false) {
+        gateway.discount = {
+          apply_at: 'total',
+          type: 'fixed',
+          value: 0,
+        };
+        ['apply_at', 'type', 'value'].forEach(
+          (field) => {
+            if (gateway.discount && discount[field]) {
+              gateway.discount[field] = discount[field];
+            }
+          },
+        );
+        if (response.discount_option && !response.discount_option.label) {
+          response.discount_option.label = label;
+        }
+      }
+
+      response.payment_gateways.push(gateway);
+    }
+  });
+
+  return response;
+};

package/src/mp-webhook.ts

@@ -0,0 +1,136 @@
+/* eslint-disable import/prefer-default-export */
+import '@cloudcommerce/firebase/lib/init';
+import { logger } from 'firebase-functions';
+import axios from 'axios';
+import api from '@cloudcommerce/api';
+// eslint-disable-next-line import/no-unresolved
+import { getFirestore } from 'firebase-admin/firestore';
+// eslint-disable-next-line import/no-unresolved
+import * as functions from 'firebase-functions/v1';
+import config from '@cloudcommerce/firebase/lib/config';
+import { parsePaymentStatus } from './mp-create-transaction';
+
+const ECHO_SKIP = 'SKIP';
+let ECHO_SUCCESS = 'OK';
+
+export const mercadopago = {
+  webhook: functions
+    .region(config.get().httpsFunctionOptions.region)
+    .https.onRequest(async (req, res) => {
+      const { method } = req;
+      if (method === 'POST') {
+        const { body } = req;
+        logger.log('>> Webhook MP #', JSON.stringify(body), ' <<');
+        try {
+          const app = (await api.get(
+            'applications?app_id=111223&fields=hidden_data',
+          )).data.result;
+          const accessTokenMp = app[0].hidden_data?.mp_access_token;
+          if (accessTokenMp) {
+            const notification = req.body;
+            if (notification.type !== 'payment' || !notification.data || !notification.data.id) {
+              res.status(404).send(ECHO_SKIP);
+            }
+
+            // setTimeout(() => {
+            logger.log('> MP Notification for Payment #', notification.data.id);
+
+            const docRef = getFirestore().collection('mp_payments')
+              .doc(String(notification.data.id));
+
+            docRef.get()
+              .then(async (doc) => {
+                if (doc.exists) {
+                  const data = doc.data();
+                  const orderId = data?.order_id;
+                  const order = (await api.get(
+                    `orders/${orderId}`,
+                  )).data;
+                  logger.log('>order ', JSON.stringify(order), '<');
+                  if (order && order.transactions) {
+                    const payment = (await axios.get(
+                      `https://api.mercadopago.com/v1/payments/${notification.data.id}`,
+                      {
+                        headers: {
+                          Authorization: `Bearer ${accessTokenMp}`,
+                          'Content-Type': 'application/json',
+                        },
+                      },
+                    )).data;
+                    logger.log('>payment ', JSON.stringify(payment), ' <');
+                    const methodPayment = payment.payment_method_id;
+
+                    const transaction = order.transactions.find(({ intermediator }) => {
+                      return intermediator
+                        && intermediator.transaction_code === notification.data.id;
+                    });
+                    const status = parsePaymentStatus(payment.status);
+                    if (transaction) {
+                      const bodyPaymentHistory = {
+                        transaction_id: transaction._id,
+                        date_time: new Date().toISOString(),
+                        status,
+                        notification_code: String(notification.id),
+                        flags: [
+                          'mercadopago',
+                        ],
+                      } as any; // TODO: incompatible type=> amount and status
+
+                      if (status !== order.financial_status?.current) {
+                      // avoid unnecessary API request
+                        await api.post(`orders/${orderId}/payments_history`, bodyPaymentHistory);
+                        const updatedAt = new Date().toISOString();
+                        docRef.set({ status, updatedAt }, { merge: true }).catch(logger.error);
+                      }
+
+                      if ((status === 'paid' && methodPayment === 'pix' && transaction)) {
+                        let { notes } = transaction;
+                        notes = notes?.replace('display:block', 'display:none'); // disable QR Code
+                        notes = `${notes} # PIX Aprovado`;
+
+                        // orders/${order._id}/transactions/${transactionId}.json { notes }
+                        // Update to disable QR Code
+                        try {
+                          await api.patch(
+                            `orders/${order._id}/transactions/${transaction._id}`,
+                            { notes },
+                          );
+                          ECHO_SUCCESS = 'SUCCESS';
+                        } catch (e) {
+                          logger.error(e);
+                        }
+                      }
+
+                      res.status(200).send(ECHO_SUCCESS);
+                    } else {
+                    // transaction not found
+                      logger.log('> Transaction not found #', notification.data.id);
+                      res.sendStatus(404);
+                    }
+                  } else {
+                  // order or order transaction not found
+                    logger.log('> Order Not Found #', orderId);
+                    res.sendStatus(404);
+                  }
+                } else {
+                  logger.log('> Payment not found in Firestore #', notification.data.id);
+                  res.sendStatus(404);
+                }
+              })
+              .catch((err) => {
+                logger.error(err);
+                res.sendStatus(503);
+              });
+          // }, 3000);
+          } else {
+            res.sendStatus(406);
+          }
+        } catch (e) {
+          logger.error(e);
+          res.sendStatus(500);
+        }
+      } else {
+        res.sendStatus(405);
+      }
+    }),
+};

package/tsconfig.json

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

package/webhook.js

@@ -0,0 +1 @@
+export * from './lib/mp-webhook.js';