Integração

Se você já possui ferramentas digitais para gerenciar o que está armazenado em seu armazém, ou como você lida com listas de carga de clientes, o Cargo-Planner pode se basear nisso com um pouco de integração.

Sincronização da Biblioteca de Cargas

A maneira mais simples de conseguir uma integração com suas ferramentas atuais é através da Biblioteca de Cargas. Todas as licenças do Cargo-Planner incluem a Biblioteca de Cargas, que é essencialmente um WMS mínimo ou sistema de planejamento de recursos.

Tê-la configurada facilita a criação de novas listas de carga em nosso aplicativo web, através de importações suaves ou autocompletar.

Este método pode essencialmente ser executado como um trabalho CRON ou sincronização diária, e o Cargo-Planner cuidará de todos os aspectos da interface do usuário para criar uma lista de carga.

Mas configurar manualmente a Biblioteca de Cargas pode ser uma tarefa e tanto. Então, vamos mantê-la sincronizada com qualquer ferramenta que você use atualmente, com um pouco de código.

// Verifique a página de Introdução para descobrir como criar seu token
const API_TOKEN = 'Token b123...';
const cargoes: CargoPlannerItem[] = [];

// vamos supor que temos uma fonte de itens/cargas que se parece com isto,
// onde tudo é definido em milímetros e gramas.
const sourceItems = [
  {
    id: 511732,
    title: 'Basket Catcher',
    description: '...',
    length: 900,
    width: 900,
    height: 500,
    weight: 20000,
    inner_quantity: 1,
  },
  {
    id: 512789,
    title: 'Putters (10pcs)',
    description: '...',
    length: 210,
    width: 210,
    height: 150,
    weight: 1700,
    inner_quantity: 10,
  },
  // ... etc
];

// Nossos sourceItems são um pouco diferentes
// de como são representados no cargo-planner
// então precisamos adaptar os dados
for (let i = 0; i < sourceItems.length; i++) {
  let s = sourceItems[i];
  // queremos que tanto nosso ID quanto o título sejam armazenados como nome
  const title = `${s.id} - ${s.title}`;

  let cargo: CargoPlannerItem = {
    name: title,
    length_dim: 'MM',
    // Cargo-Planner não aceita gramas, então convertemos para quilogramas
    weight_dim: 'KG',
    data: {
      label: title,
      l: s.length,
      w: s.width,
      h: s.height,
      wt: s.weight / 1000, // a conversão de peso
      unit_qty: s.inner_quantity,
    },
  };
  cargoes.push(cargo);
}

// Antes de criarmos todos os itens, primeiro queremos
// remover tudo que existe na biblioteca de cargas,
// para não termos duplicatas.
// Vamos usar o endpoint cargo/truncate para isso
fetch('https://api.cargo-planner.com/api/2/cargo/truncate/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: API_TOKEN,
  },
  body: JSON.stringify({ confirm: true }),
});

// E finalmente criamos em massa a lista de cargas
fetch('https://api.cargo-planner.com/api/2/cargo/bulk_create/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: API_TOKEN,
  },
  body: JSON.stringify(cargoes),
});

// definições de tipo simplificadas do que o Cargo-Planner aceita
interface CargoPlannerItem {
  name: string;
  data: ItemData;
  length_dim: 'M' | 'DM' | 'CM' | 'MM' | 'FT' | 'IN';
  weight_dim: 'KG' | 'MT' | 'LB';
}
interface ItemData {
  label: string;
  l: number;
  w: number;
  h: number;
  wt: number;
  not_stackable?: boolean | null;
  not_rotatable?: boolean | null;
  tiltable?: boolean | null;
  bottom_only?: boolean | null;
  color?: string | null;
  qty?: number | null;
  unit_qty?: number | null;
}

Agora, não precisaremos passar por importações/exportações do Excel novamente, e planejar o próximo envio será muito mais rápido.

Criando listas de carga diretamente

Se você quiser criar listas de carga diretamente de suas outras ferramentas, isso não é muito diferente do exemplo anterior em termos de chamadas de API. Desta vez, vamos pular a Biblioteca de Cargas completamente e ir direto para uma nova lista de carga.

A desvantagem deste método é que você precisa escolher o que enviar e quantos de cada antes de chamar a API. Isso provavelmente exigirá um pouco de interface do usuário.

// estamos reutilizando as constantes sourceItems e API_TOKEN
// do exemplo anterior

let cargoes: ItemData[] = [];

// A conversão de sourceItem para a representação do Cargo-Planner
for (let i = 0; i < source.length; i++) {
  let s = source[i];
  // queremos que tanto nosso ID quanto o título sejam armazenados como nome
  const title = `${s.id} - ${s.title}`;

  let cargo: ItemData = {
    label: title,
    l: s.length,
    w: s.width,
    h: s.height,
    // a conversão de peso de gramas para quilogramas
    wt: s.weight / 1000,
    unit_qty: s.inner_quantity,
    // queremos enviar 10 de cada item
    qty: 10,
  };
  cargoes.push(cargo);
}

// E finalmente criamos uma lista de carga
fetch('https://api.cargo-planner.com/api/2/loadlist/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: API_TOKEN,
  },
  body: JSON.stringify({
    name: 'Envio 123',
    data: cargoes,
    etd: '2022-12-01',
    length_dim: 'MM',
    weight_dim: 'KG',
  }),
});

A nova lista de carga será visível no aplicativo web, mas a resposta conterá uma URL vinculando diretamente à nova lista de carga.

Também é possível dar mais um passo adiante com o endpoint Criar e calcular, mas isso exigirá mais dados de entrada, como quais configurações e equipamentos usar.