Intégration

Si vous disposez déjà d’outils numériques pour gérer ce qui est stocké dans votre entrepôt, ou comment vous gérez les listes de chargement des clients, Cargo-Planner peut s’appuyer sur cela avec un peu d’intégration.

Synchronisation de la Cargo Library

La manière la plus simple d’obtenir une intégration avec vos outils actuels est via la Cargo Library. Toutes les licences Cargo-Planner incluent la Cargo Library, qui est essentiellement un système de gestion d’entrepôt (WMS) ou de planification des ressources minimal.

L’avoir configuré facilite la création de nouvelles listes de chargement dans notre application web, grâce à des importations fluides ou à l’auto-complétion.

Cette méthode peut essentiellement être exécutée comme un travail CRON ou une synchronisation quotidienne, et Cargo-Planner s’occupera de tous les aspects de l’interface utilisateur pour créer une liste de chargement.

Mais configurer manuellement la Cargo Library peut être une tâche ardue. Alors gardons-la synchronisée avec l’outil que vous utilisez actuellement, avec un peu de code.

// Consultez la page de démarrage pour savoir comment créer votre jeton
const API_TOKEN = 'Token b123...';
const cargoes: CargoPlannerItem[] = [];

// faisons semblant d'avoir une source d'articles/cargaisons qui ressemble à ceci,
// où tout est défini en millimètres et en grammes.
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
];

// Notre sourceItems est un peu différente
// de la façon dont elle est représentée dans cargo-planner
// donc nous devons adapter un peu les données
for (let i = 0; i < sourceItems.length; i++) {
  let s = sourceItems[i];
  // nous voulons que notre ID et notre titre soient stockés comme le nom
  const title = `${s.id} - ${s.title}`;

  let cargo: CargoPlannerItem = {
    name: title,
    length_dim: 'MM',
    // Cargo-Planner n'accepte pas les grammes, donc nous convertissons en kilogrammes
    weight_dim: 'KG',
    data: {
      label: title,
      l: s.length,
      w: s.width,
      h: s.height,
      wt: s.weight / 1000, // la conversion du poids
      unit_qty: s.inner_quantity,
    },
  };
  cargoes.push(cargo);
}

// Avant de créer tous les articles, nous voulons d'abord
// supprimer tout ce qui existe dans la cargo-library,
// pour éviter les doublons.
// Utilisons le point de terminaison cargo/truncate pour cela
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 }),
});

// Et enfin, nous créons en masse la liste des cargaisons
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),
});

// définitions de type simplifiées de ce que Cargo-Planner accepte
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;
}

Maintenant, nous n’aurons plus besoin de passer par des importations/exportations Excel, et planifier le prochain envoi sera beaucoup plus rapide.

Création de listes de chargement directement

Si vous souhaitez créer des listes de chargement directement à partir de vos autres outils, ce n’est pas très différent de l’exemple précédent en termes d’appels API. Cette fois, nous allons ignorer complètement la Cargo Library et aller directement pour une nouvelle liste de chargement.

L’inconvénient de cette méthode est que vous devez choisir quoi expédier, et combien de chaque avant d’appeler l’API. Cela nécessitera probablement un peu d’interface utilisateur.

// nous réutilisons les constantes sourceItems et API_TOKEN
// de l'exemple précédent

let cargoes: ItemData[] = [];

// La conversion de sourceItem à la représentation de Cargo-Planner
for (let i = 0; i < source.length; i++) {
  let s = source[i];
  // nous voulons que notre ID et notre titre soient stockés comme le nom
  const title = `${s.id} - ${s.title}`;

  let cargo: ItemData = {
    label: title,
    l: s.length,
    w: s.width,
    h: s.height,
    // la conversion du poids de grammes à kilogrammes
    wt: s.weight / 1000,
    unit_qty: s.inner_quantity,
    // nous voulons envoyer 10 de chaque article
    qty: 10,
  };
  cargoes.push(cargo);
}

// Et enfin, nous créons une liste de chargement
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 nouvelle liste de chargement sera visible dans l’application web, mais la réponse contiendra une URL menant directement à la nouvelle liste de chargement.

Il est également possible de pousser cela un peu plus loin avec le point de terminaison Créer et calculer, mais cela nécessitera quelques données d’entrée supplémentaires, telles que les paramètres et l’équipement à utiliser.