@cloudcommerce/app-tiny-erp 0.0.59 → 0.0.62

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,102 @@
+import type { Orders } 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 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;
+    }
+
+    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 }).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,162 @@
+import type { Products } from '@cloudcommerce/types';
+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 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) {
+            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({
+    sku,
+    productId,
+    hasVariations,
+    variationId,
+  }));
+  const { tinyStockUpdate } = queueEntry;
+  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);
+});

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

@@ -0,0 +1,205 @@
+import type { Orders } from '@cloudcommerce/types';
+import ecomUtils from '@ecomplus/utils';
+import formatDate from '../helpers/format-tiny-date';
+import parseStatus from './status-to-tiny';
+
+export default (order: Orders, appData) => {
+  const orderRef = String(order.number) || order._id;
+  const tinyOrder: Record<string, any> = {
+    numero_pedido_ecommerce: orderRef,
+    data_pedido: formatDate(new Date(order.opened_at || order.created_at)),
+    ecommerce: 'E-Com Plus',
+    situacao: parseStatus(order),
+    itens: [],
+  };
+
+  const buyer = order.buyers && order.buyers[0];
+  const shippingLine = order.shipping_lines && order.shipping_lines[0];
+  const transaction = order.transactions && order.transactions[0];
+  const shippingAddress = shippingLine && shippingLine.to;
+  const billingAddress = transaction && transaction.billing_address;
+
+  const parseAddress = (address, tinyObject) => {
+    [
+      ['street', 'endereco', 50],
+      ['number', 'numero', 10],
+      ['complement', 'complemento', 50],
+      ['borough', 'bairro', 30],
+      ['zip', 'cep', 10],
+      ['city', 'cidade', 30],
+      ['province_code', 'uf', 30],
+    ].forEach(([addressField, tinyField, maxLength]) => {
+      if (address[addressField]) {
+        tinyObject[tinyField] = String(address[addressField])
+          .substring(0, maxLength as number);
+      }
+    });
+  };
+
+  if (buyer) {
+    const tinyCustomer: Record<string, any> = {
+      codigo: buyer._id,
+      nome: (buyer.corporate_name || ecomUtils.fullName(buyer)).substring(0, 30)
+        || `Comprador de #${orderRef}`,
+      tipo_pessoa: buyer.registry_type === 'j' ? 'J' : 'F',
+    };
+    if (buyer.display_name) {
+      tinyCustomer.nome_fantasia = buyer.display_name.substring(0, 30);
+    }
+    if (buyer.doc_number && buyer.doc_number.length <= 18) {
+      tinyCustomer.cpf_cnpj = buyer.doc_number;
+    }
+    if (buyer.inscription_number && buyer.inscription_number.length <= 18) {
+      tinyCustomer.ie = buyer.inscription_number;
+    }
+    if (buyer.main_email && buyer.main_email.length <= 50) {
+      tinyCustomer.email = buyer.main_email;
+    }
+    if (shippingAddress) {
+      parseAddress(billingAddress || shippingAddress, tinyCustomer);
+    }
+    const phone = buyer.phones && buyer.phones[0];
+    if (phone) {
+      tinyCustomer.fone = phone.country_code ? `+${phone.country_code} ` : '';
+      tinyCustomer.fone += phone.number;
+    }
+    tinyOrder.cliente = tinyCustomer;
+  } else {
+    tinyOrder.cliente = {
+      nome: `Comprador de #${orderRef}`,
+    };
+  }
+
+  if (shippingAddress && billingAddress) {
+    tinyOrder.endereco_entrega = {};
+    parseAddress(shippingAddress, tinyOrder.endereco_entrega);
+    if (shippingAddress.name) {
+      tinyOrder.endereco_entrega.nome_destinatario = shippingAddress.name.substring(0, 60);
+    }
+  }
+
+  if (order.items) {
+    order.items.forEach((item) => {
+      if (item.quantity) {
+        const itemRef = (item.sku || item._id || Math.random().toString()).substring(0, 30);
+        tinyOrder.itens.push({
+          item: {
+            codigo: itemRef,
+            descricao: item.name ? item.name.substring(0, 120) : itemRef,
+            unidade: 'UN',
+            quantidade: item.quantity,
+            valor_unitario: ecomUtils.price(item),
+          },
+        });
+      }
+    });
+  }
+
+  if (order.payment_method_label) {
+    tinyOrder.meio_pagamento = order.payment_method_label;
+  }
+  if (transaction) {
+    switch (transaction.payment_method.code) {
+      case 'credit_card':
+        tinyOrder.forma_pagamento = 'credito';
+        break;
+      case 'banking_billet':
+        tinyOrder.forma_pagamento = 'boleto';
+        break;
+      case 'account_deposit':
+        tinyOrder.forma_pagamento = 'deposito';
+        break;
+      case 'online_debit':
+      case 'debit_card':
+      case 'balance_on_intermediary':
+        tinyOrder.forma_pagamento = 'debito';
+        break;
+      default:
+        tinyOrder.forma_pagamento = 'multiplas';
+    }
+    if (!tinyOrder.meio_pagamento && transaction.payment_method.name) {
+      tinyOrder.meio_pagamento = transaction.payment_method.name.substring(0, 100);
+    }
+  }
+
+  if (order.shipping_method_label) {
+    tinyOrder.forma_frete = order.shipping_method_label;
+  }
+  if (shippingLine) {
+    tinyOrder.forma_envio = 'X';
+    if (shippingLine.app) {
+      const { carrier } = shippingLine.app;
+      if (carrier) {
+        if (/correios/i.test(carrier)) {
+          tinyOrder.forma_envio = 'C';
+        } else if (/b2w/i.test(carrier)) {
+          tinyOrder.forma_envio = 'B';
+        } else if (/mercado envios/i.test(carrier)) {
+          tinyOrder.forma_envio = 'M';
+        } else {
+          tinyOrder.forma_envio = 'T';
+        }
+      }
+      if (
+        (!tinyOrder.forma_envio || tinyOrder.forma_envio === 'X' || tinyOrder.forma_envio === 'T')
+        && shippingLine.app.service_name && /(pac|sedex)/i.test(shippingLine.app.service_name)
+      ) {
+        tinyOrder.forma_envio = 'C';
+      }
+      if (!tinyOrder.forma_frete && shippingLine.app.label) {
+        tinyOrder.forma_frete = shippingLine.app.label;
+      }
+    }
+  } else {
+    tinyOrder.forma_envio = 'S';
+  }
+
+  const { amount } = order;
+  if (amount) {
+    if (typeof amount.freight === 'number') {
+      tinyOrder.valor_frete = amount.freight;
+      if (amount.tax) {
+        tinyOrder.valor_frete += amount.tax;
+      }
+      if (amount.extra) {
+        tinyOrder.valor_frete += amount.extra;
+      }
+    }
+    if (amount.discount) {
+      tinyOrder.valor_desconto = amount.discount;
+    }
+  }
+
+  if (order.notes) {
+    tinyOrder.obs = order.notes.substring(0, 100);
+  }
+  if (order.extra_discount && order.extra_discount.discount_coupon) {
+    tinyOrder.obs = `${(tinyOrder.obs || '')} - ${order.extra_discount.discount_coupon}`
+      .substring(0, 100);
+  }
+  if (order.staff_notes) {
+    tinyOrder.obs_internas = order.staff_notes.substring(0, 100);
+  }
+
+  if (appData.tiny_order_data && typeof appData.tiny_order_data === 'object') {
+    Object.keys(appData.tiny_order_data).forEach((field) => {
+      let value = appData.tiny_order_data[field];
+      switch (value) {
+        case undefined:
+        case '':
+        case null:
+          break;
+        default:
+          if (typeof value === 'string') {
+            value = value.trim();
+            if (value) {
+              tinyOrder[field] = value;
+            }
+          } else {
+            tinyOrder[field] = value;
+          }
+      }
+    });
+  }
+  return tinyOrder;
+};