@cloudcommerce/app-tiny-erp 2.8.8 → 2.10.0

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

@@ -1,113 +0,0 @@
-import type { Orders } from '@cloudcommerce/types';
-import logger from 'firebase-functions/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;
-    }
-
-    if (appData.ready_for_shipping_only) {
-      switch (tinyStatus) {
-        case 'aberto':
-        case 'cancelado':
-        case 'aprovado':
-        case 'preparando_envio':
-        case 'faturado':
-          if (!order.fulfillment_status || order.fulfillment_status.current !== 'ready_for_shipping') {
-            logger.info(`${orderId} skipped with status "${tinyStatus}"`);
-            return null;
-          }
-          break;
-        default:
-          break;
-      }
-    }
-
-    const tinyOrder = parseOrder(order, appData);
-    logger.info(`${orderId} ${JSON.stringify(tinyOrder)}`);
-    return postTiny('/pedido.incluir.php', {
-      pedido: {
-        pedido: tinyOrder,
-      },
-    }).then((response) => {
-      const tinyErpOnNewOrder = global.$tinyErpOnNewOrder;
-      if (tinyErpOnNewOrder && typeof tinyErpOnNewOrder === 'function') {
-        return tinyErpOnNewOrder({ response, order, postTiny });
-      }
-      return response;
-    });
-  }
-
-  if (originalTinyOrder) {
-    const { id, situacao } = originalTinyOrder;
-    logger.info(`${orderId} found with tiny status ${situacao} => ${tinyStatus}`);
-    if (tinyStatus && tinyStatus !== situacao) {
-      return postTiny('/pedido.alterar.situacao', {
-        id,
-        situacao: tinyStatus,
-      });
-    }
-  }
-  return null;
-};

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

@@ -1,60 +0,0 @@
-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

@@ -1,6 +0,0 @@
-export default (date: Date) => {
-  const d = new Date(date.getTime() - (3 * 60 * 60 * 1000));
-  return d.getDate().toString().padStart(2, '0') + '/'
-    + (d.getMonth() + 1).toString().padStart(2, '0') + '/'
-    + d.getFullYear();
-};

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

@@ -1,109 +0,0 @@
-import { getFirestore } from 'firebase-admin/firestore';
-import logger from 'firebase-functions/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 = getFirestore().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;
-    }
-
-    const { data: { result } } = await api.get('orders', {
-      fields: ['_id', 'payments_history', 'fulfillments', 'shipping_lines'] as const,
-      limit: 1,
-      params: {
-        number: orderNumber || undefined,
-        'hidden_metafields.value': `${tinyOrderId}_tiny`,
-      },
-    });
-    if (!result.length) {
-      return null;
-    }
-    const order = result[0];
-    const partialOrder = await parseOrder(pedido, order.shipping_lines);
-    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 }).catch(logger.error);
-        return (firstResult && firstResult.response) || firstResult;
-      });
-  };
-
-  const tinyOrderNumber = queueEntry.nextId;
-  if (typeof tinyOrderNumber === 'string' && tinyOrderNumber.startsWith('id:')) {
-    return getTinyOrder(tinyOrderNumber.substring(3));
-  }
-  const filter = typeof tinyOrderNumber === 'string' && tinyOrderNumber.startsWith('ecom:')
-    ? { numeroEcommerce: tinyOrderNumber.substring(5) }
-    : { numero: tinyOrderNumber };
-  return postTiny('/pedidos.pesquisa.php', filter).then(({ pedidos }) => {
-    let prop = 'numero';
-    let tinyOrderNumberSearch = tinyOrderNumber;
-    if (filter && filter.numeroEcommerce) {
-      prop = 'numero_ecommerce';
-      tinyOrderNumberSearch = tinyOrderNumber.substring(5);
-    }
-    const tinyOrder = pedidos.find(({ pedido }) => {
-      return Number(tinyOrderNumberSearch) === Number(pedido[prop]);
-    });
-
-    if (tinyOrder) {
-      return getTinyOrder(tinyOrder.pedido.id);
-    }
-    return null;
-  });
-};

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

@@ -1,176 +0,0 @@
-import type { Products } from '@cloudcommerce/types';
-import logger from 'firebase-functions/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 [queueSku, queueProductId] = String(queueEntry.nextId)
-    .split(';:') as [Products['sku'], Products['_id'] | undefined];
-  let product: Products | null = null;
-  try {
-    const resourceFind = (queueProductId || (`sku:${queueSku}` as `${string}:${string}`));
-    product = (await api.get(`products/${resourceFind}`)).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(({ sku }) => queueSku === sku);
-    if (variation) {
-      variationId = variation._id;
-    } else {
-      logger.info(`SKU not found ${queueSku}`);
-      if (!isHiddenQueue && !appData.update_product) {
-        const msg = queueSku
-          + ' 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: produtoSaldo, tipo }, tinyProduct?) => {
-    let quantity = Number(produtoSaldo.saldo) || Number(produtoSaldo.estoqueAtual);
-    if (produtoSaldo.saldoReservado) {
-      quantity -= Number(produtoSaldo.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 (!product && tinyProduct && tipo === 'produto') {
-      return parseProduct(tinyProduct, tipo, true)
-        .then((bodyProduct) => {
-          return api.post('products', bodyProduct);
-        });
-    }
-
-    if (!tinyProduct) {
-      return null;
-    }
-
-    return postTiny('/produto.obter.php', { id: (tinyProduct.id || produtoSaldo.id) })
-      .then(({ produto }) => {
-        let method;
-        let endpoint;
-        let productId = product && product._id;
-        if (productId) {
-          method = 'PATCH';
-          endpoint = `products/${productId}`;
-        } else if (tipo === 'produto' || appData.import_all_products) {
-          method = 'POST';
-          endpoint = 'products';
-        } else {
-          return null;
-        }
-        // @ts-ignore
-        return parseProduct(produto, tipo, method === 'POST').then((parsedProduct: Products) => {
-          if (!Number.isNaN(quantity)) {
-            parsedProduct.quantity = quantity >= 0 ? quantity : 0;
-          }
-          logger.info(`${method} ${endpoint}`);
-          const promise = api({
-            method,
-            endpoint,
-            data: parsedProduct,
-          });
-
-          if (Array.isArray(produto.variacoes) && produto.variacoes.length) {
-            if (!queueEntry.app) {
-              logger.warn('Variations cannot be queued without `queueEntry.app`');
-              return promise;
-            }
-            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({
-    queueSku,
-    queueProductId,
-    hasVariations,
-    variationId,
-  }));
-  const { tinyStockUpdate } = queueEntry;
-  if (tinyStockUpdate && isHiddenQueue && (queueProductId || (product && product._id))) {
-    return handleTinyStock(tinyStockUpdate as any, tinyStockUpdate.produto);
-  }
-  if (tinyStockUpdate.tipo === 'produto' && !queueProductId) {
-    return handleTinyStock({ produto: {}, tipo: 'produto' }, tinyStockUpdate.produto);
-  }
-
-  return postTiny('/produtos.pesquisa.php', { pesquisa: queueSku })
-    .then(({ produtos }) => {
-      if (Array.isArray(produtos)) {
-        let tinyProduct = produtos.find(({ produto }) => queueSku === 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 ${queueSku} 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

@@ -1,61 +0,0 @@
-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);
-          const indexFromInvoice = shippingLine.invoices
-            .findIndex((invoice) => invoice.number === number);
-
-          if (number && !(indexFromInvoice > -1)) {
-            shippingLine.invoices.push({
-              number,
-              serial_number: String(tinyInvoice.nota_fiscal.serie),
-              access_key: String(tinyInvoice.nota_fiscal.chave_acesso),
-            });
-          } else if (number && (indexFromInvoice > -1)) {
-            Object.assign(
-              shippingLine.invoices[indexFromInvoice],
-              {
-                access_key: String(tinyInvoice.nota_fiscal.chave_acesso),
-                serial_number: String(tinyInvoice.nota_fiscal.serie),
-              },
-            );
-          }
-          partialOrder.shipping_lines = shippingLines;
-          resolve(partialOrder);
-        })
-        .catch(reject);
-      return;
-    }
-  }
-  resolve(partialOrder);
-});