fix(melhor-envio): Updating to https://github.com/ecomplus/app-melhor-envio/releases/tag/v1.12.1

Fixing ME Axios client on app src

Author: leomp12

packages/apps/melhor-envio/lib-mjs/calculate-melhor-envio.mjs

@@ -1,7 +1,7 @@
 import logger from 'firebase-functions/logger';
 import api from '@cloudcommerce/api';
 import { newShipment, matchService, sortServicesBy } from './functions/new-shipment.mjs';
-import meClient from './functions/client-melhor-envio.mjs';
+import { getMEAxios } from './util/melhor-envio-api.mjs';
 import errorHandling from './functions/error-handling.mjs';
 
 export default async ({ params, application }) => {
@@ -10,16 +10,18 @@ export default async ({ params, application }) => {
     ...application.hidden_data,
   };
 
-  const melhorEnvioToken = appData.access_token;
-  if (typeof melhorEnvioToken === 'string' && melhorEnvioToken) {
-    process.env.MELHORENVIO_TOKEN = melhorEnvioToken;
+  if (appData.access_token) {
+    process.env.MELHORENVIO_TOKEN = appData.access_token;
   }
+  process.env.MELHORENVIO_ENV = appData.sandbox
+    ? 'sandbox'
+    : process.env.MELHORENVIO_ENV || 'live';
   if (!process.env.MELHORENVIO_TOKEN) {
     logger.warn('Missing Melhor Envio token');
     return {
       status: 409,
       error: 'CALCULATE_SHIPPING_DISABLED',
-      message: 'Melhor Envio Token is unset',
+      message: 'Melhor Envio Token is not set',
     };
   }
 
@@ -79,57 +81,122 @@ export default async ({ params, application }) => {
     return response;
   }
 
+  const meAxios = await getMEAxios();
+
   if (params.items) {
     const intZipCode = parseInt(params.to.zip.replace(/\D/g, ''), 10);
-    const { sandbox } = appData;
-
     if (!appData.merchant_address) {
       // get merchant_address
-      const { data } = await meClient(process.env.MELHORENVIO_TOKEN, sandbox).get('/');
+      const { data } = await meAxios.get('/');
       const merchantAddress = data.address;
 
       // update config.merchant_address
       appData.merchant_address = merchantAddress;
       // save merchant_address in hidden_data
 
-      const bodyUpdate = {
-        merchant_address: merchantAddress,
-      };
       try {
-        await api.patch(`applications/${application._id}/hidden_data`, bodyUpdate);
+        await api.patch(`applications/${application._id}/hidden_data`, {
+          merchant_address: merchantAddress,
+        });
       } catch (err) {
-        logger.error('>>(App Melhor Envio): !<> Update merchant_address failed', err.message);
+        logger.warn('Update merchant_address failed');
+        logger.error(err);
+      }
+    }
+
+    let originZip;
+    let warehouseCode;
+    let postingDeadline;
+    let warehouseConfig = {};
+    let from = {
+      zip: appData.merchant_address.postal_code,
+      street: appData.merchant_address.address,
+      number: parseInt(appData.merchant_address.number, 10),
+    };
+    if (params.from) {
+      from = params.from;
+      originZip = params.from.zip;
+    } else if (Array.isArray(appData.warehouses) && appData.warehouses.length) {
+      for (let i = 0; i < appData.warehouses.length; i++) {
+        const warehouse = appData.warehouses[i];
+        if (warehouse && warehouse.zip && checkZipCode(warehouse)) {
+          const { code } = warehouse;
+          if (!code) {
+            continue;
+          }
+          if (
+            params.items
+            && params.items.find(({ quantity, inventory }) => {
+              return inventory && Object.keys(inventory).length
+                && !(inventory[code] >= quantity);
+            })
+          ) {
+            // item not available on current warehouse
+            continue;
+          }
+          originZip = warehouse.zip;
+          if (warehouse.posting_deadline) {
+            postingDeadline = warehouse.posting_deadline;
+          }
+          if (warehouse && warehouse.street) {
+            ['zip', 'street', 'number', 'complement', 'borough', 'city', 'province_code']
+              .forEach((prop) => {
+                if (warehouse[prop]) {
+                  from[prop] = warehouse[prop];
+                }
+              });
+          }
+          /*
+          if (warehouse.doc) {
+            docNumber = warehouse.doc
+          }
+          */
+          warehouseCode = code;
+          warehouseConfig = warehouse;
+        }
       }
     }
+    if (!originZip) {
+      originZip = appData.merchant_address.postal_code;
+    }
+    originZip = typeof originZip === 'string' ? originZip.replace(/\D/g, '') : '';
 
     let schema;
     try {
-      schema = newShipment(appData, params);
+      schema = newShipment(appData, { originZip, ...params });
     } catch (err) {
-      logger.error('>>(App Melhor Envio): NEW_SHIPMENT_PARSE_ERR', err);
+      logger.warn('Failed parsing shipment');
+      logger.error(err);
       return {
         status: 400,
         error: 'CALCULATE_ERR',
         message: 'Unexpected Error Try Later',
       };
     }
 
-    // calculate the shipment
     try {
-      const data = await meClient(process.env.MELHORENVIO_TOKEN, sandbox)
-        .post('/shipment/calculate', schema);
+      const { data } = await meAxios.post('/shipment/calculate', schema);
+
+      if (!data.length) {
+        logger.warn('Empty ME calculate result', {
+          data,
+          schema,
+        });
+      }
 
       let errorMsg;
       data.forEach((service) => {
         let isAvailable = true;
         // check if service is not disabled
         if (Array.isArray(appData.unavailable_for)) {
           for (let i = 0; i < appData.unavailable_for.length; i++) {
-            if (appData.unavailable_for[i] && appData.unavailable_for[i].zip_range
+            if (
+              appData.unavailable_for[i] && appData.unavailable_for[i].zip_range
               && appData.unavailable_for[i].service_name
             ) {
               const unavailable = appData.unavailable_for[i];
-              if (intZipCode >= unavailable.zip_range.min
+              if (
+                intZipCode >= unavailable.zip_range.min
                 && intZipCode <= unavailable.zip_range.max
                 && matchService(unavailable, service.name)
               ) {
@@ -141,16 +208,14 @@ export default async ({ params, application }) => {
 
         if (!service.error && isAvailable) {
           // mounte response body
-          const { to } = params;
-          const from = {
-            zip: appData.merchant_address.postal_code,
-            street: appData.merchant_address.address,
-            number: parseInt(appData.merchant_address.number, 10),
-          };
-
           const shippingLine = {
-            to,
-            from,
+            from: {
+              ...params.from,
+              ...appData.from,
+              ...from,
+              zip: originZip,
+            },
+            to: params.to,
             own_hand: service.additional_services.own_hand,
             receipt: service.additional_services.receipt,
             discount: 0,
@@ -162,7 +227,9 @@ export default async ({ params, application }) => {
             posting_deadline: {
               days: 3,
               ...appData.posting_deadline,
+              ...postingDeadline,
             },
+            warehouse_code: warehouseCode,
             custom_fields: [
               {
                 field: 'by_melhor_envio',
@@ -173,7 +240,6 @@ export default async ({ params, application }) => {
 
           const servicePkg = (service.packages && service.packages[0])
             || (service.volumes && service.volumes[0]);
-
           if (servicePkg) {
             shippingLine.package = {};
             if (servicePkg.dimensions) {
@@ -197,10 +263,11 @@ export default async ({ params, application }) => {
             }
           }
 
-          if (appData.jadlog_agency) {
+          const jadlogAgency = warehouseConfig.jadlog_agency || appData.jadlog_agency;
+          if (jadlogAgency) {
             shippingLine.custom_fields.push({
               field: 'jadlog_agency',
-              value: String(appData.jadlog_agency),
+              value: String(jadlogAgency),
             });
           }
 
@@ -218,14 +285,20 @@ export default async ({ params, application }) => {
             }
             // update total price
             shippingLine.total_price += appData.additional_price;
+            if (shippingLine.total_price < 0) {
+              shippingLine.total_price = 0;
+            }
           }
 
-          // search for discount by shipping rule
+          // search for discount or fixed value by shipping rule
           if (Array.isArray(shippingRules)) {
             for (let i = 0; i < shippingRules.length; i++) {
               const rule = shippingRules[i];
-              if (rule && matchService(rule, service.name)
-                && checkZipCode(rule) && !(rule.min_amount > params.subtotal)
+              if (
+                rule
+                && matchService(rule, service.name)
+                && checkZipCode(rule)
+                && !(rule.min_amount > params.subtotal)
               ) {
                 // valid shipping rule
                 if (rule.free_shipping) {
@@ -237,24 +310,30 @@ export default async ({ params, application }) => {
                   if (rule.discount.percentage) {
                     discountValue *= (shippingLine.total_price / 100);
                   }
-                  shippingLine.discount += discountValue;
-                  shippingLine.total_price -= discountValue;
-                  if (shippingLine.total_price < 0) {
-                    shippingLine.total_price = 0;
+                  if (discountValue) {
+                    shippingLine.discount += discountValue;
+                    shippingLine.total_price -= discountValue;
+                    if (shippingLine.total_price < 0) {
+                      shippingLine.total_price = 0;
+                    }
                   }
                   break;
+                } else if (rule.fixed) {
+                  shippingLine.total_price = rule.fixed;
                 }
               }
             }
           }
 
-          let label = service.name;
-          if (appData.services && Array.isArray(appData.services) && appData.services.length) {
-            const serviceFound = appData.services.find((lookForService) => {
-              return lookForService && matchService(lookForService, label);
+          let label = appData.prefix_labels === true
+            ? `ME ${service.name}`
+            : service.name;
+          if (Array.isArray(appData.services) && appData.services.length) {
+            const matchedService = appData.services.find((_service) => {
+              return _service && matchService(_service, label);
             });
-            if (serviceFound && serviceFound.label) {
-              label = serviceFound.label;
+            if (matchedService?.label) {
+              label = matchedService.label;
             }
           }
 
@@ -271,21 +350,31 @@ export default async ({ params, application }) => {
         }
       });
 
-      // sort services?
-      if (appData.sort_services && Array.isArray(response.shipping_services)
-        && response.shipping_services.length) {
+      if (
+        appData.sort_services
+        && Array.isArray(response.shipping_services)
+        && response.shipping_services.length
+      ) {
         response.shipping_services.sort(sortServicesBy(appData.sort_services));
       }
+      if (appData.max_services > 0) {
+        response.shipping_services = response.shipping_services
+          .slice(0, appData.max_services);
+      }
 
-      return (!Array.isArray(response.shipping_services) || !response.shipping_services.length)
-        && errorMsg
-        ? {
-          status: 400,
-          error: 'CALCULATE_ERR_MSG',
-          message: errorMsg,
+      if (
+        !Array.isArray(response.shipping_services)
+        || !response.shipping_services.length
+      ) {
+        if (errorMsg) {
+          return {
+            status: 400,
+            error: 'CALCULATE_ERR_MSG',
+            message: errorMsg,
+          };
         }
-        // success response with available shipping services
-        : response;
+      }
+      return response;
     } catch (err) {
       let message = 'Unexpected Error Try Later';
       if (err.response && err.isAxiosError) {
@@ -295,7 +384,11 @@ export default async ({ params, application }) => {
           message = 'Melhor Envio offline no momento';
           isAppError = false;
         } else if (data) {
-          if (data.errors && typeof data.errors === 'object' && Object.keys(data.errors).length) {
+          if (
+            data.errors
+            && typeof data.errors === 'object'
+            && Object.keys(data.errors).length
+          ) {
             const errorKeys = Object.keys(data.errors);
             for (let i = 0; i < errorKeys.length; i++) {
               const meError = data.errors[errorKeys[i]];
@@ -320,27 +413,25 @@ export default async ({ params, application }) => {
 
         if (isAppError) {
           // debug unexpected error
-          logger.error('>>(App Melhor Envio): CalculateShippingErr:', JSON.stringify({
+          logger.error('CalculateShippingErr:', {
             status,
             data,
             config,
-          }, null, 4));
+          });
         }
       } else {
         errorHandling(err);
       }
-
       return {
         status: 409,
         error: 'CALCULATE_ERR',
         message,
       };
     }
-  } else {
-    return {
-      status: 400,
-      error: 'CALCULATE_EMPTY_CART',
-      message: 'Cannot calculate shipping without cart items',
-    };
   }
+  return {
+    status: 400,
+    error: 'CALCULATE_EMPTY_CART',
+    message: 'Cannot calculate shipping without cart items',
+  };
 };