cloudcommerce 0.0.133 → 0.1.0

package/packages/apps/galaxpay/src/functions-lib/ecom/events-to-galaxpay.ts

@@ -0,0 +1,85 @@
+import type { ApiEventHandler } from '@cloudcommerce/firebase/lib/helpers/pubsub';
+import type { Orders } from '@cloudcommerce/types';
+import logger from 'firebase-functions/logger';
+import { getFirestore } from 'firebase-admin/firestore';
+import config from '@cloudcommerce/firebase/lib/config';
+import GalaxpayAxios from '../galaxpay/auth/create-access';
+
+const collectionSubscription = getFirestore().collection('subscriptions');
+
+const handleApiEvent: ApiEventHandler = async ({
+  evName,
+  apiEvent,
+  apiDoc,
+  app,
+}) => {
+  const resourceId = apiEvent.resource_id;
+  logger.info('>> ', resourceId, ' - Action: ', apiEvent.action);
+  const key = `${evName}_${resourceId}`;
+  const appData = { ...app.data, ...app.hidden_data };
+  if (
+    Array.isArray(appData.ignore_events)
+    && appData.ignore_events.includes(evName)
+  ) {
+    logger.info('>> ', key, ' - Ignored event');
+    return null;
+  }
+  logger.info(`> Webhook ${resourceId} [${evName}] => ${apiDoc}`);
+  const galaxpayAxios = new GalaxpayAxios({
+    galaxpayId: appData.galaxpay_id,
+    galaxpayHash: appData.galaxpay_hash,
+  });
+
+  await galaxpayAxios.preparing;
+  const { axios } = galaxpayAxios;
+  if (axios) {
+    if (evName === 'orders-cancelled') {
+      const order = apiDoc as Orders;
+
+      if (!order.subscription_order) {
+        const documentSnapshot = await collectionSubscription.doc(order._id).get();
+        if (documentSnapshot && documentSnapshot.exists) {
+          const docSubscription = documentSnapshot.data();
+          if (docSubscription) {
+            const { status } = docSubscription.data();
+            if (status !== 'cancelled') {
+              try {
+                await axios.delete(`/subscriptions/${order._id}/myId`);
+                await collectionSubscription.doc(order._id)
+                  .set({
+                    status: 'cancelled',
+                    updatedAt: new Date().toISOString(),
+                  }, { merge: true })
+                  .catch(logger.error);
+              } catch (err: any) {
+                const statusCode = err.response?.status;
+                if (statusCode === 404) {
+                  logger.warn('> (App:GalaxPay): Subscription not found in GalaxPay');
+                  return null;
+                }
+                if (statusCode === 401 || statusCode === 403) {
+                  logger.warn('> (App:GalaxPay): Unauthorized subscription deletion request');
+                  return null;
+                }
+                throw err;
+              }
+            }
+          }
+          logger.warn('> (App:GalaxPay): Subscription not fount in Firestore');
+        }
+      }
+      return null;
+    }
+    const locationId = config.get().httpsFunctionOptions.region;
+    const webhookUrl = `https://${locationId}-${process.env.GCLOUD_PROJECT}.cloudfunctions.net/galapay-webhook`;
+
+    return axios.put('/webhooks', {
+      url: webhookUrl,
+      events: ['subscription.addTransaction', 'transaction.updateStatus'],
+    });
+  }
+  logger.warn('> (App GalaxPay) Access not found');
+  return null;
+};
+
+export default handleApiEvent;

package/packages/apps/galaxpay/src/functions-lib/galaxpay/auth/create-access.ts

@@ -0,0 +1,80 @@
+import type { AxiosInstance } from 'axios';
+import { getFirestore } from 'firebase-admin/firestore';
+import logger from 'firebase-functions/logger';
+import { isSandbox } from '../../utils';
+import gerateAccessToken from './gerate-token';
+import createAxios from './create-axios';
+
+const { GALAXPAY_PARTNER_ID, GALAXPAY_PARTNER_HASH } = process.env;
+
+const firestoreColl = 'galaxpayTokens';
+
+type Option = {
+  galaxpayId: string;
+  galaxpayHash: string;
+}
+
+export default class GalaxPay {
+  preparing: Promise<unknown>;
+  axios: AxiosInstance | undefined;
+
+  constructor(options: Option) {
+    const {
+      galaxpayId,
+      galaxpayHash,
+    } = options;
+
+    const self = this;
+
+    let documentRef;
+    const hashLogin = Buffer.from(`${galaxpayId}:${galaxpayHash}`).toString('base64');
+
+    if (firestoreColl) {
+      documentRef = getFirestore()
+        .doc(`${firestoreColl}/${hashLogin}`);
+    }
+
+    let galaxpayPartnerHash: string | undefined;
+
+    if (GALAXPAY_PARTNER_ID && GALAXPAY_PARTNER_HASH) {
+      galaxpayPartnerHash = Buffer.from(`${GALAXPAY_PARTNER_ID}:${GALAXPAY_PARTNER_HASH}`).toString('base64');
+    }
+
+    this.preparing = new Promise((resolve, reject) => {
+      const authenticate = (token: string) => {
+        self.axios = createAxios(token, isSandbox);
+        resolve(self);
+      };
+
+      const handleAuth = () => {
+        logger.log('>(App Galaxpay) Auth02 ');
+        gerateAccessToken(hashLogin, isSandbox, galaxpayPartnerHash)
+          .then((accessToken) => {
+            // logger.log(`>(App Galaxpay) ${hashLogin}: ${accessToken}`);
+            authenticate(accessToken as string);
+            if (documentRef) {
+              documentRef.set({ accessToken }).catch(logger.error);
+            }
+          })
+          .catch(reject);
+      };
+
+      if (documentRef) {
+        documentRef.get()
+          .then((documentSnapshot) => {
+            if (documentSnapshot.exists
+              && Date.now() - documentSnapshot.updateTime.toDate().getTime()
+              <= 9 * 60 * 1000 // access token expires in 10 minutes
+            ) {
+              authenticate(documentSnapshot.get('accessToken'));
+            } else {
+              handleAuth();
+            }
+          })
+          .catch(logger.error);
+      } else {
+        handleAuth();
+      }
+    });
+  }
+}

package/packages/apps/galaxpay/src/functions-lib/galaxpay/auth/create-axios.ts

@@ -0,0 +1,21 @@
+import axios from 'axios';
+// import logger from 'firebase-functions/logger';
+
+export default (accessToken: string | undefined | null, isSandbox?: boolean) => {
+  // https://docs.galaxpay.com.br/autenticacao
+  // https://docs.galaxpay.com.br/auth/token
+
+  const headers = {
+    'Content-Type': 'application/json',
+  };
+  if (accessToken) {
+    // logger.log('>(App GalaxPay) token: ', accessToken);
+    Object.assign(headers, { Authorization: `Bearer ${accessToken}` });
+    Object.assign(headers, { 'Accept-Encoding': 'gzip,deflate,compress' });
+  }
+
+  return axios.create({
+    baseURL: `https://api.${isSandbox ? 'sandbox.cloud.' : ''}galaxpay.com.br/v2`,
+    headers,
+  });
+};

package/packages/apps/galaxpay/src/functions-lib/galaxpay/auth/gerate-token.ts

@@ -0,0 +1,36 @@
+// import logger from 'firebase-functions/logger';
+import Axios from './create-axios';
+
+const gereteToken = (
+  hashLogin: string,
+  isSandbox?: boolean,
+  galaxpayPartnerHash?: string,
+) => new Promise((resolve, reject) => {
+  // https://docs.galaxpay.com.br/autenticacao
+  // https://docs.galaxpay.com.br/auth/token
+
+  const axios = Axios(null, isSandbox);
+  const request = (isRetry?: boolean) => {
+    const headers = { Authorization: `Basic ${hashLogin}` };
+    if (!isSandbox && galaxpayPartnerHash) {
+      // logger.log('#AuthorizationPartner ');
+      Object.assign(headers, { AuthorizationPartner: galaxpayPartnerHash });
+    }
+    axios.post('/token', {
+      grant_type: 'authorization_code',
+      scope: 'customers.read customers.write plans.read plans.write transactions.read transactions.write webhooks.write cards.read cards.write card-brands.read subscriptions.read subscriptions.write charges.read charges.write boletos.read',
+    }, { headers })
+      .then(({ data }) => {
+        resolve(data.access_token);
+      })
+      .catch((err) => {
+        if (!isRetry && err.response && err.response.status >= 429) {
+          setTimeout(() => request(true), 700);
+        }
+        reject(err);
+      });
+  };
+  request();
+});
+
+export default gereteToken;

package/packages/apps/galaxpay/src/functions-lib/galaxpay/handle-plans.ts

@@ -0,0 +1,92 @@
+import type { GalaxpayApp } from '../../../types/config-app';
+// import type { ListPaymentsResponse } from '@cloudcommerce/types/modules/list_payments:response';
+import type { ListPaymentsParams } from '@cloudcommerce/types/modules/list_payments:params';
+
+// type Gateway = ListPaymentsResponse['payment_gateways'][number]
+
+const handleGateway = (appData: GalaxpayApp) => {
+  const plans: Exclude<GalaxpayApp['plans'], undefined> = [];
+  if (appData.plans) {
+    // Newer versions of the app will have a list of plans
+    appData.plans.forEach((plan) => {
+      plans.push(plan);
+    });
+  }
+
+  return plans;
+};
+
+// for create-transaction
+const findPlanToCreateTransction = (label: string | undefined, appData: GalaxpayApp) => {
+  let sendPlan: Exclude<GalaxpayApp['plans'], undefined>[number] | undefined;
+  if (appData.plans) {
+    /*
+    More recent versions of the application will have a list of plans,
+    where it will be necessary to find the plan by name,
+    and return it since it will be necessary to use the periodicity and quantity property
+    */
+
+    // find plan by name (label)
+    appData.plans.forEach((plan) => {
+      // if the name of the plan is blank, on the list-payments side it is set to 'Plano'
+      let planLabel = plan.label || 'Plano';
+      planLabel = `${planLabel} ${plan.periodicity}`;
+      label = label?.trim();
+      if (label === planLabel) {
+        sendPlan = plan;
+      }
+    });
+  }
+  return sendPlan;
+};
+
+const discountPlan = (
+  planDiscount: Exclude<GalaxpayApp['plans'], undefined>[number]['discount'],
+  amount: Exclude<ListPaymentsParams['amount'], undefined>,
+) => {
+  if (planDiscount && planDiscount.value > 0) {
+    // default discount option
+    const discountOption = {
+      value: planDiscount.value,
+      apply_at: (planDiscount.apply_at === 'frete' ? 'freight' : planDiscount) as 'total' | 'subtotal' | 'freight',
+      type: planDiscount.percentage ? 'percentage' : 'fixed' as 'percentage' | 'fixed' | undefined,
+    };
+
+    if (amount.total) {
+      // check amount value to apply discount
+      if (planDiscount.min_amount && amount.total < planDiscount.min_amount) {
+        planDiscount.value = 0;
+      } else {
+        delete planDiscount.min_amount;
+
+        const maxDiscount = amount[discountOption.apply_at || 'subtotal'];
+        let discountValue: number | undefined;
+
+        if (maxDiscount && discountOption.type === 'percentage') {
+          discountValue = (maxDiscount * planDiscount.value) / 100;
+        } else {
+          discountValue = planDiscount.value;
+          if (maxDiscount && discountValue > maxDiscount) {
+            discountValue = maxDiscount;
+          }
+        }
+
+        if (discountValue && discountValue > 0) {
+          amount.discount = (amount.discount || 0) + discountValue;
+          amount.total -= discountValue;
+          if (amount.total < 0) {
+            amount.total = 0;
+          }
+        }
+      }
+    }
+    return discountOption;
+  }
+  return null;
+};
+
+export {
+  handleGateway,
+  findPlanToCreateTransction,
+  discountPlan,
+};

package/packages/apps/galaxpay/src/functions-lib/galaxpay/update-subscription.ts

@@ -0,0 +1,73 @@
+import type { Orders, Applications } from '@cloudcommerce/types';
+import GalaxpayAxios from './auth/create-access';
+
+const checkAmountItemsOrder = (
+  amount: Orders['amount'],
+  items: Exclude<Orders['items'], undefined>,
+  plan: { [x: string]: any },
+) => {
+  let subtotal = 0;
+  let item: Exclude<Orders['items'], undefined>[number];
+  for (let i = 0; i < items.length; i++) {
+    item = items[i];
+    if (item.flags && (item.flags.includes('freebie') || item.flags.includes('discount-set-free'))) {
+      items.splice(i, 1);
+    } else {
+      subtotal += item.quantity * (item.final_price || item.price);
+    }
+  }
+  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.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
+  if (plan) {
+    amount.discount = (plan.discount && !plan.discount.percentage
+      ? plan.discount.value : planDiscount) || 0;
+  }
+  if (amount.discount) {
+    amount.total -= amount.discount;
+  }
+  const total: any = amount.total - (amount.discount || 0); // BUG :(
+  return Math.floor(total.toFixed(2) * 100);
+};
+
+const updateValueSubscription = (
+  appData: Applications,
+  subscriptionId: string,
+  amount: Orders['amount'],
+  items: Exclude<Orders['items'], undefined>,
+  plan: { [x: string]: any },
+  // GalaxPaySubscription: { [x: string]: any },
+) => {
+  const value = checkAmountItemsOrder({ ...amount }, [...items], { ...plan });
+
+  return new Promise((resolve, reject) => {
+    const galaxpayAxios = new GalaxpayAxios({
+      galaxpayId: appData.hidden_data?.galaxpay_id,
+      galaxpayHash: appData.hidden_data?.galaxpay_hash,
+    });
+
+    galaxpayAxios.preparing
+      .then(async () => {
+        if (galaxpayAxios.axios) {
+          const { data } = await galaxpayAxios.axios.put(`subscriptions/${subscriptionId}/myId`, { value });
+          if (data.type) {
+            resolve(true);
+          }
+        }
+      }).catch((err) => {
+        reject(err);
+      });
+  });
+};
+
+export {
+  updateValueSubscription,
+  checkAmountItemsOrder,
+};