cloudcommerce 0.1.0 → 0.1.2

package/packages/apps/loyalty-points/lib/loyalty-points.js

@@ -0,0 +1,12 @@
+import '@cloudcommerce/firebase/lib/init';
+import handleListPayments from './loyalty-list-payments.js';
+import handleCreateTransaction from './loyalty-create-transaction.js';
+
+export const listPayments = async (modBody) => {
+  return handleListPayments(modBody);
+};
+
+export const createTransaction = async (modBody) => {
+  return handleCreateTransaction(modBody);
+};
+// # sourceMappingURL=loyalty-points.js.map

package/packages/apps/loyalty-points/lib/loyalty-points.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loyalty-points.js","sourceRoot":"","sources":["../src/loyalty-points.ts"],"names":[],"mappings":"AAAA,OAAO,kCAAkC,CAAC;AAE1C,OAAO,kBAAkB,MAAM,yBAAyB,CAAC;AACzD,OAAO,uBAAuB,MAAM,8BAA8B,CAAC;AAEnE,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,EAAE,OAAsB,EAAE,EAAE;IAC3D,OAAO,kBAAkB,CAAC,OAAO,CAAC,CAAC;AACrC,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,KAAK,EAAE,OAAsB,EAAE,EAAE;IAChE,OAAO,uBAAuB,CAAC,OAAO,CAAC,CAAC;AAC1C,CAAC,CAAC"}

package/packages/apps/loyalty-points/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@cloudcommerce/app-loyalty-points",
+  "type": "module",
+  "version": "0.1.2",
+  "description": "E-Com Plus Cloud Commerce app to handle simple loyalty points programs",
+  "main": "lib/loyalty-points.js",
+  "exports": {
+    ".": "./lib/loyalty-points.js",
+    "./events": "./lib/loyalty-points-events.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ecomplus/cloud-commerce.git",
+    "directory": "packages/loyalty-points"
+  },
+  "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/loyalty-points#readme",
+  "scripts": {
+    "build": "sh ../../../scripts/build-lib.sh"
+  },
+  "dependencies": {
+    "@cloudcommerce/api": "workspace:*",
+    "@cloudcommerce/firebase": "workspace:*"
+  },
+  "devDependencies": {
+    "@cloudcommerce/types": "workspace:*"
+  }
+}

package/packages/apps/loyalty-points/src/functions-lib/get-program-id.ts

@@ -0,0 +1,23 @@
+export default (
+  programRule: { program_id: string; name: string; },
+  index: number,
+) => {
+  let programId = `lpt__${index}`;
+  if (programRule.program_id) {
+    programId = programRule.program_id;
+  } else if (programRule.name && typeof programRule.name === 'string') {
+    programId = (`p0_${programRule.name.toLowerCase()}`)
+      .replace(/\n\s/g, '_')
+      .replace(/__/g, '_')
+      .replace(/áàãâ/g, 'a')
+      .replace(/éê/g, 'e')
+      .replace(/óõô/g, 'o')
+      .replace(/í/g, 'e')
+      .replace(/ú/g, 'u')
+      .replace(/ç/g, 'c')
+      .replace(/[^a-z0-9_]/g, '')
+      .substring(0, 30);
+  }
+
+  return programId;
+};

package/packages/apps/loyalty-points/src/functions-lib/handle-loyalty-points-event.ts

@@ -0,0 +1,207 @@
+import type { Orders, Customers } from '@cloudcommerce/types';
+import api from '@cloudcommerce/api';
+import { getFirestore } from 'firebase-admin/firestore';
+import logger from 'firebase-functions/logger';
+import getProgramId from './get-program-id';
+
+const ECHO_SUCCESS = 'SUCCESS';
+const ECHO_SKIP = 'SKIP';
+
+type UsedPointsEntries = Exclude<Customers['loyalty_points_entries'], undefined>[number]
+  & { original_active_points: number }
+
+const responsePubSub = (response: string) => {
+  logger.log('(App: Loyalty Points): ', response);
+  return null;
+};
+
+const haveEarnedPoints = (pointsList: Customers['loyalty_points_entries'], orderId: string) => {
+  if (pointsList) {
+    let hasEarned = false;
+    for (let i = 0; i < pointsList.length; i++) {
+      const point = pointsList[i];
+      if (point.order_id === orderId) {
+        hasEarned = true;
+        break;
+      }
+    }
+    return hasEarned;
+  }
+  return false;
+};
+
+const findPointIndex = (pointsList: Customers['loyalty_points_entries'], pointEntry: UsedPointsEntries) => {
+  if (pointsList) {
+    for (let i = 0; i < pointsList.length; i++) {
+      const point = pointsList[i];
+      if (point.name === pointEntry.name) {
+        return i;
+      }
+    }
+  }
+  return null;
+};
+
+const handleLoyaltyPointsEvent = async (
+  order: Orders,
+  programRules: any[],
+) => {
+  const orderId = order._id;
+  const currentStatus = order.financial_status && order.financial_status.current;
+  let isPaid: boolean = false;
+  let isCancelled: boolean = false;
+
+  switch (currentStatus) {
+    case 'paid':
+      isPaid = true;
+      break;
+    case 'unauthorized':
+    case 'partially_refunded':
+    case 'refunded':
+    case 'voided':
+      isCancelled = true;
+      break;
+    case 'partially_paid':
+      if (order.transactions) {
+        order.transactions.forEach((transaction) => {
+          if (transaction.payment_method.code !== 'loyalty_points' && transaction.status) {
+            switch (transaction.status.current) {
+              case 'unauthorized':
+              case 'refunded':
+              case 'voided':
+                isCancelled = true;
+                break;
+              default:
+                break;
+            }
+          }
+        });
+      }
+      break;
+    default:
+      break;
+  }
+
+  try {
+    if (isPaid || isCancelled) {
+      // get app configured options
+      const { amount, buyers } = order;
+      const customerId = buyers && buyers[0] && buyers[0]._id;
+      if (customerId) {
+        const pointsList: Customers['loyalty_points_entries'] = (await api.get(
+          `customers/${customerId}/loyalty_points_entries`,
+        )
+        ).data;
+
+        if (pointsList) {
+          const hasEarnedPoints = haveEarnedPoints(pointsList, orderId);
+
+          if (isPaid && !hasEarnedPoints) {
+            for (let i = 0; i < programRules.length; i++) {
+              const rule = programRules[i];
+              if (amount.subtotal) {
+                if (!rule.min_subtotal_to_earn || rule.min_subtotal_to_earn <= amount.subtotal) {
+                  const pointsValue = ((rule.earn_percentage || 1) / 100)
+                    * (amount.subtotal - (amount.discount || 0));
+
+                  let validThru: string | undefined;
+                  if (rule.expiration_days > 0) {
+                    const d = new Date();
+                    d.setDate(d.getDate() + rule.expiration_days);
+                    validThru = d.toISOString();
+                  }
+
+                  const data = {
+                    name: rule.name,
+                    program_id: getProgramId(rule, i),
+                    earned_points: pointsValue,
+                    active_points: pointsValue,
+                    ratio: rule.ratio || 1,
+                    valid_thru: validThru,
+                    order_id: orderId,
+                  } as any; // TODO: set the correct type
+
+                  // eslint-disable-next-line no-await-in-loop
+                  await api.post(`customers/${customerId}/loyalty_points_entries`, data);
+
+                  return responsePubSub(ECHO_SUCCESS);
+                }
+              }
+            }
+          }
+
+          if (isCancelled && hasEarnedPoints) {
+            for (let i = 0; i < pointsList.length; i++) {
+              if (pointsList[i].order_id === orderId) {
+                // eslint-disable-next-line no-await-in-loop
+                await api.delete(`customers/${customerId}/loyalty_points_entries/${i}`);
+              }
+            }
+
+            return responsePubSub(ECHO_SUCCESS);
+          }
+        }
+
+        if (isCancelled) {
+          const documentRef = getFirestore().doc(`billedPoints/${orderId}`);
+          const documentSnapshot = await documentRef.get();
+
+          if (documentSnapshot.exists) {
+            const usedPointsEntries = documentSnapshot.get('usedPointsEntries') as UsedPointsEntries[];
+            documentRef.delete();
+
+            if (Array.isArray(usedPointsEntries)) {
+              for (let i = 0; i < usedPointsEntries.length; i++) {
+                const pointsEntry = usedPointsEntries[i];
+                const pointsToRefund = pointsEntry.original_active_points
+                  - pointsEntry.active_points;
+                if (pointsToRefund > 0) {
+                  const pointIndex = findPointIndex(pointsList, pointsEntry);
+
+                  if (pointIndex && pointsList) {
+                    const activePoints = pointsList[pointIndex].active_points;
+                    const body = {
+                      active_points: activePoints + pointsToRefund,
+                    };
+
+                    // eslint-disable-next-line no-await-in-loop
+                    await api.patch(
+                      `customers/${customerId}/loyalty_points_entries/${pointIndex}`,
+                      body,
+                    );
+
+                    return responsePubSub(ECHO_SUCCESS);
+                  }
+                }
+              }
+
+              const transaction = order.transactions
+                && order.transactions.find((transactionFound) => {
+                  return transactionFound.payment_method.code === 'loyalty_points';
+                });
+
+              if (transaction) {
+                const bodyPaymentHistory = {
+                  transaction_id: transaction._id,
+                  date_time: new Date().toISOString(),
+                  status: currentStatus?.startsWith('partially') ? 'refunded' : currentStatus,
+                  customer_notified: true,
+                } as any; // TODO: incompatible type=> amount and status
+
+                await api.post(`orders/${orderId}/payments_history`, bodyPaymentHistory);
+              }
+            }
+          }
+        }
+      }
+      return responsePubSub('');
+    }
+    // not paid nor cancelled
+    return responsePubSub(ECHO_SKIP);
+  } catch (err) {
+    logger.error('(App Loyalty Points) Error =>', err);
+    throw err;
+  }
+};
+
+export default handleLoyaltyPointsEvent;

package/packages/apps/loyalty-points/src/index.ts

@@ -0,0 +1 @@
+export * from './loyalty-points';

package/packages/apps/loyalty-points/src/loyalty-create-transaction.ts

@@ -0,0 +1,241 @@
+import type {
+  AppModuleBody,
+  CreateTransactionParams,
+  CreateTransactionResponse,
+  Customers,
+} from '@cloudcommerce/types';
+import api from '@cloudcommerce/api';
+import { getFirestore } from 'firebase-admin/firestore';
+import logger from 'firebase-functions/logger';
+import getProgramId from './functions-lib/get-program-id';
+
+type UsedPointsEntries = Exclude<Customers['loyalty_points_entries'], undefined>[number]
+  & { original_active_points: number }
+
+const collectionRef = getFirestore().collection('billedPoints');
+
+const updateTransactionStatus = (orderId: string) => {
+  setTimeout(async () => {
+    const order = (await api.get(`orders/${orderId}`)).data;
+
+    // appSdk.apiRequest(storeId, `/orders/${orderId}.json`).then(({ response }) => {
+    const { transactions } = order;
+    if (transactions) {
+      const transaction = transactions.find((transactionFound) => {
+        return transactionFound.payment_method.code === 'loyalty_points';
+      });
+      if (transaction) {
+        const bodyPaymentHistory = {
+          transaction_id: transaction._id,
+          date_time: new Date().toISOString(),
+          status: 'paid',
+          customer_notified: true,
+        } as any; // TODO: incompatible type=> amount and status;
+        await api.post(`orders/${orderId}/payments_history`, bodyPaymentHistory);
+      }
+    }
+  }, 500);
+};
+
+const handleUpdatedPoints = (
+  endpoint: any, // TODO: endpoint type not string compatible
+  body: { [x: string]: any },
+  orderId: string,
+  usedPointsEntries?: UsedPointsEntries[],
+  timeout = 400,
+  isLastRequest = false,
+) => {
+  setTimeout(async () => {
+    await api.patch(endpoint, body);
+    // appSdk.apiRequest(storeId, endpoint, 'PATCH', data).then(() => {
+    logger.log(`#(App Loyalty Points): ${orderId} ${endpoint} => ${JSON.stringify(body)}`);
+    if (isLastRequest) {
+      updateTransactionStatus(orderId);
+      collectionRef.doc(orderId).set({ usedPointsEntries });
+    }
+    // });
+  }, timeout);
+};
+
+export default async (appData: AppModuleBody) => {
+  const { application, storeId } = appData;
+  const params = appData.params as CreateTransactionParams;
+  // app configured options
+  const appConfig = { ...application.data, ...application.hidden_data };
+  const { lang, amount } = params;
+
+  // setup required `transaction` response object
+  const transaction: CreateTransactionResponse['transaction'] = {
+    amount: amount.total,
+  };
+
+  if (params.payment_method.code === 'loyalty_points') {
+    const pointsApplied = params.loyalty_points_applied;
+    const programsRules = appConfig.programs_rules;
+    if (pointsApplied && Array.isArray(programsRules) && programsRules.length) {
+      // for (const programId in pointsApplied) {
+      Object.keys(pointsApplied).forEach((programId) => {
+        const pointsValue = pointsApplied[programId];
+        if (pointsValue > 0) {
+          const programRule = programsRules.find((programRuleFound, index) => {
+            if (programRuleFound) {
+              programRuleFound.program_id = getProgramId(programRuleFound, index);
+              return programId === programRuleFound.program_id;
+            }
+            return false;
+          });
+
+          if (programRule) {
+            const ratio = programRule.ratio || 1;
+            transaction.loyalty_points = {
+              name: programRule.name,
+              program_id: programRule.program_id,
+              ratio,
+              points_value: programRule.max_points < pointsValue
+                ? programRule.max_points
+                : pointsValue,
+            };
+            transaction.amount = pointsValue * ratio;
+          }
+        }
+      });
+    }
+  }
+
+  if (transaction.amount) {
+    const loyaltyPoints = transaction.loyalty_points;
+    const customerId = params.buyer.customer_id;
+    const orderId = params.order_id as string;
+    const usedPointsEntries: UsedPointsEntries[] = [];
+    try {
+      const customer = (await api.get(`customers/${customerId}`)).data;
+      // return appSdk.apiRequest(storeId, `/customers/${customerId}.json`)
+      //   .then(({ response }) => {
+      const pointsEntries = customer.loyalty_points_entries;
+      let pointsToConsume = loyaltyPoints?.points_value;
+
+      if (pointsEntries && pointsToConsume) {
+        pointsEntries.sort((a, b) => {
+          let value = 0;
+          if (a.valid_thru && b.valid_thru) {
+            if (a.valid_thru < b.valid_thru) {
+              value = -1;
+            } else if (a.valid_thru > b.valid_thru) {
+              value = 1;
+            }
+          }
+          return value;
+        });
+
+        for (let i = 0; i < pointsEntries.length; i++) {
+          if (pointsToConsume <= 0) {
+            break;
+          }
+          const pointsEntry = pointsEntries[i];
+          if (pointsEntry.program_id === loyaltyPoints?.program_id) {
+            const validThru = pointsEntry.valid_thru;
+            const activePoints = pointsEntry.active_points;
+            if (activePoints > 0 && (!validThru || new Date(validThru).getTime() >= Date.now())) {
+              const pointsDiff = activePoints - pointsToConsume;
+              if (pointsDiff > 0 && pointsDiff < 0.01) {
+                pointsToConsume = activePoints;
+              }
+              if (pointsToConsume >= activePoints) {
+                pointsToConsume -= activePoints;
+                pointsEntry.active_points = 0;
+                if (pointsToConsume < 0.02) {
+                  pointsToConsume = 0;
+                }
+              } else {
+                pointsEntry.active_points -= pointsToConsume;
+                pointsToConsume = 0;
+              }
+              usedPointsEntries.push({
+                ...pointsEntry,
+                original_active_points: activePoints,
+              });
+            }
+          }
+        }
+
+        if (pointsToConsume <= 0) {
+          if (usedPointsEntries.length <= 3) {
+            usedPointsEntries.forEach((pointsEntry, i) => {
+              /* Obs:
+                Store api v2 => loyalty_points_entries do not have id,
+                but change can be done by index
+              */
+              const endpoint = `customers/${customerId}/loyalty_points_entries/${i}`;
+              const body = {
+                active_points: pointsEntry.active_points,
+              };
+              handleUpdatedPoints(
+                endpoint,
+                body,
+                orderId,
+                usedPointsEntries,
+                (i + 1) * 400,
+                i + 1 === usedPointsEntries.length,
+              );
+            });
+          } else {
+            const endpoint = `customers/${customerId}`;
+            const body = {
+              loyalty_points_entries: pointsEntries,
+            };
+            handleUpdatedPoints(endpoint, body, orderId, usedPointsEntries, 400, true);
+          }
+        }
+      }
+
+      transaction.status = {
+        current: pointsToConsume && pointsToConsume <= 0 ? 'authorized' : 'unauthorized',
+      };
+
+      return {
+        status: 200,
+        redirect_to_payment: false,
+        transaction,
+      };
+    } catch (error: any) {
+      // try to debug request error
+      const errCode = 'POINTS_TRANSACTION_ERR';
+      let { message } = error;
+      const err = {
+        message: `CREATE_TRANSACTION_ERR #${storeId} - ${orderId} => ${message}`,
+        payment: '',
+        status: 0,
+        response: '',
+        usedPointsEntries,
+      };
+
+      if (error.response) {
+        const { status, data } = error.response;
+        err.status = status;
+        if (status !== 401 && status !== 403) {
+          if (typeof data === 'object' && data) {
+            err.response = JSON.stringify(data);
+          } else {
+            err.response = data;
+          }
+        }
+        if (data && data.user_message) {
+          message = lang ? data.user_message[lang] : data.user_message.en_us;
+        }
+      }
+
+      logger.error(err);
+
+      return {
+        error: errCode,
+        message,
+      };
+    }
+  }
+
+  return {
+    status: 200,
+    redirect_to_payment: false,
+    transaction,
+  };
+};

package/packages/apps/loyalty-points/src/loyalty-list-payments.ts

@@ -0,0 +1,55 @@
+import type {
+  AppModuleBody,
+  ListPaymentsResponse,
+  ListPaymentsParams,
+} from '@cloudcommerce/types';
+import getProgramId from './functions-lib/get-program-id';
+
+export default (data: AppModuleBody) => {
+  const { application } = data;
+  const params = data.params as ListPaymentsParams;
+
+  const appData = {
+    ...application.data,
+    ...application.hidden_data,
+  };
+
+  // const { storeId } = req
+  // setup basic required response object
+  const response: ListPaymentsResponse = {
+    payment_gateways: [],
+  };
+
+  const label = params.lang === 'pt_br' || !params.lang
+    ? 'Pontos de fidelidade'
+    : 'Loyalty points';
+
+  response.payment_gateways.push({
+    type: 'payment',
+    payment_method: {
+      code: 'loyalty_points',
+      name: label,
+    },
+    label,
+  });
+
+  if (Array.isArray(appData.programs_rules)) {
+    const pointsPrograms = {};
+    appData.programs_rules.forEach((programRule, index) => {
+      const programId = getProgramId(programRule, index);
+      pointsPrograms[programId] = {
+        name: programRule.name,
+        ratio: programRule.ratio || 1,
+        max_points: programRule.max_points,
+        min_subtotal_to_earn: programRule.min_subtotal_to_earn,
+        earn_percentage: programRule.earn_percentage,
+      };
+    });
+
+    if (Object.keys(pointsPrograms).length) {
+      response.loyalty_points_programs = pointsPrograms;
+    }
+  }
+
+  return response;
+};

package/packages/apps/loyalty-points/src/loyalty-points-events.ts

@@ -0,0 +1,41 @@
+/* eslint-disable import/prefer-default-export */
+import '@cloudcommerce/firebase/lib/init';
+import type { Orders } from '@cloudcommerce/types';
+import {
+  createAppEventsFunction,
+  ApiEventHandler,
+} from '@cloudcommerce/firebase/lib/helpers/pubsub';
+import logger from 'firebase-functions/logger';
+import handleLoyaltyPointsEvent from './functions-lib/handle-loyalty-points-event';
+
+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 };
+  const programRules = appData.programs_rules;
+
+  if (
+    (Array.isArray(appData.ignore_events)
+      && appData.ignore_events.includes(evName))
+    || (!Array.isArray(programRules) || !programRules.length)
+  ) {
+    logger.info('>> ', key, ' - Ignored event');
+    return null;
+  }
+  logger.info(`> Webhook ${resourceId} [${evName}]`);
+
+  return handleLoyaltyPointsEvent(apiDoc as Orders, programRules);
+};
+
+export const loyaltypoints = {
+  onStoreEvent: createAppEventsFunction(
+    'loyaltyPoints',
+    handleApiEvent,
+  ) as any,
+};

package/packages/apps/loyalty-points/src/loyalty-points.ts

@@ -0,0 +1,12 @@
+import '@cloudcommerce/firebase/lib/init';
+import type { AppModuleBody } from '@cloudcommerce/types';
+import handleListPayments from './loyalty-list-payments';
+import handleCreateTransaction from './loyalty-create-transaction';
+
+export const listPayments = async (modBody: AppModuleBody) => {
+  return handleListPayments(modBody);
+};
+
+export const createTransaction = async (modBody: AppModuleBody) => {
+  return handleCreateTransaction(modBody);
+};

package/packages/apps/loyalty-points/tsconfig.json

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

package/packages/apps/mercadopago/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloudcommerce/app-mercadopago",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "E-Com Plus Cloud Commerce app to integrate Mercado Pago",
   "main": "lib/mercadopago.js",
   "exports": {

package/packages/apps/pagarme/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloudcommerce/app-pagarme",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "E-Com Plus Cloud Commerce app to integrate Pagar.me",
   "main": "lib/pagarme.js",
   "exports": {

package/packages/apps/pix/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloudcommerce/app-pix",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "E-Com Plus Cloud Commerce app to integrate Pix API (Bacen)",
   "main": "lib/pix.js",
   "exports": {

package/packages/apps/tiny-erp/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloudcommerce/app-tiny-erp",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "E-Com Plus Cloud Commerce app for Tiny ERP",
   "main": "lib/tiny-erp.js",
   "repository": {