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 bibliothèque de cargaisons

La façon la plus simple d’obtenir une intégration avec vos outils actuels est via la Bibliothèque de Cargaisons. Toutes les licences Cargo-Planner incluent la Bibliothèque de Cargaisons, qui est essentiellement un système minimal de gestion d’entrepôt ou de planification des ressources.

L’avoir configurée 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 prendra en charge tous les aspects de l’interface utilisateur pour créer une liste de chargement.

Mais configurer manuellement la Bibliothèque de Cargaisons 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
];

// Nos sourceItems sont un peu différents
// de la façon dont ils sont représentés 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 bibliothèque de cargaisons,
// 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 types 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 la planification du prochain envoi sera beaucoup plus rapide.

Création directe de listes de chargement

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 Bibliothèque de Cargaisons 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 en 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: 'Envoi 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 pointant directement vers 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 plus de données d’entrée, telles que les paramètres et l’équipement à utiliser.