@cloudcommerce/app-tiny-erp 0.0.59 → 0.0.60

package/src/integration/after-tiny-queue.ts

@@ -0,0 +1,80 @@
+import logger from 'firebase-functions/lib/logger';
+import updateAppData from '@cloudcommerce/firebase/lib/helpers/update-app-data';
+
+export default async (queueEntry, appData, application, payload) => {
+  const isError = payload instanceof Error;
+  const isImportation = queueEntry.action.endsWith('importation');
+  const logs = appData.logs || [];
+  const logEntry = {
+    resource: /order/i.test(queueEntry.queue) ? 'orders' : 'products',
+    [(isImportation ? 'tiny_id' : 'resource_id')]: queueEntry.nextId,
+    success: !isError,
+    imestamp: new Date().toISOString(),
+  };
+
+  let notes;
+  if (payload) {
+    if (!isError) {
+      // payload = response
+      const { data, status, config } = payload;
+      if (data && data._id) {
+        logEntry.resource_id = data._id;
+      }
+      notes = `Status ${status}`;
+      if (config) {
+        notes += ` [${config.url}]`;
+      }
+    } else {
+      const { config, response } = payload as any;
+      if (response) {
+        const { data, status } = response;
+        notes = `Error: Status ${status} \n${JSON.stringify(data)}`;
+        if (!status || status === 429 || status >= 500) {
+          return setTimeout(() => {
+            throw payload;
+          }, 2000);
+        }
+        if (config) {
+          const { url, method, data } = config;
+          notes += `\n\n-- Request -- \n${method} ${url} \n${JSON.stringify(data)}`;
+        }
+        // @ts-ignore
+      } else if (payload.isConfigError === true) {
+        notes = payload.message;
+      } else {
+        notes = payload.stack;
+      }
+    }
+  }
+  if (notes) {
+    logEntry.notes = notes.substring(0, 5000);
+  }
+
+  if (isError || !isImportation) {
+    logs.unshift(logEntry);
+    await updateAppData(application, {
+      logs: logs.slice(0, 200),
+    }, {
+      isHiddenData: true,
+      canSendPubSub: false,
+    });
+  }
+  const { action, queue, nextId } = queueEntry;
+  let queueList = appData[action][queue];
+  if (Array.isArray(queueList)) {
+    const idIndex = queueList.indexOf(nextId);
+    if (idIndex > -1) {
+      queueList.splice(idIndex, 1);
+    }
+  } else {
+    queueList = [];
+  }
+  const data = {
+    [action]: {
+      ...appData[action],
+      [queue]: queueList,
+    },
+  };
+  logger.info(JSON.stringify(data));
+  return updateAppData(application, data);
+};

package/src/integration/export-order-to-tiny.ts

@@ -0,0 +1,86 @@
+import type { Orders } from '@cloudcommerce/types';
+import logger from 'firebase-functions/lib/logger';
+import api from '@cloudcommerce/api';
+import postTiny from './post-tiny-erp';
+import parseStatus from './parsers/status-to-tiny';
+import parseOrder from './parsers/order-to-tiny';
+
+export default async (apiDoc, queueEntry, appData, canCreateNew) => {
+  const orderId = queueEntry.nextId;
+  let order: Orders;
+  if (orderId === apiDoc._id) {
+    order = apiDoc;
+  } else {
+    try {
+      order = (await api.get(`orders/${orderId}`)).data;
+    } catch (err: any) {
+      if (err.statusCode === 404) {
+        const msg = `O pedido ${orderId} não existe (:${err.statusCode})`;
+        const error: any = new Error(msg);
+        error.isConfigError = true;
+        return error;
+      }
+      throw err;
+    }
+  }
+  if (!order.financial_status) {
+    logger.info(`${orderId} skipped with no financial status`);
+    return null;
+  }
+  logger.info(`${orderId} searching order ${order.number}`);
+
+  let tinyData: { pedidos?: any };
+  try {
+    tinyData = await postTiny('/pedidos.pesquisa.php', {
+      numeroEcommerce: String(order.number),
+    });
+  } catch (err: any) {
+    const status = err.response && err.response.status;
+    if (status === 404) {
+      tinyData = {};
+    } else {
+      logger.info(`${orderId} search on tiny ends with status ${status}`);
+      throw err;
+    }
+  }
+
+  const { pedidos } = tinyData;
+  const tinyStatus = parseStatus(order);
+  let originalTinyOrder;
+  if (Array.isArray(pedidos)) {
+    originalTinyOrder = pedidos.find(({ pedido }) => {
+      return order.number === Number(pedido.numero_ecommerce);
+    });
+    if (originalTinyOrder) {
+      originalTinyOrder = originalTinyOrder.pedido;
+    }
+  }
+  if (!originalTinyOrder) {
+    if (!canCreateNew) {
+      return null;
+    }
+    if (
+      appData.approved_orders_only
+      && (tinyStatus === 'aberto' || tinyStatus === 'cancelado')
+    ) {
+      logger.info(`${orderId} skipped with status "${tinyStatus}"`);
+      return null;
+    }
+    const tinyOrder = parseOrder(order, appData);
+    logger.info(`${orderId} ${JSON.stringify(tinyOrder)}`);
+    return postTiny('/pedido.incluir.php', {
+      pedido: {
+        pedido: tinyOrder,
+      },
+    });
+  }
+
+  logger.info(`${orderId} found with tiny status ${tinyStatus}`);
+  if (tinyStatus) {
+    return postTiny('/pedido.alterar.situacao', {
+      id: originalTinyOrder.id,
+      situacao: tinyStatus,
+    });
+  }
+  return null;
+};

package/src/integration/export-product-to-tiny.ts

@@ -0,0 +1,60 @@
+import type { Products } from '@cloudcommerce/types';
+import api from '@cloudcommerce/api';
+import postTiny from './post-tiny-erp';
+import parseProduct from './parsers/product-to-tiny';
+
+export default async (apiDoc, queueEntry, appData, canCreateNew) => {
+  const productId = queueEntry.nextId;
+  let product: Products;
+  if (productId === apiDoc._id) {
+    product = apiDoc;
+  } else {
+    try {
+      product = (await api.get(`products/${productId}`)).data;
+    } catch (err: any) {
+      if (err.statusCode === 404) {
+        const msg = `O produto ${productId} não existe (:${err.statusCode})`;
+        const error: any = new Error(msg);
+        error.isConfigError = true;
+        return error;
+      }
+      throw err;
+    }
+  }
+
+  let tinyData: { produtos?: any };
+  try {
+    tinyData = await postTiny('/produtos.pesquisa.php', {
+      pesquisa: product.sku,
+    });
+  } catch (err: any) {
+    if (err.response && err.response.status === 404) {
+      tinyData = {};
+    } else {
+      throw err;
+    }
+  }
+
+  const { produtos } = tinyData;
+  let originalTinyProduct;
+  if (Array.isArray(produtos)) {
+    originalTinyProduct = produtos.find(({ produto }) => {
+      return product.sku === String(produto.codigo);
+    });
+    if (originalTinyProduct) {
+      originalTinyProduct = originalTinyProduct.produto;
+    } else if (!canCreateNew) {
+      return null;
+    }
+  }
+  const tinyProduct = parseProduct(product, originalTinyProduct, appData);
+  return tinyProduct
+    ? postTiny(originalTinyProduct ? '/produto.alterar.php' : '/produto.incluir.php', {
+      produto: {
+        produtos: [{
+          produto: tinyProduct,
+        }],
+      },
+    })
+    : null;
+};

package/src/integration/helpers/format-tiny-date.ts

@@ -0,0 +1,6 @@
+export default (d: Date) => {
+  /* eslint-disable prefer-template */
+  return d.getDate().toString().padStart(2, '0') + '/'
+    + (d.getMonth() + 1).toString().padStart(2, '0') + '/'
+    + d.getFullYear();
+};

package/src/integration/import-order-from-tiny.ts

@@ -0,0 +1,104 @@
+import type { Orders } from '@cloudcommerce/types';
+import { firestore } from 'firebase-admin';
+import logger from 'firebase-functions/lib/logger';
+import api from '@cloudcommerce/api';
+import postTiny from './post-tiny-erp';
+import parseOrder from './parsers/order-from-tiny';
+import parseStatus from './parsers/status-from-tiny';
+
+const getLastStatus = (records) => {
+  let statusRecord;
+  records.forEach((record) => {
+    if (
+      record
+      && (!statusRecord || !record.date_time || record.date_time >= statusRecord.date_time)
+    ) {
+      statusRecord = record;
+    }
+  });
+  return statusRecord && statusRecord.status;
+};
+
+export default async (apiDoc, queueEntry) => {
+  const getTinyOrder = async (tinyOrderId) => {
+    const { pedido } = await postTiny('/pedido.obter.php', {
+      id: Number(tinyOrderId),
+    });
+    const situacao = typeof pedido.situacao === 'string'
+      ? pedido.situacao.toLowerCase()
+      : null;
+    const orderNumber = pedido.numero_ecommerce;
+    logger.info(`Import order n${orderNumber} ${tinyOrderId} => ${situacao}`);
+
+    const documentRef = firestore().doc(`tinyErpOrders/${tinyOrderId}`);
+    const documentSnapshot = await documentRef.get();
+    if (
+      documentSnapshot.exists
+      && documentSnapshot.get('situacao') === situacao
+    ) {
+      logger.info(`>> Ignoring Tiny order n${orderNumber} ${tinyOrderId} with same status`);
+      return null;
+    }
+
+    let listEndpoint = 'orders?limit=1&fields=_id,payments_history,fulfillments,shipping_lines';
+    if (orderNumber) {
+      listEndpoint += `&number=${orderNumber}`;
+    } else {
+      listEndpoint += `&hidden_metafields.value=${tinyOrderId}_tiny`;
+    }
+    const { data: { result } } = await api.get(listEndpoint as 'orders');
+    if (!result.length) {
+      return null;
+    }
+    const order = result[0];
+    const partialOrder = await parseOrder(pedido, order.shipping_lines) as Orders;
+    const promises: Promise<any>[] = [];
+    if (partialOrder && Object.keys(partialOrder).length) {
+      promises.push(api.patch(`orders/${order._id}`, partialOrder));
+    }
+    const { fulfillmentStatus, financialStatus } = parseStatus(situacao);
+    const data: Record<string, any> = {
+      date_time: new Date().toISOString(),
+      flags: ['from-tiny'],
+    };
+    [
+      [financialStatus, 'payments_history'],
+      [fulfillmentStatus, 'fulfillments'],
+    ].forEach(([newStatus, subresource]) => {
+      if (
+        newStatus
+        // @ts-ignore
+        && (!order[subresource] || getLastStatus(order[subresource]) !== newStatus)
+      ) {
+        data.status = newStatus;
+        promises.push(api.post(`orders/${order._id}/${subresource}`, data as any));
+        logger.info(`${order._id} updated to ${newStatus} from Tiny ${tinyOrderId}`);
+      }
+    });
+
+    return Promise.all(promises)
+      .then(([firstResult]) => {
+        documentRef.set({
+          situacao,
+          updatedAt: firestore.Timestamp.fromDate(new Date()),
+        }).catch(logger.error);
+        return (firstResult && firstResult.response) || firstResult;
+      });
+  };
+
+  const tinyOrderNumber = queueEntry.nextId;
+  if (typeof tinyOrderNumber === 'string' && tinyOrderNumber.startsWith('id:')) {
+    return getTinyOrder(tinyOrderNumber.substring(3));
+  }
+  return postTiny('/pedidos.pesquisa.php', {
+    numero: tinyOrderNumber,
+  }).then(({ pedidos }) => {
+    const tinyOrder = pedidos.find(({ pedido }) => {
+      return Number(tinyOrderNumber) === Number(pedido.numero);
+    });
+    if (tinyOrder) {
+      return getTinyOrder(tinyOrder.pedido.id);
+    }
+    return null;
+  });
+};

package/src/integration/import-product-from-tiny.ts

@@ -0,0 +1,174 @@
+import type { Products } from '@cloudcommerce/types';
+// eslint-disable-next-line import/no-unresolved
+import { getFirestore } from 'firebase-admin/firestore';
+import logger from 'firebase-functions/lib/logger';
+import api from '@cloudcommerce/api';
+import updateAppData from '@cloudcommerce/firebase/lib/helpers/update-app-data';
+import postTiny from './post-tiny-erp';
+import parseProduct from './parsers/product-from-tiny';
+
+export default async (apiDoc, queueEntry, appData, canCreateNew, isHiddenQueue) => {
+  const [sku, productId] = String(queueEntry.nextId).split(';:');
+  let { tinyStockUpdate } = queueEntry;
+  if (!tinyStockUpdate) {
+    const querySnapshot = await getFirestore().collection('tinyErpStockUpdates')
+      .where('ref', '==', `${sku}`).get();
+    let lastUpdateTime;
+    querySnapshot.forEach((documentSnapshot) => {
+      const updateTime = documentSnapshot.updateTime.toDate().getTime();
+      if (!lastUpdateTime || updateTime > lastUpdateTime) {
+        lastUpdateTime = updateTime;
+        tinyStockUpdate = documentSnapshot.data();
+      }
+      documentSnapshot.ref.delete().catch(logger.error);
+    });
+  }
+
+  let product: Products | null = null;
+  try {
+    product = (await api.get(`products/${(productId || `sku:${sku}`)}`)).data;
+  } catch (err: any) {
+    if (err.statusCode !== 404) {
+      throw err;
+    }
+  }
+  let hasVariations: boolean = false;
+  let variationId: string | undefined;
+  if (product) {
+    const { variations } = product;
+    hasVariations = Boolean(variations && variations.length);
+    const variation = variations?.find((variation) => sku === variation.sku);
+    if (variation) {
+      variationId = variation._id;
+    } else {
+      logger.info(`SKU not found ${sku}`);
+      if (!isHiddenQueue && !appData.update_product) {
+        const msg = sku
+          + ' corresponde a um produto com variações,'
+          + ' especifique o SKU da variação para importar.';
+        const err: any = new Error(msg);
+        err.isConfigError = true;
+        return err;
+      }
+      return null;
+    }
+  }
+
+  const handleTinyStock = ({ produto, tipo }, tinyProduct?) => {
+    let quantity = Number(produto.saldo) || Number(produto.estoqueAtual);
+    if (produto.saldoReservado) {
+      quantity -= Number(produto.saldoReservado);
+    }
+    if (product && (!appData.update_product || variationId)) {
+      if (!Number.isNaN(quantity)) {
+        if (quantity < 0) {
+          quantity = 0;
+        }
+        let endpoint = `products/${product._id}`;
+        if (variationId) {
+          endpoint += `variations/${variationId}`;
+        }
+        endpoint += '/quantity';
+        logger.info(endpoint, { quantity });
+        // @ts-ignore
+        return api.put(endpoint, quantity);
+      }
+      return null;
+    }
+    if (!tinyProduct) {
+      return null;
+    }
+
+    return postTiny('/produto.obter.php', { id: tinyProduct.id })
+      .then(({ produto }) => {
+        let method;
+        let endpoint;
+        let productId = product && product._id;
+        if (productId) {
+          method = 'PATCH';
+          endpoint = `products/${productId}`;
+        } else if (tipo === 'produto' || !tipo) {
+          method = 'POST';
+          endpoint = 'products';
+        } else {
+          return null;
+        }
+        // @ts-ignore
+        return parseProduct(produto, method === 'POST').then((product: Products) => {
+          if (!Number.isNaN(quantity)) {
+            product.quantity = quantity >= 0 ? quantity : 0;
+          }
+          logger.info(`${method} ${endpoint}`);
+          const promise = api({
+            method,
+            endpoint,
+            data: product,
+          });
+
+          if (Array.isArray(produto.variacoes) && produto.variacoes.length) {
+            promise.then((response) => {
+              let skus = appData.__importation && appData.__importation.skus;
+              if (!Array.isArray(skus)) {
+                skus = [];
+              }
+              let isQueuedVariations = false;
+              produto.variacoes.forEach(({ variacao }) => {
+                const { codigo } = variacao;
+                let skuAndId = codigo;
+                if (!productId) {
+                  productId = response.data && response.data._id;
+                }
+                if (productId) {
+                  skuAndId += `;:${productId}`;
+                }
+                if (!skus.includes(codigo) && !skus.includes(skuAndId)) {
+                  isQueuedVariations = true;
+                  skus.push(skuAndId);
+                }
+              });
+              return isQueuedVariations
+                ? updateAppData(queueEntry.app, {
+                  __importation: {
+                    ...appData.__importation,
+                    skus,
+                  },
+                })
+                : response;
+            });
+          }
+          return promise;
+        });
+      });
+  };
+
+  logger.info(JSON.stringify({
+    sku,
+    productId,
+    hasVariations,
+    variationId,
+  }));
+  if (tinyStockUpdate && isHiddenQueue && productId) {
+    return handleTinyStock(tinyStockUpdate as any);
+  }
+  return postTiny('/produtos.pesquisa.php', { pesquisa: sku })
+    .then(({ produtos }) => {
+      if (Array.isArray(produtos)) {
+        let tinyProduct = produtos.find(({ produto }) => sku === String(produto.codigo));
+        if (tinyProduct) {
+          tinyProduct = tinyProduct.produto;
+          if (!hasVariations || variationId) {
+            if (tinyStockUpdate) {
+              return handleTinyStock(tinyStockUpdate as any, tinyProduct);
+            }
+            return postTiny('/produto.obter.estoque.php', { id: tinyProduct.id })
+              .then((tinyStock) => handleTinyStock(tinyStock, tinyProduct));
+          }
+          return handleTinyStock({ produto: {} } as any, tinyProduct);
+        }
+      }
+      const msg = `SKU ${sku} não encontrado no Tiny`;
+      const err: any = new Error(msg);
+      err.isConfigError = true;
+      throw new Error(err);
+    });
+};

package/src/integration/parsers/order-from-tiny.ts

@@ -0,0 +1,49 @@
+import postTiny from '../post-tiny-erp';
+
+export default (tinyOrder, shippingLines) => new Promise((resolve, reject) => {
+  const partialOrder: Record<string, any> = {};
+  if (tinyOrder.obs_interna) {
+    partialOrder.staff_notes = tinyOrder.obs_interna;
+  }
+
+  if (shippingLines && shippingLines.length) {
+    const shippingLine = shippingLines[0];
+    if (
+      (tinyOrder.codigo_rastreamento || tinyOrder.url_rastreamento)
+      && (!shippingLine.tracking_codes || !shippingLine.tracking_codes.length)
+    ) {
+      let link;
+      if (tinyOrder.url_rastreamento) {
+        link = tinyOrder.url_rastreamento;
+      }
+      const tracking = {
+        code: String(tinyOrder.codigo_rastreamento)
+          || link.replace(/^https?:\/\/[^/]+/, '').replace(/^[^?]+\?/, '').substring(0, 70),
+        link,
+      };
+      shippingLine.tracking_codes = [tracking];
+      partialOrder.shipping_lines = shippingLines;
+    }
+
+    if (tinyOrder.id_nota_fiscal > 0) {
+      if (!shippingLine.invoices) {
+        shippingLine.invoices = [];
+      }
+      postTiny('/nota.fiscal.obter.php', { id: tinyOrder.id_nota_fiscal })
+        .then((tinyInvoice) => {
+          const number = String(tinyInvoice.nota_fiscal.numero);
+          if (number && !shippingLine.invoices.find((invoice) => invoice.number === number)) {
+            shippingLine.invoices.push({
+              number,
+              serial_number: String(tinyInvoice.nota_fiscal.serie),
+            });
+          }
+          partialOrder.shipping_lines = shippingLines;
+          resolve(partialOrder);
+        })
+        .catch(reject);
+      return;
+    }
+  }
+  resolve(partialOrder);
+});