@cloudcommerce/app-tiny-erp 0.0.59 → 0.0.60

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;
+};

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

@@ -0,0 +1,215 @@
+import type { Products } from '@cloudcommerce/types';
+import logger from 'firebase-functions/lib/logger';
+import axios from 'axios';
+import FormData from 'form-data';
+import ecomUtils from '@ecomplus/utils';
+import getEnv from '@cloudcommerce/firebase/lib/env';
+
+const removeAccents = (str: string) => str.replace(/áàãâÁÀÃÂ/g, 'a')
+  .replace(/éêÉÊ/g, 'e')
+  .replace(/óõôÓÕÔ/g, 'o')
+  .replace(/íÍ/g, 'e')
+  .replace(/úÚ/g, 'u')
+  .replace(/çÇ/g, 'c');
+
+const tryImageUpload = (originImgUrl: string, product: Products) => new Promise((resolve) => {
+  const {
+    storeId,
+    apiAuth: {
+      authenticationId,
+      apiKey,
+    },
+  } = getEnv();
+  axios.get(originImgUrl, {
+    responseType: 'arraybuffer',
+  }).then(({ data }) => {
+    const form = new FormData();
+    form.append('file', Buffer.from(data), originImgUrl.replace(/.*\/([^/]+)$/, '$1'));
+
+    return axios.post(`https://apx-storage.e-com.plus/${storeId}/api/v1/upload.json`, form, {
+      headers: {
+        ...form.getHeaders(),
+        'X-Store-ID': storeId,
+        'X-My-ID': authenticationId,
+        'X-API-Key': apiKey,
+      },
+    }).then(({ data, status }) => {
+      if (data.picture) {
+        Object.keys(data.picture).forEach((imgSize) => {
+          if (data.picture[imgSize]) {
+            if (!data.picture[imgSize].url) {
+              delete data.picture[imgSize];
+              return;
+            }
+            if (data.picture[imgSize].size !== undefined) {
+              delete data.picture[imgSize].size;
+            }
+            data.picture[imgSize].alt = `${product.name} (${imgSize})`;
+          }
+        });
+        if (Object.keys(data.picture).length) {
+          return resolve({
+            _id: ecomUtils.randomObjectId(),
+            ...data.picture,
+          });
+        }
+      }
+      const err: any = new Error('Unexpected Storage API response');
+      err.response = { data, status };
+      throw err;
+    });
+  })
+
+    .catch((err) => {
+      logger.error(err);
+      resolve({
+        _id: ecomUtils.randomObjectId(),
+        normal: {
+          url: originImgUrl,
+          alt: product.name,
+        },
+      });
+    });
+}).then((picture) => {
+  if (product && product.pictures) {
+    // @ts-ignore
+    product.pictures.push(picture);
+  }
+  return picture;
+});
+
+export default (tinyProduct, isNew = true) => new Promise((resolve) => {
+  const sku = tinyProduct.codigo || String(tinyProduct.id);
+  const name = (tinyProduct.nome || sku).trim();
+  const product: Omit<Products, '_id'| 'store_id' | 'created_at' | 'updated_at'> = {
+    available: tinyProduct.situacao === 'A',
+    sku,
+    name,
+    cost_price: tinyProduct.preco_custo,
+    price: tinyProduct.preco_promocional || tinyProduct.preco,
+    base_price: tinyProduct.preco,
+    body_html: tinyProduct.descricao_complementar,
+  };
+
+  if (isNew) {
+    product.slug = removeAccents(name.toLowerCase())
+      .replace(/\s+/g, '-')
+      .replace(/[^a-z0-9-_./]/g, '');
+    if (!/[a-z0-9]/.test(product.slug.charAt(0))) {
+      product.slug = `p-${product.slug}`;
+    }
+  }
+  if (tinyProduct.garantia) {
+    product.warranty = tinyProduct.garantia;
+  }
+  if (tinyProduct.unidade_por_caixa) {
+    product.min_quantity = Number(tinyProduct.unidade_por_caixa);
+  }
+  if (tinyProduct.ncm) {
+    product.mpn = [tinyProduct.ncm];
+  }
+  const validateGtin = (gtin) => {
+    return typeof gtin === 'string' && /^([0-9]{8}|[0-9]{12,14})$/.test(gtin);
+  };
+  if (validateGtin(tinyProduct.gtin)) {
+    product.gtin = [tinyProduct.gtin];
+    if (validateGtin(tinyProduct.gtin_embalagem)) {
+      product.gtin.push(tinyProduct.gtin_embalagem);
+    }
+  }
+
+  const weight = tinyProduct.peso_bruto || tinyProduct.peso_liquido;
+  if (weight > 0) {
+    product.weight = {
+      unit: 'kg',
+      value: parseFloat(weight),
+    };
+  }
+  [
+    ['largura', 'width'],
+    ['altura', 'height'],
+    ['comprimento', 'length'],
+  ].forEach(([lado, side]) => {
+    const dimension = tinyProduct[`${lado}_embalagem`] || tinyProduct[`${lado}Embalagem`];
+    if (dimension > 0) {
+      if (!product.dimensions) {
+        product.dimensions = {};
+      }
+      product.dimensions[side] = {
+        unit: 'cm',
+        value: parseFloat(dimension),
+      };
+    }
+  });
+
+  if (isNew) {
+    if (Array.isArray(tinyProduct.variacoes) && tinyProduct.variacoes.length) {
+      product.variations = [];
+      tinyProduct.variacoes.forEach(({ variacao }) => {
+        const { codigo, preco, grade } = variacao;
+        if (grade && typeof grade === 'object') {
+          const specifications = {};
+          const specTexts: string[] = [];
+          Object.keys(grade).forEach((tipo) => {
+            if (grade[tipo]) {
+              const gridId = removeAccents(tipo.toLowerCase())
+                .replace(/\s+/g, '_')
+                .replace(/[^a-z0-9_]/g, '')
+                .substring(0, 30)
+                .padStart(2, 'i');
+              const spec: Record<string, string> = {
+                text: grade[tipo],
+              };
+              specTexts.push(spec.text);
+              if (gridId !== 'colors') {
+                spec.value = removeAccents(spec.text.toLowerCase()).substring(0, 100);
+              }
+              specifications[gridId] = [spec];
+            }
+          });
+
+          if (specTexts.length) {
+            product.variations?.push({
+              _id: ecomUtils.randomObjectId(),
+              name: `${name} / ${specTexts.join(' / ')}`.substring(0, 100),
+              sku: codigo,
+              specifications,
+              price: parseFloat(preco || 0),
+            });
+          }
+        }
+      });
+    }
+
+    if (Array.isArray(tinyProduct.imagens_externas)) {
+      product.pictures = [];
+      tinyProduct.imagens_externas.forEach((imagemExterna) => {
+        if (imagemExterna.imagem_externa) {
+          const { url } = imagemExterna.imagem_externa;
+          if (url) {
+            product.pictures?.push({
+              normal: { url },
+              _id: ecomUtils.randomObjectId(),
+            });
+          }
+        }
+      });
+    }
+
+    if (tinyProduct.anexos) {
+      if (!product.pictures) {
+        product.pictures = [];
+      }
+      const promises: Promise<any>[] = [];
+      tinyProduct.anexos.forEach(({ anexo }) => {
+        if (typeof anexo === 'string' && anexo.startsWith('http')) {
+          promises.push(tryImageUpload(anexo, product as Products));
+        }
+      });
+      Promise.all(promises).then(() => resolve(product));
+      return;
+    }
+  }
+
+  resolve(product);
+});

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

@@ -0,0 +1,138 @@
+/* eslint-disable no-nested-ternary */
+import type { Products } from '@cloudcommerce/types';
+import ecomUtils from '@ecomplus/utils';
+
+export default async (product: Products, originalTinyProduct, appData) => {
+  const hasVariations = product.variations && product.variations.length;
+  const tinyProduct: Record<string, any> = {
+    sequencia: 1,
+    origem: 0,
+    situacao: product.available && product.visible ? 'A' : 'I',
+    tipo: 'P',
+    classe_produto: hasVariations ? 'V' : 'S',
+    codigo: product.sku,
+    nome: ecomUtils.name(product, 'pt_br').substring(0, 120),
+    unidade: originalTinyProduct && originalTinyProduct.unidade
+      ? originalTinyProduct.unidade
+      : product.measurement && product.measurement.unit !== 'oz' && product.measurement.unit !== 'ct'
+        ? product.measurement.unit.substring(0, 3).toUpperCase()
+        : 'UN',
+  };
+
+  if (ecomUtils.onPromotion(product)) {
+    tinyProduct.preco = product.base_price;
+    tinyProduct.preco_promocional = ecomUtils.price(product);
+  } else {
+    tinyProduct.preco = product.price;
+  }
+  if (product.cost_price) {
+    tinyProduct.preco_custo = product.cost_price;
+  }
+  if (product.min_quantity) {
+    tinyProduct.unidade_por_caixa = product.min_quantity < 1000
+      ? String(product.min_quantity) : '999';
+  }
+
+  if (product.short_description) {
+    tinyProduct.descricao_complementar = product.short_description;
+  }
+  if (product.warranty) {
+    tinyProduct.garantia = product.warranty.substring(0, 20);
+  }
+
+  if (product.mpn && product.mpn.length) {
+    [tinyProduct.ncm] = product.mpn;
+  }
+  if (product.gtin && product.gtin.length) {
+    [tinyProduct.gtin] = product.gtin;
+    if (product.gtin[1]) {
+      // eslint-disable-next-line prefer-destructuring
+      tinyProduct.gtin_embalagem = product.gtin[1];
+    }
+  }
+
+  if (product.weight && product.weight.value) {
+    tinyProduct.peso_bruto = product.weight.value;
+    if (product.weight.unit === 'mg') {
+      tinyProduct.peso_bruto /= 1000000;
+    } else if (product.weight.unit === 'g') {
+      tinyProduct.peso_bruto /= 1000;
+    }
+  }
+  const { dimensions } = product;
+  if (dimensions) {
+    Object.keys(dimensions).forEach((side) => {
+      if (dimensions[side] && dimensions[side].value) {
+        let field = side === 'width' ? 'largura'
+          : side === 'height' ? 'altura'
+            : 'comprimento';
+        field += '_embalagem';
+        tinyProduct[field] = dimensions[side].value;
+        if (dimensions[side].unit === 'mm') {
+          tinyProduct[field] *= 0.1;
+        } else if (dimensions[side].unit === 'm') {
+          tinyProduct[field] *= 100;
+        }
+      }
+    });
+  }
+
+  if (product.brands && product.brands.length) {
+    tinyProduct.marca = product.brands[0].name;
+  }
+  if (product.category_tree) {
+    tinyProduct.categoria = product.category_tree.replace(/\s?>\s?/g, ' >> ');
+  } else if (product.categories && product.categories.length) {
+    tinyProduct.categoria = product.categories.map(({ name }) => name).join(' >> ');
+  }
+
+  if (product.pictures && product.pictures.length) {
+    tinyProduct.anexos = [];
+    product.pictures.forEach(({ zoom, big, normal }) => {
+      const img = (zoom || big || normal) as { url: string };
+      if (img) {
+        tinyProduct.anexos.push({
+          anexo: img.url,
+        });
+      }
+    });
+  }
+
+  if (originalTinyProduct) {
+    tinyProduct.id = originalTinyProduct.id;
+    if (!appData.update_price) {
+      ['preco', 'preco_promocional', 'preco_custo'].forEach((field) => {
+        if (typeof originalTinyProduct[field] === 'number') {
+          tinyProduct[field] = originalTinyProduct[field];
+        }
+      });
+    }
+  } else {
+    tinyProduct.estoque_atual = product.quantity || 0;
+  }
+
+  if (hasVariations) {
+    tinyProduct.variacoes = [];
+    product.variations?.forEach((variation, i) => {
+      const tinyVariation: Record<string, any> = {
+        codigo: variation.sku || `${product.sku}-${(i + 1)}`,
+        grade: {},
+      };
+      if (!originalTinyProduct) {
+        tinyVariation.estoque_atual = variation.quantity || 0;
+      }
+      Object.keys(variation.specifications).forEach((gridId) => {
+        const gridOptions = variation.specifications[gridId];
+        if (gridOptions && gridOptions.length) {
+          gridOptions.forEach(({ text }, i) => {
+            tinyVariation.grade[i === 0 ? gridId : `${gridId}_${(i + 1)}`] = text;
+          });
+        }
+      });
+      tinyProduct.variacoes.push({
+        variacao: tinyVariation,
+      });
+    });
+  }
+  return tinyProduct;
+};

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

@@ -0,0 +1,35 @@
+import type { Orders } from '@cloudcommerce/types';
+
+export default (situacao: string) => {
+  let financialStatus: Exclude<Orders['financial_status'], undefined>['current'] | undefined;
+  let fulfillmentStatus: Exclude<Orders['fulfillment_status'], undefined>['current'] | undefined;
+  switch (situacao) {
+    case 'aprovado':
+      financialStatus = 'paid';
+      break;
+    case 'preparando_envio':
+    case 'preparando envio':
+      fulfillmentStatus = 'in_separation';
+      break;
+    case 'faturado':
+    case 'faturado (atendido)':
+    case 'atendido':
+      fulfillmentStatus = 'invoice_issued';
+      break;
+    case 'pronto_envio':
+    case 'pronto para envio':
+      fulfillmentStatus = 'ready_for_shipping';
+      break;
+    case 'enviado':
+      fulfillmentStatus = 'shipped';
+      break;
+    case 'entregue':
+      fulfillmentStatus = 'delivered';
+      break;
+    case 'cancelado':
+      financialStatus = 'voided';
+      break;
+    default:
+  }
+  return { financialStatus, fulfillmentStatus };
+};

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

@@ -0,0 +1,42 @@
+import type { Orders } from '@cloudcommerce/types';
+
+export default (order: Orders) => {
+  const financialStatus = order.financial_status && order.financial_status.current;
+  switch (financialStatus) {
+    case 'pending':
+    case 'under_analysis':
+    case 'unknown':
+    case 'authorized':
+    case 'partially_paid':
+      return 'aberto';
+    case 'voided':
+    case 'refunded':
+    case 'in_dispute':
+    case 'unauthorized':
+      return 'cancelado';
+    default:
+  }
+
+  switch (order.fulfillment_status && order.fulfillment_status.current) {
+    case 'in_production':
+    case 'in_separation':
+      return 'preparando_envio';
+    case 'invoice_issued':
+      return 'faturado';
+    case 'ready_for_shipping':
+      return 'pronto_envio';
+    case 'shipped':
+    case 'partially_shipped':
+      return 'enviado';
+    case 'delivered':
+      return 'entregue';
+    case 'returned':
+      return 'cancelado';
+    default:
+  }
+
+  if (financialStatus === 'paid') {
+    return 'aprovado';
+  }
+  return 'aberto';
+};

package/src/integration/post-tiny-erp.ts

@@ -0,0 +1,52 @@
+import axios, { AxiosRequestConfig } from 'axios';
+
+export default (
+  url: string,
+  body: Record<string, any>,
+  token = process.env.TINY_ERP_TOKEN,
+  options: AxiosRequestConfig = {},
+) => {
+  // https://www.tiny.com.br/ajuda/api/api2
+  let data = `token=${token}&formato=JSON`;
+  if (body) {
+    Object.keys(body).forEach((field) => {
+      if (body[field]) {
+        switch (typeof body[field]) {
+          case 'object':
+            data += `&${field}=${JSON.stringify(body[field])}`;
+            break;
+          case 'string':
+          case 'number':
+            data += `&${field}=${body[field]}`;
+            break;
+          default:
+        }
+      }
+    });
+  }
+
+  return axios.post(url, data, {
+    baseURL: 'https://api.tiny.com.br/api2/',
+    timeout: 30000,
+    ...options,
+  })
+    .then((response) => {
+      const { retorno } = response.data;
+      if (retorno.status === 'Erro') {
+        const err: any = new Error('Tiny error response');
+        const tinyErrorCode = parseInt(retorno.codigo_erro, 10);
+        if (tinyErrorCode <= 2) {
+          response.status = 401;
+        } else if (tinyErrorCode === 6) {
+          response.status = 503;
+        } else if (tinyErrorCode === 20) {
+          response.status = 404;
+        }
+        err.response = response;
+        err.config = response.config;
+        err.request = response.request;
+        throw err;
+      }
+      return retorno;
+    });
+};