Integrazione

Se hai già strumenti digitali per gestire ciò che è immagazzinato nel tuo magazzino, o come gestisci le liste di carico dei clienti, Cargo-Planner può costruire su questo con un po’ di integrazione.

Sincronizzazione della Libreria Cargo

Il modo più semplice per ottenere un’integrazione con i tuoi strumenti attuali è attraverso la Libreria Cargo. Tutte le licenze di Cargo-Planner includono la Libreria Cargo, che è essenzialmente un sistema WMS o di pianificazione delle risorse minimale.

Averla configurata rende facile creare nuove liste di carico nella nostra app web, attraverso importazioni fluide o autocompletamento.

Questo metodo può essenzialmente essere eseguito come un lavoro CRON o una sincronizzazione giornaliera, e Cargo-Planner si occuperà di tutti gli aspetti dell’interfaccia utente per creare una lista di carico.

Ma configurare manualmente la Libreria Cargo può essere un compito piuttosto impegnativo. Quindi manteniamola sincronizzata con qualsiasi strumento tu stia attualmente utilizzando, con un po’ di codice.

// Controlla la pagina Getting Started per scoprire come creare il tuo token
const API_TOKEN = 'Token b123...';
const cargoes: CargoPlannerItem[] = [];

// supponiamo di avere una fonte di articoli/cargoes che appare così,
// dove tutto è definito in millimetri e grammi.
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
];

// I nostri sourceItems sono un po' diversi
// da come sono rappresentati in cargo-planner
// quindi dobbiamo fare qualche adattamento dei dati
for (let i = 0; i < sourceItems.length; i++) {
  let s = sourceItems[i];
  // vogliamo che sia il nostro ID che il titolo siano memorizzati come nome
  const title = `${s.id} - ${s.title}`;

  let cargo: CargoPlannerItem = {
    name: title,
    length_dim: 'MM',
    // Cargo-Planner non accetta grammi, quindi convertiamo in chilogrammi
    weight_dim: 'KG',
    data: {
      label: title,
      l: s.length,
      w: s.width,
      h: s.height,
      wt: s.weight / 1000, // la conversione del peso
      unit_qty: s.inner_quantity,
    },
  };
  cargoes.push(cargo);
}

// Prima di creare tutti gli articoli vogliamo prima
// rimuovere tutto ciò che esiste nella libreria cargo,
// così non avremo duplicati.
// Usiamo l'endpoint cargo/truncate per questo
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 infine creiamo in blocco la lista dei cargoes
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),
});

// definizioni di tipo semplificate di ciò che Cargo-Planner accetta
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;
}

Ora, non dovremo più passare attraverso importazioni/esportazioni Excel, e pianificare la prossima spedizione sarà molto più veloce.

Creazione diretta delle liste di carico

Se vuoi creare liste di carico direttamente dai tuoi altri strumenti, non è molto diverso dall’esempio precedente in termini di chiamate API. Questa volta salteremo completamente la Libreria Cargo e andremo direttamente per una nuova lista di carico.

Lo svantaggio di questo metodo è che devi scegliere cosa spedire e quanti di ciascuno prima di chiamare l’API. Questo richiederà molto probabilmente un po’ di interfaccia utente.

// stiamo riutilizzando le costanti sourceItems e API_TOKEN
// dall'esempio precedente

let cargoes: ItemData[] = [];

// La conversione da sourceItem alla rappresentazione di Cargo-Planner
for (let i = 0; i < source.length; i++) {
  let s = source[i];
  // vogliamo che sia il nostro ID che il titolo siano memorizzati come nome
  const title = `${s.id} - ${s.title}`;

  let cargo: ItemData = {
    label: title,
    l: s.length,
    w: s.width,
    h: s.height,
    // la conversione del peso da grammi a chilogrammi
    wt: s.weight / 1000,
    unit_qty: s.inner_quantity,
    // vogliamo inviare 10 di ciascun articolo
    qty: 10,
  };
  cargoes.push(cargo);
}

// E infine creiamo una lista di carico
fetch('https://api.cargo-planner.com/api/2/loadlist/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: API_TOKEN,
  },
  body: JSON.stringify({
    name: 'Shipment 123',
    data: cargoes,
    etd: '2022-12-01',
    length_dim: 'MM',
    weight_dim: 'KG',
  }),
});

La nuova lista di carico sarà visibile nell’app web, ma la risposta conterrà un URL che collega direttamente alla nuova lista di carico.

È anche possibile fare un ulteriore passo avanti con l’endpoint Crea e calcola, ma questo richiederà alcuni dati di input aggiuntivi, come quali impostazioni e attrezzature utilizzare.