@cloudcommerce/app-pagarme-v5 0.32.0

package/lib-mjs/functions-lib/pagarme/payment-subscription.mjs

@@ -0,0 +1,244 @@
+import logger from 'firebase-functions/logger';
+import axios from './create-axios.mjs';
+import { parseAddress } from './parses-utils.mjs';
+
+const paymentMethods = {
+  credit_card: 'credit_card',
+  banking_billet: 'boleto',
+  account_deposit: 'pix',
+};
+
+const parseIntervalPlan = {
+  // day, week, month ou year.
+  Diaria: {
+    interval: 'day',
+    interval_count: 1,
+  },
+  Semanal: {
+    interval: 'week',
+    interval_count: 1,
+  },
+  Mensal: {
+    interval: 'month',
+    interval_count: 1,
+
+  },
+  Bimestral: {
+    interval: 'month',
+    interval_count: 2,
+  },
+  Trimestral: {
+    interval: 'month',
+    interval_count: 3,
+  },
+  Semestral: {
+    interval: 'month',
+    interval_count: 6,
+  },
+  Anual: {
+    interval: 'year',
+    interval_count: 1,
+  },
+};
+
+const createSubscription = async (params, appData, storeId, plan, customer) => {
+  const pagarmeAxios = axios(appData.pagarme_api_token);
+
+  const orderId = params.order_id;
+  const { amount, items } = params;
+
+  const paymentMethod = paymentMethods[params.payment_method.code] || 'credit_card';
+
+  const intervalPlan = parseIntervalPlan[plan.periodicity];
+
+  const statementDescriptor = appData.soft_descriptor || params?.domain
+    .replace('www.', '')
+    .replace('https://', '')
+    .split('.')[0] || '*';
+
+  const pagarmeSubscription = {
+    code: orderId,
+    payment_method: paymentMethod,
+    currency: 'BRL',
+    interval: intervalPlan.interval || 'month',
+    interval_count: intervalPlan.interval_count || 1,
+    billing_type: 'prepaid', //
+    customer,
+    statement_descriptor: (`Assinatura ${statementDescriptor}`).substring(13),
+  };
+
+  pagarmeSubscription.metada = {
+    order_number: params.order_number,
+    store_id: storeId,
+    order_id: orderId,
+    platform_integration: 'ecomplus',
+  };
+
+  if (paymentMethod === 'credit_card') {
+    pagarmeSubscription.card_token = params.credit_card.hash;
+    const address = parseAddress(params.to || params.billing_address);
+    pagarmeSubscription.card = {
+      billing_address: address,
+    };
+  }
+
+  pagarmeSubscription.discounts = [];
+  pagarmeSubscription.items = [];
+
+  items.forEach(async (item) => {
+    if (item.quantity > 0) {
+      const itemSubscription = {
+        name: item.name || item.variation_id || item.product_id,
+        quantity: item.quantity,
+        description: item.name || item.variation_id || item.product_id,
+        id: `pi_${item.sku}`,
+        status: 'active',
+        pricing_scheme: {
+          scheme_type: 'unit',
+          price: Math.floor((item.final_price || item.price) * 100),
+        },
+      };
+      // if the item is a bonus, create a discount for repeat one time
+      if (
+        item.flags && (item.flags.includes('freebie')
+          || item.flags.includes('discount-set-free'))
+      ) {
+        itemSubscription.cycles = 1;
+      }
+
+      pagarmeSubscription.items.push(itemSubscription);
+    }
+  });
+
+  if (amount.freight) {
+    const itemFreight = {
+      name: 'Frete',
+      quantity: 1,
+      description: 'Frete',
+      id: `pi_freight_${orderId}`,
+      status: 'active',
+      pricing_scheme: {
+        scheme_type: 'unit',
+        price: Math.floor((amount.freight).toFixed(2) * 1000) / 10,
+      },
+    };
+    pagarmeSubscription.items.push(itemFreight);
+  }
+
+  // console.log('>> amount ', JSON.stringify(amount))
+  // Add once discont, but webhook invoce check discount plan
+  const discountSubscription = amount.discount && {
+    value: `${Math.floor((amount.discount).toFixed(2) * 1000) / 10}`,
+    discount_type: 'flat',
+    cycles: 1,
+  };
+
+  if (discountSubscription) {
+    pagarmeSubscription.discounts.push(discountSubscription);
+  }
+
+  logger.log('[PagarMe V5] Subscription: ', JSON.stringify(pagarmeSubscription));
+
+  return pagarmeAxios.post(
+    '/subscriptions',
+    pagarmeSubscription,
+  );
+};
+
+const createPayment = async (params, appData, customer) => {
+  const pagarmeAxios = axios(appData.pagarme_api_token);
+
+  const { amount, items } = params;
+
+  const address = parseAddress(params.to || params.billing_address);
+
+  logger.log('[PagarMe V5] Try payment');
+  let discountEach;
+  if (amount.discount) {
+    const quantityItems = items.reduce((acumulador, item) => {
+      return acumulador + (item.quantity || 0);
+    }, 0);
+    discountEach = amount.discount / quantityItems;
+  }
+
+  const paymentMethod = paymentMethods[params.payment_method.code] || 'credit_card';
+  const methodConfig = appData[params.payment_method.code];
+
+  const statementDescriptor = appData.soft_descriptor || params?.domain
+    .replace('www.', '')
+    .replace('https://', '')
+    .split('.')[0] || '*';
+
+  const pagarmeOrder = { customer };
+
+  const phone = customer.phones[0];
+  if (amount.freight) {
+    pagarmeOrder.shipping = {
+      amount: Math.floor((amount.freight) * 100),
+      description: 'Frete',
+      recipient_name: customer.name,
+      recipient_phone: `${phone?.area_code || ''}${phone?.number}`,
+      address,
+    };
+  }
+
+  if (params.browser_ip) {
+    pagarmeOrder.ip = params.browser_ip;
+  }
+
+  pagarmeOrder.items = [];
+
+  items.forEach(async (item) => {
+    if (item.quantity > 0) {
+      const itemOrder = {
+        quantity: item.quantity,
+        description: item.name || item.variation_id || item.product_id,
+        code: item.sku || item.variation_id || item.product_id,
+        amount: Math.floor(((item.final_price || item.price) - (discountEach || 0)) * 100),
+      };
+      pagarmeOrder.items.push(itemOrder);
+    }
+  });
+
+  const payment = {
+    payment_method: paymentMethod,
+    amount: Math.floor((amount.total)) * 100,
+  };
+
+  if (paymentMethod === 'credit_card') {
+    payment.credit_card = {
+      operation_type: 'auth_and_capture', // auth_only
+      installments: params.installments_number || 1,
+      statement_descriptor: statementDescriptor.substring(13),
+      card_token: params.credit_card.hash,
+      card: {
+        billing_address: address,
+      },
+    };
+  } else if (paymentMethod === 'pix') {
+    payment.pix = {
+      expires_in: (methodConfig.due_time || 60) * 60,
+    };
+  } else {
+    payment.boleto = {
+      due_at: new Date(new Date().getTime()
+        + ((methodConfig.days_due_date || 1) * 24 * 60 * 60 * 1000)).toISOString(),
+      instructions: methodConfig.instructions || statementDescriptor,
+      billing_address: address,
+    };
+  }
+
+  pagarmeOrder.payments = [payment];
+
+  logger.log('[PagarMe V5] Order PagarMe: ', JSON.stringify(pagarmeOrder));
+
+  return pagarmeAxios.post(
+    '/orders',
+    pagarmeOrder,
+  );
+};
+
+export {
+  createSubscription,
+  createPayment,
+};

package/lib-mjs/functions-lib/payments/add-installments.mjs

@@ -0,0 +1,45 @@
+export default (amount, response, installments = {}, gateway = {}) => {
+  const maxInterestFree = installments.max_interest_free;
+  const minInstallment = installments.min_installment || 5;
+  const qtyPosssibleInstallment = Math.floor((amount.total / minInstallment));
+  const maxInstallments = installments.max_number
+    || (qtyPosssibleInstallment < 12 ? qtyPosssibleInstallment : 12);
+  const monthlyInterest = installments.monthly_interest || 0;
+
+  if (maxInstallments > 1) {
+    if (response) {
+      response.installments_option = {
+        min_installment: minInstallment,
+        max_number: maxInterestFree > 1 ? maxInterestFree : maxInstallments,
+        monthly_interest: maxInterestFree > 1 ? 0 : monthlyInterest,
+      };
+    }
+
+    const isInterestFreeMinAmount = installments.interest_free_min_amount
+      && amount.total >= (installments.interest_free_min_amount);
+
+    // list installment options
+    gateway.installment_options = [];
+    for (let number = 2; number <= maxInstallments; number++) {
+      const tax = !(maxInterestFree >= number);
+      let interest;
+      if (tax || !isInterestFreeMinAmount) {
+        interest = monthlyInterest / 100;
+      }
+      let value;
+      if ((!tax && isInterestFreeMinAmount) || !interest) {
+        value = amount.total / number;
+      } else {
+        value = amount.total * (interest / (1 - (1 + interest) ** -number));
+      }
+      if (value && value >= 1) {
+        gateway.installment_options.push({
+          number,
+          value,
+          tax: tax || !isInterestFreeMinAmount,
+        });
+      }
+    }
+  }
+  return { response, gateway };
+};

package/lib-mjs/list-pagarme5-payments.mjs

@@ -0,0 +1,218 @@
+import path from 'path';
+import fs from 'fs';
+import url from 'node:url';
+import logger from 'firebase-functions/logger';
+import api from '@cloudcommerce/api';
+import addInstallments from './functions-lib/payments/add-installments.mjs';
+import { discountPlanPayment } from './functions-lib/pagarme/handle-plans.mjs';
+
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
+export default async (data) => {
+  const { application, params } = data;
+  const { items } = params;
+
+  const configApp = {
+    ...application.data,
+    ...application.hidden_data,
+  };
+
+  if (!process.env.PAGARMEV5_PUBLIC_KEY) {
+    const pagarmePublicKey = configApp.pagarme_public_key;
+    if (pagarmePublicKey && typeof pagarmePublicKey === 'string') {
+      process.env.PAGARMEV5_PUBLIC_KEY = pagarmePublicKey;
+    } else {
+      logger.warn('Missing PAGARMEV5 PUBLIC KEY');
+    }
+  }
+
+  if (!process.env.PAGARMEV5_API_TOKEN) {
+    const pagarmeApiKey = configApp.pagarme_api_token;
+    if (pagarmeApiKey && typeof pagarmeApiKey === 'string') {
+      process.env.PAGARMEV5_API_TOKEN = pagarmeApiKey;
+    } else {
+      logger.warn('Missing PAGARMEV5 API TOKEN');
+    }
+  }
+
+  if (!process.env.PAGARMEV5_API_TOKEN || !process.env.PAGARMEV5_PUBLIC_KEY) {
+    return {
+      error: 'NO_PAGARMEV5_KEYS',
+      message: 'Chave de API e/ou criptografia não configurada (lojista deve configurar o aplicativo)',
+    };
+  }
+
+  const categoryIds = configApp.recurrency_category_ids;
+  let hasRecurrence = false;
+  let isAllRecurring = true;
+
+  if (categoryIds.length) {
+    try {
+      const { data: { result } } = await api.get('search/v1', {
+        limit: items.length,
+        params: {
+          _id: items.map((item) => item.product_id),
+          'categories._id': categoryIds,
+        },
+      });
+
+      hasRecurrence = result.length > 0;
+      isAllRecurring = result.length === items.length;
+    } catch (err) {
+      logger.error(err);
+    }
+  }
+
+  const response = {
+    payment_gateways: [],
+  };
+
+  const paymentTypes = [];
+  if ((isAllRecurring) && configApp.recurrence && configApp.recurrence.length
+    && configApp.recurrence[0].label) {
+    paymentTypes.push('recurrence');
+  }
+
+  if ((!hasRecurrence) && (!configApp.credit_card.disable || !configApp.banking_billet.disable
+    || !configApp.account_deposit.disable)) {
+    paymentTypes.push('payment');
+  }
+
+  // setup payment gateway objects
+  const intermediator = {
+    name: 'Pagar.me',
+    link: 'https://pagar.me/',
+    code: 'pagarme',
+  };
+
+  const listPaymentMethod = ['credit_card', 'banking_billet'];
+
+  if (!configApp.account_deposit?.disable) {
+    listPaymentMethod.push('account_deposit');
+  }
+
+  paymentTypes.forEach((type) => {
+    // At first the occurrence only with credit card
+    const isRecurrence = type === 'recurrence';
+    const plans = isRecurrence ? configApp.recurrence : ['single_payment'];
+    plans.forEach((plan) => {
+      listPaymentMethod.forEach((paymentMethod) => {
+        // console.log('>> List Payments ', type, ' ', plan, ' ', paymentMethod)
+        const amount = { ...params.amount } || {};
+        const isCreditCard = paymentMethod === 'credit_card';
+        const isPix = paymentMethod === 'account_deposit';
+        const methodConfig = configApp[paymentMethod] || {};
+        let methodEnable = isRecurrence ? methodConfig.enable_recurrence : !methodConfig.disable;
+
+        // Pix not active in recurrence
+        methodEnable = isPix && isRecurrence ? false : methodEnable;
+
+        const minAmount = methodConfig?.min_amount || 0;
+        const validateAmount = amount.total
+          ? (amount.total >= minAmount) : true; // Workaround for showcase
+        if (methodEnable && validateAmount) {
+          let label = isRecurrence ? plan.label : methodConfig.label;
+          if (!label) {
+            if (isCreditCard) {
+              label = 'Cartão de crédito';
+            } else {
+              label = !isPix ? 'Boleto bancário' : 'Pix';
+            }
+          }
+          const gateway = {
+            label,
+            icon: methodConfig.icon,
+            text: methodConfig.text,
+            payment_method: {
+              code: paymentMethod,
+              name: `${isRecurrence ? `Assinatura ${plan.periodicity} ` : ''}`
+                + `${label} - ${intermediator.name}`,
+            },
+            type,
+            intermediator,
+          };
+
+          let discount;
+          if (isRecurrence) {
+            discount = discountPlanPayment(label, plan, amount);
+          } else {
+            discount = configApp.discount;
+          }
+
+          if (discount) {
+            if (isRecurrence) {
+              gateway.discount = !plan.discount_first_installment?.disable
+                ? plan.discount_first_installment : plan.discount;
+              gateway.discount.type = discount.discountOption.type;
+              response.discount_option = discount.discountOption;
+            } else if (discount[paymentMethod]) {
+              gateway.discount = {
+                apply_at: discount.apply_at,
+                type: discount.type,
+                value: discount.value,
+              };
+
+              // check amount value to apply discount
+              if (amount.total < (discount.min_amount || 0)) {
+                delete gateway.discount;
+              } 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) {
+                  amount.discount = (amount.discount || 0) + discountValue;
+                  amount.total -= discountValue;
+                  if (amount.total < 0) {
+                    amount.total = 0;
+                  }
+                }
+              }
+              if (response.discount_option) {
+                response.discount_option.min_amount = discount.min_amount;
+              }
+            }
+          }
+
+          if (isCreditCard) {
+            if (!gateway.icon) {
+              // gateway.icon = `${hostingUri}/credit-card.png`;
+            }
+            // https://github.com/pagarme/pagarme-js
+            gateway.js_client = {
+              script_uri: 'https://checkout.pagar.me/v1/tokenizecard.js',
+              onload_expression: `window._pagarmeKey="${process.env.PAGARMEV5_PUBLIC_KEY}";`
+                + fs.readFileSync(path.join(__dirname, '../assets/onload-expression.min.js'), 'utf8'),
+              cc_hash: {
+                function: '_pagarmeHash',
+                is_promise: true,
+              },
+            };
+            if (!isRecurrence) {
+              const { installments } = configApp;
+              if (installments) {
+                // list all installment options and default one
+                addInstallments(amount, response, installments, gateway);
+              }
+            }
+          }
+          response.payment_gateways.push(gateway);
+        }
+      });
+    });
+  });
+
+  return response;
+};