@cloudcommerce/app-melhor-envio 0.3.0

package/src/functions-lib/database.ts

@@ -0,0 +1,140 @@
+import { getFirestore, Timestamp } from 'firebase-admin/firestore';
+import logger from 'firebase-functions/logger';
+
+const firestoreColl = 'melhorEnvioTracking';
+
+export type Lable = {
+  id: string,
+  labelId: string,
+  status: string,
+  resourceId: string,
+  createdAt: Timestamp,
+  updateAt?: string,
+};
+
+const searchLabel = async (resourceId: string): Promise<Lable | null> => new Promise(
+  (resolve, reject) => {
+    getFirestore().doc(`${firestoreColl}/${resourceId}`)
+      .get()
+      .then((documentSnapshot) => {
+        if (documentSnapshot && documentSnapshot.exists) {
+          const data = documentSnapshot.data() as Lable;
+          if (data) {
+            resolve(data);
+          } else {
+            resolve(null);
+          }
+        } else {
+          resolve(null);
+        }
+      })
+      .catch((err: any) => {
+        reject(err);
+      });
+  },
+);
+
+const saveLabel = (
+  labelId: string,
+  status: string,
+  resourceId: string,
+) => new Promise((resolve) => {
+  const documentRef = getFirestore().doc(`${firestoreColl}/${resourceId}`);
+  if (documentRef) {
+    documentRef.set({
+      id: resourceId,
+      labelId,
+      status,
+      resourceId,
+      createdAt: Timestamp.now(),
+    }).then(() => resolve(true))
+      .catch(logger.error);
+  }
+});
+
+const getAllLabels = (): Promise<Lable[]> => new Promise((resolve, reject) => {
+  getFirestore().collection(firestoreColl).get()
+    .then((docsRef) => {
+      if (docsRef.size > 0) {
+        const list: Lable[] = [];
+        docsRef.forEach((documentSnapshot) => {
+          if (documentSnapshot && documentSnapshot.exists) {
+            const data = documentSnapshot.data() as Lable;
+            list.push(data);
+          }
+        });
+        resolve(list);
+      } else {
+        const err = new Error('No label');
+        reject(err);
+      }
+    })
+    .catch(reject);
+});
+
+const updateLabel = async (
+  status: string,
+  labelId: string,
+): Promise<boolean> => new Promise((resolve, reject) => {
+  getFirestore().collection(firestoreColl)
+    .where('labelId', '==', labelId)
+    .get()
+    .then((docsRef) => {
+      if (docsRef.size > 0) {
+        docsRef.forEach(async (documentSnapshot) => {
+          if (documentSnapshot && documentSnapshot.exists) {
+            const documentRef = documentSnapshot.ref;
+            await documentRef.set({
+              status,
+              updateAt: new Date().toISOString(),
+            }, { merge: true });
+          }
+        });
+      }
+      resolve(true);
+    })
+    .catch(reject);
+});
+
+const deleteLabel = async (id: string): Promise<boolean> => new Promise((resolve, reject) => {
+  getFirestore().doc(`${firestoreColl}/${id}`)
+    .get()
+    .then(async (documentSnapshot) => {
+      if (documentSnapshot && documentSnapshot.exists) {
+        const data = documentSnapshot.data();
+        if (data) {
+          await documentSnapshot.ref.delete();
+          resolve(true);
+        }
+      }
+      resolve(false);
+    })
+    .catch(reject);
+});
+
+const clearLabels = async (): Promise<boolean> => new Promise((resolve, reject) => {
+  const deadline = new Date();
+  deadline.setMonth(deadline.getMonth() - 2);
+
+  getFirestore().collection(firestoreColl)
+    .where('createdAt', '<=', deadline)
+    .get()
+    .then((docsRef) => {
+      docsRef.docs.forEach((doc) => {
+        doc.ref.delete();
+      });
+      resolve(true);
+    })
+    .catch(reject);
+});
+
+const db = {
+  searchLabel,
+  saveLabel,
+  getAllLabels,
+  updateLabel,
+  deleteLabel,
+  clearLabels,
+};
+
+export default db;

package/src/functions-lib/events-to-melhor-envio.ts

@@ -0,0 +1,137 @@
+import type { Orders } from '@cloudcommerce/types';
+import logger from 'firebase-functions/logger';
+import api from '@cloudcommerce/api';
+import meClient from '../../lib-mjs/functions/client-melhor-envio.mjs';
+import errorHandling from '../../lib-mjs/functions/error-handling.mjs';
+import db from './database';
+import orderIsValid from './order-is-valid';
+import newLabel from './new-label';
+
+const ECHO_SKIP = (msg?: string) => logger.warn(msg || 'SKIP');
+
+const metafieldName = 'melhor_envio_label_id';
+
+const handleApiEvent = 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}`);
+
+  try {
+    const trackingCode = await db.searchLabel(resourceId);
+    if (!trackingCode) {
+      const accessToken = appData.access_token;
+      const { sandbox } = appData;
+      if (!accessToken) {
+        ECHO_SKIP('>> Melhor Envio token not found');
+        return null;
+      }
+
+      const order = apiDoc as Orders;
+      if (!appData.enabled_label_purchase || !orderIsValid(order, appData)) {
+        ECHO_SKIP();
+        return null;
+      }
+      const merchantData = await meClient(accessToken, sandbox).get('/')
+        .then(({ data }) => data);
+
+      const label = newLabel(order, appData, merchantData);
+      // logger.log(`>> Comprando etiquetas #${storeId} ${order._id}`);
+      const { data } = await meClient(accessToken, sandbox).post('/cart', label);
+      if (data) {
+        logger.log(`>> Etiqueta inserida no carrinho com sucesso #${data.id}`);
+        if (appData.enabled_label_checkout) {
+          await meClient(accessToken, sandbox).post('/shipment/checkout', { orders: [data.id] });
+        }
+
+        // logger.log(`>> Carrinho finalizado com sucesso #${data.id}`);
+        await db.saveLabel(data.id, data.status, resourceId);
+
+        // logger.log(`>> Etiquetas salvas no db para futuros rastreio #${storeId} ${resourceId}`);
+        // updates hidden_metafields with the generated tag id
+        const bodyHiddenMetaField = {
+          namespace: 'app-melhor-envio',
+          field: metafieldName,
+          value: data.id,
+        } as any; // TODO: type amount
+        await api.post(`orders/${resourceId}/hidden_metafields`, bodyHiddenMetaField);
+
+        if (typeof data.tracking === 'string' && data.tracking.length) {
+          let shippingLine = order.shipping_lines?.find(({ app: application }) => application
+            && application.service_code && application.service_code.startsWith('ME'));
+
+          if (!shippingLine && order.shipping_lines) {
+            [shippingLine] = order.shipping_lines;
+          }
+          if (shippingLine) {
+            const trackingCodes = shippingLine.tracking_codes || [];
+            trackingCodes.push({
+              code: data.tracking,
+              link: `https://www.melhorrastreio.com.br/rastreio/${data.tracking}`,
+            });
+
+            await api.patch(
+              `orders/${resourceId}/shipping_lines/${shippingLine._id}`,
+              { tracking_codes: trackingCodes },
+            );
+
+            logger.log(`>> 'hidden_metafields' do pedido ${order._id} atualizado com sucesso!`);
+            // done
+            return null;
+          }
+        }
+      }
+    }
+    ECHO_SKIP();
+    return null;
+  } catch (err: any) {
+    if (err.response && err.isAxiosError) {
+      const { data } = err.response;
+
+      if (data) {
+        // update order hidden_metafields
+        const bodyHiddenMetaField = {
+          namespace: 'app-melhor-envio',
+          field: 'melhor_envio_label_error',
+          value: JSON.stringify(data).substring(0, 255),
+        } as any;
+
+        await api.post(`orders/${resourceId}/hidden_metafields`, bodyHiddenMetaField);
+
+        if (
+          data.error
+          === 'Os documentos (CPFs) dos participantes do frete não podem ser iguais'
+          || data.error.startsWith('Seu saldo de R$ ')
+        ) {
+          // ignoring known ME/merchant errors
+          logger.warn(`ME: ${data.error}`);
+          return null;
+        }
+      }
+
+      logger.error('BuyLabelErr:', JSON.stringify({
+        data,
+        status: err.response.status,
+        config: err.response.config,
+      }, null, 4));
+    } else {
+      errorHandling(err);
+    }
+    return err;
+  }
+};
+
+export default handleApiEvent;

package/src/functions-lib/new-label.ts

@@ -0,0 +1,214 @@
+import type { Orders } from '@cloudcommerce/types';
+
+export default (
+  order: Orders,
+  appConfig: { [x: string]: any },
+  merchantData: { [x: string]: any },
+) => {
+  const {
+    firstname, lastname, phone, email, address,
+  } = merchantData;
+  const from: { [x: string]: any } = {
+    name: `${firstname} ${lastname}`,
+    phone: (phone && phone.phone) || '',
+    email,
+  };
+  if (merchantData.company_document) {
+    from.company_document = merchantData.company_document;
+  }
+  if (merchantData.document) {
+    const field = merchantData.document.length > 11 ? 'company_document' : 'document';
+    from[field] = merchantData.document;
+  }
+  if (address) {
+    if (typeof address === 'string') {
+      from.address = address;
+    } else {
+      [
+        'address',
+        'complement',
+        'number',
+        'district',
+        'postal_code',
+        'city',
+        'state_abbr',
+        'country_id',
+      ].forEach((field) => {
+        from[field] = address[field] || '';
+      });
+      if (typeof address.city === 'object') {
+        from.city = address.city.city || '';
+        if (address.city.state) {
+          from.state_abbr = address.city.state.state_abbr || '';
+          from.country_id = (address.city.state.country && address.city.state.country.id) || '';
+        }
+      }
+    }
+  }
+
+  const shippingLine = (order.shipping_lines && order.shipping_lines[0]);
+  // || {};
+  const buyer = order.buyers && order.buyers[0];
+  const to = {
+    email: '',
+  };
+
+  if (buyer && buyer.main_email) {
+    to.email = buyer.main_email;
+    if (buyer.registry_type === 'j') {
+      Object.assign(to, { company_document: buyer.doc_number || '' });
+    } else {
+      Object.assign(to, { document: buyer.doc_number || '' });
+    }
+    if (buyer.phones && buyer.phones[0]) {
+      Object.assign(to, { phone: buyer.phones[0].number });
+    }
+  }
+
+  if (shippingLine?.to) {
+    const {
+      name,
+      street,
+      complement,
+      number,
+      borough,
+      city,
+      zip,
+    } = shippingLine.to;
+
+    Object.assign(to, {
+      name,
+      address: street || '',
+      complement,
+      number,
+      district: borough || '',
+      city,
+      state_abbr: shippingLine.to.province_code || '',
+      country_id: shippingLine.to.country_code || 'BR',
+      postal_code: zip || '',
+      note: shippingLine.to.near_to || '',
+    });
+  }
+
+  let physicalWeight = 0;
+  if (shippingLine?.package) {
+    const { weight } = shippingLine.package;
+    if (weight && weight.value) {
+      switch (weight.unit) {
+        case 'kg':
+          physicalWeight = weight.value;
+          break;
+        case 'g':
+          physicalWeight = weight.value / 1000;
+          break;
+        case 'mg':
+          physicalWeight = weight.value / 1000000;
+          break;
+        default:
+          break;
+      }
+    }
+  }
+
+  const getDimensions = (side: string) => {
+    const dimensions = shippingLine?.package && shippingLine.package.dimensions;
+    if (dimensions && dimensions[side]) {
+      const dimension = dimensions[side];
+      if (dimension && dimension.unit) {
+        let dimensionValue = 0;
+        switch (dimension.unit) {
+          case 'cm':
+            dimensionValue = dimension.value;
+            break;
+          case 'm':
+            dimensionValue = dimension.value * 100;
+            break;
+          case 'mm':
+            dimensionValue = dimension.value / 10;
+            break;
+          default:
+            break;
+        }
+        return dimensionValue;
+      }
+    }
+    return 0;
+  };
+
+  const products: {
+    name: string
+    quantity: number
+    unitary_value: number
+  }[] = [];
+
+  let insuranceValue = 0;
+  if (order.items) {
+    order.items.forEach((item) => {
+      products.push({
+        name: item.name || item.product_id,
+        quantity: item.quantity,
+        unitary_value: item.price,
+      });
+      insuranceValue += item.final_price || item.price;
+    });
+  }
+
+  const options = {
+    insurance_value: insuranceValue,
+    receipt: (appConfig.receipt),
+    own_hand: (appConfig.own_hand),
+    collect: false,
+    reverse: false,
+    platform: 'E-Com Plus',
+    tags: [
+      {
+        tag: `Etiqueta referente ao pedido: #${order.number}`,
+      },
+      {
+        tag: 'order_id',
+        url: order._id,
+      },
+    ],
+  };
+
+  // https://docs.menv.io/?version=latest#9a8f308b-4872-4268-b402-e1b0d64d1f1c
+  if (appConfig.enabled_non_commercial) {
+    Object.assign(options, { non_commercial: true });
+  }
+
+  const invoices = shippingLine?.invoices;
+  if (invoices && Array.isArray(invoices) && invoices[0].number) {
+    Object.assign(options, {
+      invoice: {
+        number: invoices[0].number,
+        key: invoices[0].access_key,
+      },
+    });
+  }
+
+  const label = {
+    from,
+    to,
+    package: {
+      weight: physicalWeight,
+      width: getDimensions('width'),
+      height: getDimensions('height'),
+      length: getDimensions('length'),
+    },
+    products,
+    options,
+  };
+
+  if (shippingLine?.app && shippingLine.app.service_code) {
+    Object.assign(label, {
+      service: parseInt(shippingLine.app.service_code.replace('ME ', ''), 10),
+    });
+  }
+  if (appConfig.jadlog_agency) {
+    Object.assign(label, {
+      agency: appConfig.jadlog_agency,
+    });
+  }
+
+  return label;
+};

package/src/functions-lib/order-is-valid.ts

@@ -0,0 +1,51 @@
+import type { Orders } from '@cloudcommerce/types';
+
+export default (order: Orders, appConfig: { [x: string]: any; }) => {
+  if (!order.fulfillment_status || !order.shipping_lines) {
+    return false;
+  }
+
+  // check if the shipping calculation was done with the app-melhor-envio
+  const isByMelhorEnvio = Boolean(order.shipping_lines.find((shippingLine) => {
+    return shippingLine.custom_fields && shippingLine.custom_fields.find(({ field }) => {
+      return field === 'by_melhor_envio';
+    });
+  }));
+
+  // checks if the non-commercial shipping option is enabled
+  const isNonCommercial = () => (appConfig.enabled_non_commercial);
+
+  // checks if order is ready to ship by last
+  // entry in fulfillments instead of checking fulfillment_status
+
+  const isReadyForShipping = () => {
+    const current = order.fulfillment_status?.current;
+    return (current && current === 'ready_for_shipping');
+  };
+
+  // check if nf was issued for the order
+  const hasInvoice = () => {
+    return Boolean(order.shipping_lines?.find(({ invoices }) => {
+      return invoices && invoices[0] && invoices[0].number;
+    }));
+  };
+
+  const hasLabelBuyIt = () => {
+    if (order.hidden_metafields) {
+      return order.hidden_metafields
+        .find(({ field }) => field === 'melhor_envio_label_id');
+    }
+
+    return false;
+  };
+
+  if (!isByMelhorEnvio || !isReadyForShipping() || hasLabelBuyIt()) {
+    return false;
+  }
+
+  if (isNonCommercial() || hasInvoice()) {
+    return true;
+  }
+
+  return false;
+};