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 los clientes, Cargo-Planner puede construir sobre eso con un poco de integración.

Sincronización de la Cargo Library

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

Tenerla configurada 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 Cargo Library 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 ítems/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 algunas adaptaciones 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 ítems, primero queremos
// eliminar todo lo que existe en la cargo-library,
// 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 directa de listas de carga

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 Cargo Library e iremos directamente a 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 ítem
    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 con 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á algunos datos de entrada adicionales, como qué configuraciones y equipos usar.