Premiers pas avec Fleet Engine

L'API Fleet Engine Deliveries vous permet de modéliser les activités de votre parc pour le premier et le dernier kilomètre de livraisons. L'API Deliveries est exposée via le SDK Driver pour Android et iOS, et peut également être utilisée directement via des appels HTTP REST ou gRPC.

Configuration initiale

L'API Fleet Engine Deliveries est configurée via la console Google Cloud. Pour en savoir plus sur les étapes à suivre dans la console et sur la création d'un jeton Web JSON pour l'autorisation, consultez la page Authentification et autorisation. Pour en savoir plus sur l'utilisation de la console, consultez la documentation de la console Google Cloud.

Vérifier votre configuration

Après avoir créé des comptes de service, vérifiez que la configuration est terminée et que vous pouvez créer un véhicule de livraison. En effectuant une vérification à ce stade de votre workflow, vous vous assurez d'avoir résolu les problèmes d'autorisation courants qui peuvent survenir lors de la configuration de votre projet. Suivez le guide Vérifier votre configuration. Ce guide explique comment utiliser l'utilitaire de ligne de commande gcloud pour tester deux éléments clés de votre configuration: la signature des jetons d'autorisation et la création d'un véhicule de livraison d'essai.

Vous pouvez également utiliser les exemples de scripts d'authentification Fleet Engine pour tester votre configuration.

Bibliothèques clientes

Nous publions des bibliothèques clientes dans plusieurs langages de programmation courants. Ces bibliothèques offrent une meilleure expérience de développement par rapport aux bibliothèques REST ou gRPC brutes. Pour savoir comment obtenir des bibliothèques clientes pour votre application serveur, consultez la page Bibliothèques clientes.

Les exemples Java de cette documentation supposent une bonne connaissance de gRPC.

Structures de données

L'API Deliveries utilise deux structures de données pour modéliser le retrait et la livraison des expéditions:

• Véhicule de livraison utilisé pour transporter le colis.
• Les tâches de retrait et de livraison des envois.

De plus, vous pouvez utiliser des tâches pour modéliser les pauses et les arrêts planifiés tout au long de la journée.

Véhicules de livraison

Les véhicules de livraison transportent les colis entre un dépôt et un lieu de livraison, et entre un lieu de retrait et le dépôt. Dans certains cas, ils peuvent également transporter une commande directement du lieu de retrait au lieu de livraison.

Vous pouvez utiliser le SDK Driver pour créer un objet DeliveryVehicle dans Fleet Engine et pour envoyer des mises à jour de position pour le suivi de la livraison et de la flotte.

Tâches

Des tâches sont attribuées à chaque véhicule. Il peut s'agir de tâches de ramassage ou de livraison, de pauses obligatoires pour les chauffeurs ou d'arrêts planifiés dans des boîtes ou des points de dépôt clients. Chaque tâche doit avoir un ID de tâche unique, mais peut partager le même ID de suivi. Les tâches et l'ordre dans lequel elles sont planifiées sont utilisées pour calculer les périodes de temps d'exécution (ETA) de chaque tâche.

Utilisez le gestionnaire de tâches du SDK pilote pour créer des tâches dans Fleet Engine.

Tâches de livraison

Les tâches de livraison sont liées au retrait ou au dépôt de la livraison. Vous devez spécifier un numéro ou un identifiant de suivi lorsque vous créez une tâche d'expédition. Vous devez également spécifier une durée d'interaction afin de tenir compte du temps supplémentaire nécessaire pour effectuer la tâche, rechercher une place de parking ou marcher jusqu'au lieu de transfert.

• Créez une tâche de retrait pour récupérer un colis, en spécifiant le lieu de retrait ainsi que le numéro ou l'identifiant de suivi.
• Créez une tâche de livraison pour la livraison d'un envoi, en spécifiant l'emplacement de livraison et le numéro ou l'ID de suivi.

Tâches liées à l'indisponibilité

Créez une tâche d'indisponibilité pour une période pendant laquelle le véhicule ne sera pas disponible pour le retrait ni la livraison. Il peut s'agir d'une pause pour faire le plein dans le véhicule ou d'une pause pour le conducteur. Spécifiez la durée de la coupure lorsque vous créez la tâche. Vous n'avez pas besoin de faire des pauses à un endroit spécifique, mais spécifier un emplacement fournit des fenêtres d'heure d'arrivée prévue plus précises tout au long de la journée.

Lors d'une tâche d'indisponibilité, aucune information de localisation n'est partagée avec un utilisateur final. Par exemple, l'emplacement du véhicule de livraison est masqué aux gestionnaires de parc à l'aide de la bibliothèque de suivi du parc.

Tâches d'arrêt planifié

Créez des tâches d'arrêt planifiées pour modéliser les arrêts que doit effectuer un véhicule de livraison. Par exemple, vous pouvez créer une tâche d'arrêt planifiée pour un arrêt planifié quotidien à un emplacement spécifique, indépendamment des autres livraisons ou retraits au même endroit. Vous pouvez également créer des tâches planifiées d'arrêt pour les retraits effectués à partir de boîtes de dépôt, ou pour modéliser les correspondances entre le chargeur et le véhicule, ou les arrêts dans les centres et les points de service.

Pour voir les champs spécifiques contenus dans chaque structure de données, consultez la documentation de référence de l'API pour DeliveryVehicle (gRPC, REST) et Task (gRPC, REST).

• Les identifiants doivent être des chaînes Unicode valides.
• Les ID ne doivent pas comporter plus de 64 caractères.
• Les ID seront normalisés conformément au formulaire de normalisation Unicode C.
• Les ID ne doivent pas contenir les caractères ASCII suivants: "/", ":", ""\", "?" ou "#".

Voici quelques exemples d'ID de tâche corrects:

• 566c33d9-2a31-4b6a-9cd4-80ba1a0c643b
• e4708eabcfa39bf2767c9546c9273f747b4626e8cc44e9630d50f6d129013d38
• NTA1YTliYWNkYmViMTI0ZmMzMWFmOWY2NzNkM2Jk

Le tableau suivant présente des exemples d'ID de tâche incorrects:

Cycle de vie d'un véhicule

L'objet DeliveryVehicle représente un véhicule de livraison situé au premier ou au dernier kilomètre. Vous créez un objet DeliveryVehicle à l'aide de la commande suivante:

• ID du projet Google Cloud contenant le compte de service utilisé pour appeler les API Fleet Engine.
• ID de véhicule appartenant au client.

L'ID de chaque véhicule doit être unique. Ils ne doivent pas être réutilisés pour un autre véhicule, sauf s'il n'y a aucune tâche active pour ce véhicule.

Veillez à rechercher une erreur NOT_FOUND lorsque vous appelez UpdateDeliveryVehicle, puis, si nécessaire, appelez CreateDeliveryVehicle pour créer un véhicule. Un objet DeliveryVehicle qui n'a pas été mis à jour à l'aide de UpdateDeliveryVehicle est automatiquement supprimé au bout de sept jours. Notez que si vous appelez CreateDeliveryVehicle avec une paire ID de projet/ID de véhicule existante, une erreur est générée.

Attributs du véhicule

L'entité DeliveryVehicle contient un champ répété de DeliveryVehicleAttribute. L'API ListDeliveryVehicles inclut un champ filter qui peut limiter les entités DeliveryVehicle renvoyées à celles ayant les attributs spécifiés. Les DeliveryVehicleAttribute n'ont aucune incidence sur le comportement de routage de Fleet Engine.

N'incluez pas d'informations personnelles ou sensibles dans les attributs, car ce champ peut être visible par les utilisateurs.

Cycle de vie d'une tâche

Les tâches dans Fleet Engine peuvent être créées, mises à jour et interrogées à l'aide des interfaces gRPC ou REST de l'API Deliveries.

Un objet Task comporte un champ d'état permettant de suivre sa progression tout au long de son cycle de vie. Les valeurs passent de OPEN à CLOSED. Les nouvelles tâches sont créées à l'état OPEN, ce qui indique que:

• La tâche n'a pas encore été attribuée à un véhicule de livraison.
• Le véhicule de livraison n'a pas encore passé l'arrêt attribué à la tâche.

Une tâche ne peut être attribuée à un véhicule que lorsqu'il est à l'état OUVERT.

Vous pouvez annuler une tâche en la supprimant de la liste des arrêts des véhicules. Son état est alors automatiquement défini sur FERMÉ.

Lorsque le véhicule de la tâche termine son arrêt, définissez le champ de résultat de la tâche sur SUCCEEDED ou FAILED et spécifiez l'horodatage de l'événement. Le résultat de la tâche peut être défini à tout moment avant ou après son achèvement, mais il ne peut l'être qu'une seule fois.

La bibliothèque JavaScript Fleet Tracking peut ensuite indiquer le résultat de la tâche. L'état de la tâche est automatiquement défini sur FERMÉE. Pour en savoir plus, consultez l'article Effectuer le suivi de votre parc avec la bibliothèque JavaScript Fleet Tracking Library.

Comme pour les véhicules, les tâches qui n'ont pas été mises à jour après sept jours sont supprimées, et toute tentative de création d'une tâche avec un ID existant renvoie une erreur.

Remarque:Fleet Engine ne permet pas de supprimer explicitement une tâche. Le service supprime automatiquement les tâches après sept jours sans mise à jour. Si vous souhaitez conserver des données de tâche pendant plus de sept jours, vous devez implémenter cette fonctionnalité vous-même.

Attributs de la tâche

L'entité Task contient un champ répété de TaskAttribute, qui peut avoir une valeur de l'un des trois types suivants: chaîne, nombre et valeur booléenne. L'API ListTasks inclut un champ filter qui peut limiter les entités Task renvoyées à celles comportant les attributs spécifiés. Les TaskAttribute n'ont aucune incidence sur le comportement de routage de Fleet Engine.

N'incluez pas d'informations personnelles ou sensibles dans les attributs, car ce champ peut être visible par les utilisateurs.

Gérer le cycle de vie des véhicules et des tâches

Pour gérer le cycle de vie des véhicules et des tâches dans votre système, l'API Fleet Engine Deliveries vous permet de créer, mettre à jour et suivre vos véhicules et leurs tâches associées. Votre système interne agit en tant que source de confiance pour les données que l'API Fleet Engine Deliveries améliore en votre nom.

En même temps, l'application du pilote communique directement avec Fleet Engine afin de mettre à jour la position de l'appareil et les informations sur l'itinéraire. Ce modèle permet à Fleet Engine de gérer efficacement la localisation en temps réel et de l'envoyer directement à la bibliothèque de suivi, que vous pouvez ensuite utiliser pour les consommateurs qui ont besoin de connaître l'état de leur commande.

Par exemple, supposons que vous ayez le scénario suivant:

• Un chauffeur se rapproche d'un arrêt de livraison et Fleet Engine envoie la position de l'appareil à la bibliothèque de suivi, que votre application consommateur utilise pour alerter le consommateur à proximité de son colis.
• Une fois que le livreur a terminé l'envoi, il clique sur le bouton "Expédition livrée" dans l'application du pilote.
• Les informations sont alors envoyées à votre système backend, qui effectue les étapes de validation et de validation métier nécessaires.
• Votre système confirme que la tâche est RÉUSSITE et met à jour Fleet Engine à l'aide de l'API Deliveries.

Le schéma suivant illustre ces processus à un niveau générique. Il indique également la relation standard entre votre système, le client et Fleet Engine.

Gestion des jetons client

Toutes les mises à jour de la position provenant de l'application du pilote et envoyées directement à Fleet Engine nécessitent des jetons d'autorisation. L'approche recommandée pour gérer les mises à jour du client vers Fleet Engine consiste à fournir à l'application de pilote un jeton de champ d'application limité afin qu'elle ne puisse mettre à jour que la position de l'appareil dans Fleet Engine. Pour ce type de jeton, vous devez utiliser un rôle de compte de service appelé Utilisateur non approuvé Fleet Engine Delivery. Cela garantit que les appels provenant d'appareils mobiles (c'est-à-dire d'environnements peu fiables) respectent le principe du moindre privilège.

Autres rôles de compte de service

Si vous souhaitez autoriser les applications de pilote à effectuer directement des mises à jour de Parc Engine autres que celles limitées au rôle de Conducteur non approuvé, par exemple pour certaines mises à jour de tâches, vous pouvez utiliser le rôle Conducteur de confiance. Pour en savoir plus sur un modèle qui utilise le rôle de Conducteur de confiance, consultez la section Modèle de pilote de confiance.

Pour en savoir plus sur les utilisations des rôles de pilote de confiance et non fiables, consultez la section Configurer un projet Cloud.

Modéliser une journée de travail

Le tableau suivant décrit à quoi peut ressembler une journée de travail pour les chauffeurs sur le premier ou le dernier kilomètre dans une entreprise de livraison et de logistique. Les détails de votre entreprise peuvent différer, mais vous pouvez voir comment modéliser une journée de travail.

Comprendre les mises à jour de la position géographique

Les mises à jour de la position sont envoyées à Fleet Engine une fois qu'un véhicule de livraison est en route depuis un arrêt (y compris le dépôt) jusqu'à ce qu'il arrive au prochain arrêt. Étant donné que ces événements ne sont pas détectés automatiquement, vous devez les marquer par programmation. Utilisez des bibliothèques qui détectent les changements de mode de transport pour déclencher l'envoi des notifications requises à Fleet Engine.

Les mises à jour de la position doivent être suspendues lorsque le conducteur ne conduit pas, car la qualité des signaux de localisation diminue considérablement lorsque quelqu'un se trouve dans un bâtiment.

La fréquence de mise à jour de la position peut être définie dans le SDK Driver. Par défaut, elle envoie des mises à jour toutes les 10 secondes.

Arrêts des véhicules et lieux de livraison

Un arrêt de véhicule est le moment où un véhicule de livraison termine une tâche d'expédition ou une autre tâche. Il peut s'agir d'un point d'accès tel qu'un quai de chargement ou d'un emplacement accroché à une route.

Le lieu de livraison est celui où le colis est livré ou récupéré. Pour se rendre au lieu de livraison et en revenir, il peut être nécessaire de marcher depuis l'arrêt du véhicule.

Par exemple, lorsqu'un livreur livre un colis dans un magasin d'un centre commercial, le véhicule de livraison s'arrête sur le parking du centre commercial près de l'entrée la plus proche du magasin. Il s'agit de l'arrêt du véhicule. Il se rend ensuite à pied de l'arrêt du véhicule jusqu'à l'emplacement du magasin dans le centre commercial. Il s'agit de l'adresse de livraison.

Pour optimiser le suivi des livraisons pour vos utilisateurs, réfléchissez à la manière dont les tâches d'expédition sont attribuées aux arrêts de véhicules. N'oubliez pas que le nombre d'arrêts restants pour les tâches d'expédition est communiqué à l'utilisateur pour l'aider à suivre la progression de son expédition.

Par exemple, si un chauffeur effectue de nombreuses livraisons dans un seul immeuble de bureaux, envisagez d'attribuer toutes les tâches de livraison à un seul arrêt de véhicule. Si chaque tâche de livraison est attribuée à son propre arrêt de véhicule, votre expérience de suivi des livraisons serait moins utile pour vos utilisateurs, car le suivi n'est disponible que lorsque le véhicule se trouve dans un nombre limité d'arrêts avant sa destination. Si de nombreux arrêts sont effectués en peu de temps, l'utilisateur ne dispose pas de beaucoup de temps pour suivre la progression de sa livraison.

Utiliser les SDK pour mobile

Avant d'appeler le SDK Driver, veillez à l'initialiser.

Initialiser l'API Delivery Driver

Avant d'initialiser l'API Delivery Driver dans le SDK Driver, veillez à initialiser le SDK Navigation. Ensuite, initialisez l'API Delivery Driver comme indiqué dans l'exemple suivant:

static final String PROVIDER_ID = "provider-1234";
static final String VEHICLE_ID = "vehicle-8241890";

NavigationApi.getNavigator(
   this, // Activity.
   new NavigatorListener() {
     @Override
     public void onNavigatorReady(Navigator navigator) {
       DeliveryDriverApi.createInstance(DriverContext.builder(getApplication())
         .setNavigator(navigator)
         .setProviderId(PROVIDER_ID)
         .setVehicleId(VEHICLE_ID)
         .setAuthTokenFactory((context) -> "JWT") // AuthTokenFactory returns JWT for call context.
         .setRoadSnappedLocationProvider(NavigationApi.getRoadSnappedLocationProvider(getApplication()))
         .setNavigationTransactionRecorder(NavigationApi.getNavigationTransactionRecorder(getApplication()))
         .setStatusListener((statusLevel,statusCode,statusMsg) -> // Optional, surfaces polling errors.
             Log.d("TAG", String.format("New status update. %s, %s, %s", statusLevel, statusCode, statusMsg)))
         .build));
     }

     @Override
     public void onError(int errorCode) {
       Log.e("TAG", String.format("Error loading Navigator instance: %s", errorCode));
     }
   });

Cas d'utilisation

Cette section explique comment utiliser l'API Deliveries pour modéliser des cas d'utilisation courants.

Identifiants d'entité uniques

Le format et la valeur des identifiants d'entité uniques utilisés dans les appels REST sont opaques pour Fleet Engine. Évitez d'utiliser des ID d'incrémentation automatique et assurez-vous que l'identifiant ne contient aucune information personnelle, telle que le numéro de téléphone du conducteur.

Créer un véhicule

Vous pouvez créer un véhicule à partir du SDK Driver ou de l'environnement de serveur.

gRPC

Pour créer un véhicule, vous devez envoyer un appel CreateDeliveryVehicle à Fleet Engine. Utilisez l'objet CreateDeliveryVehicleRequest pour définir les attributs du nouveau véhicule de livraison. Notez que toute valeur spécifiée pour le champ Name sera ignorée conformément aux instructions de l'API pour les ID spécifiés par l'utilisateur. Vous devez utiliser le champ DeliveryVehicleId pour définir l'ID du véhicule.

Lorsque vous créez un DeliveryVehicle, vous pouvez éventuellement spécifier deux champs:

• Attributs
• Dernière position

Aucun autre champ ne doit être défini. Sinon, Fleet Engine renverra une erreur, car ces champs sont en lecture seule ou ne peuvent être mis à jour que via des appels UpdateDeliveryVehicle.

Pour créer un véhicule sans définir de champs facultatifs, vous pouvez laisser le champ DeliveryVehicle non défini dans CreateDeliveryVehicleRequest.

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour créer un véhicule:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890"; // Avoid auto-incrementing IDs.

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String parent = "providers/" + PROJECT_ID;
DeliveryVehicle vehicle = DeliveryVehicle.newBuilder()
  .addAttributes(DeliveryVehicleAttribute.newBuilder()
    .setKey("route_number").setValue("1"))  // Opaque to the Fleet Engine
  .build();

// Vehicle request
CreateDeliveryVehicleRequest createVehicleRequest =
  CreateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setParent(parent)
      .setDeliveryVehicleId(VEHICLE_ID)     // Vehicle ID assigned by the Provider
      .setDeliveryVehicle(vehicle)
      .build();

// Error handling
// If Fleet Engine does not have vehicle with that ID and the credentials of the
// requestor pass, the service creates the vehicle successfully.

try {
  DeliveryVehicle createdVehicle =
    deliveryService.createDeliveryVehicle(createVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour créer un véhicule à partir d'un environnement de serveur, envoyez un appel HTTP REST à CreateDeliveryVehicle:

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles?deliveryVehicleId=<id>

<id> est un identifiant unique pour un véhicule de livraison de votre parc.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps POST représente l'entité DeliveryVehicle à créer. Vous pouvez spécifier les champs facultatifs suivants:

• attributs
• dernier lieu

Exemple de commande curl :

# Set $JWT, $PROJECT_ID, and $VEHICLE_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles?deliveryVehicleId=${VEHICLE_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
--data-binary @- << EOM
{
  "attributes": [{"key": "model", "value": "sedan"}],
  "lastLocation": {"location": {"latitude": 12.1, "longitude": 14.5}}
}
EOM

Fleet Engine ignore le champ name de l'entité DeliveryVehicle conformément aux directives de l'API pour les ID spécifiés par l'utilisateur. Aucun autre champ ne doit être défini. Sinon, Fleet Engine renverra une erreur, car ces champs sont en lecture seule ou ne peuvent être mis à jour que via des appels UpdateDeliveryVehicle.

Pour créer un véhicule sans définir de champ, vous pouvez laisser le corps de la requête POST vide. L'ID du véhicule que vous venez de créer sera extrait du paramètre deliveryVehicleId dans l'URL POST.

Exemple de commande curl :

# Set $JWT, $PROJECT_ID, and $VEHICLE_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles?deliveryVehicleId=${VEHICLE_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}"

Créer une tâche de retrait de colis

Vous pouvez créer une tâche de retrait d'un colis à partir du SDK Driver ou de l'environnement serveur.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour créer une tâche de retrait de colis:

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String parent = "providers/" + PROJECT_ID;
Task task = Task.newBuilder()
  .setType(Task.Type.PICKUP)
  .setState(Task.State.OPEN)
  .setTrackingId("my-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .setTargetTimeWindow(
    TimeWindow.newBuilder()
      .setStartTime(Timestamp.newBuilder().setSeconds(1680123600))
      .setEndTime(Timestamp.newBuilder().setSeconds(1680130800)))
  .addAttributes(TaskAttribute.newBuilder().setKey("foo").setStringValue("value"))
  .addAttributes(TaskAttribute.newBuilder().setKey("bar").setNumberValue(10))
  .addAttributes(TaskAttribute.newBuilder().setKey("baz").setBoolValue(false))
  .build();

// Task request
CreateTaskRequest createTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header
      .setParent(parent)          // Avoid using auto-incrementing IDs for the taskId
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTask(task)              // Initial state
      .build();

// Error handling
// If Fleet Engine does not have a task with that ID and the credentials of the
// requestor pass, the service creates the task successfully.

try {
  Task createdTask = deliveryService.createTask(createTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour créer une tâche de retrait de colis à partir d'un environnement de serveur, envoyez un appel HTTP REST à "CreateTask":

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>

<id> est un identifiant unique pour la tâche. Il ne doit pas s'agir du numéro de suivi du colis. Si vous n'avez pas d'ID de tâche dans votre système, vous pouvez générer un identifiant unique universel (UUID).

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité Task:

• Champs obligatoires :

  Champ	Valeur
  type	Type.PICKUP
  final	State.OPEN
  IDdesuivi	Numéro ou identifiant que vous utilisez pour suivre un envoi.
  Lieu planifié	Lieu où la tâche doit être effectuée, dans ce cas le lieu de retrait du colis.
  durée de la tâche	Délai estimé, en secondes, pour retirer le colis au point de retrait.

• Champs facultatifs :

  Champ	Valeur
  targetTimeWindow	Période pendant laquelle la tâche doit être effectuée. Pour le moment, cela n'affecte pas le comportement du routage.
  attributs	Liste d'attributs Task personnalisés. Chaque attribut doit avoir une clé unique.

Tous les autres champs de l'entité sont ignorés pour la création. Fleet Engine génère une exception si la requête inclut un DeliveryVehicleId attribué. Vous attribuez les tâches à l'aide de UpdateDeliveryVehicleRequests. Pour en savoir plus, consultez Attribuer des tâches à un véhicule.

Exemple de commande curl :

# Set $JWT, $PROJECT_ID, $TRACKING_ID, and $TASK_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "type": "PICKUP",
  "state": "OPEN",
  "trackingId": "${TRACKING_ID}",
  "plannedLocation": {
     "point": {
        "latitude": -6.195139,
        "longitude": 106.820826
     }
  },
  "taskDuration": "90s",
  "targetTimeWindow": {
    "startTime": "2023-03-29T21:00:00Z",
    "endTime": "2023-03-29T23:00:00Z"
  }
}
EOM

Créer une tâche de livraison d'expédition

Vous pouvez créer une tâche de livraison de livraison à partir du SDK Driver ou de l'environnement du serveur.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour créer une tâche de livraison de livraison:

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String parent = "providers/" + PROJECT_ID;
Task task = Task.newBuilder()
  .setType(Task.Type.DELIVERY)
  .setState(Task.State.OPEN)
  .setTrackingId("my-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .setTargetTimeWindow(
    TimeWindow.newBuilder()
      .setStartTime(Timestamp.newBuilder().setSeconds(1680123600))
      .setEndTime(Timestamp.newBuilder().setSeconds(1680130800)))
  .addAttributes(TaskAttribute.newBuilder().setKey("foo").setStringValue("value"))
  .addAttributes(TaskAttribute.newBuilder().setKey("bar").setNumberValue(10))
  .addAttributes(TaskAttribute.newBuilder().setKey("baz").setBoolValue(false))
  .build();

// Task request
CreateTaskRequest createTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header
      .setParent(parent)          // Avoid using auto-incrementing IDs for the taskId
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTask(task)              // Initial state
      .build();

// Error handling
// If Fleet Engine does not have task with that ID and the credentials of the
// requestor pass, the service creates the task successfully.

try {
  Task createdTask = deliveryService.createTask(createTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour créer une tâche de livraison de livraison à partir d'un environnement de serveur, envoyez un appel HTTP REST à "CreateTask":

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>

<id> est un identifiant unique pour la tâche. Il ne doit pas s'agir du numéro de suivi du colis. Si vous n'avez pas d'ID de tâche dans votre système, vous pouvez générer un identifiant unique universel (UUID).

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité Task:

• Champs obligatoires :

  Champ	Valeur
  type	Type.DELIVERY
  final	State.OPEN
  IDdesuivi	Numéro ou identifiant que vous utilisez pour suivre un envoi.
  Lieu planifié	Lieu où la tâche doit être effectuée, dans ce cas l'emplacement de livraison pour la livraison.
  durée de la tâche	Délai estimé, en secondes, pour déposer le colis au lieu de livraison.

• Champs facultatifs :

  Champ	Valeur
  targetTimeWindow	Période pendant laquelle la tâche doit être effectuée. Pour le moment, cela n'affecte pas le comportement du routage.
  attributs	Liste d'attributs Task personnalisés. Chaque attribut doit avoir une clé unique.

Tous les autres champs de l'entité sont ignorés pour la création. Fleet Engine génère une exception si la requête inclut un DeliveryVehicleId attribué. Vous attribuez les tâches à l'aide de UpdateDeliveryVehicleRequests. Pour en savoir plus, consultez Attribuer des tâches à un véhicule.

Exemple de commande curl :

# Set $JWT, $PROJECT_ID, $TRACKING_ID, and $TASK_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "type": "DELIVERY",
  "state": "OPEN",
  "trackingId": "${TRACKING_ID}",
  "plannedLocation": {
     "point": {
        "latitude": -6.195139,
        "longitude": 106.820826
     }
  },
  "taskDuration": "90s",
  "targetTimeWindow": {
    "startTime": "2023-03-29T21:00:00Z",
    "endTime": "2023-03-29T23:00:00Z"
  }
}
EOM

Créer des tâches de manière groupée

Vous pouvez créer un lot de tâches à partir de l'environnement du serveur.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour créer deux tâches, l'une pour une livraison et l'autre pour un retrait au même emplacement:

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Delivery Task settings
Task deliveryTask = Task.newBuilder()
  .setType(Task.Type.DELIVERY)
  .setState(Task.State.OPEN)
  .setTrackingId("delivery-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .build();

// Delivery Task request
CreateTaskRequest createDeliveryTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header or parent fields
      .setTaskId("task-8312508")  // Task ID assigned by the Provider
      .setTask(deliveryTask)      // Initial state
      .build();

// Pickup Task settings
Task pickupTask = Task.newBuilder()
  .setType(Task.Type.PICKUP)
  .setState(Task.State.OPEN)
  .setTrackingId("pickup-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .build();

// Pickup Task request
CreateTaskRequest createPickupTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header or parent fields
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTask(pickupTask)        // Initial state
      .build();

// Batch Create Tasks settings
String parent = "providers/" + PROJECT_ID;

// Batch Create Tasks request
BatchCreateTasksRequest batchCreateTasksRequest =
  BatchCreateTasksRequest.newBuilder()
      .setParent(parent)
      .addRequests(createDeliveryTaskRequest)
      .addRequests(createPickupTaskRequest)
      .build();

// Error handling
// If Fleet Engine does not have any task(s) with these task ID(s) and the
// credentials of the requestor pass, the service creates the task(s)
// successfully.

try {
  BatchCreateTasksResponse createdTasks = deliveryService.batchCreateTasks(
    batchCreateTasksRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour créer une tâche de livraison et de retrait à partir de l'environnement de serveur, envoyez un appel HTTP REST à BatchCreateTasks:

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks:batchCreate

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité BatchCreateTasksRequest:

• Champs obligatoires :

  Champ	Valeur
  requêtes	Tableau<CreateTasksRequest>

• Champs facultatifs :

  Champ	Valeur
  en-tête	"DeliveryRequestHeader"

Chaque élément CreateTasksRequest de requests doit passer les mêmes règles de validation qu'une requête CreateTask, à l'exception des champs parent et header qui sont facultatifs. S'ils sont définis, ils doivent être identiques à leurs champs respectifs au niveau de BatchCreateTasksRequest de premier niveau. Consultez les sections Créer une tâche de retrait de colis et Créer une tâche de livraison de livraison pour connaître les règles de validation spécifiques à chaque tâche.

Pour en savoir plus, consultez la documentation de référence de l'API pour BatchCreateTasks (gRPC, REST).

Exemple de commande curl :

# Set $JWT, $PROJECT_ID, $DELIVERY_TRACKING_ID, $DELIVERY_TASK_ID,
# $PICKUP_TRACKING_ID, and $PICKUP_TASK_ID in the local environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks:batchCreate" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "requests" : [
    {
      "taskId": "${DELIVERY_TASK_ID}",
      "task" : {
        "type": "DELIVERY",
        "state": "OPEN",
        "trackingId": "${DELIVERY_TRACKING_ID}",
        "plannedLocation": {
          "point": {
              "latitude": -6.195139,
              "longitude": 106.820826
          }
        },
        "taskDuration": "90s"
      }
    },
    {
      "taskId": "${PICKUP_TASK_ID}",
      "task" : {
        "type": "PICKUP",
        "state": "OPEN",
        "trackingId": "${PICKUP_TRACKING_ID}",
        "plannedLocation": {
          "point": {
              "latitude": -6.195139,
              "longitude": 106.820826
          }
        },
        "taskDuration": "90s"
      }
    }
  ]
}
EOM

Indisponibilité planifiée

Vous pouvez créer une tâche indiquant une indisponibilité (par exemple, pour les temps de trajet ou le ravitaillement d'un véhicule) à partir du SDK Driver ou de l'environnement serveur. Une tâche d'indisponibilité planifiée ne doit pas inclure d'ID de suivi. Vous pouvez éventuellement indiquer un lieu.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour créer une tâche d'indisponibilité:

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String parent = "providers/" + PROJECT_ID;
Task task = Task.newBuilder()
  .setType(Task.Type.UNAVAILABLE)
  .setState(Task.State.OPEN)
  .setTaskDuration(
    Duration.newBuilder().setSeconds(60 * 60))  // 1hr break
  .build();

// Task request
CreateTaskRequest createTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header
      .setParent(parent)          // Avoid using auto-incrementing IDs for the taskId
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTask(task)              // Initial state
      .build();

// Error handling
// If Fleet Engine does not have task with that ID and the credentials of the
// requestor pass, the service creates the task successfully.

try {
  Task createdTask = deliveryService.createTask(createTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour créer une tâche d'indisponibilité à partir d'un environnement de serveur, envoyez un appel REST HTTP à "CreateTask":

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>

<id> est un identifiant unique pour la tâche. Si vous n'avez pas d'ID de tâche dans votre système, vous pouvez générer un identifiant unique universel (UUID).

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité Task:

• Champs obligatoires :

  Champ	Valeur
  type	Type.UNAVAILABLE
  final	State.OPEN
  durée de la tâche	Durée de la coupure en secondes.

• Champs facultatifs :

  Champ	Valeur
  Lieu planifié	Lieu de la pause (si elle doit être prise à un endroit spécifique).

Tous les autres champs de l'entité sont ignorés pour la création. Fleet Engine génère une exception si la requête inclut un DeliveryVehicleId attribué. Vous attribuez les tâches à l'aide de UpdateDeliveryVehicleRequests. Pour en savoir plus, consultez Attribuer des tâches à un véhicule.

Exemple de commande curl :

# Set $JWT, $PROJECT_ID, and $TASK_ID in the local environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "type": "UNAVAILABLE",
  "state": "OPEN",
  "plannedLocation": {
     "point": {
        "latitude": -6.195139,
        "longitude": 106.820826
     }
  },
  "taskDuration": "300s"
}
EOM

Arrêts planifiés

Vous pouvez créer une tâche d'arrêt planifiée à partir du SDK du pilote ou de l'environnement du serveur. Une tâche d'arrêt planifiée peut ne pas inclure d'ID de suivi.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour créer une tâche d'arrêt planifiée:

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String parent = "providers/" + PROJECT_ID;
Task task = Task.newBuilder()
  .setType(Task.Type.SCHEDULED_STOP)
  .setState(Task.State.OPEN)
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .build();

// Task request
CreateTaskRequest createTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header
      .setParent(parent)
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTrip(task)              // Initial state
      .build();

// Error handling
// If Fleet Engine does not have task with that ID and the credentials of the
// requestor pass, the service creates the task successfully.

try {
  Task createdTask = deliveryService.createTask(createTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour créer une tâche d'arrêt planifiée à partir d'un environnement de serveur, envoyez un appel REST HTTP à CreateTask:

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>

<id> est un identifiant unique pour la tâche. Si vous n'avez pas d'ID de tâche dans votre système, vous pouvez générer un identifiant unique universel (UUID).

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité Task:

• Champs obligatoires :

  Champ	Valeur
  type	Tapez.SCHEDULED_STOP
  final	State.OPEN
  Lieu planifié	Emplacement de l'arrêt.
  durée de la tâche	Durée prévue de l'arrêt en secondes.

• Champs facultatifs :

  • Aucune

Tous les autres champs de l'entité sont ignorés pour la création. Fleet Engine génère une exception si la requête inclut un DeliveryVehicleId attribué. Vous attribuez les tâches à l'aide de UpdateDeliveryVehicleRequests. Pour en savoir plus, consultez Attribuer des tâches à un véhicule.

Exemple de commande curl :

# Set $JWT, $PROJECT_ID, and $TASK_ID in the local environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "type": "SCHEDULED_STOP",
  "state": "OPEN",
  "plannedLocation": {
     "point": {
        "latitude": -6.195139,
        "longitude": 106.820826
     }
  },
  "taskDuration": "600s"
}
EOM

La fenêtre temporelle cible correspond à la valeur TimeWindow au cours de laquelle la tâche doit être effectuée. Par exemple, si vous communiquez un délai de livraison aux destinataires de la livraison, vous pouvez utiliser la période cible de la tâche pour capturer cette période et générer des alertes ou analyser les performances post-voyage à l'aide de ce champ.

La période cible se compose d'une heure de début et d'une heure de fin, et peut être définie sur n'importe quel type de tâche. Actuellement, la période cible n'affecte pas le comportement du routage.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour définir une fenêtre de temps de tâche:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
Task task = Task.newBuilder()
  .setName(taskName)
  .setTargetTimeWindow(
    TimeWindow.newBuilder()
      .setStartTime(Timestamp.newBuilder().setSeconds(1680123600))
      .setEndTime(Timestamp.newBuilder().setSeconds(1680130800)))
  .build();

// Task request
UpdateTaskRequest updateTaskRequest =
  UpdateTaskRequest.newBuilder()  // No need for the header
      .setTask(task)
      .setUpdateMask(FieldMask.newBuilder().addPaths("targetTimeWindow"))
      .build();

try {
  Task updatedTask = deliveryService.updateTask(updateTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour définir une fenêtre de temps de tâche à l'aide de HTTP, appelez UpdateTask:

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=targetTimeWindow

<id> est un identifiant unique pour la tâche.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité Task:

• Champs obligatoires :

  Champ	Valeur
  targetTimeWindow	Période pendant laquelle la tâche doit être effectuée. Cela n'affecte pas le comportement de routage pour le moment

• Champs facultatifs :

  • Aucune

Tous les autres champs de l'entité sont ignorés pour la mise à jour.

Exemple de commande curl :

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=targetTimeWindow" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "targetTimeWindow": {
    "startTime": "2023-03-29T21:00:00Z",
    "endTime": "2023-03-29T23:00:00Z"
  }
}
EOM

Définir la configuration de la visibilité du suivi des tâches

La visibilité des données dans la bibliothèque Shipment Tracking et de celles renvoyées par un appel à GetTaskTrackingInfo peut être contrôlée pour chaque tâche en définissant un TaskTrackingViewConfig. Pour en savoir plus, consultez Tâches actives pour les véhicules. Vous pouvez le faire lors de la création ou de la mise à jour de la tâche. Voici un exemple de mise à jour de la tâche avec cette configuration:

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour définir la configuration de la vue de suivi des tâches:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
Task task = Task.newBuilder()
  .setName(taskName)
  .setTaskTrackingViewConfig(
    TaskTrackingViewConfig.newBuilder()
      .setRoutePolylinePointsVisibility(
        VisibilityOption.newBuilder().setRemainingStopCountThreshold(3))
      .setEstimatedArrivalTimeVisibility(
        VisibilityOption.newBuilder().remainingDrivingDistanceMetersThreshold(5000))
      .setRemainingStopCountVisibility(
        VisibilityOption.newBuilder().setNever(true)))
  .build();

// Task request
UpdateTaskRequest updateTaskRequest =
  UpdateTaskRequest.newBuilder()  // No need for the header
      .setTask(task)
      .setUpdateMask(FieldMask.newBuilder().addPaths("taskTrackingViewConfig"))
      .build();

try {
  Task updatedTask = deliveryService.updateTask(updateTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
      case NOT_FOUND:
        break;
      case PERMISSION_DENIED:
        break;
  }
  return;
}

REST

Pour définir la fenêtre de configuration de la vue de suivi des tâches à l'aide de HTTP, appelez UpdateTask:

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=taskTrackingViewConfig

<id> est un identifiant unique pour la tâche.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité Task:

• Champs obligatoires :

  Champ	Valeur
  taskTrackingViewConfig	Configuration du suivi des tâches, qui spécifie les éléments de données visibles par les utilisateurs finaux dans quelles circonstances.

• Champs facultatifs :

  • Aucune

Tous les autres champs de l'entité sont ignorés pour la mise à jour.

Exemple de commande curl :

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=taskTrackingViewConfig" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "taskTrackingViewConfig": {
    "routePolylinePointsVisibility": {
      "remainingStopCountThreshold": 3
    },
    "estimatedArrivalTimeVisibility": {
      "remainingDrivingDistanceMetersThreshold": 5000
    },
    "remainingStopCountVisibility": {
      "never": true
    }
  }
}
EOM

Attribuer des tâches à un véhicule

Vous pouvez attribuer des tâches à un véhicule de livraison en mettant à jour l'ordre des tâches pour le véhicule. L'ordre des tâches pour un véhicule est déterminé par la liste des arrêts des véhicules du véhicule de livraison. Une ou plusieurs tâches peuvent être attribuées à chaque arrêt d'un véhicule.

La mise à jour de l'ordre des tâches pour une tâche précédemment attribuée à un autre véhicule génère une erreur.

Pour modifier un envoi d'un véhicule à un autre, fermez la tâche d'origine, puis recréez-la avant de lui attribuer le nouveau véhicule.

Mettre à jour l'ordre des tâches

Vous pouvez mettre à jour l'ordre d'exécution des tâches attribuées à un véhicule à partir du SDK Driver ou de l'environnement de serveur. Ne mélangez pas les deux méthodes pour éviter les conditions de concurrence.

La mise à jour de l'ordre des tâches assigne également des tâches à un véhicule si elles n'ont pas été précédemment assignées à un véhicule, et ferme les tâches qui ont été assignées à un véhicule, mais qui ne sont pas incluses dans l'ordre mis à jour. L'attribution d'une tâche à un véhicule différent génère une erreur. Commencez par fermer la tâche existante, puis créez-en une autre avant de l'attribuer au nouveau véhicule.

L'ordre des tâches peut être modifié à tout moment.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour mettre à jour l'ordre des tâches du véhicule:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";
static final String TASK1_ID = "task-756390";
static final String TASK2_ID = "task-849263";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String vehicleName = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 1st stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.7749)
                   .setLongitude(122.4194)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
           .setState(VehicleStop.State.NEW)))
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 2nd stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.3382)
                   .setLongitude(121.8863)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
           .setState(VehicleStop.State.NEW)))
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(deliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder().addPaths("remaining_vehicle_journey_segments"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour mettre à jour l'ordre des tâches d'un véhicule à partir d'un environnement de serveur, effectuez un appel HTTP REST à "UpdateDeliveryVehicle":

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remainingVehicleJourneySegments

<id> est un identifiant unique d'un véhicule de livraison de votre parc pour lequel vous souhaitez mettre à jour l'ordre des tâches. Il s'agit de l'identifiant que vous avez spécifié lors de la création du véhicule.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité DeliveryVehicle:

• Champs obligatoires :

  Champ	Valeur
  Secteurs restantsduvéhicule	Une liste de segments de parcours pour les tâches dans l'ordre dans lequel elles doivent être exécutées. La première tâche de la liste est exécutée en premier.
  restantVehicleJourneySegments[i].stop	L'arrêt de la tâche i dans la liste.
  restantesVehicleJourneySegments[i].stop.plannedLocation	Emplacement prévu de l'arrêt.
  restantVehicleJourneySegments[i].stop.tasks	Liste des tâches à effectuer à cet arrêt du véhicule.
  restantsVehicleJourneySegments[i].stop.state	État.NEW

• Champs facultatifs :

  • Aucune

Tous les autres champs de l'entité sont ignorés pour la mise à jour.

Exemple de commande curl :

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "remainingVehicleJourneySegments": [
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.7749,
            "longitude": -122.084061
          }
        },
        "tasks": [
          {
            "taskId": "${TASK1_ID}"
          }
        ]
      }
    },
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.3382,
            "longitude": 121.8863
          }
        },
        "tasks": [
          {
            "taskId": "${TASK2_ID}"
          }
        ]
      }
    }
  ]
}
EOM

Fleet Engine doit être averti lorsqu'un véhicule quitte un arrêt ou démarre la navigation. Vous pouvez notifier Fleet Engine à partir du SDK du pilote ou de l'environnement du serveur. Les deux méthodes ne doivent pas être mélangées pour éviter les conditions de concurrence et maintenir une source unique de vérité.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour avertir Fleet Engine qu'un véhicule est en route vers son prochain arrêt.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
    // Next stop marked as ENROUTE
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 1st stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.7749)
                   .setLongitude(122.4194)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
           .setState(VehicleStop.State.ENROUTE)))
    // All other stops marked as NEW
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 2nd stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.3382)
                   .setLongitude(121.8863)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
           .setState(VehicleStop.State.NEW)))
    .build();


// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(deliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder().addPaths("remaining_vehicle_journey_segments"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour avertir Fleet Engine qu'un véhicule est en route vers son prochain arrêt depuis un environnement de serveur, envoyez un appel REST HTTP à "UpdateDeliveryVehicle":

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remainingVehicleJourneySegments

<id> est un identifiant unique pour le véhicule de livraison de votre parc pour lequel vous souhaitez mettre à jour l'ordre des tâches. Il s'agit de l'identifiant que vous avez spécifié lors de la création du véhicule.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité DeliveryVehicle:

• Champ obligatoire:

  Champ	Valeur
  Secteurs restantsduvéhicule	Liste des arrêts de véhicules restants, avec leurs états marqués comme State.NEW. L'état du premier arrêt de la liste doit être défini sur State.ENROUTE.

• Champs facultatifs :

  • Aucune

Tous les autres champs de l'entité sont ignorés pour la notification.

Exemple de commande curl :

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "remainingVehicleJourneySegments": [
    {
      "stop": {
        "state": "ENROUTE",
        "plannedLocation": {
          "point": {
            "latitude": 37.7749,
            "longitude": -122.084061
          }
        },
        "tasks": [
          {
            "taskId": "${TASK1_ID}"
          }
        ]
      }
    },
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.3382,
            "longitude": 121.8863
          }
        },
        "tasks": [
          {
            "taskId": "${TASK2_ID}"
          }
        ]
      }
    }
  ]
}
EOM

Fleet Engine doit être averti lorsqu'un véhicule arrive à un arrêt. Vous pouvez notifier Fleet Engine à partir du SDK du pilote ou de l'environnement de serveur. Les deux méthodes ne doivent pas être mélangées pour éviter les conditions de concurrence et maintenir une source unique de vérité.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour avertir Fleet Engine qu'un véhicule est arrivé à l'arrêt:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String vehicleName = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
    // Marking the arrival at stop.
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.7749)
                   .setLongitude(122.4194)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
           .setState(VehicleStop.State.ARRIVED)))
    // All other remaining stops marked as NEW.
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 2nd stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.3382)
                   .setLongitude(121.8863)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
           .setState(VehicleStop.State.NEW))) // Remaining stops must be NEW.
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(deliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder()
          .addPaths("remaining_vehicle_journey_segments"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour avertir Fleet Engine de l'arrivée d'un véhicule à l'arrêt depuis un environnement de serveur, envoyez un appel HTTP REST à "UpdateDeliveryVehicle":

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remainingVehicleJourneySegments

<id> est un identifiant unique pour le véhicule de livraison de votre parc pour lequel vous souhaitez mettre à jour l'ordre des tâches. Il s'agit de l'identifiant que vous avez spécifié lors de la création du véhicule.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité DeliveryVehicle:

• Champs obligatoires :

  Champ	Valeur
  Secteurs restantsduvéhicule	L'arrêt où vous êtes arrivé, dont l'état est défini sur State.ARRIVED, suivi d'une liste des arrêts où se trouvent les véhicules restants dont l'état est défini sur State.NEW.

• Champs facultatifs :

  • Aucune

Tous les autres champs de l'entité sont ignorés pour la mise à jour.

Exemple de commande curl :

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "remainingVehicleJourneySegments": [
    {
      "stop": {
        "state": "ARRIVED",
        "plannedLocation": {
          "point": {
            "latitude": 37.7749,
            "longitude": -122.084061
          }
        },
        "tasks": [
          {
            "taskId": "${TASK1_ID}"
          }
        ]
      }
    },
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.3382,
            "longitude": 121.8863
          }
        },
        "tasks": [
          {
            "taskId": "${TASK2_ID}"
          }
        ]
      }
    }
  ]
}
EOM

Fleet Engine doit être averti lorsqu'un véhicule est à l'arrêt. Toutes les tâches associées à l'arrêt sont alors définies sur l'état CLOSED (FERMÉE). Vous pouvez envoyer des notifications à Fleet Engine à partir du SDK Driver ou de l'environnement du serveur. Les deux méthodes ne doivent pas être mélangées pour éviter les conditions de concurrence et maintenir une source unique de vérité.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour avertir Fleet Engine qu'un véhicule s'est arrêté.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String vehicleName = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
    // This stop has been completed and is commented out to indicate it
    // should be removed from the list of vehicle journey segments.
    // .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()
    //    .setStop(VehicleStop.newBuilder()
    //        .setPlannedLocation(LocationInfo.newBuilder()
    //            .setPoint(LatLng.newBuilder()
    //                .setLatitude(37.7749)
    //                .setLongitude(122.4194)))
    //        .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
    //        .setState(VehicleStop.State.ARRIVED)))
    // All other remaining stops marked as NEW.
    // The next stop could be marked as ENROUTE if the vehicle has begun
    // its journey to the next stop.
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // Next stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.3382)
                   .setLongitude(121.8863)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
           .setState(VehicleStop.State.NEW)))
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // no need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(deliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder()
          .addPaths("remaining_vehicle_journey_segments"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour avertir Fleet Engine de la fin d'un arrêt depuis un environnement de serveur, envoyez un appel REST HTTP à "UpdateDeliveryVehicle":

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remaining_vehicle_journey_segments

<id> est un identifiant unique pour le véhicule de livraison de votre parc pour lequel vous souhaitez mettre à jour l'ordre des tâches. Il s'agit de l'identifiant que vous avez spécifié lors de la création du véhicule.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité DeliveryVehicle:

• Champs obligatoires :

  Champ	Valeur
  segments_journey_véhicule_restants	L'arrêt que vous avez terminé ne doit plus figurer dans la liste des arrêts restants pour véhicules.

• Champs facultatifs :

  • Aucune

Tous les autres champs de l'entité sont ignorés pour la mise à jour.

Exemple de commande curl :

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "remainingVehicleJourneySegments": [
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.3382,
            "longitude": 121.8863
          }
        },
        "tasks": [
          {
            "taskId": "${TASK2_ID}",
            "taskDuration": "120s"
          }
        ]
      }
    }
  ]
}
EOM

Voici un exemple de mise à jour d'une tâche via gRPC.

REST

Voici un exemple de mise à jour d'une tâche via REST.

Pour fermer une tâche attribuée à un véhicule, informez Fleet Engine que le véhicule est à l'arrêt où la tâche a lieu ou supprimez-le de la liste des arrêts des véhicules. Pour ce faire, vous pouvez définir la liste des arrêts restants du véhicule, comme pour mettre à jour l'ordre des tâches d'un véhicule.

Si une tâche n'a pas encore de véhicule et doit être fermée, définissez-la sur CLOSED (FERMÉE). Toutefois, vous ne pouvez pas rouvrir une tâche FERMÉE.

La clôture d'une tâche n'indique pas la réussite ou l'échec. Il indique que la tâche n'est plus considérée comme en cours. Pour le suivi du parc, il est important d'indiquer le résultat réel d'une tâche afin qu'un résultat de livraison puisse être affiché.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
Task task = Task.newBuilder()
  .setName(taskName)
  .setState(Task.State.CLOSED) // It's only possible to directly CLOSE a
  .build();                    // task which is NOT assigned to a vehicle.

// Task request
UpdateTaskRequest updateTaskRequest =
  UpdateTaskRequest.newBuilder()  // No need for the header
      .setTask(task)
      .setUpdateMask(FieldMask.newBuilder().addPaths("state"))
      .build();

try {
  Task updatedTask = deliveryService.updateTask(updateTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=state

<id> est un identifiant unique pour la tâche.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité Task:

• Champs obligatoires :

  Champ	Valeur
  final	État.FERMÉ

• Champs facultatifs :

  Champ	Valeur
  Résultat de la tâche	Result.SUCCEEDED ou Outcome.FAILED.
  tâcheResultTime	Heure à laquelle la tâche a été terminée.
  tâcheResultLocation	Emplacement où la tâche a été effectuée. Fleet Engine utilise par défaut la dernière position du véhicule, sauf si le fournisseur le désactive manuellement.

Tous les autres champs de l'entité sont ignorés pour la mise à jour.

Exemple de commande curl :

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=state,taskOutcome,taskOutcomeTime" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "state": "CLOSED",
  "taskOutcome": "SUCCEEDED",
  "taskOutcomeTime": "$(date -u --iso-8601=seconds)"
}
EOM

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour définir le résultat d'une tâche sur SUCCEEDED et l'emplacement où la tâche a été effectuée:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
Task task = Task.newBuilder()
  .setName(taskName)
  .setTaskOutcome(TaskOutcome.SUCCEEDED)
  .setTaskOutcomeTime(now())
  .setTaskOutcomeLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .build();

// Task request
UpdateTaskRequest updateTaskRequest =
  UpdateTaskRequest.newBuilder()  // No need for the header
      .setTask(task)
      .setUpdateMask(FieldMask.newBuilder().addPaths("task_outcome", "task_outcome_time", "task_outcome_location"))
      .build();

try {
  Task updatedTask = deliveryService.updateTask(updateTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=taskOutcome,taskOutcomeTime,taskOutcomeLocation

<id> est un identifiant unique pour la tâche.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit contenir une entité Task:

• Champs obligatoires :

  Champ	Valeur
  Résultat de la tâche	Result.SUCCEEDED ou Outcome.FAILED.
  tâcheResultTime	Horodatage indiquant le moment où le résultat de la tâche a été défini (à partir du fournisseur). Il s'agit de l'heure à laquelle la tâche a été terminée.

• Champs facultatifs :

  Champ	Valeur
  tâcheResultLocation	Emplacement où la tâche a été effectuée. Fleet Engine utilise par défaut la dernière position du véhicule, sauf si le fournisseur le désactive manuellement.

Tous les autres champs de l'entité sont ignorés pour la mise à jour.

Exemple de commande curl :

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=taskOutcome,taskOutcomeTime,taskOutcomeLocation" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "taskOutcome": "SUCCEEDED",
  "taskOutcomeTime": "$(date -u --iso-8601=seconds)",
  "taskOutcomeLocation": {
    "point": {
      "latitude": -6.195139,
      "longitude": 106.820826
    }
  }
}
EOM

Réacheminer un colis

Une fois qu'une tâche d'expédition a été créée, son emplacement planifié ne peut plus être modifié. Pour réacheminer un envoi, fermez la tâche d'expédition sans définir de résultat, puis créez une tâche avec l'emplacement planifié mis à jour. Après avoir créé la tâche, attribuez-la au même véhicule. Pour en savoir plus, consultez Fermer la tâche d'expédition et attribuer la tâche.

Utiliser des véhicules d'actualisation et de livraison

Si vous utilisez des véhicules d'actualisation pour transporter des envois vers des véhicules de livraison tout au long de la journée, modélisez le transfert des envois en tant que tâche d'arrêt programmée pour le véhicule de livraison. Pour assurer un suivi précis de la localisation, n'attribuez une tâche de livraison à un colis transféré qu'après son chargement dans le véhicule de livraison. Pour en savoir plus, consultez la section Arrêt programmé.

État de la livraison en magasin et autres méta-informations

Lorsqu'une tâche d'expédition est terminée, son état et son résultat sont enregistrés dans la tâche. Toutefois, vous pouvez modifier d'autres métadonnées spécifiques à la livraison. Pour stocker d'autres méta-informations que vous pouvez référencer en dehors du service Fleet Engine, utilisez l'ID de suivi associé à la tâche comme clé dans une table externe.

Pour en savoir plus, consultez Cycle de vie d'une tâche.

Rechercher un véhicule

Vous pouvez rechercher un véhicule à partir du SDK Driver ou de l'environnement du serveur.

gRPC

L'exemple suivant montre comment rechercher un véhicule à l'aide de la bibliothèque Java gRPC:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle request
String name = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
GetDeliveryVehicleRequest getVehicleRequest = GetDeliveryVehicleRequest.newBuilder()  // No need for the header
    .setName(name)
    .build();

try {
  DeliveryVehicle vehicle = deliveryService.getDeliveryVehicle(getVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour rechercher un véhicule dans un environnement de serveur, envoyez un appel HTTP REST à "GetVehicle":

GET https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<vehicleId>

<id> est un identifiant unique pour la tâche.

<vehicleId> est l'identifiant du véhicule à rechercher.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit être vide.

Si la recherche aboutit, le corps de la réponse contient une entité de véhicule.

Exemple de commande curl :

# Set JWT, PROJECT_ID, and VEHICLE_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}"

Rechercher une tâche

Vous pouvez rechercher une tâche dans un environnement de serveur. Le SDK Driver ne permet pas de rechercher une tâche.

gRPC

L'exemple suivant montre comment rechercher une tâche à l'aide de la bibliothèque Java gRPC:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8597549";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task request
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
GetTaskRequest getTaskRequest = GetTaskRequest.newBuilder()  // No need for the header
    .setName(taskName)
    .build();

try {
  Task task = deliveryService.getTask(getTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;

     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour rechercher une tâche dans un environnement de serveur, envoyez un appel HTTP REST à "GetTask":

GET https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<taskId>

<id> est un identifiant unique pour la tâche.

<taskId> est l'ID de la tâche à rechercher.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Le corps de la requête doit être vide.

Si la recherche aboutit, le corps de la réponse contient une entité de tâche.

Exemple de commande curl :

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}"

Rechercher les informations sur la tâche de livraison à l'aide de son ID de suivi

Vous pouvez consulter les informations sur les tâches d'expédition de différentes manières, chacune ayant un objectif distinct:

• par un ID de tâche: utilisé par les utilisateurs tels que les opérateurs de parc qui ont accès à la vue complète des données de la tâche.
• par un ID de suivi: utilisé par votre logiciel client pour fournir des informations limitées à un utilisateur final, par exemple, l'heure d'arrivée d'un colis chez lui.

Cette section explique comment rechercher des informations sur une tâche à l'aide d'un ID de suivi. Si vous souhaitez rechercher une tâche à partir de son ID, consultez la section Rechercher une tâche.

Pour rechercher des informations à l'aide d'un ID de suivi, vous pouvez utiliser l'une des méthodes suivantes:

• Recherches avec Java à l'aide de gRPC
• Recherches utilisant HTTP

Conditions requises pour la recherche

• Les informations de livraison fournies par un ID de suivi respectent les règles de visibilité définies dans la section Contrôler la visibilité des lieux suivis.

• Utilisez Fleet Engine pour rechercher des informations de livraison par ID de suivi. Le SDK Driver n'est pas compatible avec la recherche d'informations par ID de suivi. Pour ce faire, avec Fleet Engine, vous utiliserez soit un environnement de serveur, soit un environnement de navigateur.

• Utilisez le jeton le plus étroit possible afin de limiter les risques de sécurité. Par exemple, si vous utilisez un jeton client de livraison, les appels de l'API Fleet Engine Deliveries ne renvoient que des informations pertinentes pour cet utilisateur final, comme l'expéditeur ou le destinataire d'un colis. Toutes les autres informations contenues dans les réponses sont masquées. Pour en savoir plus sur les jetons, consultez la page Créer un jeton Web JSON (JWT) pour l'autorisation.

Recherches avec Java à l'aide de gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour rechercher des informations sur une tâche de livraison à l'aide de son ID de suivi.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TRACKING_ID = "TID-7449w087464x5";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Tasks request
String parent = "providers/" + PROJECT_ID;
GetTaskTrackingInfoRequest getTaskTrackingInfoRequest = GetTaskTrackingInfoRequest.newBuilder()  // No need for the header
    .setParent(parent)
    .setTrackingId(TRACKING_ID)
    .build();

try {
  TaskTrackingInfo taskTrackingInfo = deliveryService.getTaskTrackingInfo(getTaskTrackingInfoRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;

     case PERMISSION_DENIED:
       break;
  }
  return;
}

Recherches utilisant HTTP

Pour rechercher une tâche de livraison dans un navigateur, envoyez un appel HTTP REST à GetTaskTrackingInfo:

GET https://fleetengine.googleapis.com/v1/providers/<project_id>/taskTrackingInfo/<tracking_id>

<tracking_id> est l'ID de suivi associé à la tâche.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton émis par une fabrique de jetons Fleet Engine.

Si la recherche aboutit, le corps de la réponse contient une entité taskTrackingInfo.

Exemple de commande curl :

# Set JWT, PROJECT_ID, and TRACKING_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/taskTrackingInfo/${TRACKING_ID}"

Répertorier les tâches

Vous pouvez répertorier les tâches à partir d'un serveur ou d'un environnement de navigateur. Le SDK Driver ne permet pas de répertorier les tâches.

La liste des tâches nécessite un accès étendu à celles-ci. La liste des tâches est destinée uniquement aux utilisateurs de confiance. Utilisez le lecteur de parc de livraison ou les jetons d'authentification du super-utilisateur de livraison lorsque vous effectuez des requêtes de liste de tâches.

Les champs suivants sont masqués pour les tâches répertoriées:

• VehicleStop.planned_location
• VehicleStop.state
• VehicleStop.TaskInfo.taskId

Les tâches répertoriées peuvent être filtrées selon la plupart des propriétés de tâche. Pour connaître la syntaxe des requêtes de filtre, consultez la section AIP-160. La liste suivante présente les propriétés de tâche valides que vous pouvez utiliser pour le filtrage:

• attributs
• id_du_véhicule_livraison
• final
• lieu_planifié
• durée_tâche
• tâche_résultat
• emplacement_tâche
• source_location_tâche
• tâche_outcome_time
• ID_suivi
• type

Utilisez les formats de champ suivants en fonction des propositions d'amélioration de l'API Google:

Consultez la page AIP-160 pour obtenir la liste complète des opérateurs de requête de filtre.

Si aucune requête de filtre n'est spécifiée, toutes les tâches sont répertoriées.

Les listes de tâches sont paginées. Une taille de page peut être spécifiée dans les requêtes de liste de tâches. Si une taille de page est spécifiée, le nombre de tâches renvoyées n'est pas supérieur à la taille de page spécifiée. En l'absence de taille de page, une valeur par défaut raisonnable est utilisée. Si la taille de page demandée dépasse une valeur maximale interne, la valeur maximale interne est utilisée.

Une liste de tâches peut inclure un jeton permettant de lire la page de résultats suivante. Utilisez le jeton de page avec une requête identique à la précédente pour récupérer la page de tâches suivante. Lorsque le jeton de page renvoyé est vide, plus aucune tâche n'est disponible pour la récupération.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour répertorier les tâches pour un DeliveryVehicleId et un attribut de tâche. Une réponse réussie peut toujours être vide. Une réponse vide indique qu'aucune tâche n'est associée à l'ID de livraison fourni.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TRACKING_ID = "TID-7449w087464x5";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Tasks request
String parent = "providers/" + PROJECT_ID;
ListTasksRequest listTasksRequest = ListTasksRequest.newBuilder()  // No need for the header
    .setParent(parent)
    .setFilter("delivery_vehicle_id = 123 AND attributes.foo = true")
    .build();

try {
  ListTasksResponse listTasksResponse = deliveryService.listTasks(listTasksRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;

     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Pour répertorier les tâches à partir d'un navigateur, envoyez un appel REST HTTP à ListTasks:

GET https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks

Pour appliquer un filtre aux tâches répertoriées, incluez un paramètre d'URL "filter" avec une requête de filtre avec séquence d'échappement dans l'URL comme valeur.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Si la recherche aboutit, le corps de la réponse contient des données présentant la structure suivante:

// JSON representation
{
  "tasks": [
    {
      object (Task)
    }
  ],
  "nextPageToken": string,
  "totalSize": integer
}

Une réponse positive peut toujours être vide. Une réponse vide indique qu'aucune tâche ne correspond aux critères de filtre spécifiés.

Exemple de commande curl :

# Set JWT, PROJECT_ID, and VEHICLE_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?filter=state%20%3D%20OPEN%20AND%20delivery_vehicle_id%20%3D%20${VEHICLE_ID}"

Lister les véhicules de livraison

Vous pouvez lister les véhicules de livraison à partir d'un serveur ou d'un environnement de navigateur. Le SDK Driver ne permet pas de lister les véhicules de livraison.

Répertorier les véhicules de livraison nécessite un accès étendu aux véhicules de livraison et est destiné uniquement aux utilisateurs de confiance. Utilisez le lecteur de parc de livraison ou les jetons d'authentification du super-utilisateur de livraison lorsque vous effectuez des requêtes de véhicules de livraison de listes.

Les champs suivants des véhicules de livraison répertoriés sont masqués en raison de leur impact sur la taille des réponses:

• Segment de route actuelle
• Segments de véhicules restants

Vous pouvez filtrer la liste des véhicules de livraison en fonction de leur propriété attributes. Par exemple, pour interroger un attribut avec la clé my_key et la valeur my_value, utilisez attributes.my_key = my_value. Pour interroger plusieurs attributs, joignez les requêtes à l'aide des opérateurs logiques AND et OR, comme dans attributes.key1 = value1 AND attributes.key2 = value2. Consultez la page AIP-160 pour obtenir une description complète de la syntaxe des requêtes de filtre.

Vous pouvez filtrer les véhicules de livraison répertoriés par zone géographique à l'aide du paramètre de requête viewport. Le paramètre de requête viewport définit les fenêtres d'affichage à l'aide de deux coordonnées de délimitation: latitude/longitude high (nord-est) et low (sud-ouest). Les requêtes sont refusées si elles contiennent une haute latitude géographiquement inférieure à une faible latitude.

Par défaut, les listes des véhicules de livraison sont paginées avec une taille de page raisonnable. Si vous spécifiez une taille de page, la requête ne renvoie que le nombre de véhicules spécifié par cette limite, ou moins. Si la taille de page demandée dépasse une valeur interne maximale, la valeur maximale interne est utilisée. Les tailles de page par défaut et maximale sont de 100 véhicules.

Une liste de véhicules de livraison peut inclure un jeton permettant de lire la page de résultats suivante. Un jeton de page n'est présent dans une réponse que lorsque davantage de pages de véhicules de livraison peuvent être récupérées. Pour récupérer la page de tâches suivante, utilisez le jeton de page avec une requête identique à la précédente.

gRPC

L'exemple suivant montre comment utiliser la bibliothèque Java gRPC pour répertorier les véhicules de livraison d'une région particulière avec un certain attribut. Une réponse réussie peut toujours être vide. Dans ce cas, aucun véhicule avec l'attribut spécifié ne se trouve actuellement dans la fenêtre d'affichage spécifiée.

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Tasks request
String parent = "providers/" + PROJECT_ID;
ListDeliveryVehiclesRequest listDeliveryVehiclesRequest =
  ListDeliveryVehiclesRequest.newBuilder()  // No need for the header
      .setParent(parent)
      .setViewport(
            Viewport.newBuilder()
              .setHigh(LatLng.newBuilder()
                  .setLatitude(37.45)
                  .setLongitude(-122.06)
                  .build())
              .setLow(LatLng.newBuilder()
                  .setLatitude(37.41)
                  .setLongitude(-122.11)
                  .build())
      .setFilter("attributes.my_key = my_value")
      .build();

try {
  ListDeliveryVehiclesResponse listDeliveryVehiclesResponse =
      deliveryService.listDeliveryVehicles(listDeliveryVehiclesRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
      case NOT_FOUND:
          break;

      case PERMISSION_DENIED:
          break;
  }
  return;
}

REST

Pour répertorier les tâches à partir d'un navigateur, envoyez un appel REST HTTP à ListDeliveryVehicles:

GET https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles

Pour appliquer un filtre aux tâches répertoriées, incluez un paramètre d'URL "filter" avec une requête de filtre avec échappement comme valeur.

L'en-tête de requête doit contenir un champ Authorization avec la valeur Bearer <token>, où <token> est un jeton créé par une fabrique de jetons Fleet Engine.

Si la recherche aboutit, le corps de la réponse contient des données présentant la structure suivante:

// JSON representation
{
  "deliveryVehicles": [
    {
      object (DeliveryVehicle)
    }
  ],
  "nextPageToken": string,
  "totalSize": integer
}

Une réponse positive peut toujours être vide. Dans ce cas, aucun véhicule de livraison ne correspond à la requête de filtre et à la fenêtre d'affichage spécifiées.

Exemple de commande curl :

# Set JWT, PROJECT_ID, and VEHICLE_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles?filter=attributes.my_key%20%3D%20my_value%20&viewport.high.latitude=37.45&viewport.high.longitude=-122.06&viewport.low.latitude=37.41&viewport.low.longitude=-122.11"

Suivi de parc

Vous avez deux options pour utiliser l'API Fleet Engine Deliveries afin d'activer le suivi de parc:

• À privilégier:utilisez la bibliothèque JavaScript Fleet Tracking. Cette bibliothèque vous permet de visualiser la localisation des véhicules et des lieux d'intérêt suivis dans Fleet Engine. Il contient un composant de carte JavaScript qui remplace un objet google.maps.Map standard, ainsi que des composants de données à connecter à Fleet Engine. Cela vous permet de proposer une expérience de suivi de parc animée et personnalisable à partir de votre application Web ou mobile.

• Implémentez votre propre suivi de parc en plus de l'API Fleet Engine Deliveries.

Journalisation

Vous pouvez activer une option permettant à Fleet Engine d'envoyer des journaux RPC à Cloud Logging. Pour en savoir plus, consultez la section Journalisation.

Comme décrit dans la section Intégrer l'API Deliveries et dans les notes d'autorisation pour des cas d'utilisation individuels, les appels à Fleet Engine nécessitent une authentification avec des jetons Web JSON signés à l'aide des identifiants du compte de service. Les comptes de service utilisés pour générer ces jetons peuvent avoir un ou plusieurs rôles, chacun accordant un ensemble d'autorisations différent.

Pour en savoir plus, consultez la page Authentification et autorisation.

Dépannage

Résilience

Fleet Engine n'est pas considéré comme une source de référence. C'est à vous de restaurer l'état de votre système, si nécessaire, sans dépendre de Fleet Engine.

État perdu dans Fleet Engine

Lorsque vous travaillez avec Fleet Engine, implémentez des clients afin que le système se répare tout seul en cas de défaillance. Par exemple, lorsque Fleet Engine tente de mettre à jour un véhicule, il peut renvoyer un message d'erreur indiquant que le véhicule n'existe pas. Le client doit ensuite recréer le véhicule dans le nouvel état. Cela arrive rarement, et le système doit être résilient.

Dans le scénario extrêmement improbable d'une défaillance catastrophique de Fleet Engine, vous devrez peut-être recréer la plupart ou la totalité des véhicules et des tâches. Si le taux de création devient trop élevé, certaines requêtes peuvent échouer à nouveau en raison de problèmes de quota, car des contrôles de quota sont en place pour éviter les attaques par déni de service (DoS). Dans ce cas, ralentissez le taux de recréation à l'aide d'une stratégie d'intervalle entre les tentatives pour les nouvelles tentatives.

État perdu dans l'application du conducteur

Si l'application du pilote plante, l'application doit recréer l'état actuel dans le SDK Driver. L'application doit tenter de recréer des tâches pour s'assurer qu'elles existent et pour restaurer leurs états actuels. L'application doit également recréer et définir explicitement la liste des arrêts pour le SDK Driver.

Notez que ces restaurations doivent être effectuées de manière autonome, sans s'appuyer sur les informations de Fleet Engine, autres que les erreurs indiquant si et quand une entité existe déjà dans la base de données. Si une entité existe déjà, cette erreur peut être absorbée et l'entité peut être mise à jour à l'aide de son ID.

Questions fréquentes

Que se passe-t-il si un conducteur s'arrête pour une tâche dans le désordre ?

Dans ce cas, vous devez d'abord modifier l'ordre des tâches, puis continuer normalement, en marquant l'arrivée à l'arrêt, en indiquant la fin de la tâche, etc. Sinon, le système risque de devenir incohérent. Les heures d'arrivée prévues peuvent devenir incorrectes, et des erreurs inattendues peuvent être signalées.