Integración

Si ya tienes herramientas digitales para gestionar lo que se almacena en tu almacén, o cómo manejas las listas de carga de clientes, Cargo-Planner puede construir sobre eso con un poco de integración.

Sincronización de la Biblioteca de Carga

La forma más sencilla de lograr una integración con tus herramientas actuales es a través de la Biblioteca de Carga. Todas las licencias de Cargo-Planner incluyen la Biblioteca de Carga, que es esencialmente un sistema mínimo de WMS o planificación de recursos.

Tenerlo configurado facilita la creación de nuevas listas de carga en nuestra aplicación web, a través de importaciones fluidas o autocompletado.

Este método puede ejecutarse esencialmente como un trabajo CRON o sincronización diaria, y Cargo-Planner se encargará de todos los aspectos de la interfaz de usuario para crear una lista de carga.

Pero configurar la Biblioteca de Carga manualmente puede ser una tarea considerable. Así que mantengámosla sincronizada con cualquier herramienta que uses actualmente, con un poco de código.

// Consulta la página de Introducción para saber cómo crear tu token
const API_TOKEN = 'Token b123...';
const cargoes: CargoPlannerItem[] = [];

// vamos a suponer que tenemos una fuente de artículos/cargas que se ve así,
// donde todo está definido en milímetros y gramos.
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
];

// Nuestros sourceItems son un poco diferentes
// de cómo se representan en cargo-planner
// así que necesitamos hacer alguna adaptación de los datos
for (let i = 0; i < sourceItems.length; i++) {
  let s = sourceItems[i];
  // queremos que tanto nuestro ID como el título se almacenen como el nombre
  const title = `${s.id} - ${s.title}`;

  let cargo: CargoPlannerItem = {
    name: title,
    length_dim: 'MM',
    // Cargo-Planner no acepta gramos, así que convertimos a kilogramos
    weight_dim: 'KG',
    data: {
      label: title,
      l: s.length,
      w: s.width,
      h: s.height,
      wt: s.weight / 1000, // la conversión de peso
      unit_qty: s.inner_quantity,
    },
  };
  cargoes.push(cargo);
}

// Antes de crear todos los artículos primero queremos
// eliminar todo lo que existe en la biblioteca de carga,
// para no tener duplicados.
// Usemos el endpoint cargo/truncate para esto
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 }),
});

// Y finalmente creamos en masa la 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),
});

// definiciones de tipo simplificadas de lo que acepta Cargo-Planner
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;
}

Ahora, no tendremos que pasar por importaciones/exportaciones de Excel nuevamente, y planificar el próximo envío será mucho más rápido.

Creación de listas de carga directamente

Si deseas crear listas de carga directamente desde tus otras herramientas, no es muy diferente del ejemplo anterior en términos de llamadas a la API. Esta vez omitiremos completamente la Biblioteca de Carga e iremos directamente a por una nueva lista de carga.

La desventaja de este método es que necesitas elegir qué enviar y cuántos de cada uno antes de llamar a la API. Esto probablemente requerirá un poco de interfaz de usuario.

// estamos reutilizando las constantes sourceItems y API_TOKEN
// del ejemplo anterior

let cargoes: ItemData[] = [];

// La conversión de sourceItem a la representación de Cargo-Planner
for (let i = 0; i < source.length; i++) {
  let s = source[i];
  // queremos que tanto nuestro ID como el título se almacenen como el nombre
  const title = `${s.id} - ${s.title}`;

  let cargo: ItemData = {
    label: title,
    l: s.length,
    w: s.width,
    h: s.height,
    // la conversión de peso de gramos a kilogramos
    wt: s.weight / 1000,
    unit_qty: s.inner_quantity,
    // queremos enviar 10 de cada artículo
    qty: 10,
  };
  cargoes.push(cargo);
}

// Y finalmente creamos una 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: 'Envío 123',
    data: cargoes,
    etd: '2022-12-01',
    length_dim: 'MM',
    weight_dim: 'KG',
  }),
});

La nueva lista de carga será visible en la aplicación web, pero la respuesta contendrá una URL que enlaza directamente a la nueva lista de carga.

También es posible llevar esto un paso más allá con el endpoint Crear y calcular, pero esto requerirá más datos de entrada, como qué configuraciones y equipos usar.